@sqlite-sync/core 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,20 +1,23 @@
-import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, C as CrdtEventType, a as CrdtEventOrigin, P as PersistedCrdtEvent, E as EventsPushRequest, b as EventsPushResponse, c as ExecuteParams, d as ExecuteResult, e as EventsPullRequest, f as EventsPullResponse, g as TypedBroadcastChannel } from './crdt-sync-remote-source-rrqinqLn.js';
-export { q as CrdtEventStatus, m as CrdtStorage, o as CrdtSyncRemoteSource, s as CrdtUpdateLogItem, t as CrdtUpdateLogPayload, R as DatabaseIntrospection, G as DeferredPromise, H as DistributiveOmit, K as KyselyQueryFactory, J as LogLevel, M as MetaItem, k as PendingCrdtEvent, h as PreparedStatement, Q as QueryBuilderOutput, i as SQLiteTransactionWrapper, v as SyncIdCounter, O as TableMetadata, j as applyCrdtEventMutations, p as crdtSchema, B as createAsyncAutoFlushBuffer, A as createAutoFlushBuffer, l as createCrdtStorage, n as createCrdtSyncRemoteSource, x as createDeferredPromise, u as createSyncIdCounter, D as createTypedEventTarget, y as ensureSingletonExecution, w as generateId, N as introspectDb, F as jsonSafeParse, z as orderBy, r as registerCrdtFunctions, I as startPerformanceLogger } from './crdt-sync-remote-source-rrqinqLn.js';
-import { Driver, DatabaseConnection, Kysely, Migration, Migrator } from 'kysely';
-export { c as createCrdtSyncProducer, d as dummyKysely } from './crdt-sync-producer-0toEpGf0.js';
+import * as kysely from 'kysely';
+import { Kysely, SchemaModule, SelectQueryBuilder } from 'kysely';
+import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, a as SQLiteTransactionWrapper, b as StoredValue, C as CrdtStorage, P as PersistedCrdtEvent, G as GetEventsOptions, E as ExecuteParams, c as ExecuteResult, Q as QueryBuilderOutput, K as KyselyQueryFactory, W as WorkerState } from './crdt-sync-remote-source-idoIjMcs.js';
+export { z as CrdtEventOrigin, A as CrdtEventStatus, B as CrdtEventType, u as CrdtSyncRemoteSource, F as CrdtUpdateLogItem, I as CrdtUpdateLogPayload, D as DatabaseIntrospection, U as DeferredPromise, V as DistributiveOmit, w as EventsPullRequest, x as EventsPushRequest, y as EventsPushResponse, H as HLC, f as HLCCounter, h as LogLevel, M as MigratableEvent, m as Migrations, n as MigrationsDb, r as PendingCrdtEvent, N as PreparedStatement, o as SyncDbMigrator, g as TableMetadata, _ as TypedBroadcastChannel, $ as TypedEventTarget, a2 as WorkerConfig, d as compareHLC, p as createCrdtApplyFunction, t as createCrdtStorage, v as createCrdtSyncRemoteSource, O as createDeferredPromise, k as createMigrations, l as createMigrator, q as createSQLiteCrdtApplyFunction, J as createStoredValue, R as createTypedEventTarget, e as deserializeHLC, X as generateId, i as introspectDb, Y as jsonSafeParse, Z as quoteId, s as serializeHLC, j as startPerformanceLogger, a0 as tryCatch, a1 as tryCatchAsync } from './crdt-sync-remote-source-idoIjMcs.js';
+import { S as SyncDbSchema } from './crdt-schema-DQ1cYsFE.js';
+export { C as CreateCrdtSchemaOptions, c as createSyncDbSchema } from './crdt-schema-DQ1cYsFE.js';
 import '@sqlite.org/sqlite-wasm';
 
+declare const dummyKysely: Kysely<any>;
+
 type TableName<Database> = keyof Database extends string ? keyof Database : never;
 type SQLiteReactiveDbOptions = {
-    snapshot?: Uint8Array<ArrayBufferLike>;
-    logger?: Logger;
+    snapshot: Uint8Array<ArrayBufferLike>;
+    logger: Logger;
 };
 type EventsMap = {
-    "transaction-committed": void;
-    "transaction-rolled-back": void;
-    "any-table-changed": void;
+    "transaction-committed": undefined;
+    "transaction-rolled-back": undefined;
+    "any-table-changed": undefined;
 } & Record<`table:${string}`, void>;
-declare function createSQLiteReactiveDb<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
 declare class SQLiteReactiveDb<Database> {
     readonly db: SQLiteDbWrapper<Database>;
     private sqlite3;
@@ -23,12 +26,13 @@ declare class SQLiteReactiveDb<Database> {
     private eventTarget;
     private constructor();
     static create<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
+    private liveQueryStatements;
     createLiveQuery<TResult>(query: {
         sql: string;
         parameters: readonly unknown[];
     }): {
         getRows: () => TResult[];
-        refresh: () => void;
+        refresh: (parameters?: readonly unknown[]) => void;
         subscribe: (onchange: () => void) => () => void;
     };
     subscribeToQueryChanges(params: {
@@ -51,125 +55,81 @@ declare class SQLiteReactiveDb<Database> {
     private registerDbHooks;
     createSnapshot(): Uint8Array<ArrayBuffer>;
     useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
+    dispose(): void;
 }
 
-interface HLC {
-    timestamp: number;
-    counter: number;
-    nodeId: string;
-}
-declare class HLCCounter {
-    private timestamp;
-    private counter;
-    private nodeId;
-    private readonly getTimestamp;
-    constructor(nodeId: string, getTimestamp: () => number);
-    getCurrentHLC(): HLC;
-    getNextHLC(): HLC;
-    mergeHLC(hlc: HLC): void;
-}
-declare function serializeHLC(hlc: HLC): string;
-declare function deserializeHLC(serialized: string): {
-    timestamp: number;
-    counter: number;
-    nodeId: string;
+type KvStoreItem = {
+    key: string;
+    value: string;
+};
+declare function createKvStoreTableQuery(schema: SchemaModule, tableName: string): kysely.CreateTableBuilder<string, "key" | "value">;
+declare function createSQLiteKvStore({ db, metaTableName, }: {
+    db: SQLiteTransactionWrapper<any>;
+    metaTableName: string;
+}): {
+    get: (key: string) => string | null;
+    set: (key: string, value: string) => void;
+    remove: (key: string) => void;
+    createStringStoredValue: (key: string, defaultValue: string) => StoredValue<string>;
+    createNumberStoredValue: (key: string, defaultValue: number) => StoredValue<number>;
 };
-declare function compareHLC(one: HLC, two: HLC): number;
 
-type MemoryDbCrdtTableConfig = {
-    baseTableName: string;
-    crdtTableName: string;
-};
-type MemoryDbOptions<Database> = {
-    reactiveDb: SQLiteReactiveDb<Database>;
-    hlcCounter: HLCCounter;
-    tabId: string;
-    crdtTables: MemoryDbCrdtTableConfig[];
-};
-declare function createMemoryDb<Database>({ reactiveDb: _reactiveDb, hlcCounter, tabId, crdtTables, }: MemoryDbOptions<Database>): Promise<{
-    crdtStorage: {
-        enqueueEvents: (events: {
-            type: CrdtEventType;
-            timestamp: string;
-            dataset: string;
-            item_id: string;
-            payload: string;
-            origin: CrdtEventOrigin;
-        }[]) => {
-            firstEventSyncId: number;
-            lastEventSyncId: number;
-        };
-        addEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
-            "event-applied": PersistedCrdtEvent;
-            "event-processing-done": void;
-        }[K]>) => void) => void;
-        removeEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
-            "event-applied": PersistedCrdtEvent;
-            "event-processing-done": void;
-        }[K]>) => void) => void;
-        dispatchEvent: <K extends "event-applied" | "event-processing-done">(type: K, payload: {
-            "event-applied": PersistedCrdtEvent;
-            "event-processing-done": void;
-        }[K]) => void;
-    };
-}>;
+type SystemMigrationContext = {
+    eventsTableName: string;
+    updateLogTableName: string;
+    execute: (sql: string) => void;
+};
+type SystemMigration = {
+    version: number;
+    up: (ctx: SystemMigrationContext) => void;
+};
+declare const baseSystemMigrations: SystemMigration[];
+declare function runSystemMigrations(opts: {
+    version: StoredValue<number>;
+    migrations: SystemMigration[];
+    eventsTableName: string;
+    updateLogTableName: string;
+    execute: (sql: string) => void;
+    transaction: (callback: () => void) => void;
+}): void;
+declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): void;
+declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
 
-type SyncedDbOptions = {
-    dbPath: string;
-    clearOnInit?: boolean;
-    crdtTables: MemoryDbCrdtTableConfig[];
-    worker: Worker;
+type CrdtStorageMutator<Database> = ReturnType<typeof createCrdtStorageMutator<Database>>;
+type CommitEventOptions<Database, Table extends keyof Database & string> = {
+    type: "item-created";
+    dataset: Table;
+    item_id: string;
+    payload: CreateEventPayload<Database, Table>;
+} | {
+    type: "item-updated";
+    dataset: Table;
+    item_id: string;
+    payload: UpdateEventPayload<Database, Table>;
+} | {
+    type: "item-deleted";
+    dataset: Table;
+    item_id: string;
+};
+type CreateEventPayload<Database, Table extends keyof Database> = Omit<Database[Table], "tombstone">;
+type UpdateEventPayload<Database, Table extends keyof Database> = Omit<Partial<Database[Table]>, "id" | "tombstone">;
+declare function createCrdtStorageMutator<Database>({ storage }: {
+    storage: CrdtStorage;
+}): {
+    enqueueEvents: (events: CommitEventOptions<Database, keyof Database & string>[]) => void;
+    createEvent: <Table extends keyof Database & string>(event: CommitEventOptions<Database, Table>) => CommitEventOptions<Database, Table>;
+    enqueueEvent: (event: CommitEventOptions<Database, keyof Database & string>) => void;
 };
-declare function createSyncedDb<Database>(options: SyncedDbOptions): Promise<{
-    db: SQLiteDbWrapper<Database>;
-    reactiveDb: Omit<SQLiteReactiveDb<Database>, "db">;
-    workerDb: {
-        addEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
-            "new-notification": WorkerNotificationMessage;
-        }[K]>) => void) => void;
-        removeEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
-            "new-notification": WorkerNotificationMessage;
-        }[K]>) => void) => void;
-        getSnapshot: () => Promise<GetSnapshotResponse>;
-        pushTabEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
-        execute: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
-        pullEvents: (params: EventsPullRequest) => Promise<EventsPullResponse>;
-        postInitReady: () => Promise<void>;
-    };
-}>;
-type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
 
-type SqliteDatabase = {
-    execute: (opts: {
-        sql: string;
-        parameters: readonly unknown[];
-    }) => {
-        rows: unknown[];
-    };
-    close: () => void;
+type CrdtSyncProducer = {
+    storage: CrdtStorage;
+    broadcastEvents: (request: {
+        newSyncId: number;
+    }) => void;
 };
-declare class SqliteDriver implements Driver {
-    #private;
-    constructor(db: SqliteDatabase);
-    init(): Promise<void>;
-    acquireConnection(): Promise<DatabaseConnection>;
-    beginTransaction(connection: DatabaseConnection): Promise<void>;
-    commitTransaction(connection: DatabaseConnection): Promise<void>;
-    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
-    releaseConnection(): Promise<void>;
-    destroy(): Promise<void>;
-}
-declare function createSQLiteKysely<Database>(sqliteDb: SqliteDatabase): Kysely<Database>;
+declare const createCrdtSyncProducer: ({ storage, broadcastEvents }: CrdtSyncProducer) => void;
 
-type SyncDbMigratorOptions = {
-    db: Kysely<unknown>;
-    migrations: Record<string, Migration>;
-};
-declare function createSyncDbMigrator(options: SyncDbMigratorOptions): Migrator;
-declare function createSyncDbMigrations(migrations: Record<number, Migration>): Record<number, Migration>;
-
-declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): void;
-declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
+declare function applyKyselyEventsBatchFilters(query: SelectQueryBuilder<any, any, PersistedCrdtEvent>, opts: GetEventsOptions): SelectQueryBuilder<any, any, PersistedCrdtEvent>;
 
 declare function makeCrdtTable({ db, baseTableName, crdtTableName, }: {
     db: SQLiteDbWrapper<any>;
@@ -177,92 +137,42 @@ declare function makeCrdtTable({ db, baseTableName, crdtTableName, }: {
     crdtTableName: string;
 }): void;
 
-declare const syncDbWorkerLockName = "sync-db-worker-lock";
-type WorkerNotificationMessage = {
-    notificationType: "new-event-chunk-applied";
-    newSyncId: number;
-};
-type PushTabEventsResponse = {
-    firstEventSyncId: number;
-    lastEventSyncId: number;
-};
-type GetSnapshotResponse = {
-    file: Uint8Array<ArrayBufferLike>;
-    syncId: number;
-};
-interface WorkerRpc {
-    getSnapshot: () => GetSnapshotResponse;
-    pushTabEvents: (request: EventsPushRequest) => EventsPushResponse;
-    execute: (query: ExecuteParams) => ExecuteResult<unknown>;
-    pullEvents: (params: EventsPullRequest) => EventsPullResponse;
-    postInitReady: () => void;
-}
-type WorkerRequestMethod = keyof WorkerRpc;
-type WorkerRequestMessage<TMethod extends WorkerRequestMethod = WorkerRequestMethod> = {
-    type: "request";
-    requestId: string;
-    method: TMethod;
-    args: Parameters<WorkerRpc[TMethod]>;
-};
-type WorkerResponseMessage<TMethod extends WorkerRequestMethod = WorkerRequestMethod> = {
-    type: "response";
-    requestId: string;
-    data: ReturnType<WorkerRpc[TMethod]>;
-};
-type AsyncRpc<T> = {
-    [K in keyof T]: T[K] extends (...args: infer U) => infer V ? (...args: U) => V extends Promise<infer W> ? Promise<W> : Promise<V> : never;
-};
-declare const broadcastChannelNames: {
-    readonly requests: "sync-db-worker-requests";
-    readonly responses: "sync-db-worker-responses";
-};
-type WorkerBroadcastChannels = {
-    requests: TypedBroadcastChannel<WorkerRequestMessage>;
-    responses: TypedBroadcastChannel<WorkerResponseMessage | WorkerNotificationMessage | WorkerInitResponse>;
-};
-declare const createBroadcastChannels: () => WorkerBroadcastChannels;
-type WorkerConfig = {
-    dbPath: string;
-    clientId: string;
+type SyncedDbOptions<Database, Props = undefined> = {
+    dbId: string;
     clearOnInit?: boolean;
-    syncServer: SyncServerConfig;
-};
-type SyncServerConfig = {
-    host: string;
-    room: string;
-};
-type WorkerInitMessage = {
-    type: "init";
-    config: WorkerConfig;
-};
-declare function isWorkerInitMessage(message: unknown): message is WorkerInitMessage;
-type WorkerInitResponse = {
-    type: "init-ready";
-};
-declare function isWorkerInitResponse(message: unknown): message is WorkerInitResponse;
-declare function isWorkerRequestMessage(message: unknown): message is WorkerRequestMessage;
-declare function isWorkerResponseMessage(message: unknown): message is WorkerResponseMessage;
-declare function isWorkerNotificationMessage(message: unknown): message is WorkerNotificationMessage;
-
-declare const createWorkerDbClient: ({ broadcastChannels, }: {
-    broadcastChannels: WorkerBroadcastChannels;
-}) => {
-    addEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
-        "new-notification": WorkerNotificationMessage;
-    }[K]>) => void) => void;
-    removeEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
-        "new-notification": WorkerNotificationMessage;
-    }[K]>) => void) => void;
-    getSnapshot: () => Promise<GetSnapshotResponse>;
-    pushTabEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
-    execute: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
-    pullEvents: (params: EventsPullRequest) => Promise<EventsPullResponse>;
-    postInitReady: () => Promise<void>;
-};
-declare function initializeWorkerDb({ worker, broadcastChannels, config, }: {
     worker: Worker;
-    broadcastChannels: WorkerBroadcastChannels;
-    config: WorkerConfig;
-}): Promise<void>;
+    workerProps: Props;
+    syncDbSchema: SyncDbSchema<Database>;
+};
+declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOptions<Database, Props>): Promise<{
+    db: {
+        execute: <T = unknown>(opts: ExecuteParams | string | kysely.CompiledQuery<T>, meta?: {
+            loggerLevel?: "info" | "system";
+        }) => ExecuteResult<T>;
+        executeKysely: <TQuery extends kysely.Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>>(factory: KyselyQueryFactory<Database, TQuery, TResult>, meta?: {
+            loggerLevel?: "info" | "system";
+        }) => ExecuteResult<TResult>;
+        executeTransaction: <T>(callback: (db: SQLiteTransactionWrapper<Database>) => T) => T;
+        createLiveQuery: <TResult>(query: {
+            sql: string;
+            parameters: readonly unknown[];
+        }) => {
+            getRows: () => TResult[];
+            refresh: (parameters?: readonly unknown[]) => void;
+            subscribe: (onchange: () => void) => () => void;
+        };
+    };
+    state: {
+        getState: () => WorkerState;
+        subscribe: (onChange: () => void) => () => void;
+        goOnline: () => Promise<void>;
+        goOffline: () => Promise<void>;
+    };
+    dispose: () => Promise<void>;
+    _internal: {
+        executeAsync: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
+    };
+}>;
+type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
 
-export { type AsyncRpc, CrdtEventOrigin, CrdtEventType, EventsPullRequest, EventsPullResponse, EventsPushRequest, EventsPushResponse, ExecuteParams, ExecuteResult, type GetSnapshotResponse, type HLC, HLCCounter, Logger, type MemoryDbCrdtTableConfig, PersistedCrdtEvent, type PushTabEventsResponse, SQLiteDbWrapper, SQLiteReactiveDb, SqliteDriver, type SyncServerConfig, type SyncedDb, TypedBroadcastChannel, TypedEvent, type WorkerBroadcastChannels, type WorkerConfig, type WorkerInitMessage, type WorkerInitResponse, type WorkerNotificationMessage, type WorkerRequestMessage, type WorkerRequestMethod, type WorkerResponseMessage, type WorkerRpc, applyMemoryDbSchema, applyWorkerDbSchema, broadcastChannelNames, compareHLC, createBroadcastChannels, createMemoryDb, createSQLiteKysely, createSQLiteReactiveDb, createSyncDbMigrations, createSyncDbMigrator, createSyncedDb, createWorkerDbClient, deserializeHLC, initializeWorkerDb, isWorkerInitMessage, isWorkerInitResponse, isWorkerNotificationMessage, isWorkerRequestMessage, isWorkerResponseMessage, makeCrdtTable, serializeHLC, syncDbWorkerLockName };
+export { CrdtStorage, type CrdtStorageMutator, ExecuteParams, ExecuteResult, type KvStoreItem, KyselyQueryFactory, Logger, PersistedCrdtEvent, QueryBuilderOutput, SQLiteDbWrapper, SQLiteReactiveDb, SQLiteTransactionWrapper, StoredValue, SyncDbSchema, type SyncedDb, type SystemMigration, type SystemMigrationContext, TypedEvent, WorkerState, applyKyselyEventsBatchFilters, applyMemoryDbSchema, applyWorkerDbSchema, baseSystemMigrations, createCrdtStorageMutator, createCrdtSyncProducer, createKvStoreTableQuery, createSQLiteKvStore, createSyncedDb, dummyKysely, makeCrdtTable, runSystemMigrations };