~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
176 lines · 5.1 KB Raw History
// IndexedDB mirror of the vuln-notif record graph.
//
// Stores the wanted atproto records keyed by URI, the links derived from them,
// and a small key/value meta store. All functions use the single database
// handle opened by openDb().

const DB_NAME = "vuln-notif-graph";
const DB_VERSION = 1;

let db = null;

function requestResult(request) {
  return new Promise((resolve, reject) => {
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
}

function transactionDone(tx) {
  return new Promise((resolve, reject) => {
    tx.oncomplete = () => resolve();
    tx.onerror = () => reject(tx.error || new Error("IndexedDB transaction failed"));
    tx.onabort = () => reject(tx.error || new Error("IndexedDB transaction aborted"));
  });
}

export function openDb() {
  if (db) return Promise.resolve(db);
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);
    request.onupgradeneeded = () => {
      const handle = request.result;
      if (!handle.objectStoreNames.contains("records")) {
        const records = handle.createObjectStore("records", { keyPath: "uri" });
        records.createIndex("collection", "collection");
      }
      if (!handle.objectStoreNames.contains("edges")) {
        const edges = handle.createObjectStore("edges", {
          keyPath: ["source", "target", "label"],
        });
        edges.createIndex("source", "source");
      }
      if (!handle.objectStoreNames.contains("meta")) {
        handle.createObjectStore("meta");
      }
    };
    request.onsuccess = () => {
      db = request.result;
      resolve(db);
    };
    request.onerror = () => reject(request.error);
  });
}

export function getHandle() {
  return db;
}

function requireDb() {
  if (!db) throw new Error("IndexedDB is not open; call openDb() first");
  return db;
}

export async function countRecords() {
  const handle = requireDb();
  const tx = handle.transaction("records", "readonly");
  return requestResult(tx.objectStore("records").count());
}

export function putRecord(record) {
  const handle = requireDb();
  const tx = handle.transaction("records", "readwrite");
  tx.objectStore("records").put(record);
  return transactionDone(tx);
}

export function putBatch(records, edges) {
  const handle = requireDb();
  const tx = handle.transaction(["records", "edges"], "readwrite");
  const recordStore = tx.objectStore("records");
  const edgeStore = tx.objectStore("edges");
  for (const record of records) recordStore.put(record);
  for (const edge of edges) {
    edgeStore.put({
      source: edge.source,
      target: edge.target,
      label: edge.label,
      collection: edge.collection,
    });
  }
  return transactionDone(tx);
}

function deleteEdgesBySource(uri) {
  const handle = requireDb();
  const tx = handle.transaction("edges", "readwrite");
  const index = tx.objectStore("edges").index("source");
  const request = index.openCursor(IDBKeyRange.only(uri));
  request.onsuccess = () => {
    const cursor = request.result;
    if (!cursor) return;
    cursor.delete();
    cursor.continue();
  };
  return transactionDone(tx);
}

export async function replaceEdgesForSource(uri, edges) {
  await deleteEdgesBySource(uri);
  if (!edges || edges.length === 0) return;
  const handle = requireDb();
  const tx = handle.transaction("edges", "readwrite");
  const store = tx.objectStore("edges");
  for (const edge of edges) {
    store.put({
      source: uri,
      target: edge.target,
      label: edge.label,
      collection: edge.collection,
    });
  }
  await transactionDone(tx);
}

export async function deleteRecordByUri(uri) {
  const handle = requireDb();
  const tx = handle.transaction(["records", "edges"], "readwrite");
  tx.objectStore("records").delete(uri);
  const index = tx.objectStore("edges").index("source");
  const request = index.openCursor(IDBKeyRange.only(uri));
  request.onsuccess = () => {
    const cursor = request.result;
    if (!cursor) return;
    cursor.delete();
    cursor.continue();
  };
  await transactionDone(tx);
}

export async function allRecords() {
  const handle = requireDb();
  const tx = handle.transaction("records", "readonly");
  return requestResult(tx.objectStore("records").getAll());
}

export async function allEdges() {
  const handle = requireDb();
  const tx = handle.transaction("edges", "readonly");
  return requestResult(tx.objectStore("edges").getAll());
}

export async function getMeta(key) {
  const handle = requireDb();
  const tx = handle.transaction("meta", "readonly");
  return requestResult(tx.objectStore("meta").get(key));
}

export async function setMeta(key, value) {
  const handle = requireDb();
  const tx = handle.transaction("meta", "readwrite");
  tx.objectStore("meta").put(value, key);
  await transactionDone(tx);
}

export async function clearAll() {
  const handle = requireDb();
  const tx = handle.transaction(["records", "edges", "meta"], "readwrite");
  tx.objectStore("records").clear();
  tx.objectStore("edges").clear();
  tx.objectStore("meta").clear();
  await transactionDone(tx);
}

export async function isEmpty() {
  return (await countRecords()) === 0;
}