tablinum 0.0.1

package/src/sync/relay.ts

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

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

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

@@ -0,0 +1,22 @@
+/** 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)}`;
+}