tablinum 0.0.1

package/tests/db/create-localstr.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect } from "vitest";
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { field } from "../../src/schema/field.ts";
+import { collection } from "../../src/schema/collection.ts";
+import { createLocalstr } from "../../src/db/create-localstr.ts";
+
+describe("createLocalstr", () => {
+  it.effect("creates a database and performs CRUD", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+        done: field.boolean(),
+      });
+
+      const db = yield* createLocalstr({
+        schema: { todos },
+        relays: ["wss://relay.example.com"],
+        dbName: "test-crud",
+      });
+
+      const col = db.collection("todos");
+
+      // Add
+      const id = yield* col.add({
+        title: "Buy milk",
+        done: false,
+      } as any);
+      expect(id).toBeDefined();
+      expect(id.length).toBeGreaterThan(0);
+
+      // Get
+      const record = yield* col.get(id);
+      expect(record.id).toBe(id);
+      expect(record.title).toBe("Buy milk");
+      expect(record.done).toBe(false);
+
+      // Update
+      yield* col.update(id, { done: true } as any);
+      const updated = yield* col.get(id);
+      expect(updated.done).toBe(true);
+      expect(updated.title).toBe("Buy milk");
+
+      // Count
+      const count = yield* col.count();
+      expect(count).toBe(1);
+
+      // First
+      const first = yield* col.first();
+      expect(first).not.toBeNull();
+      expect(first!.id).toBe(id);
+
+      // Delete
+      yield* col.delete(id);
+      const countAfter = yield* col.count();
+      expect(countAfter).toBe(0);
+
+      // Get after delete returns NotFoundError
+      const getResult = yield* Effect.result(col.get(id));
+      expect(getResult._tag).toBe("Failure");
+    }),
+  );
+
+  it.effect("rejects missing relays", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+      });
+      const result = yield* Effect.result(
+        createLocalstr({
+          schema: { todos },
+          relays: [],
+          dbName: "test-no-relays",
+        }),
+      );
+      expect(result._tag).toBe("Failure");
+    }),
+  );
+
+  it.effect("exports key", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+      });
+      const db = yield* createLocalstr({
+        schema: { todos },
+        relays: ["wss://relay.example.com"],
+        dbName: "test-key",
+      });
+      const key = db.exportKey();
+      expect(key).toBeDefined();
+      expect(key.length).toBe(64);
+    }),
+  );
+
+  it.effect("rebuild regenerates records from events", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+        done: field.boolean(),
+      });
+
+      const db = yield* createLocalstr({
+        schema: { todos },
+        relays: ["wss://relay.example.com"],
+        dbName: "test-rebuild",
+      });
+
+      const col = db.collection("todos");
+      const id = yield* col.add({
+        title: "Rebuild test",
+        done: false,
+      } as any);
+
+      yield* col.update(id, { done: true } as any);
+
+      yield* db.rebuild();
+
+      const record = yield* col.get(id);
+      expect(record.title).toBe("Rebuild test");
+      expect(record.done).toBe(true);
+    }),
+  );
+
+  it.effect("getSyncStatus returns idle", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+      });
+      const db = yield* createLocalstr({
+        schema: { todos },
+        relays: ["wss://relay.example.com"],
+        dbName: "test-status",
+      });
+      const status = yield* db.getSyncStatus();
+      expect(status).toBe("idle");
+    }),
+  );
+
+  it.effect("where().equals() filters records", () =>
+    Effect.gen(function* () {
+      const todos = collection("todos", {
+        title: field.string(),
+        done: field.boolean(),
+      });
+
+      const db = yield* createLocalstr({
+        schema: { todos },
+        relays: ["wss://relay.example.com"],
+        dbName: "test-where",
+      });
+
+      const col = db.collection("todos");
+      yield* col.add({ title: "A", done: false } as any);
+      yield* col.add({ title: "B", done: true } as any);
+      yield* col.add({ title: "C", done: false } as any);
+
+      const where = col.where("done");
+      const doneItems = yield* where.equals(true).get();
+      expect(doneItems.length).toBe(1);
+      expect(doneItems[0]!.title).toBe("B");
+
+      const notDoneItems = yield* where.equals(false).get();
+      expect(notDoneItems.length).toBe(2);
+
+      const count = yield* where.equals(true).count();
+      expect(count).toBe(1);
+
+      const first = yield* where.equals(true).first();
+      expect(first).not.toBeNull();
+      expect(first!.title).toBe("B");
+    }),
+  );
+});

package/tests/db/identity.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect } from "vitest";
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { createIdentity } from "../../src/db/identity.ts";
+
+describe("identity", () => {
+  it.effect("generates a random key", () =>
+    Effect.gen(function* () {
+      const identity = yield* createIdentity();
+      expect(identity.privateKey.length).toBe(32);
+      expect(identity.exportKey().length).toBe(64);
+    }),
+  );
+
+  it.effect("accepts a supplied key", () =>
+    Effect.gen(function* () {
+      const key = new Uint8Array(32);
+      key.fill(1);
+      const identity = yield* createIdentity(key);
+      expect(identity.privateKey).toBe(key);
+      expect(identity.exportKey()).toBe(
+        "0101010101010101010101010101010101010101010101010101010101010101",
+      );
+    }),
+  );
+
+  it.effect("rejects invalid key length", () =>
+    Effect.gen(function* () {
+      const result = yield* Effect.result(createIdentity(new Uint8Array(16)));
+      expect(result._tag).toBe("Failure");
+    }),
+  );
+});

package/tests/main.test.ts

@@ -0,0 +1,9 @@
+import { it, expect } from "@effect/vitest";
+import { Effect } from "effect";
+
+it.effect("should return 42", () =>
+  Effect.gen(function* () {
+    const result = yield* Effect.succeed(42);
+    expect(result).toBe(42);
+  }),
+);

package/tests/schema/collection.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { field } from "../../src/schema/field.ts";
+import { collection } from "../../src/schema/collection.ts";
+
+describe("collection builder", () => {
+  it("creates a valid collection", () => {
+    const col = collection("todos", {
+      title: field.string(),
+      done: field.boolean(),
+    });
+    expect(col._tag).toBe("CollectionDef");
+    expect(col.name).toBe("todos");
+    expect(Object.keys(col.fields)).toEqual(["title", "done"]);
+  });
+
+  it("rejects empty name", () => {
+    expect(() => collection("", { title: field.string() })).toThrow();
+  });
+
+  it("rejects empty fields", () => {
+    expect(() => collection("empty", {})).toThrow();
+  });
+
+  it("rejects reserved field names", () => {
+    expect(() => collection("bad", { id: field.string() })).toThrow();
+  });
+});

package/tests/schema/field.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "vitest";
+import { field } from "../../src/schema/field.ts";
+
+describe("field builders", () => {
+  test("field.string() creates a string field", () => {
+    const f = field.string();
+    expect(f._tag).toBe("FieldDef");
+    expect(f.kind).toBe("string");
+    expect(f.isOptional).toBe(false);
+    expect(f.isArray).toBe(false);
+  });
+
+  test("field.number() creates a number field", () => {
+    const f = field.number();
+    expect(f.kind).toBe("number");
+  });
+
+  test("field.boolean() creates a boolean field", () => {
+    const f = field.boolean();
+    expect(f.kind).toBe("boolean");
+  });
+
+  test("field.json() creates a json field", () => {
+    const f = field.json();
+    expect(f.kind).toBe("json");
+  });
+
+  test("field.optional() wraps a field as optional", () => {
+    const f = field.optional(field.string());
+    expect(f.kind).toBe("string");
+    expect(f.isOptional).toBe(true);
+    expect(f.isArray).toBe(false);
+  });
+
+  test("field.array() wraps a field as array", () => {
+    const f = field.array(field.number());
+    expect(f.kind).toBe("number");
+    expect(f.isOptional).toBe(false);
+    expect(f.isArray).toBe(true);
+  });
+});

package/tests/schema/validate.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect } from "vitest";
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { field } from "../../src/schema/field.ts";
+import { collection } from "../../src/schema/collection.ts";
+import { buildValidator, buildPartialValidator } from "../../src/schema/validate.ts";
+
+describe("schema validation", () => {
+  it.effect("validates a correct record", () =>
+    Effect.gen(function* () {
+      const def = collection("todos", {
+        title: field.string(),
+        done: field.boolean(),
+      });
+      const validate = buildValidator("todos", def);
+      const result = yield* validate({
+        id: "abc",
+        title: "Test",
+        done: false,
+      });
+      expect(result).toEqual({ id: "abc", title: "Test", done: false });
+    }),
+  );
+
+  it.effect("rejects invalid types", () =>
+    Effect.gen(function* () {
+      const def = collection("todos", {
+        title: field.string(),
+      });
+      const validate = buildValidator("todos", def);
+      const result = yield* Effect.result(validate({ id: "abc", title: 42 }));
+      expect(result._tag).toBe("Failure");
+    }),
+  );
+
+  it.effect("handles optional fields", () =>
+    Effect.gen(function* () {
+      const def = collection("notes", {
+        text: field.string(),
+        tag: field.optional(field.string()),
+      });
+      const validate = buildValidator("notes", def);
+      const result = yield* validate({
+        id: "abc",
+        text: "hello",
+        tag: undefined,
+      });
+      expect(result).toEqual({ id: "abc", text: "hello", tag: undefined });
+    }),
+  );
+
+  it.effect("validates array fields", () =>
+    Effect.gen(function* () {
+      const def = collection("lists", {
+        items: field.array(field.string()),
+      });
+      const validate = buildValidator("lists", def);
+      const result = yield* validate({ id: "abc", items: ["a", "b"] });
+      expect(result).toEqual({ id: "abc", items: ["a", "b"] });
+    }),
+  );
+
+  it.effect("partial validator accepts subset of fields", () =>
+    Effect.gen(function* () {
+      const def = collection("todos", {
+        title: field.string(),
+        done: field.boolean(),
+      });
+      const validate = buildPartialValidator("todos", def);
+      const result = yield* validate({ title: "Updated" });
+      expect(result).toEqual({ title: "Updated" });
+    }),
+  );
+
+  it.effect("partial validator rejects unknown fields", () =>
+    Effect.gen(function* () {
+      const def = collection("todos", {
+        title: field.string(),
+      });
+      const validate = buildPartialValidator("todos", def);
+      const result = yield* Effect.result(validate({ unknown: "value" }));
+      expect(result._tag).toBe("Failure");
+    }),
+  );
+});

package/tests/setup.ts

@@ -0,0 +1 @@
+import "fake-indexeddb/auto";

package/tests/storage/idb.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect } from "vitest";
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { openIDBStorage } from "../../src/storage/idb.ts";
+import { field } from "../../src/schema/field.ts";
+import { collection } from "../../src/schema/collection.ts";
+
+const makeSchema = () => ({
+  todos: collection("todos", {
+    title: field.string(),
+  }),
+  notes: collection("notes", {
+    text: field.string(),
+  }),
+});
+
+describe("IDBStorage", () => {
+  it.effect("opens and closes without error", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-open", schema);
+      expect(storage).toBeDefined();
+    }),
+  );
+
+  it.effect("puts and gets a record", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-put-get", schema);
+      yield* storage.putRecord("todos", {
+        id: "r1",
+        title: "Test",
+        _deleted: false,
+        _updatedAt: 100,
+      });
+      const record = yield* storage.getRecord("todos", "r1");
+      expect(record).toBeDefined();
+      expect(record!.title).toBe("Test");
+    }),
+  );
+
+  it.effect("gets all records for a collection", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-get-all", schema);
+      yield* storage.putRecord("todos", {
+        id: "r1",
+        title: "A",
+        _deleted: false,
+        _updatedAt: 100,
+      });
+      yield* storage.putRecord("todos", {
+        id: "r2",
+        title: "B",
+        _deleted: false,
+        _updatedAt: 200,
+      });
+      yield* storage.putRecord("notes", {
+        id: "r3",
+        text: "C",
+        _deleted: false,
+        _updatedAt: 300,
+      });
+      const todos = yield* storage.getAllRecords("todos");
+      expect(todos.length).toBe(2);
+      const notes = yield* storage.getAllRecords("notes");
+      expect(notes.length).toBe(1);
+    }),
+  );
+
+  it.effect("clears records store", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-clear", schema);
+      yield* storage.putRecord("todos", {
+        id: "r1",
+        title: "X",
+        _deleted: false,
+        _updatedAt: 100,
+      });
+      yield* storage.clearRecords("todos");
+      const all = yield* storage.getAllRecords("todos");
+      expect(all.length).toBe(0);
+    }),
+  );
+
+  it.effect("puts and gets events", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-events", schema);
+      yield* storage.putEvent({
+        id: "e1",
+        collection: "todos",
+        recordId: "r1",
+        kind: "create",
+        data: { title: "Test" },
+        createdAt: 100,
+      });
+      const event = yield* storage.getEvent("e1");
+      expect(event).toBeDefined();
+      expect(event!.recordId).toBe("r1");
+    }),
+  );
+
+  it.effect("gets events by record", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-events-by-record", schema);
+      yield* storage.putEvent({
+        id: "e1",
+        collection: "todos",
+        recordId: "r1",
+        kind: "create",
+        data: { title: "V1" },
+        createdAt: 100,
+      });
+      yield* storage.putEvent({
+        id: "e2",
+        collection: "todos",
+        recordId: "r1",
+        kind: "update",
+        data: { title: "V2" },
+        createdAt: 200,
+      });
+      const events = yield* storage.getEventsByRecord("todos", "r1");
+      expect(events.length).toBe(2);
+    }),
+  );
+
+  it.effect("puts and gets gift wraps", () =>
+    Effect.gen(function* () {
+      const schema = makeSchema();
+      const storage = yield* openIDBStorage("test-giftwraps", schema);
+      yield* storage.putGiftWrap({
+        id: "gw1",
+        event: { kind: 1059 },
+        createdAt: 100,
+      });
+      const gw = yield* storage.getGiftWrap("gw1");
+      expect(gw).toBeDefined();
+      expect(gw!.event.kind).toBe(1059);
+    }),
+  );
+});

package/tests/storage/lww.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "vitest";
+import { resolveWinner } from "../../src/storage/lww.ts";
+
+describe("LWW resolution", () => {
+  test("incoming wins when no existing", () => {
+    const incoming = { id: "b", createdAt: 100 };
+    expect(resolveWinner(null, incoming)).toBe(incoming);
+  });
+
+  test("newer timestamp wins", () => {
+    const existing = { id: "a", createdAt: 100 };
+    const incoming = { id: "b", createdAt: 200 };
+    expect(resolveWinner(existing, incoming)).toBe(incoming);
+  });
+
+  test("older timestamp loses", () => {
+    const existing = { id: "a", createdAt: 200 };
+    const incoming = { id: "b", createdAt: 100 };
+    expect(resolveWinner(existing, incoming)).toBe(existing);
+  });
+
+  test("tie broken by lowest event ID", () => {
+    const existing = { id: "b", createdAt: 100 };
+    const incoming = { id: "a", createdAt: 100 };
+    expect(resolveWinner(existing, incoming)).toBe(incoming); // "a" < "b"
+  });
+
+  test("tie: existing wins when its ID is lower", () => {
+    const existing = { id: "a", createdAt: 100 };
+    const incoming = { id: "b", createdAt: 100 };
+    expect(resolveWinner(existing, incoming)).toBe(existing); // "a" < "b"
+  });
+});

package/tests/sync/gift-wrap.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect } from "vitest";
+import { it } from "@effect/vitest";
+import { Effect } from "effect";
+import { generateSecretKey, getPublicKey } from "nostr-tools/pure";
+import { createGiftWrapHandle } from "../../src/sync/gift-wrap.ts";
+
+describe("gift wrap", () => {
+  it.effect("round-trips wrap and unwrap", () =>
+    Effect.gen(function* () {
+      const sk = generateSecretKey();
+      const pk = getPublicKey(sk);
+      const handle = createGiftWrapHandle(sk, pk);
+
+      const giftWrap = yield* handle.wrap({
+        kind: 1,
+        content: JSON.stringify({ title: "Test", done: false }),
+        tags: [["d", "todos:abc-123"]],
+        created_at: Math.floor(Date.now() / 1000),
+      });
+
+      expect(giftWrap.kind).toBe(1059);
+      expect(giftWrap.id).toBeDefined();
+      expect(giftWrap.sig).toBeDefined();
+
+      const rumor = yield* handle.unwrap(giftWrap);
+      expect(rumor.kind).toBe(1);
+      expect(rumor.content).toBe(JSON.stringify({ title: "Test", done: false }));
+      const dTag = rumor.tags.find((t: string[]) => t[0] === "d");
+      expect(dTag).toBeDefined();
+      expect(dTag![1]).toBe("todos:abc-123");
+    }),
+  );
+
+  it.effect("gift wrap uses random key (different pubkey each time)", () =>
+    Effect.gen(function* () {
+      const sk = generateSecretKey();
+      const pk = getPublicKey(sk);
+      const handle = createGiftWrapHandle(sk, pk);
+
+      const rumor = {
+        kind: 1,
+        content: "test",
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000),
+      };
+
+      const gw1 = yield* handle.wrap(rumor);
+      const gw2 = yield* handle.wrap(rumor);
+
+      // Gift wraps should have different pubkeys (random disposable keys)
+      expect(gw1.pubkey).not.toBe(gw2.pubkey);
+      // And different from the author's pubkey
+      expect(gw1.pubkey).not.toBe(pk);
+    }),
+  );
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.svelte.ts", "tests/**/*.ts", "scripts/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+    setupFiles: ["tests/setup.ts"],
+  },
+});