tablinum 0.1.3 → 0.4.0

package/dist/svelte/query.svelte.d.ts

@@ -1,6 +1,4 @@
 import type { WhereClause, 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>;
@@ -10,7 +8,6 @@ export interface 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>;
@@ -33,7 +30,10 @@ export interface SvelteOrderByBuilder<T> {
     readonly get: () => Promise<ReadonlyArray<T>>;
     readonly first: () => Promise<T | null>;
     readonly count: () => Promise<number>;
-    readonly live: () => LiveQuery<T>;
 }
-export declare function wrapWhereClause<T>(clause: WhereClause<T>, onLive?: OnLiveCallback): SvelteWhereClause<T>;
-export declare function wrapOrderByBuilder<T>(builder: OrderByBuilder<T>, onLive?: OnLiveCallback): SvelteOrderByBuilder<T>;
+type TouchVersion = () => void;
+type WhereFactory<T> = () => WhereClause<T>;
+type OrderByFactory<T> = () => OrderByBuilder<T>;
+export declare function wrapWhereClause<T>(getClause: WhereFactory<T>, touchVersion: TouchVersion, ready: Promise<void>): SvelteWhereClause<T>;
+export declare function wrapOrderByBuilder<T>(getBuilder: OrderByFactory<T>, touchVersion: TouchVersion, ready: Promise<void>): SvelteOrderByBuilder<T>;
+export {};

package/dist/svelte/tablinum.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { SchemaConfig } from "../schema/types.ts";
+import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+import type { SyncStatus } from "../db/database-handle.ts";
+import type { RelayStatus } from "../sync/relay.ts";
+import type { Invite } from "../db/invite.ts";
+import type { MemberRecord, AuthorProfile } from "../db/members.ts";
+import { type TablinumConfig } from "../db/create-tablinum.ts";
+import { Collection } from "./collection.svelte.ts";
+export declare class Tablinum<S extends SchemaConfig> {
+    #private;
+    status: "initializing" | "ready" | "error" | "closed";
+    syncStatus: SyncStatus;
+    pendingCount: number;
+    relayStatus: RelayStatus;
+    error: Error | null;
+    readonly ready: Promise<void>;
+    constructor(config: TablinumConfig<S>);
+    get publicKey(): string;
+    get members(): Collection<CollectionDef<CollectionFields>>;
+    collection<K extends string & keyof S>(name: K): Collection<S[K]>;
+    exportKey(): string;
+    exportInvite(): Invite;
+    close: () => Promise<void>;
+    sync: () => Promise<void>;
+    rebuild: () => Promise<void>;
+    addMember: (pubkey: string) => Promise<void>;
+    removeMember: (pubkey: string) => Promise<void>;
+    getMembers: () => Promise<ReadonlyArray<MemberRecord>>;
+    getProfile: () => Promise<AuthorProfile>;
+    setProfile: (profile: {
+        name?: string;
+        picture?: string;
+        about?: string;
+        nip05?: string;
+    }) => Promise<void>;
+}

package/dist/sync/gift-wrap.d.ts

@@ -1,9 +1,13 @@
 import { Effect } from "effect";
-import { type Rumor } from "nostr-tools/nip59";
+import { unwrapEvent } from "nostr-tools/nip59";
 import type { NostrEvent, UnsignedEvent } from "nostr-tools/pure";
 import { CryptoError } from "../errors.ts";
+import type { EpochStore } from "../db/epoch.ts";
+type Rumor = ReturnType<typeof unwrapEvent>;
 export interface GiftWrapHandle {
     readonly wrap: (rumor: Partial<UnsignedEvent>) => Effect.Effect<NostrEvent, CryptoError>;
     readonly unwrap: (giftWrap: NostrEvent) => Effect.Effect<Rumor, CryptoError>;
 }
-export declare function createGiftWrapHandle(privateKey: Uint8Array, publicKey: string): GiftWrapHandle;
+export declare function createGiftWrapHandle(senderPrivateKey: Uint8Array, recipientPublicKey: string, decryptionPrivateKey: Uint8Array): GiftWrapHandle;
+export declare function createEpochGiftWrapHandle(senderPrivateKey: Uint8Array, epochStore: EpochStore): GiftWrapHandle;
+export {};

package/dist/sync/negentropy.d.ts

@@ -6,4 +6,4 @@ export interface ReconcileResult {
     readonly haveIds: string[];
     readonly needIds: string[];
 }
-export declare function reconcileWithRelay(storage: IDBStorageHandle, relay: RelayHandle, relayUrl: string, publicKey: string): Effect.Effect<ReconcileResult, SyncError | RelayError | StorageError>;
+export declare function reconcileWithRelay(storage: IDBStorageHandle, relay: RelayHandle, relayUrl: string, publicKeys: string | string[]): Effect.Effect<ReconcileResult, SyncError | RelayError | StorageError>;

package/dist/sync/publish-queue.d.ts

@@ -3,8 +3,9 @@ import type { IDBStorageHandle } from "../storage/idb.ts";
 import type { RelayHandle } from "./relay.ts";
 import type { RelayError, StorageError } from "../errors.ts";
 export interface PublishQueueHandle {
-    readonly enqueue: (eventId: string) => Effect.Effect<void>;
+    readonly enqueue: (eventId: string) => Effect.Effect<void, StorageError>;
     readonly flush: (relayUrls: readonly string[]) => Effect.Effect<void, RelayError | StorageError>;
     readonly size: () => Effect.Effect<number>;
+    readonly subscribe: (callback: (count: number) => void) => () => void;
 }
-export declare function createPublishQueue(storage: IDBStorageHandle, relay: RelayHandle): Effect.Effect<PublishQueueHandle>;
+export declare function createPublishQueue(storage: IDBStorageHandle, relay: RelayHandle): Effect.Effect<PublishQueueHandle, StorageError>;

package/dist/sync/relay.d.ts

@@ -1,7 +1,10 @@
-import { Effect } from "effect";
+import { Effect, Option, Scope } from "effect";
 import type { NostrEvent } from "nostr-tools/pure";
 import type { Filter } from "nostr-tools/filter";
 import { RelayError } from "../errors.ts";
+export interface RelayStatus {
+    readonly connectedUrls: ReadonlyArray<string>;
+}
 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>;
@@ -13,5 +16,9 @@ export interface RelayHandle {
         needIds: string[];
     }, RelayError>;
     readonly closeAll: () => Effect.Effect<void>;
+    readonly getStatus: () => RelayStatus;
+    readonly subscribeStatus: (callback: (status: RelayStatus) => void) => () => void;
 }
-export declare function createRelayHandle(): RelayHandle;
+export type NegFrame = readonly ["NEG-MSG", string, string] | readonly ["NEG-ERR", string, string];
+export declare function parseNegMessageFrame(data: string): Option.Option<NegFrame>;
+export declare function createRelayHandle(): Effect.Effect<RelayHandle, never, Scope.Scope>;

package/dist/sync/sync-service.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Scope } from "effect";
 import type { IDBStorageHandle, StoredGiftWrap } from "../storage/idb.ts";
 import type { GiftWrapHandle } from "./gift-wrap.ts";
 import type { RelayHandle } from "./relay.ts";
@@ -6,9 +6,12 @@ import type { PublishQueueHandle } from "./publish-queue.ts";
 import type { SyncStatusHandle } from "./sync-status.ts";
 import type { WatchContext } from "../crud/watch.ts";
 import { CryptoError, RelayError, StorageError, SyncError } from "../errors.ts";
+import type { EpochStore } from "../db/epoch.ts";
+import type { RemovalNotice } from "../db/key-rotation.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>;
+    readonly addEpochSubscription: (publicKey: string) => Effect.Effect<void>;
 }
-export declare 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;
+export declare function createSyncHandle(storage: IDBStorageHandle, giftWrapHandle: GiftWrapHandle, relay: RelayHandle, publishQueue: PublishQueueHandle, syncStatus: SyncStatusHandle, watchCtx: WatchContext, relayUrls: readonly string[], knownCollections: ReadonlyMap<string, number>, epochStore: EpochStore, personalPrivateKey: Uint8Array, personalPublicKey: string, scope: Scope.Scope, onSyncError?: ((error: unknown) => void) | undefined, onNewAuthor?: ((pubkey: string) => void) | undefined, onRemoved?: ((notice: RemovalNotice) => void) | undefined, onMembersChanged?: (() => void) | undefined): SyncHandle;

package/dist/sync/sync-status.d.ts

@@ -3,5 +3,6 @@ import type { SyncStatus } from "../db/database-handle.ts";
 export interface SyncStatusHandle {
     readonly get: () => Effect.Effect<SyncStatus>;
     readonly set: (status: SyncStatus) => Effect.Effect<void>;
+    readonly subscribe: (callback: (status: SyncStatus) => void) => () => void;
 }
 export declare function createSyncStatusHandle(): Effect.Effect<SyncStatusHandle>;

package/dist/utils/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function deepDiff(before: Record<string, unknown>, after: Record<string, unknown>): Record<string, unknown> | null;
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;

package/dist/utils/uuid.d.ts

@@ -1,2 +1 @@
-/** Generate a UUIDv7 (time-sortable) using crypto.getRandomValues. */
 export declare function uuidv7(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tablinum",
-  "version": "0.1.3",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kevmodrome/tablinum.git"
@@ -35,7 +35,10 @@
     "build": "bun build src/index.ts --outdir dist --format esm --packages external && bun build src/svelte/index.svelte.ts --outdir dist/svelte --format esm --packages external && tsc -p tsconfig.build.json --noCheck && tsc -p tsconfig.build.svelte.json --noCheck",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "changeset publish"
+    "release": "changeset publish",
+    "relays": "docker compose up -d",
+    "relays:down": "docker compose down",
+    "relays:clean": "docker compose down -v"
   },
   "dependencies": {
     "@noble/curves": "^2.0.1",
@@ -46,13 +49,13 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
-    "@effect/vitest": "4.0.0-beta.28",
-    "@j178/prek": "latest",
+    "@effect/vitest": "4.0.0-beta.31",
+    "@j178/prek": "0.3.5",
     "@types/bun": "^1.3.10",
     "fake-indexeddb": "^6.2.5",
-    "oxfmt": "latest",
-    "oxlint": "^1.51.0",
-    "svelte": "^5.0.0",
+    "oxfmt": "0.38.0",
+    "oxlint": "^1.53.0",
+    "svelte": "^5.53.10",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   },

package/dist/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/storage/events-store.d.ts

@@ -1,6 +0,0 @@
-import { Effect } from "effect";
-import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
-import type { StorageError } from "../errors.ts";
-export declare function putEvent(storage: IDBStorageHandle, event: StoredEvent): Effect.Effect<void, StorageError>;
-export declare function getEventsByRecord(storage: IDBStorageHandle, collection: string, recordId: string): Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
-export declare function getAllEvents(storage: IDBStorageHandle): Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;

package/dist/storage/giftwraps-store.d.ts

@@ -1,6 +0,0 @@
-import { Effect } from "effect";
-import type { IDBStorageHandle, StoredGiftWrap } from "./idb.ts";
-import type { StorageError } from "../errors.ts";
-export declare function putGiftWrap(storage: IDBStorageHandle, gw: StoredGiftWrap): Effect.Effect<void, StorageError>;
-export declare function getGiftWrap(storage: IDBStorageHandle, id: string): Effect.Effect<StoredGiftWrap | undefined, StorageError>;
-export declare function getAllGiftWraps(storage: IDBStorageHandle): Effect.Effect<ReadonlyArray<StoredGiftWrap>, StorageError>;

package/dist/svelte/database.svelte.d.ts

@@ -1,15 +0,0 @@
-import { Scope } from "effect";
-import type { SchemaConfig } from "../schema/types.ts";
-import type { DatabaseHandle } from "../db/database-handle.ts";
-import { Collection } from "./collection.svelte.ts";
-export declare class Database<S extends SchemaConfig> {
-    #private;
-    status: any;
-    error: any;
-    constructor(handle: DatabaseHandle<S>, scope: Scope.Closeable);
-    collection<K extends string & keyof S>(name: K): Collection<S[K]>;
-    exportKey(): string;
-    close: () => Promise<void>;
-    sync: () => Promise<void>;
-    rebuild: () => Promise<void>;
-}

package/dist/svelte/live-query.svelte.d.ts

@@ -1,8 +0,0 @@
-import { Stream } from "effect";
-export declare class LiveQuery<T> {
-    #private;
-    items: any;
-    error: any;
-    constructor(stream: Stream.Stream<ReadonlyArray<T>, unknown>);
-    destroy(): void;
-}