tablinum 0.0.1 → 0.1.1

package/src/sync/gift-wrap.ts

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

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

@@ -1,61 +0,0 @@
-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)),
-    };
-  });
-}

package/src/sync/relay.ts

@@ -1,239 +0,0 @@
-import { Effect } from "effect";
-import { Relay } from "nostr-tools/relay";
-import type { NostrEvent } from "nostr-tools/pure";
-import type { Filter } from "nostr-tools/filter";
-import { RelayError } from "../errors.ts";
-
-export interface RelayHandle {
-  readonly publish: (event: NostrEvent, urls: readonly string[]) => Effect.Effect<void, RelayError>;
-  readonly fetchEvents: (
-    ids: readonly string[],
-    url: string,
-  ) => Effect.Effect<NostrEvent[], RelayError>;
-  readonly fetchByFilter: (filter: Filter, url: string) => Effect.Effect<NostrEvent[], RelayError>;
-  readonly subscribe: (
-    filter: Filter,
-    url: string,
-    onEvent: (event: NostrEvent) => void,
-  ) => Effect.Effect<void, RelayError>;
-  readonly sendNegMsg: (
-    url: string,
-    subId: string,
-    filter: Filter,
-    msgHex: string,
-  ) => Effect.Effect<{ msgHex: string | null; haveIds: string[]; needIds: string[] }, RelayError>;
-  readonly closeAll: () => Effect.Effect<void>;
-}
-
-export function createRelayHandle(): RelayHandle {
-  const connections = new Map<string, Relay>();
-
-  const getRelay = (url: string): Effect.Effect<Relay, RelayError> =>
-    Effect.tryPromise({
-      try: async () => {
-        const existing = connections.get(url);
-        if (existing && (existing as any).connected !== false) {
-          return existing;
-        }
-        // Clean up stale entry
-        connections.delete(url);
-        const relay = await Relay.connect(url);
-        connections.set(url, relay);
-        return relay;
-      },
-      catch: (e) =>
-        new RelayError({
-          message: `Connect to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-          url,
-          cause: e,
-        }),
-    });
-
-  return {
-    publish: (event, urls) =>
-      Effect.gen(function* () {
-        const errors: Array<{ url: string; error: unknown }> = [];
-        for (const url of urls) {
-          const result = yield* Effect.result(
-            Effect.gen(function* () {
-              const relay = yield* getRelay(url);
-              yield* Effect.tryPromise({
-                try: () => relay.publish(event),
-                catch: (e) => {
-                  // Connection may be stale, remove so next attempt reconnects
-                  connections.delete(url);
-                  return new RelayError({
-                    message: `Publish to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-                    url,
-                    cause: e,
-                  });
-                },
-              });
-            }),
-          );
-          if (result._tag === "Failure") {
-            errors.push({ url, error: result });
-          }
-        }
-        if (errors.length === urls.length && urls.length > 0) {
-          return yield* new RelayError({
-            message: `Publish failed on all ${urls.length} relays`,
-          });
-        }
-      }),
-
-    fetchEvents: (ids, url) =>
-      Effect.gen(function* () {
-        if (ids.length === 0) return [] as NostrEvent[];
-        const relay = yield* getRelay(url);
-        return yield* Effect.tryPromise({
-          try: () =>
-            new Promise<NostrEvent[]>((resolve) => {
-              const events: NostrEvent[] = [];
-              const timer = setTimeout(() => {
-                sub.close();
-                resolve(events);
-              }, 10000);
-              const sub = relay.subscribe([{ ids: ids as string[] }], {
-                onevent(evt: NostrEvent) {
-                  events.push(evt);
-                },
-                oneose() {
-                  clearTimeout(timer);
-                  sub.close();
-                  resolve(events);
-                },
-              });
-            }),
-          catch: (e) => {
-            connections.delete(url);
-            return new RelayError({
-              message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-              url,
-              cause: e,
-            });
-          },
-        });
-      }),
-
-    fetchByFilter: (filter, url) =>
-      Effect.gen(function* () {
-        const relay = yield* getRelay(url);
-        return yield* Effect.tryPromise({
-          try: () =>
-            new Promise<NostrEvent[]>((resolve) => {
-              const events: NostrEvent[] = [];
-              const timer = setTimeout(() => {
-                sub.close();
-                resolve(events);
-              }, 10000);
-              const sub = relay.subscribe([filter], {
-                onevent(evt: NostrEvent) {
-                  events.push(evt);
-                },
-                oneose() {
-                  clearTimeout(timer);
-                  sub.close();
-                  resolve(events);
-                },
-              });
-            }),
-          catch: (e) => {
-            connections.delete(url);
-            return new RelayError({
-              message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-              url,
-              cause: e,
-            });
-          },
-        });
-      }),
-
-    subscribe: (filter, url, onEvent) =>
-      Effect.gen(function* () {
-        const relay = yield* getRelay(url);
-        relay.subscribe([filter], {
-          onevent(evt: NostrEvent) {
-            onEvent(evt);
-          },
-          oneose() {
-            // Initial fetch complete, keep subscription open for real-time
-          },
-        });
-      }),
-
-    sendNegMsg: (url, subId, filter, msgHex) =>
-      Effect.gen(function* () {
-        const relay = yield* getRelay(url);
-        return yield* Effect.tryPromise({
-          try: () =>
-            new Promise<{
-              msgHex: string | null;
-              haveIds: string[];
-              needIds: string[];
-            }>((resolve, reject) => {
-              const timer = setTimeout(() => {
-                reject(new Error("NIP-77 negotiation timeout"));
-              }, 30000);
-
-              const sub = relay.subscribe([filter], {
-                onevent() {},
-                oneose() {},
-              });
-
-              // Use raw WebSocket for NIP-77
-              const ws = (relay as any)._ws || (relay as any).ws;
-              if (!ws) {
-                clearTimeout(timer);
-                sub.close();
-                reject(new Error("Cannot access relay WebSocket"));
-                return;
-              }
-
-              const handler = (msg: MessageEvent) => {
-                try {
-                  const data = JSON.parse(typeof msg.data === "string" ? msg.data : "");
-                  if (!Array.isArray(data)) return;
-                  if (data[0] === "NEG-MSG" && data[1] === subId) {
-                    clearTimeout(timer);
-                    sub.close();
-                    resolve({
-                      msgHex: data[2] as string,
-                      haveIds: [],
-                      needIds: [],
-                    });
-                    ws.removeEventListener("message", handler);
-                  } else if (data[0] === "NEG-ERR" && data[1] === subId) {
-                    clearTimeout(timer);
-                    sub.close();
-                    reject(new Error(`NEG-ERR: ${data[2]}`));
-                    ws.removeEventListener("message", handler);
-                  }
-                } catch {
-                  // ignore parse errors
-                }
-              };
-
-              ws.addEventListener("message", handler);
-              ws.send(JSON.stringify(["NEG-OPEN", subId, filter, msgHex]));
-            }),
-          catch: (e) => {
-            connections.delete(url);
-            return new RelayError({
-              message: `NIP-77 negotiation with ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-              url,
-              cause: e,
-            });
-          },
-        });
-      }),
-
-    closeAll: () =>
-      Effect.sync(() => {
-        for (const [url, relay] of connections) {
-          relay.close();
-          connections.delete(url);
-        }
-      }),
-  };
-}

package/src/sync/sync-service.ts

@@ -1,183 +0,0 @@
-import { Effect, Ref } from "effect";
-import type { NostrEvent } from "nostr-tools/pure";
-import type { IDBStorageHandle, StoredEvent, StoredGiftWrap } from "../storage/idb.ts";
-import { applyEvent } from "../storage/records-store.ts";
-import type { GiftWrapHandle } from "./gift-wrap.ts";
-import type { RelayHandle } from "./relay.ts";
-import type { PublishQueueHandle } from "./publish-queue.ts";
-import type { SyncStatusHandle } from "./sync-status.ts";
-import { reconcileWithRelay } from "./negentropy.ts";
-import type { WatchContext } from "../crud/watch.ts";
-import { notifyChange, notifyReplayComplete } from "../crud/watch.ts";
-import { CryptoError, RelayError, StorageError, SyncError } from "../errors.ts";
-
-export interface SyncHandle {
-  readonly sync: () => Effect.Effect<void, SyncError | RelayError | CryptoError | StorageError>;
-  readonly publishLocal: (giftWrap: StoredGiftWrap) => Effect.Effect<void>;
-  readonly startSubscription: () => Effect.Effect<void>;
-}
-
-export function createSyncHandle(
-  storage: IDBStorageHandle,
-  giftWrapHandle: GiftWrapHandle,
-  relay: RelayHandle,
-  publishQueue: PublishQueueHandle,
-  syncStatus: SyncStatusHandle,
-  watchCtx: WatchContext,
-  relayUrls: readonly string[],
-  publicKey: string,
-  onSyncError?: ((error: unknown) => void) | undefined,
-): SyncHandle {
-  // Process a single remote gift wrap: store, unwrap, apply event
-  const processGiftWrap = (
-    remoteGw: NostrEvent,
-  ): Effect.Effect<string | null, StorageError | CryptoError> =>
-    Effect.gen(function* () {
-      // Skip if we already have this gift wrap
-      const existing = yield* storage.getGiftWrap(remoteGw.id);
-      if (existing) return null;
-
-      // Store gift wrap
-      yield* storage.putGiftWrap({
-        id: remoteGw.id,
-        event: remoteGw as unknown as Record<string, unknown>,
-        createdAt: remoteGw.created_at,
-      });
-
-      // Unwrap to get rumor
-      const unwrapResult = yield* Effect.result(giftWrapHandle.unwrap(remoteGw));
-      if (unwrapResult._tag === "Failure") return null;
-
-      const rumor = unwrapResult.success;
-
-      // Parse the rumor content and d-tag
-      const dTag = rumor.tags.find((t: string[]) => t[0] === "d")?.[1];
-      if (!dTag) return null;
-
-      const colonIdx = dTag.indexOf(":");
-      if (colonIdx === -1) return null;
-
-      const collectionName = dTag.substring(0, colonIdx);
-      const recordId = dTag.substring(colonIdx + 1);
-
-      let data: Record<string, unknown> | null = null;
-      let kind: "create" | "update" | "delete" = "update";
-
-      try {
-        const parsed = JSON.parse(rumor.content);
-        if (parsed === null || parsed._deleted) {
-          kind = "delete";
-        } else {
-          data = parsed;
-        }
-      } catch {
-        return null;
-      }
-
-      const event: StoredEvent = {
-        id: rumor.id,
-        collection: collectionName,
-        recordId,
-        kind,
-        data,
-        createdAt: rumor.created_at * 1000,
-      };
-
-      yield* storage.putEvent(event);
-      yield* applyEvent(storage, event);
-      return collectionName;
-    });
-
-  return {
-    sync: () =>
-      Effect.gen(function* () {
-        yield* syncStatus.set("syncing");
-        yield* Ref.set(watchCtx.replayingRef, true);
-
-        const changedCollections = new Set<string>();
-
-        try {
-          for (const url of relayUrls) {
-            const reconcileResult = yield* Effect.result(
-              reconcileWithRelay(storage, relay, url, publicKey),
-            );
-
-            if (reconcileResult._tag === "Failure") continue;
-
-            const { haveIds, needIds } = reconcileResult.success;
-
-            // Download missing gift wraps
-            if (needIds.length > 0) {
-              const fetchResult = yield* Effect.result(relay.fetchEvents(needIds, url));
-
-              if (fetchResult._tag === "Success") {
-                for (const remoteGw of fetchResult.success) {
-                  const result = yield* Effect.result(processGiftWrap(remoteGw));
-                  if (result._tag === "Success" && result.success) {
-                    changedCollections.add(result.success);
-                  }
-                }
-              }
-            }
-
-            // Upload gift wraps the relay is missing
-            if (haveIds.length > 0) {
-              for (const id of haveIds) {
-                const gw = yield* storage.getGiftWrap(id);
-                if (gw) {
-                  yield* Effect.result(relay.publish(gw.event as unknown as NostrEvent, [url]));
-                }
-              }
-            }
-          }
-
-          // Flush pending publications
-          yield* Effect.result(publishQueue.flush(relayUrls));
-        } finally {
-          yield* notifyReplayComplete(watchCtx, [...changedCollections]);
-          yield* syncStatus.set("idle");
-        }
-      }),
-
-    publishLocal: (giftWrap) =>
-      Effect.gen(function* () {
-        const result = yield* Effect.result(
-          relay.publish(giftWrap.event as unknown as NostrEvent, relayUrls),
-        );
-        if (result._tag === "Failure") {
-          yield* publishQueue.enqueue(giftWrap.id);
-          console.error("[localstr:publishLocal] relay error:", result.failure);
-          if (onSyncError) onSyncError(result.failure);
-        }
-      }),
-
-    startSubscription: () =>
-      Effect.gen(function* () {
-        for (const url of relayUrls) {
-          const subResult = yield* Effect.result(
-            relay.subscribe({ kinds: [1059], "#p": [publicKey] }, url, (evt: NostrEvent) => {
-              // Process incoming gift wrap in a fire-and-forget fiber
-              Effect.runFork(
-                Effect.gen(function* () {
-                  const result = yield* Effect.result(processGiftWrap(evt));
-                  if (result._tag === "Success" && result.success) {
-                    yield* notifyChange(watchCtx, {
-                      collection: result.success,
-                      recordId: "",
-                      kind: "create",
-                    });
-                  }
-                }),
-              );
-            }),
-          );
-          if (subResult._tag === "Failure") {
-            console.error("[localstr:subscribe] failed for", url, subResult.failure);
-            if (onSyncError) onSyncError(subResult.failure);
-          } else {
-            console.log("[localstr:subscribe] listening on", url);
-          }
-        }
-      }),
-  };
-}

package/src/sync/sync-status.ts

@@ -1,17 +0,0 @@
-import { Effect, SubscriptionRef } from "effect";
-import type { SyncStatus } from "../db/database-handle.ts";
-
-export interface SyncStatusHandle {
-  readonly get: () => Effect.Effect<SyncStatus>;
-  readonly set: (status: SyncStatus) => Effect.Effect<void>;
-}
-
-export function createSyncStatusHandle(): Effect.Effect<SyncStatusHandle> {
-  return Effect.gen(function* () {
-    const ref = yield* SubscriptionRef.make<SyncStatus>("idle");
-    return {
-      get: () => SubscriptionRef.get(ref),
-      set: (status: SyncStatus) => SubscriptionRef.set(ref, status),
-    };
-  });
-}

package/src/utils/uuid.ts

@@ -1,22 +0,0 @@
-/** Generate a UUIDv7 (time-sortable) using crypto.getRandomValues. */
-export function uuidv7(): string {
-  const now = Date.now();
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-
-  // Timestamp: 48 bits in bytes 0-5
-  bytes[0] = (now / 2 ** 40) & 0xff;
-  bytes[1] = (now / 2 ** 32) & 0xff;
-  bytes[2] = (now / 2 ** 24) & 0xff;
-  bytes[3] = (now / 2 ** 16) & 0xff;
-  bytes[4] = (now / 2 ** 8) & 0xff;
-  bytes[5] = now & 0xff;
-
-  // Version 7: set bits 0111 in byte 6 high nibble
-  bytes[6] = (bytes[6]! & 0x0f) | 0x70;
-  // Variant 10: set bits 10 in byte 8 high 2 bits
-  bytes[8] = (bytes[8]! & 0x3f) | 0x80;
-
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}