tablinum 0.0.1 → 0.1.1

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

@@ -1,174 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

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

package/tests/storage/idb.test.ts

@@ -1,144 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,18 +0,0 @@
-{
-  "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

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