@freqhole/playlistz 0.0.1

package/src/services/docIndexService.test.ts

@@ -0,0 +1,179 @@
+// tests for docIndexService crud helpers.
+// uses fake-indexeddb (wired via test-setup.ts) so no real IDB needed.
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { IDBFactory } from "fake-indexeddb";
+import { resetDBCache } from "./indexedDBService.js";
+import {
+  addDocIndexEntry,
+  removeDocIndexEntry,
+  getDocIndexEntry,
+  getAllDocIndexEntries,
+  upsertKnock,
+  getKnock,
+  getAllKnocks,
+  deleteKnock,
+  upsertAccessGrant,
+  getAccessGrant,
+  getAllAccessGrants,
+  deleteAccessGrant,
+} from "./docIndexService.js";
+import type { DocIndexEntry, KnockRecord, AccessGrantRecord } from "./indexedDBService.js";
+
+// fresh idb + db connection for each test (avoids data leaking across tests)
+beforeEach(() => {
+  globalThis.indexedDB = new IDBFactory();
+  resetDBCache();
+});
+
+// --- helpers ---
+
+function makeEntry(overrides: Partial<DocIndexEntry> = {}): DocIndexEntry {
+  return {
+    docId: "automerge:abc123",
+    title: "test playlist",
+    addedAt: 1_000_000,
+    source: "local",
+    ...overrides,
+  };
+}
+
+function makeKnock(overrides: Partial<KnockRecord> = {}): KnockRecord {
+  return {
+    id: "knock-1",
+    nodeId: "node-abc",
+    direction: "inbound",
+    name: "alice",
+    message: "let me in",
+    status: "pending",
+    createdAt: 1_000_000,
+    ...overrides,
+  };
+}
+
+function makeGrant(overrides: Partial<AccessGrantRecord> = {}): AccessGrantRecord {
+  return {
+    nodeId: "node-abc",
+    name: "alice",
+    grantedAt: 1_000_000,
+    ...overrides,
+  };
+}
+
+// --- docIndex ---
+
+describe("docIndex CRUD", () => {
+  it("addDocIndexEntry and getDocIndexEntry round-trip", async () => {
+    const entry = makeEntry({ docId: "automerge:abc", title: "my list" });
+    await addDocIndexEntry(entry);
+    const fetched = await getDocIndexEntry("automerge:abc");
+    expect(fetched).toEqual(entry);
+  });
+
+  it("getDocIndexEntry returns undefined for missing key", async () => {
+    const result = await getDocIndexEntry("automerge:missing");
+    expect(result).toBeUndefined();
+  });
+
+  it("getAllDocIndexEntries returns all entries", async () => {
+    await addDocIndexEntry(makeEntry({ docId: "automerge:a", title: "A" }));
+    await addDocIndexEntry(makeEntry({ docId: "automerge:b", title: "B" }));
+    const all = await getAllDocIndexEntries();
+    expect(all).toHaveLength(2);
+    const titles = all.map((e) => e.title).sort();
+    expect(titles).toEqual(["A", "B"]);
+  });
+
+  it("removeDocIndexEntry removes the entry", async () => {
+    await addDocIndexEntry(makeEntry({ docId: "automerge:del" }));
+    await removeDocIndexEntry("automerge:del");
+    const result = await getDocIndexEntry("automerge:del");
+    expect(result).toBeUndefined();
+  });
+
+  it("removeDocIndexEntry is idempotent for missing key", async () => {
+    // should not throw
+    await expect(
+      removeDocIndexEntry("automerge:never-existed")
+    ).resolves.toBeUndefined();
+  });
+
+  it("addDocIndexEntry overwrites an existing entry", async () => {
+    await addDocIndexEntry(makeEntry({ docId: "automerge:x", title: "old" }));
+    await addDocIndexEntry(makeEntry({ docId: "automerge:x", title: "new" }));
+    const fetched = await getDocIndexEntry("automerge:x");
+    expect(fetched?.title).toBe("new");
+  });
+
+  it("source field round-trips for all source types", async () => {
+    for (const source of ["local", "shared", "freqhole"] as const) {
+      await addDocIndexEntry(
+        makeEntry({ docId: `automerge:${source}`, source })
+      );
+      const result = await getDocIndexEntry(`automerge:${source}`);
+      expect(result?.source).toBe(source);
+    }
+  });
+});
+
+// --- knocks ---
+
+describe("knocks CRUD", () => {
+  it("upsertKnock and getKnock round-trip", async () => {
+    const knock = makeKnock();
+    await upsertKnock(knock);
+    const fetched = await getKnock("knock-1");
+    expect(fetched).toEqual(knock);
+  });
+
+  it("getAllKnocks returns all records", async () => {
+    await upsertKnock(makeKnock({ id: "k1" }));
+    await upsertKnock(makeKnock({ id: "k2", direction: "outbound" }));
+    const all = await getAllKnocks();
+    expect(all).toHaveLength(2);
+  });
+
+  it("deleteKnock removes the record", async () => {
+    await upsertKnock(makeKnock({ id: "k-del" }));
+    await deleteKnock("k-del");
+    expect(await getKnock("k-del")).toBeUndefined();
+  });
+
+  it("upsertKnock updates an existing record", async () => {
+    await upsertKnock(makeKnock({ id: "k-upd", status: "pending" }));
+    await upsertKnock(makeKnock({ id: "k-upd", status: "accepted" }));
+    const result = await getKnock("k-upd");
+    expect(result?.status).toBe("accepted");
+  });
+});
+
+// --- accessGrants ---
+
+describe("accessGrants CRUD", () => {
+  it("upsertAccessGrant and getAccessGrant round-trip", async () => {
+    const grant = makeGrant();
+    await upsertAccessGrant(grant);
+    const fetched = await getAccessGrant("node-abc");
+    expect(fetched).toEqual(grant);
+  });
+
+  it("getAllAccessGrants returns all records", async () => {
+    await upsertAccessGrant(makeGrant({ nodeId: "n1", name: "alice" }));
+    await upsertAccessGrant(makeGrant({ nodeId: "n2", name: "bob" }));
+    const all = await getAllAccessGrants();
+    expect(all).toHaveLength(2);
+  });
+
+  it("deleteAccessGrant removes the record", async () => {
+    await upsertAccessGrant(makeGrant({ nodeId: "n-del" }));
+    await deleteAccessGrant("n-del");
+    expect(await getAccessGrant("n-del")).toBeUndefined();
+  });
+
+  it("upsertAccessGrant overwrites an existing record", async () => {
+    await upsertAccessGrant(makeGrant({ nodeId: "n-upd", name: "old" }));
+    await upsertAccessGrant(makeGrant({ nodeId: "n-upd", name: "new" }));
+    const result = await getAccessGrant("n-upd");
+    expect(result?.name).toBe("new");
+  });
+});

package/src/services/docIndexService.ts

@@ -0,0 +1,118 @@
+// crud helpers for the automerge doc layer stores:
+// docIndex, knocks, and accessGrants.
+//
+// all three stores live in musicPlaylistDB (same db as the rest of the app).
+// docIndex entries are broadcast-invalidated for cross-tab reactivity;
+// knocks and accessGrants are lower-traffic and not live-queried from here.
+
+import {
+  setupDB,
+  DB_NAME,
+  DOC_INDEX_STORE,
+  KNOCKS_STORE,
+  ACCESS_GRANTS_STORE,
+} from "./indexedDBService.js";
+import type {
+  DocIndexEntry,
+  KnockRecord,
+  AccessGrantRecord,
+} from "./indexedDBService.js";
+import { log } from "../utils/log.js";
+
+// event name for same-page doc index invalidation.
+// used alongside BroadcastChannel so file:// (null origin) still works.
+const DOC_INDEX_CHANGE_EVENT = "playlistz:docindex-changed";
+
+// broadcast a docIndex mutation so same-tab queries and other tabs refresh.
+function broadcastDocIndexChange(): void {
+  log.trace("idb.docindex", "broadcast mutation");
+  // CustomEvent works in any origin including file:// (null)
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(DOC_INDEX_CHANGE_EVENT));
+  }
+  try {
+    const bc = new BroadcastChannel(`${DB_NAME}-changes`);
+    bc.postMessage({ type: "mutation", store: DOC_INDEX_STORE });
+    bc.close();
+  } catch {
+    // broadcastchannel unavailable in some environments (workers, tests)
+  }
+}
+
+export { DOC_INDEX_CHANGE_EVENT };
+
+// --- docIndex ---
+
+export async function addDocIndexEntry(entry: DocIndexEntry): Promise<void> {
+  log.trace("idb.docindex", "addEntry", entry.docId);
+  const db = await setupDB();
+  await db.put(DOC_INDEX_STORE, entry);
+  broadcastDocIndexChange();
+}
+
+export async function removeDocIndexEntry(docId: string): Promise<void> {
+  log.trace("idb.docindex", "removeEntry", docId);
+  const db = await setupDB();
+  await db.delete(DOC_INDEX_STORE, docId);
+  broadcastDocIndexChange();
+}
+
+export async function getDocIndexEntry(
+  docId: string
+): Promise<DocIndexEntry | undefined> {
+  const db = await setupDB();
+  return db.get(DOC_INDEX_STORE, docId);
+}
+
+export async function getAllDocIndexEntries(): Promise<DocIndexEntry[]> {
+  const db = await setupDB();
+  return db.getAll(DOC_INDEX_STORE);
+}
+
+// --- knocks ---
+
+export async function upsertKnock(knock: KnockRecord): Promise<void> {
+  const db = await setupDB();
+  await db.put(KNOCKS_STORE, knock);
+}
+
+export async function getKnock(id: string): Promise<KnockRecord | undefined> {
+  const db = await setupDB();
+  return db.get(KNOCKS_STORE, id);
+}
+
+export async function getAllKnocks(): Promise<KnockRecord[]> {
+  const db = await setupDB();
+  return db.getAll(KNOCKS_STORE);
+}
+
+export async function deleteKnock(id: string): Promise<void> {
+  const db = await setupDB();
+  await db.delete(KNOCKS_STORE, id);
+}
+
+// --- accessGrants ---
+
+export async function upsertAccessGrant(
+  grant: AccessGrantRecord
+): Promise<void> {
+  const db = await setupDB();
+  await db.put(ACCESS_GRANTS_STORE, grant);
+}
+
+export async function getAccessGrant(
+  nodeId: string
+): Promise<AccessGrantRecord | undefined> {
+  const db = await setupDB();
+  return db.get(ACCESS_GRANTS_STORE, nodeId);
+}
+
+export async function getAllAccessGrants(): Promise<AccessGrantRecord[]> {
+  const db = await setupDB();
+  return db.getAll(ACCESS_GRANTS_STORE);
+}
+
+export async function deleteAccessGrant(nodeId: string): Promise<void> {
+  const db = await setupDB();
+  await db.delete(ACCESS_GRANTS_STORE, nodeId);
+}