tablinum 0.0.1

package/src/storage/records-store.ts

@@ -0,0 +1,76 @@
+import { Effect } from "effect";
+import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
+import { resolveWinner } from "./lww.ts";
+import type { StorageError } from "../errors.ts";
+
+/**
+ * Build a flat record from an event for storage in per-collection IDB stores.
+ */
+function buildRecord(event: StoredEvent): Record<string, unknown> {
+  return {
+    id: event.recordId,
+    _deleted: event.kind === "delete",
+    _updatedAt: event.createdAt,
+    ...(event.data ?? {}),
+  };
+}
+
+/**
+ * Apply an event to the records store using LWW resolution.
+ * Returns true if the incoming event won and the record was updated.
+ */
+export function applyEvent(
+  storage: IDBStorageHandle,
+  event: StoredEvent,
+): Effect.Effect<boolean, StorageError> {
+  return Effect.gen(function* () {
+    const existingEvents = yield* storage.getEventsByRecord(event.collection, event.recordId);
+
+    // Find the current winning event for this record
+    let currentWinner: StoredEvent | null = null;
+    for (const e of existingEvents) {
+      if (e.id === event.id) continue; // Skip the event we're applying
+      currentWinner = resolveWinner(currentWinner, e);
+    }
+
+    const winner = resolveWinner(currentWinner, event);
+    const incomingWon = winner.id === event.id;
+
+    if (incomingWon) {
+      yield* storage.putRecord(event.collection, buildRecord(event));
+    }
+
+    return incomingWon;
+  });
+}
+
+/**
+ * Rebuild the records store by clearing it and replaying all events.
+ */
+export function rebuild(
+  storage: IDBStorageHandle,
+  collections: ReadonlyArray<string>,
+): Effect.Effect<void, StorageError> {
+  return Effect.gen(function* () {
+    for (const col of collections) {
+      yield* storage.clearRecords(col);
+    }
+    const allEvents = yield* storage.getAllEvents();
+
+    // Sort by createdAt for deterministic replay
+    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt);
+
+    // Group events by record and resolve each
+    const winners = new Map<string, StoredEvent>();
+    for (const event of sorted) {
+      const key = `${event.collection}:${event.recordId}`;
+      const current = winners.get(key) ?? null;
+      winners.set(key, resolveWinner(current, event));
+    }
+
+    // Write winning records
+    for (const event of winners.values()) {
+      yield* storage.putRecord(event.collection, buildRecord(event));
+    }
+  });
+}

package/src/svelte/collection.svelte.ts

@@ -0,0 +1,87 @@
+import { Effect, Fiber, Stream } from "effect";
+import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+import type { InferRecord } from "../schema/types.ts";
+import type { CollectionHandle } from "../crud/collection-handle.ts";
+import { LiveQuery } from "./live-query.svelte.ts";
+import {
+  wrapWhereClause,
+  wrapOrderByBuilder,
+  type SvelteWhereClause,
+  type SvelteOrderByBuilder,
+} from "./query.svelte.ts";
+
+export class Collection<C extends CollectionDef<CollectionFields>> {
+  items = $state<ReadonlyArray<InferRecord<C>>>([]);
+  error = $state<Error | null>(null);
+
+  #handle: CollectionHandle<C>;
+  #watchFiber: Fiber.Fiber<void, unknown> | null = null;
+  #liveQueries: Set<LiveQuery<unknown>> = new Set();
+
+  constructor(handle: CollectionHandle<C>) {
+    this.#handle = handle;
+
+    // Auto-watch: subscribe to all records, surface errors to this.error
+    const watchEffect = Stream.runForEach(handle.watch(), (records) =>
+      Effect.sync(() => {
+        this.items = records;
+      }),
+    ).pipe(
+      Effect.catch((e) =>
+        Effect.sync(() => {
+          this.error = e instanceof Error ? e : new Error(String(e));
+        }),
+      ),
+    );
+    this.#watchFiber = Effect.runFork(watchEffect);
+  }
+
+  #run = async <R>(effect: Effect.Effect<R, unknown>): Promise<R> => {
+    try {
+      this.error = null;
+      return await Effect.runPromise(effect);
+    } catch (e) {
+      this.error = e instanceof Error ? e : new Error(String(e));
+      throw this.error;
+    }
+  };
+
+  #onLive = (lq: LiveQuery<unknown>): void => {
+    this.#liveQueries.add(lq);
+  };
+
+  add = (data: Omit<InferRecord<C>, "id">): Promise<string> => this.#run(this.#handle.add(data));
+
+  update = (id: string, data: Partial<Omit<InferRecord<C>, "id">>): Promise<void> =>
+    this.#run(this.#handle.update(id, data));
+
+  delete = (id: string): Promise<void> => this.#run(this.#handle.delete(id));
+
+  get = (id: string): Promise<InferRecord<C>> => this.#run(this.#handle.get(id));
+
+  first = (): Promise<InferRecord<C> | null> => this.#run(this.#handle.first());
+
+  count = (): Promise<number> => this.#run(this.#handle.count());
+
+  where = (field: string & keyof Omit<InferRecord<C>, "id">): SvelteWhereClause<InferRecord<C>> => {
+    return wrapWhereClause(this.#handle.where(field), this.#onLive);
+  };
+
+  orderBy = (
+    field: string & keyof Omit<InferRecord<C>, "id">,
+  ): SvelteOrderByBuilder<InferRecord<C>> => {
+    return wrapOrderByBuilder(this.#handle.orderBy(field), this.#onLive);
+  };
+
+  /** @internal Called by Database.close() */
+  _destroy(): void {
+    if (this.#watchFiber) {
+      Effect.runFork(Fiber.interrupt(this.#watchFiber));
+      this.#watchFiber = null;
+    }
+    for (const lq of this.#liveQueries) {
+      lq.destroy();
+    }
+    this.#liveQueries.clear();
+  }
+}

package/src/svelte/database.svelte.ts

@@ -0,0 +1,83 @@
+import { Effect, Scope, Exit } from "effect";
+import type { SchemaConfig } from "../schema/types.ts";
+import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+import type { DatabaseHandle, SyncStatus } from "../db/database-handle.ts";
+import { Collection } from "./collection.svelte.ts";
+
+export class Database<S extends SchemaConfig> {
+  status = $state<SyncStatus>("idle");
+  error = $state<Error | null>(null);
+
+  #handle: DatabaseHandle<S>;
+  #scope: Scope.Closeable;
+  #collections = new Map<string, Collection<CollectionDef<CollectionFields>>>();
+  #statusInterval: ReturnType<typeof setInterval> | null = null;
+  #closed = false;
+
+  constructor(handle: DatabaseHandle<S>, scope: Scope.Closeable) {
+    this.#handle = handle;
+    this.#scope = scope;
+
+    // Poll sync status
+    this.#statusInterval = setInterval(() => {
+      if (this.#closed) return;
+      Effect.runPromise(this.#handle.getSyncStatus())
+        .then((s) => {
+          this.status = s;
+        })
+        .catch(() => {
+          /* database may be closed, ignore */
+        });
+    }, 1000);
+  }
+
+  collection<K extends string & keyof S>(name: K): Collection<S[K]> {
+    let col = this.#collections.get(name);
+    if (!col) {
+      const handle = this.#handle.collection(name);
+      col = new Collection(handle) as Collection<CollectionDef<CollectionFields>>;
+      this.#collections.set(name, col);
+    }
+    return col as unknown as Collection<S[K]>;
+  }
+
+  exportKey(): string {
+    return this.#handle.exportKey();
+  }
+
+  close = async (): Promise<void> => {
+    if (this.#closed) return;
+    this.#closed = true;
+
+    if (this.#statusInterval) {
+      clearInterval(this.#statusInterval);
+      this.#statusInterval = null;
+    }
+    for (const col of this.#collections.values()) {
+      col._destroy();
+    }
+    this.#collections.clear();
+    await Effect.runPromise(this.#handle.close());
+    await Effect.runPromise(Scope.close(this.#scope, Exit.void));
+  };
+
+  sync = async (): Promise<void> => {
+    try {
+      this.error = null;
+      await Effect.runPromise(this.#handle.sync());
+    } catch (e) {
+      this.error = e instanceof Error ? e : new Error(String(e));
+      throw this.error;
+    }
+  };
+
+  rebuild = async (): Promise<void> => {
+    try {
+      this.error = null;
+      await Effect.runPromise(this.#handle.rebuild());
+    } catch (e) {
+      this.error = e instanceof Error ? e : new Error(String(e));
+      throw this.error;
+    }
+  };
+}

package/src/svelte/index.svelte.ts

@@ -0,0 +1,52 @@
+import { Effect, Exit, Scope } from "effect";
+import type { SchemaConfig } from "../schema/types.ts";
+import {
+  createLocalstr as coreCreateLocalstr,
+  type LocalstrConfig,
+} from "../db/create-localstr.ts";
+import { Database } from "./database.svelte.ts";
+
+// Re-export schema utilities (unchanged)
+export { field } from "../schema/field.ts";
+export { collection } from "../schema/collection.ts";
+export type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+export type { FieldDef, FieldKind } from "../schema/field.ts";
+export type { InferRecord, SchemaConfig } from "../schema/types.ts";
+export type { LocalstrConfig } from "../db/create-localstr.ts";
+export type { SyncStatus } from "../db/database-handle.ts";
+
+// Re-export errors
+export {
+  ValidationError,
+  StorageError,
+  CryptoError,
+  RelayError,
+  SyncError,
+  NotFoundError,
+  ClosedError,
+} from "../errors.ts";
+
+// Re-export Svelte classes
+export { Database } from "./database.svelte.ts";
+export { Collection } from "./collection.svelte.ts";
+export { LiveQuery } from "./live-query.svelte.ts";
+export type {
+  SvelteQueryBuilder,
+  SvelteWhereClause,
+  SvelteOrderByBuilder,
+} from "./query.svelte.ts";
+
+export async function createLocalstr<S extends SchemaConfig>(
+  config: LocalstrConfig<S>,
+): Promise<Database<S>> {
+  const scope = Effect.runSync(Scope.make());
+  try {
+    const handle = await Effect.runPromise(
+      coreCreateLocalstr(config).pipe(Effect.provideService(Scope.Scope, scope)),
+    );
+    return new Database(handle, scope) as Database<S>;
+  } catch (e) {
+    await Effect.runPromise(Scope.close(scope, Exit.fail(e)));
+    throw e;
+  }
+}

package/src/svelte/live-query.svelte.ts

@@ -0,0 +1,29 @@
+import { Effect, Fiber, Stream } from "effect";
+
+export class LiveQuery<T> {
+  items = $state<ReadonlyArray<T>>([]);
+  error = $state<Error | null>(null);
+  #fiber: Fiber.Fiber<void, unknown> | null = null;
+
+  constructor(stream: Stream.Stream<ReadonlyArray<T>, unknown>) {
+    const effect = Stream.runForEach(stream, (records) =>
+      Effect.sync(() => {
+        this.items = records;
+      }),
+    ).pipe(
+      Effect.catch((e) =>
+        Effect.sync(() => {
+          this.error = e instanceof Error ? e : new Error(String(e));
+        }),
+      ),
+    );
+    this.#fiber = Effect.runFork(effect);
+  }
+
+  destroy(): void {
+    if (this.#fiber) {
+      Effect.runFork(Fiber.interrupt(this.#fiber));
+      this.#fiber = null;
+    }
+  }
+}

package/src/svelte/query.svelte.ts

@@ -0,0 +1,101 @@
+import { Effect } from "effect";
+import type { WhereClause, QueryBuilder, OrderByBuilder } from "../crud/query-builder.ts";
+import { LiveQuery } from "./live-query.svelte.ts";
+
+export type OnLiveCallback = (lq: LiveQuery<unknown>) => void;
+
+export interface SvelteQueryBuilder<T> {
+  readonly and: (fn: (item: T) => boolean) => SvelteQueryBuilder<T>;
+  readonly sortBy: (field: string) => SvelteQueryBuilder<T>;
+  readonly reverse: () => SvelteQueryBuilder<T>;
+  readonly offset: (n: number) => SvelteQueryBuilder<T>;
+  readonly limit: (n: number) => SvelteQueryBuilder<T>;
+  readonly get: () => Promise<ReadonlyArray<T>>;
+  readonly first: () => Promise<T | null>;
+  readonly count: () => Promise<number>;
+  readonly live: () => LiveQuery<T>;
+}
+
+export interface SvelteWhereClause<T> {
+  readonly equals: (value: string | number | boolean) => SvelteQueryBuilder<T>;
+  readonly above: (value: number) => SvelteQueryBuilder<T>;
+  readonly aboveOrEqual: (value: number) => SvelteQueryBuilder<T>;
+  readonly below: (value: number) => SvelteQueryBuilder<T>;
+  readonly belowOrEqual: (value: number) => SvelteQueryBuilder<T>;
+  readonly between: (
+    lower: number,
+    upper: number,
+    options?: { includeLower?: boolean; includeUpper?: boolean },
+  ) => SvelteQueryBuilder<T>;
+  readonly startsWith: (prefix: string) => SvelteQueryBuilder<T>;
+  readonly anyOf: (values: ReadonlyArray<string | number | boolean>) => SvelteQueryBuilder<T>;
+  readonly noneOf: (values: ReadonlyArray<string | number | boolean>) => SvelteQueryBuilder<T>;
+}
+
+export interface SvelteOrderByBuilder<T> {
+  readonly reverse: () => SvelteOrderByBuilder<T>;
+  readonly offset: (n: number) => SvelteOrderByBuilder<T>;
+  readonly limit: (n: number) => SvelteOrderByBuilder<T>;
+  readonly get: () => Promise<ReadonlyArray<T>>;
+  readonly first: () => Promise<T | null>;
+  readonly count: () => Promise<number>;
+  readonly live: () => LiveQuery<T>;
+}
+
+function wrapQueryBuilder<T>(
+  builder: QueryBuilder<T>,
+  onLive?: OnLiveCallback,
+): SvelteQueryBuilder<T> {
+  return {
+    and: (fn) => wrapQueryBuilder(builder.and(fn), onLive),
+    sortBy: (field) => wrapQueryBuilder(builder.sortBy(field), onLive),
+    reverse: () => wrapQueryBuilder(builder.reverse(), onLive),
+    offset: (n) => wrapQueryBuilder(builder.offset(n), onLive),
+    limit: (n) => wrapQueryBuilder(builder.limit(n), onLive),
+    get: () => Effect.runPromise(builder.get()),
+    first: () => Effect.runPromise(builder.first()),
+    count: () => Effect.runPromise(builder.count()),
+    live: () => {
+      const lq = new LiveQuery(builder.watch());
+      onLive?.(lq as LiveQuery<unknown>);
+      return lq;
+    },
+  };
+}
+
+export function wrapWhereClause<T>(
+  clause: WhereClause<T>,
+  onLive?: OnLiveCallback,
+): SvelteWhereClause<T> {
+  return {
+    equals: (value) => wrapQueryBuilder(clause.equals(value), onLive),
+    above: (value) => wrapQueryBuilder(clause.above(value), onLive),
+    aboveOrEqual: (value) => wrapQueryBuilder(clause.aboveOrEqual(value), onLive),
+    below: (value) => wrapQueryBuilder(clause.below(value), onLive),
+    belowOrEqual: (value) => wrapQueryBuilder(clause.belowOrEqual(value), onLive),
+    between: (lower, upper, options) =>
+      wrapQueryBuilder(clause.between(lower, upper, options), onLive),
+    startsWith: (prefix) => wrapQueryBuilder(clause.startsWith(prefix), onLive),
+    anyOf: (values) => wrapQueryBuilder(clause.anyOf(values), onLive),
+    noneOf: (values) => wrapQueryBuilder(clause.noneOf(values), onLive),
+  };
+}
+
+export function wrapOrderByBuilder<T>(
+  builder: OrderByBuilder<T>,
+  onLive?: OnLiveCallback,
+): SvelteOrderByBuilder<T> {
+  return {
+    reverse: () => wrapOrderByBuilder(builder.reverse(), onLive),
+    offset: (n) => wrapOrderByBuilder(builder.offset(n), onLive),
+    limit: (n) => wrapOrderByBuilder(builder.limit(n), onLive),
+    get: () => Effect.runPromise(builder.get()),
+    first: () => Effect.runPromise(builder.first()),
+    count: () => Effect.runPromise(builder.count()),
+    live: () => {
+      const lq = new LiveQuery(builder.watch());
+      onLive?.(lq as LiveQuery<unknown>);
+      return lq;
+    },
+  };
+}

package/src/sync/gift-wrap.ts

@@ -0,0 +1,33 @@
+import { Effect } from "effect";
+import { wrapEvent, unwrapEvent, type Rumor } from "nostr-tools/nip59";
+import type { NostrEvent, UnsignedEvent } from "nostr-tools/pure";
+import { CryptoError } from "../errors.ts";
+
+export interface GiftWrapHandle {
+  readonly wrap: (rumor: Partial<UnsignedEvent>) => Effect.Effect<NostrEvent, CryptoError>;
+  readonly unwrap: (giftWrap: NostrEvent) => Effect.Effect<Rumor, CryptoError>;
+}
+
+export function createGiftWrapHandle(privateKey: Uint8Array, publicKey: string): GiftWrapHandle {
+  return {
+    wrap: (rumor) =>
+      Effect.try({
+        try: () => wrapEvent(rumor, privateKey, publicKey),
+        catch: (e) =>
+          new CryptoError({
+            message: `Gift wrap failed: ${e instanceof Error ? e.message : String(e)}`,
+            cause: e,
+          }),
+      }),
+
+    unwrap: (giftWrap) =>
+      Effect.try({
+        try: () => unwrapEvent(giftWrap, privateKey),
+        catch: (e) =>
+          new CryptoError({
+            message: `Gift unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
+            cause: e,
+          }),
+      }),
+  };
+}

package/src/sync/negentropy.ts

@@ -0,0 +1,83 @@
+import { Effect } from "effect";
+// @ts-expect-error -- vendored JS without types
+import { Negentropy, NegentropyStorageVector } from "../vendor/negentropy.js";
+import type { IDBStorageHandle } from "../storage/idb.ts";
+import type { RelayHandle } from "./relay.ts";
+import type { Filter } from "nostr-tools/filter";
+import { SyncError, RelayError, StorageError } from "../errors.ts";
+
+export interface ReconcileResult {
+  readonly haveIds: string[];
+  readonly needIds: string[];
+}
+
+function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+export function reconcileWithRelay(
+  storage: IDBStorageHandle,
+  relay: RelayHandle,
+  relayUrl: string,
+  publicKey: string,
+): Effect.Effect<ReconcileResult, SyncError | RelayError | StorageError> {
+  return Effect.gen(function* () {
+    const allGiftWraps = yield* storage.getAllGiftWraps();
+
+    const storageVector = new NegentropyStorageVector();
+    for (const gw of allGiftWraps) {
+      storageVector.insert(gw.createdAt, hexToBytes(gw.id));
+    }
+    storageVector.seal();
+
+    const neg = new Negentropy(storageVector, 0);
+
+    const filter: Filter = {
+      kinds: [1059],
+      "#p": [publicKey],
+    };
+
+    const allHaveIds: string[] = [];
+    const allNeedIds: string[] = [];
+    const subId = `neg-${Date.now()}`;
+
+    const initialMsg: string = yield* Effect.tryPromise({
+      try: () => neg.initiate(),
+      catch: (e) =>
+        new SyncError({
+          message: `Negentropy initiate failed: ${e instanceof Error ? e.message : String(e)}`,
+          phase: "negotiate",
+          cause: e,
+        }),
+    });
+
+    let currentMsg: string | null = initialMsg;
+
+    while (currentMsg !== null) {
+      const response = yield* relay.sendNegMsg(relayUrl, subId, filter, currentMsg);
+
+      if (response.msgHex === null) break;
+
+      const reconcileResult: [string | null, string[], string[]] = yield* Effect.tryPromise({
+        try: () => neg.reconcile(response.msgHex),
+        catch: (e) =>
+          new SyncError({
+            message: `Negentropy reconcile failed: ${e instanceof Error ? e.message : String(e)}`,
+            phase: "negotiate",
+            cause: e,
+          }),
+      });
+
+      const [nextMsg, haveIds, needIds] = reconcileResult;
+      for (const id of haveIds) allHaveIds.push(id);
+      for (const id of needIds) allNeedIds.push(id);
+      currentMsg = nextMsg;
+    }
+
+    return { haveIds: allHaveIds, needIds: allNeedIds };
+  });
+}

package/src/sync/publish-queue.ts

@@ -0,0 +1,61 @@
+import { Effect, Ref } from "effect";
+import type { IDBStorageHandle } from "../storage/idb.ts";
+import type { RelayHandle } from "./relay.ts";
+import type { NostrEvent } from "nostr-tools/pure";
+import type { RelayError, StorageError } from "../errors.ts";
+
+export interface PublishQueueHandle {
+  readonly enqueue: (eventId: string) => Effect.Effect<void>;
+  readonly flush: (relayUrls: readonly string[]) => Effect.Effect<void, RelayError | StorageError>;
+  readonly size: () => Effect.Effect<number>;
+}
+
+export function createPublishQueue(
+  storage: IDBStorageHandle,
+  relay: RelayHandle,
+): Effect.Effect<PublishQueueHandle> {
+  return Effect.gen(function* () {
+    const pendingRef = yield* Ref.make<Set<string>>(new Set());
+
+    return {
+      enqueue: (eventId) =>
+        Ref.update(pendingRef, (set) => {
+          const next = new Set(set);
+          next.add(eventId);
+          return next;
+        }),
+
+      flush: (relayUrls) =>
+        Effect.gen(function* () {
+          const pending = yield* Ref.get(pendingRef);
+          if (pending.size === 0) return;
+
+          const succeeded = new Set<string>();
+
+          for (const eventId of pending) {
+            const gw = yield* storage.getGiftWrap(eventId);
+            if (!gw) {
+              succeeded.add(eventId);
+              continue;
+            }
+            const result = yield* Effect.result(
+              relay.publish(gw.event as unknown as NostrEvent, relayUrls),
+            );
+            if (result._tag === "Success") {
+              succeeded.add(eventId);
+            }
+          }
+
+          yield* Ref.update(pendingRef, (set) => {
+            const next = new Set(set);
+            for (const id of succeeded) {
+              next.delete(id);
+            }
+            return next;
+          });
+        }),
+
+      size: () => Ref.get(pendingRef).pipe(Effect.map((s) => s.size)),
+    };
+  });
+}