@delali/sirannon-db 0.1.3 → 0.1.4

package/dist/{sirannon-BJ8Yd1Uf.d.ts → sirannon-B1oTfebD.d.ts}

@@ -1,5 +1,6 @@
-import { Q as QueryHookContext, g as ConnectionHookContext, c as BeforeSubscribeHook, H as HookConfig, M as MetricsConfig, l as QueryMetrics, h as ConnectionMetrics, C as CDCMetrics, P as Params, E as ExecuteResult, D as DatabaseOptions, p as SubscriptionBuilder, B as BackupScheduleOptions, b as BeforeQueryHook, A as AfterQueryHook, n as SirannonOptions, a as BeforeConnectHook, k as DatabaseOpenHook, j as DatabaseCloseHook } from './types-DArCObcu.js';
-import Database$1 from 'better-sqlite3';
+import { S as SQLiteDriver } from './types-BFSsG77t.js';
+import { Q as QueryHookContext, C as ConnectionHookContext, B as BeforeSubscribeHook, H as HookConfig, M as MetricsConfig, a as QueryMetrics, b as ConnectionMetrics, c as CDCMetrics, D as DatabaseOptions, P as Params, E as ExecuteResult, d as SubscriptionBuilder, e as BackupScheduleOptions, f as BeforeQueryHook, A as AfterQueryHook, g as SirannonOptions, h as BeforeConnectHook, i as DatabaseOpenHook, j as DatabaseCloseHook } from './types-DtDutWRU.js';
+import { T as Transaction, M as Migration, a as MigrationResult, R as RollbackResult } from './types-DRkJlqex.js';
 
 type HookEvent = 'beforeQuery' | 'afterQuery' | 'beforeConnect' | 'databaseOpen' | 'databaseClose' | 'beforeSubscribe';
 type SubscribeHookContext = Parameters<BeforeSubscribeHook>[0];
@@ -32,47 +33,12 @@ declare class HookRegistry {
 declare class MetricsCollector {
     private config;
     constructor(config?: MetricsConfig);
-    trackQuery<T>(fn: () => T, context: Omit<QueryMetrics, 'durationMs' | 'error'>): T;
+    trackQuery<T>(fn: () => Promise<T>, context: Omit<QueryMetrics, 'durationMs' | 'error'>): Promise<T>;
     trackConnection(metrics: ConnectionMetrics): void;
     trackCDCEvent(metrics: CDCMetrics): void;
     get active(): boolean;
 }
 
-type SqliteDb = InstanceType<typeof Database$1>;
-declare class Transaction {
-    private readonly db;
-    private _lastInsertRowId;
-    constructor(db: SqliteDb);
-    query<T = Record<string, unknown>>(sql: string, params?: Params): T[];
-    execute(sql: string, params?: Params): ExecuteResult;
-    executeBatch(sql: string, paramsBatch: Params[]): ExecuteResult[];
-    get lastInsertRowId(): number | bigint;
-    static run<T>(db: SqliteDb, fn: (tx: Transaction) => T): T;
-}
-
-interface AppliedMigration {
-    version: number;
-    name: string;
-    applied_at: number;
-}
-interface Migration {
-    version: number;
-    name: string;
-    up: string | ((tx: Transaction) => void);
-    down?: string | ((tx: Transaction) => void);
-}
-interface AppliedMigrationEntry {
-    version: number;
-    name: string;
-}
-interface MigrationResult {
-    applied: AppliedMigrationEntry[];
-    skipped: number;
-}
-interface RollbackResult {
-    rolledBack: AppliedMigrationEntry[];
-}
-
 interface DatabaseInternals {
     parentHooks?: HookRegistry;
     metrics?: MetricsCollector;
@@ -82,6 +48,7 @@ declare class Database {
     readonly path: string;
     readonly readOnly: boolean;
     private readonly pool;
+    private readonly driver;
     private readonly closeListeners;
     private _closed;
     private changeTracker;
@@ -95,24 +62,25 @@ declare class Database {
     private readonly backupManager;
     private readonly backupScheduler;
     private readonly scheduledBackupCancellers;
-    constructor(id: string, path: string, options?: DatabaseOptions, internals?: DatabaseInternals);
-    query<T = Record<string, unknown>>(sql: string, params?: Params): T[];
-    queryOne<T = Record<string, unknown>>(sql: string, params?: Params): T | undefined;
-    execute(sql: string, params?: Params): ExecuteResult;
-    executeBatch(sql: string, paramsBatch: Params[]): ExecuteResult[];
-    transaction<T>(fn: (tx: Transaction) => T): T;
-    watch(table: string): void;
-    unwatch(table: string): void;
+    private constructor();
+    static create(id: string, path: string, driver: SQLiteDriver, options?: DatabaseOptions, internals?: DatabaseInternals): Promise<Database>;
+    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
+    queryOne<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T | undefined>;
+    execute(sql: string, params?: Params): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
+    watch(table: string): Promise<void>;
+    unwatch(table: string): Promise<void>;
     on(table: string): SubscriptionBuilder;
-    migrate(input: string | Migration[]): MigrationResult;
-    rollback(input: string | Migration[], version?: number): RollbackResult;
-    backup(destPath: string): void;
+    migrate(migrations: Migration[]): Promise<MigrationResult>;
+    rollback(migrations: Migration[], version?: number): Promise<RollbackResult>;
+    backup(destPath: string): Promise<void>;
     scheduleBackup(options: BackupScheduleOptions): void;
-    loadExtension(extensionPath: string): void;
+    loadExtension(extensionPath: string): Promise<void>;
     onBeforeQuery(hook: BeforeQueryHook): void;
     onAfterQuery(hook: AfterQueryHook): void;
-    addCloseListener(fn: () => void): void;
-    close(): void;
+    addCloseListener(fn: () => void | Promise<void>): void;
+    close(): Promise<void>;
     get closed(): boolean;
     get readerCount(): number;
     private ensureOpen;
@@ -124,19 +92,23 @@ declare class Database {
 }
 
 declare class Sirannon {
-    readonly options?: SirannonOptions | undefined;
+    readonly options: SirannonOptions;
     private readonly dbs;
+    private readonly opening;
     private _shutdown;
+    private readonly _driver;
     private readonly hookRegistry;
     private readonly metricsCollector;
     private readonly lifecycleManager;
-    constructor(options?: SirannonOptions | undefined);
-    open(id: string, path: string, options?: DatabaseOptions): Database;
-    close(id: string): void;
+    constructor(options: SirannonOptions);
+    get driver(): SQLiteDriver;
+    open(id: string, path: string, options?: DatabaseOptions): Promise<Database>;
+    close(id: string): Promise<void>;
     get(id: string): Database | undefined;
+    resolve(id: string): Promise<Database | undefined>;
     has(id: string): boolean;
     databases(): Map<string, Database>;
-    shutdown(): void;
+    shutdown(): Promise<void>;
     onBeforeQuery(hook: BeforeQueryHook): void;
     onAfterQuery(hook: AfterQueryHook): void;
     onBeforeConnect(hook: BeforeConnectHook): void;
@@ -145,4 +117,4 @@ declare class Sirannon {
     private ensureRunning;
 }
 
-export { type AppliedMigration as A, Database as D, type HookDispose as H, type Migration as M, type RollbackResult as R, Sirannon as S, Transaction as T, type MigrationResult as a, type AppliedMigrationEntry as b, type HookEvent as c, type HookEventContextMap as d, type HookHandler as e, HookRegistry as f, MetricsCollector as g, type SubscribeHookContext as h };
+export { Database as D, type HookDispose as H, MetricsCollector as M, Sirannon as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d, type SubscribeHookContext as e };

package/dist/types-BFSsG77t.d.ts

@@ -0,0 +1,29 @@
+interface RunResult {
+    changes: number;
+    lastInsertRowId: number | bigint;
+}
+interface SQLiteStatement {
+    all<T = unknown>(...params: unknown[]): Promise<T[]>;
+    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
+    run(...params: unknown[]): Promise<RunResult>;
+}
+interface SQLiteConnection {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<SQLiteStatement>;
+    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+interface OpenOptions {
+    readonly?: boolean;
+    walMode?: boolean;
+}
+interface DriverCapabilities {
+    multipleConnections: boolean;
+    extensions: boolean;
+}
+interface SQLiteDriver {
+    readonly capabilities: DriverCapabilities;
+    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
+}
+
+export type { DriverCapabilities as D, OpenOptions as O, RunResult as R, SQLiteDriver as S, SQLiteConnection as a, SQLiteStatement as b };

package/dist/types-DRkJlqex.d.ts

@@ -0,0 +1,38 @@
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { P as Params, E as ExecuteResult } from './types-DtDutWRU.js';
+
+declare class Transaction {
+    private readonly conn;
+    private _lastInsertRowId;
+    constructor(conn: SQLiteConnection);
+    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
+    execute(sql: string, params?: Params): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    get lastInsertRowId(): number | bigint;
+    static run<T>(conn: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
+}
+
+interface AppliedMigration {
+    version: number;
+    name: string;
+    applied_at: number;
+}
+interface Migration {
+    version: number;
+    name: string;
+    up: string | ((tx: Transaction) => void | Promise<void>);
+    down?: string | ((tx: Transaction) => void | Promise<void>);
+}
+interface AppliedMigrationEntry {
+    version: number;
+    name: string;
+}
+interface MigrationResult {
+    applied: AppliedMigrationEntry[];
+    skipped: number;
+}
+interface RollbackResult {
+    rolledBack: AppliedMigrationEntry[];
+}
+
+export { type AppliedMigration as A, type Migration as M, type RollbackResult as R, Transaction as T, type MigrationResult as a, type AppliedMigrationEntry as b };

package/dist/{types-DArCObcu.d.ts → types-DtDutWRU.d.ts}

@@ -1,3 +1,5 @@
+import { S as SQLiteDriver } from './types-BFSsG77t.js';
+
 /** Query parameter types: named (object) or positional (array). */
 type Params = Record<string, unknown> | unknown[];
 /** Result returned by mutation statements (INSERT, UPDATE, DELETE). */
@@ -113,6 +115,7 @@ interface DatabaseOptions {
 }
 /** Top-level options for the Sirannon database registry. */
 interface SirannonOptions {
+    driver: SQLiteDriver;
     hooks?: HookConfig;
     metrics?: MetricsConfig;
     lifecycle?: LifecycleConfig;
@@ -183,4 +186,4 @@ interface ClientOptions {
     reconnectInterval?: number;
 }
 
-export type { AfterQueryHook as A, BackupScheduleOptions as B, CDCMetrics as C, DatabaseOptions as D, ExecuteResult as E, HookConfig as H, LifecycleConfig as L, MetricsConfig as M, OnRequestHook as O, Params as P, QueryHookContext as Q, RequestContext as R, ServerOptions as S, WSHandlerOptions as W, BeforeConnectHook as a, BeforeQueryHook as b, BeforeSubscribeHook as c, ChangeEvent as d, ChangeOperation as e, ClientOptions as f, ConnectionHookContext as g, ConnectionMetrics as h, CorsOptions as i, DatabaseCloseHook as j, DatabaseOpenHook as k, QueryMetrics as l, RequestDenial as m, SirannonOptions as n, Subscription as o, SubscriptionBuilder as p };
+export type { AfterQueryHook as A, BeforeSubscribeHook as B, ConnectionHookContext as C, DatabaseOptions as D, ExecuteResult as E, HookConfig as H, LifecycleConfig as L, MetricsConfig as M, OnRequestHook as O, Params as P, QueryHookContext as Q, RequestContext as R, ServerOptions as S, WSHandlerOptions as W, QueryMetrics as a, ConnectionMetrics as b, CDCMetrics as c, SubscriptionBuilder as d, BackupScheduleOptions as e, BeforeQueryHook as f, SirannonOptions as g, BeforeConnectHook as h, DatabaseOpenHook as i, DatabaseCloseHook as j, ChangeEvent as k, ChangeOperation as l, ClientOptions as m, CorsOptions as n, RequestDenial as o, Subscription as p };

package/dist/vfs-INWQ5DTE.mjs

@@ -0,0 +1,2 @@
+export { AccessHandlePoolVFS } from 'wa-sqlite/src/examples/AccessHandlePoolVFS.js';
+export { IDBBatchAtomicVFS } from 'wa-sqlite/src/examples/IDBBatchAtomicVFS.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",
@@ -22,13 +22,42 @@
     "subscriptions",
     "websocket",
     "embedded",
-    "better-sqlite3"
+    "better-sqlite3",
+    "wa-sqlite",
+    "expo-sqlite",
+    "pluggable"
   ],
   "exports": {
     ".": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.mjs"
     },
+    "./driver/better-sqlite3": {
+      "types": "./dist/driver/better-sqlite3.d.ts",
+      "import": "./dist/driver/better-sqlite3.mjs"
+    },
+    "./driver/node": {
+      "types": "./dist/driver/node.d.ts",
+      "import": "./dist/driver/node.mjs"
+    },
+    "./driver/bun": {
+      "import": "./dist/driver/bun.mjs"
+    },
+    "./driver/wa-sqlite": {
+      "types": "./dist/driver/wa-sqlite.d.ts",
+      "import": "./dist/driver/wa-sqlite.mjs"
+    },
+    "./driver/expo": {
+      "import": "./dist/driver/expo.mjs"
+    },
+    "./file-migrations": {
+      "types": "./dist/file-migrations/index.d.ts",
+      "import": "./dist/file-migrations/index.mjs"
+    },
+    "./backup-scheduler": {
+      "types": "./dist/backup-scheduler/index.d.ts",
+      "import": "./dist/backup-scheduler/index.mjs"
+    },
     "./server": {
       "types": "./dist/server/index.d.ts",
       "import": "./dist/server/index.mjs"
@@ -46,26 +75,48 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
-    "better-sqlite3": "12.6.2",
-    "croner": "10.0.1",
-    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.58.0"
+  "peerDependencies": {
+    "better-sqlite3": ">=12.0.0",
+    "wa-sqlite": ">=1.0.0",
+    "expo-sqlite": ">=14.0.0",
+    "croner": ">=10.0.0",
+    "uWebSockets.js": ">=20.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "wa-sqlite": {
+      "optional": true
+    },
+    "expo-sqlite": {
+      "optional": true
+    },
+    "croner": {
+      "optional": true
+    },
+    "uWebSockets.js": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "25.3.3",
     "@types/pg": "8.11.10",
     "@vitest/coverage-v8": "4.0.18",
+    "better-sqlite3": "12.6.2",
+    "croner": "10.0.1",
     "pg": "8.19.0",
     "simple-statistics": "7.8.7",
     "tinybench": "6.0.0",
     "tsup": "8.5.1",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.58.0",
     "vitest": "4.0.18"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "rm -rf dist && tsup",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",

package/dist/protocol-BX1H-_Mz.d.ts

@@ -1,104 +0,0 @@
-import { E as ExecuteResult } from './types-DArCObcu.js';
-
-/** Body for POST /db/:id/query */
-interface QueryRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-/** Body for POST /db/:id/execute */
-interface ExecuteRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-/** A single statement within a transaction batch. */
-interface TransactionStatement {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-/** Body for POST /db/:id/transaction */
-interface TransactionRequest {
-    statements: TransactionStatement[];
-}
-/** Response for a successful query. */
-interface QueryResponse {
-    rows: Record<string, unknown>[];
-}
-/** Response for a successful execute. */
-interface ExecuteResponse {
-    changes: number;
-    lastInsertRowId: number | string;
-}
-/** Response for a successful transaction. */
-interface TransactionResponse {
-    results: ExecuteResponse[];
-}
-/** Standard error response envelope. */
-interface ErrorResponse {
-    error: {
-        code: string;
-        message: string;
-    };
-}
-/** Inbound WS message types. */
-type WSClientMessage = WSSubscribeMessage | WSUnsubscribeMessage | WSQueryMessage | WSExecuteMessage;
-interface WSSubscribeMessage {
-    type: 'subscribe';
-    id: string;
-    table: string;
-    filter?: Record<string, unknown>;
-}
-interface WSUnsubscribeMessage {
-    type: 'unsubscribe';
-    id: string;
-}
-interface WSQueryMessage {
-    type: 'query';
-    id: string;
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-interface WSExecuteMessage {
-    type: 'execute';
-    id: string;
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-/** Outbound WS message types. */
-type WSServerMessage = WSSubscribedMessage | WSUnsubscribedMessage | WSChangeMessage | WSResultMessage | WSErrorMessage;
-interface WSSubscribedMessage {
-    type: 'subscribed';
-    id: string;
-}
-interface WSUnsubscribedMessage {
-    type: 'unsubscribed';
-    id: string;
-}
-interface WSChangeMessage {
-    type: 'change';
-    id: string;
-    event: {
-        type: 'insert' | 'update' | 'delete';
-        table: string;
-        row: Record<string, unknown>;
-        oldRow?: Record<string, unknown>;
-        seq: string;
-        timestamp: number;
-    };
-}
-interface WSResultMessage {
-    type: 'result';
-    id: string;
-    data: QueryResponse | ExecuteResponse;
-}
-interface WSErrorMessage {
-    type: 'error';
-    id: string;
-    error: {
-        code: string;
-        message: string;
-    };
-}
-/** Convert an ExecuteResult (with possible bigint) to a JSON-safe response. */
-declare function toExecuteResponse(result: ExecuteResult): ExecuteResponse;
-
-export { type ErrorResponse as E, type QueryRequest as Q, type TransactionRequest as T, type WSChangeMessage as W, type ExecuteRequest as a, type ExecuteResponse as b, type QueryResponse as c, type TransactionResponse as d, type TransactionStatement as e, type WSClientMessage as f, type WSErrorMessage as g, type WSExecuteMessage as h, type WSQueryMessage as i, type WSResultMessage as j, type WSServerMessage as k, type WSSubscribeMessage as l, type WSSubscribedMessage as m, type WSUnsubscribeMessage as n, type WSUnsubscribedMessage as o, toExecuteResponse as t };