@anfenn/dync 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-YSn6c01d.cjs';
+export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-Bv-fV10P.cjs';
+export { S as SQLiteDatabaseDriver, b as SQLiteQueryResult, a as SQLiteRunResult } from './types-CSbIAfu2.cjs';
+import 'dexie';
+
+declare function createLocalId(): string;
+
+export { createLocalId };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-CPIge2ZM.js';
+export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-DJFApKsM.js';
+export { S as SQLiteDatabaseDriver, b as SQLiteQueryResult, a as SQLiteRunResult } from './types-CSbIAfu2.js';
+import 'dexie';
+
+declare function createLocalId(): string;
+
+export { createLocalId };

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  Dync,
+  MemoryAdapter,
+  MemoryQueryContext,
+  SQLiteAdapter,
+  SqliteQueryContext,
+  SyncAction,
+  createLocalId
+} from "./chunk-LGHOZECP.js";
+import "./chunk-SQB6E7V2.js";
+export {
+  Dync,
+  MemoryAdapter,
+  MemoryQueryContext,
+  SQLiteAdapter,
+  SqliteQueryContext,
+  SyncAction,
+  createLocalId
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.shared-CPIge2ZM.d.ts

@@ -0,0 +1,234 @@
+import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-DJFApKsM.js';
+import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.js';
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+interface Logger {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+
+interface SyncedRecord {
+    _localId: string;
+    id?: any;
+    updated_at: string;
+    [k: string]: any;
+}
+interface ApiFunctions {
+    add: (item: any) => Promise<any | undefined>;
+    update: (id: any, changes: any, item: any) => Promise<boolean>;
+    remove: (id: any) => Promise<void>;
+    list: (lastUpdatedAt: Date) => Promise<any[]>;
+    firstLoad?: (lastId: any) => Promise<any[]>;
+}
+/**
+ * Payload for a single change in a batch push request.
+ */
+interface BatchPushPayload {
+    table: string;
+    action: 'add' | 'update' | 'remove';
+    localId: string;
+    id?: any;
+    data?: any;
+}
+/**
+ * Result for a single change in a batch push response.
+ */
+interface BatchPushResult {
+    localId: string;
+    success: boolean;
+    id?: any;
+    updated_at?: string;
+    error?: string;
+}
+/**
+ * Result for batch first load operation.
+ */
+interface BatchFirstLoadResult {
+    data: Record<string, any[]>;
+    cursors: Record<string, any>;
+    hasMore: boolean;
+}
+/**
+ * Batch sync configuration for
+ */
+interface BatchSync {
+    /**
+     * Array of table names to sync.
+     */
+    syncTables: string[];
+    /**
+     * Push all pending changes to the server in a single request.
+     * @param changes Array of changes to push
+     * @returns Array of results, one per change, correlated by localId
+     */
+    push: (changes: BatchPushPayload[]) => Promise<BatchPushResult[]>;
+    /**
+     * Pull changes from server since last sync.
+     * @param since Map of table name to last pulled timestamp
+     * @returns Map of table name to array of changed records
+     */
+    pull: (since: Record<string, Date>) => Promise<Record<string, any[]>>;
+    /**
+     * Initial data load for all tables (optional).
+     * @param cursors Map of table name to pagination cursor
+     * @returns Batch first load result with data, cursors, and hasMore flag
+     */
+    firstLoad?: (cursors: Record<string, any>) => Promise<BatchFirstLoadResult>;
+}
+type MissingRemoteRecordStrategy = 'ignore' | 'delete-local-record' | 'insert-remote-record';
+type ConflictResolutionStrategy = 'local-wins' | 'remote-wins' | 'try-shallow-merge';
+type AfterRemoteAddCallback = (stateKey: string, item: SyncedRecord) => void;
+type MissingRemoteRecordDuringUpdateCallback = (strategy: MissingRemoteRecordStrategy, item: SyncedRecord) => void;
+interface SyncOptions {
+    syncInterval?: number;
+    logger?: Logger;
+    minLogLevel?: LogLevel;
+    onAfterRemoteAdd?: AfterRemoteAddCallback;
+    missingRemoteRecordDuringUpdateStrategy?: MissingRemoteRecordStrategy;
+    onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
+    conflictResolutionStrategy?: ConflictResolutionStrategy;
+}
+interface FirstLoadProgress {
+    table: string;
+    inserted: number;
+    updated: number;
+    total: number;
+}
+type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
+type SyncApi = {
+    enable: (enabled: boolean) => Promise<void>;
+    startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
+    getState: () => SyncState;
+    resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
+    onStateChange: (fn: (state: SyncState) => void) => () => void;
+    onMutation: (fn: (event: MutationEvent) => void) => () => void;
+};
+interface MutationEvent {
+    type: 'add' | 'update' | 'delete' | 'bulkAdd' | 'bulkPut' | 'bulkDelete' | 'clear' | 'put' | 'modify' | 'pull';
+    tableName: string;
+    keys?: unknown[];
+}
+interface PersistedSyncState {
+    firstLoadDone: boolean;
+    pendingChanges: PendingChange[];
+    lastPulled: Record<string, string>;
+    error?: Error;
+    conflicts?: Record<string, Conflict>;
+}
+type SyncStatus = 'disabled' | 'disabling' | 'idle' | 'syncing' | 'error';
+interface SyncState extends PersistedSyncState {
+    status: SyncStatus;
+    hydrated: boolean;
+}
+declare enum SyncAction {
+    Create = "create",
+    Update = "update",
+    Remove = "remove"
+}
+interface PendingChange {
+    action: SyncAction;
+    stateKey: string;
+    localId: string;
+    id?: any;
+    version: number;
+    changes?: any;
+    before?: any;
+    after?: any;
+}
+interface Conflict {
+    stateKey: string;
+    fields: FieldConflict[];
+}
+interface FieldConflict {
+    key: string;
+    localValue: any;
+    remoteValue: any;
+}
+type TableMap<TStoreMap extends Record<string, unknown>> = {
+    [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
+};
+
+declare class DyncBase<_TStoreMap = Record<string, any>> {
+    private readonly adapter;
+    private readonly tableCache;
+    private readonly mutationWrappedTables;
+    private readonly syncEnhancedTables;
+    private readonly mutationListeners;
+    private visibilitySubscription?;
+    private openPromise?;
+    private disableSyncPromise?;
+    private disableSyncPromiseResolver?;
+    private sleepAbortController?;
+    private closing;
+    private syncApis;
+    private batchSync?;
+    private syncedTables;
+    private syncOptions;
+    private logger;
+    private syncTimerStarted;
+    private mutationsDuringSync;
+    private state;
+    readonly name: string;
+    /**
+     * Create a new Dync instance.
+     *
+     * Mode 1 - Per-table endpoints:
+     * @param databaseName - Name of the database
+     * @param syncApis - Map of table names to API functions
+     * @param storageAdapter - Storage adapter implementation (required)
+     * @param options - Sync options
+     *
+     * Mode 2 - Batch endpoints:
+     * @param databaseName - Name of the database
+     * @param batchSync - Batch sync config (syncTables, push, pull, firstLoad)
+     * @param storageAdapter - Storage adapter implementation (required)
+     * @param options - Sync options
+     */
+    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
+    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
+    version(versionNumber: number): {
+        stores(schema: Record<string, TableSchemaDefinition>): /*elided*/ any;
+        sqlite(configure: (builder: SQLiteVersionConfigurator) => void): /*elided*/ any;
+    };
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
+    table<K extends keyof _TStoreMap>(name: K): StorageTable<_TStoreMap[K]>;
+    table<T = any>(name: string): StorageTable<T>;
+    private withTransaction;
+    private setupEnhancedTables;
+    private injectSyncColumns;
+    private enhanceSyncTable;
+    private syncOnce;
+    private pullAll;
+    private pushAll;
+    private startSyncTimer;
+    private tryStart;
+    private setupVisibilityListener;
+    private handleVisibilityChange;
+    private startFirstLoad;
+    private getSyncState;
+    private resolveConflict;
+    private enableSync;
+    get syncStatus(): SyncStatus;
+    set syncStatus(status: SyncStatus);
+    private onSyncStateChange;
+    private onMutation;
+    private emitMutation;
+    sync: SyncApi;
+}
+type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> & TableMap<TStoreMap> & {
+    table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
+    table(name: string): StorageTable<any>;
+};
+declare const Dync: {
+    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
+    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
+    prototype: DyncInstance<Record<string, unknown>>;
+} & typeof DyncBase;
+type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
+
+export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, Dync as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, SyncAction as S, type TableMap as T, type ApiFunctions as a, type BatchPushPayload as b, type BatchPushResult as c, type BatchFirstLoadResult as d, type FirstLoadProgressCallback as e, type MissingRemoteRecordDuringUpdateCallback as f, type MutationEvent as g, type SyncOptions as h, type SyncState as i, type SyncedRecord as j };

package/dist/index.shared-YSn6c01d.d.cts

@@ -0,0 +1,234 @@
+import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-Bv-fV10P.cjs';
+import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.cjs';
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+interface Logger {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+
+interface SyncedRecord {
+    _localId: string;
+    id?: any;
+    updated_at: string;
+    [k: string]: any;
+}
+interface ApiFunctions {
+    add: (item: any) => Promise<any | undefined>;
+    update: (id: any, changes: any, item: any) => Promise<boolean>;
+    remove: (id: any) => Promise<void>;
+    list: (lastUpdatedAt: Date) => Promise<any[]>;
+    firstLoad?: (lastId: any) => Promise<any[]>;
+}
+/**
+ * Payload for a single change in a batch push request.
+ */
+interface BatchPushPayload {
+    table: string;
+    action: 'add' | 'update' | 'remove';
+    localId: string;
+    id?: any;
+    data?: any;
+}
+/**
+ * Result for a single change in a batch push response.
+ */
+interface BatchPushResult {
+    localId: string;
+    success: boolean;
+    id?: any;
+    updated_at?: string;
+    error?: string;
+}
+/**
+ * Result for batch first load operation.
+ */
+interface BatchFirstLoadResult {
+    data: Record<string, any[]>;
+    cursors: Record<string, any>;
+    hasMore: boolean;
+}
+/**
+ * Batch sync configuration for
+ */
+interface BatchSync {
+    /**
+     * Array of table names to sync.
+     */
+    syncTables: string[];
+    /**
+     * Push all pending changes to the server in a single request.
+     * @param changes Array of changes to push
+     * @returns Array of results, one per change, correlated by localId
+     */
+    push: (changes: BatchPushPayload[]) => Promise<BatchPushResult[]>;
+    /**
+     * Pull changes from server since last sync.
+     * @param since Map of table name to last pulled timestamp
+     * @returns Map of table name to array of changed records
+     */
+    pull: (since: Record<string, Date>) => Promise<Record<string, any[]>>;
+    /**
+     * Initial data load for all tables (optional).
+     * @param cursors Map of table name to pagination cursor
+     * @returns Batch first load result with data, cursors, and hasMore flag
+     */
+    firstLoad?: (cursors: Record<string, any>) => Promise<BatchFirstLoadResult>;
+}
+type MissingRemoteRecordStrategy = 'ignore' | 'delete-local-record' | 'insert-remote-record';
+type ConflictResolutionStrategy = 'local-wins' | 'remote-wins' | 'try-shallow-merge';
+type AfterRemoteAddCallback = (stateKey: string, item: SyncedRecord) => void;
+type MissingRemoteRecordDuringUpdateCallback = (strategy: MissingRemoteRecordStrategy, item: SyncedRecord) => void;
+interface SyncOptions {
+    syncInterval?: number;
+    logger?: Logger;
+    minLogLevel?: LogLevel;
+    onAfterRemoteAdd?: AfterRemoteAddCallback;
+    missingRemoteRecordDuringUpdateStrategy?: MissingRemoteRecordStrategy;
+    onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
+    conflictResolutionStrategy?: ConflictResolutionStrategy;
+}
+interface FirstLoadProgress {
+    table: string;
+    inserted: number;
+    updated: number;
+    total: number;
+}
+type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
+type SyncApi = {
+    enable: (enabled: boolean) => Promise<void>;
+    startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
+    getState: () => SyncState;
+    resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
+    onStateChange: (fn: (state: SyncState) => void) => () => void;
+    onMutation: (fn: (event: MutationEvent) => void) => () => void;
+};
+interface MutationEvent {
+    type: 'add' | 'update' | 'delete' | 'bulkAdd' | 'bulkPut' | 'bulkDelete' | 'clear' | 'put' | 'modify' | 'pull';
+    tableName: string;
+    keys?: unknown[];
+}
+interface PersistedSyncState {
+    firstLoadDone: boolean;
+    pendingChanges: PendingChange[];
+    lastPulled: Record<string, string>;
+    error?: Error;
+    conflicts?: Record<string, Conflict>;
+}
+type SyncStatus = 'disabled' | 'disabling' | 'idle' | 'syncing' | 'error';
+interface SyncState extends PersistedSyncState {
+    status: SyncStatus;
+    hydrated: boolean;
+}
+declare enum SyncAction {
+    Create = "create",
+    Update = "update",
+    Remove = "remove"
+}
+interface PendingChange {
+    action: SyncAction;
+    stateKey: string;
+    localId: string;
+    id?: any;
+    version: number;
+    changes?: any;
+    before?: any;
+    after?: any;
+}
+interface Conflict {
+    stateKey: string;
+    fields: FieldConflict[];
+}
+interface FieldConflict {
+    key: string;
+    localValue: any;
+    remoteValue: any;
+}
+type TableMap<TStoreMap extends Record<string, unknown>> = {
+    [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
+};
+
+declare class DyncBase<_TStoreMap = Record<string, any>> {
+    private readonly adapter;
+    private readonly tableCache;
+    private readonly mutationWrappedTables;
+    private readonly syncEnhancedTables;
+    private readonly mutationListeners;
+    private visibilitySubscription?;
+    private openPromise?;
+    private disableSyncPromise?;
+    private disableSyncPromiseResolver?;
+    private sleepAbortController?;
+    private closing;
+    private syncApis;
+    private batchSync?;
+    private syncedTables;
+    private syncOptions;
+    private logger;
+    private syncTimerStarted;
+    private mutationsDuringSync;
+    private state;
+    readonly name: string;
+    /**
+     * Create a new Dync instance.
+     *
+     * Mode 1 - Per-table endpoints:
+     * @param databaseName - Name of the database
+     * @param syncApis - Map of table names to API functions
+     * @param storageAdapter - Storage adapter implementation (required)
+     * @param options - Sync options
+     *
+     * Mode 2 - Batch endpoints:
+     * @param databaseName - Name of the database
+     * @param batchSync - Batch sync config (syncTables, push, pull, firstLoad)
+     * @param storageAdapter - Storage adapter implementation (required)
+     * @param options - Sync options
+     */
+    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
+    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
+    version(versionNumber: number): {
+        stores(schema: Record<string, TableSchemaDefinition>): /*elided*/ any;
+        sqlite(configure: (builder: SQLiteVersionConfigurator) => void): /*elided*/ any;
+    };
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
+    table<K extends keyof _TStoreMap>(name: K): StorageTable<_TStoreMap[K]>;
+    table<T = any>(name: string): StorageTable<T>;
+    private withTransaction;
+    private setupEnhancedTables;
+    private injectSyncColumns;
+    private enhanceSyncTable;
+    private syncOnce;
+    private pullAll;
+    private pushAll;
+    private startSyncTimer;
+    private tryStart;
+    private setupVisibilityListener;
+    private handleVisibilityChange;
+    private startFirstLoad;
+    private getSyncState;
+    private resolveConflict;
+    private enableSync;
+    get syncStatus(): SyncStatus;
+    set syncStatus(status: SyncStatus);
+    private onSyncStateChange;
+    private onMutation;
+    private emitMutation;
+    sync: SyncApi;
+}
+type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> & TableMap<TStoreMap> & {
+    table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
+    table(name: string): StorageTable<any>;
+};
+declare const Dync: {
+    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
+    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
+    prototype: DyncInstance<Record<string, unknown>>;
+} & typeof DyncBase;
+type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
+
+export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, Dync as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, SyncAction as S, type TableMap as T, type ApiFunctions as a, type BatchPushPayload as b, type BatchPushResult as c, type BatchFirstLoadResult as d, type FirstLoadProgressCallback as e, type MissingRemoteRecordDuringUpdateCallback as f, type MutationEvent as g, type SyncOptions as h, type SyncState as i, type SyncedRecord as j };

package/dist/node.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  BetterSqlite3Driver: () => BetterSqlite3Driver
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/storage/sqlite/drivers/BetterSqlite3Driver.ts
+var BetterSqlite3Driver = class {
+  type = "BetterSqlite3Driver";
+  db = null;
+  options;
+  opened = false;
+  name;
+  constructor(databasePath, options = {}) {
+    this.name = databasePath;
+    this.options = {
+      wal: true,
+      ...options
+    };
+  }
+  async open() {
+    if (this.opened) return;
+    const Database = (await import("better-sqlite3")).default;
+    this.db = new Database(this.name, {
+      readonly: this.options.readonly ?? false,
+      fileMustExist: this.options.fileMustExist ?? false,
+      timeout: this.options.timeout ?? 5e3,
+      verbose: this.options.verbose
+    });
+    if (this.options.wal && !this.options.readonly) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.opened = true;
+  }
+  async close() {
+    if (!this.db) return;
+    this.db.close();
+    this.db = null;
+    this.opened = false;
+  }
+  async execute(statement) {
+    await this.open();
+    this.db.exec(statement);
+  }
+  async run(statement, values = []) {
+    await this.open();
+    const stmt = this.db.prepare(statement);
+    const result = stmt.run(...values);
+    return {
+      changes: result.changes,
+      lastId: result.lastInsertRowid !== void 0 ? Number(result.lastInsertRowid) : void 0
+    };
+  }
+  async query(statement, values = []) {
+    await this.open();
+    const stmt = this.db.prepare(statement);
+    const rows = stmt.all(...values);
+    if (rows.length === 0) {
+      return { columns: [], values: [] };
+    }
+    const firstRow = rows[0];
+    const columns = Object.keys(firstRow);
+    const valuesMatrix = rows.map((row) => columns.map((col) => row[col]));
+    return { columns, values: valuesMatrix };
+  }
+  /**
+   * Access the underlying better-sqlite3 Database instance for advanced operations.
+   * Returns null if the database is not open.
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * Execute a function within a transaction.
+   * This provides better performance when doing many writes.
+   *
+   * @example
+   * ```ts
+   * await driver.transaction(() => {
+   *   driver.run('INSERT INTO users (name) VALUES (?)', ['Alice']);
+   *   driver.run('INSERT INTO users (name) VALUES (?)', ['Bob']);
+   * });
+   * ```
+   */
+  transaction(fn) {
+    if (!this.db) {
+      throw new Error("Database not open. Call open() first.");
+    }
+    return this.db.transaction(fn)();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BetterSqlite3Driver
+});
+//# sourceMappingURL=node.cjs.map

package/dist/node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node.ts","../src/storage/sqlite/drivers/BetterSqlite3Driver.ts"],"sourcesContent":["// Node.js SQLite Driver using better-sqlite3\n// Works in Node.js apps and Electron main process\nexport { BetterSqlite3Driver, type BetterSqlite3DriverOptions } from './storage/sqlite/drivers/BetterSqlite3Driver';\nexport type { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult } from './storage/sqlite/types';\n","import type { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult } from '../types';\n\n/**\n * Options for configuring the BetterSqlite3Driver.\n */\nexport interface BetterSqlite3DriverOptions {\n    /**\n     * Open the database in readonly mode.\n     * @default false\n     */\n    readonly?: boolean;\n\n    /**\n     * Create the database file if it doesn't exist.\n     * Set to false to throw an error if the file doesn't exist.\n     * @default true\n     */\n    fileMustExist?: boolean;\n\n    /**\n     * Timeout in milliseconds when waiting for the database to become unlocked.\n     * @default 5000\n     */\n    timeout?: number;\n\n    /**\n     * Enable verbose mode for debugging SQL statements.\n     */\n    verbose?: (message?: unknown, ...additionalArgs: unknown[]) => void;\n\n    /**\n     * Enable WAL (Write-Ahead Logging) mode for better concurrent access.\n     * Recommended for most use cases.\n     * @default true\n     */\n    wal?: boolean;\n}\n\n/**\n * SQLite driver for Node.js using better-sqlite3.\n * This driver is synchronous but wraps operations in Promises for API compatibility.\n *\n * @example\n * ```ts\n * import { BetterSqlite3Driver } from '@anfenn/dync/node';\n * import { SQLiteAdapter } from '@anfenn/dync';\n *\n * const driver = new BetterSqlite3Driver('myapp.db', { wal: true });\n * const adapter = new SQLiteAdapter('myapp', driver);\n * ```\n */\nexport class BetterSqlite3Driver implements SQLiteDatabaseDriver {\n    readonly type = 'BetterSqlite3Driver';\n    private db: import('better-sqlite3').Database | null = null;\n    private readonly options: BetterSqlite3DriverOptions;\n    private opened = false;\n    readonly name: string;\n\n    constructor(databasePath: string, options: BetterSqlite3DriverOptions = {}) {\n        this.name = databasePath;\n        this.options = {\n            wal: true,\n            ...options,\n        };\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n\n        // Dynamic import to avoid bundling issues in non-Electron environments\n        const Database = (await import('better-sqlite3')).default;\n\n        this.db = new Database(this.name, {\n            readonly: this.options.readonly ?? false,\n            fileMustExist: this.options.fileMustExist ?? false,\n            timeout: this.options.timeout ?? 5000,\n            verbose: this.options.verbose,\n        });\n\n        // Enable WAL mode for better concurrent access (recommended)\n        if (this.options.wal && !this.options.readonly) {\n            this.db.pragma('journal_mode = WAL');\n        }\n\n        this.opened = true;\n    }\n\n    async close(): Promise<void> {\n        if (!this.db) return;\n\n        this.db.close();\n        this.db = null;\n        this.opened = false;\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n        this.db!.exec(statement);\n    }\n\n    async run(statement: string, values: unknown[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n\n        const stmt = this.db!.prepare(statement);\n        const result = stmt.run(...values);\n\n        return {\n            changes: result.changes,\n            lastId: result.lastInsertRowid !== undefined ? Number(result.lastInsertRowid) : undefined,\n        };\n    }\n\n    async query(statement: string, values: unknown[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n\n        const stmt = this.db!.prepare(statement);\n        const rows = stmt.all(...values) as Record<string, unknown>[];\n\n        if (rows.length === 0) {\n            return { columns: [], values: [] };\n        }\n\n        const firstRow = rows[0]!;\n        const columns = Object.keys(firstRow);\n        const valuesMatrix = rows.map((row) => columns.map((col) => row[col]));\n\n        return { columns, values: valuesMatrix };\n    }\n\n    /**\n     * Access the underlying better-sqlite3 Database instance for advanced operations.\n     * Returns null if the database is not open.\n     */\n    getDatabase(): import('better-sqlite3').Database | null {\n        return this.db;\n    }\n\n    /**\n     * Execute a function within a transaction.\n     * This provides better performance when doing many writes.\n     *\n     * @example\n     * ```ts\n     * await driver.transaction(() => {\n     *   driver.run('INSERT INTO users (name) VALUES (?)', ['Alice']);\n     *   driver.run('INSERT INTO users (name) VALUES (?)', ['Bob']);\n     * });\n     * ```\n     */\n    transaction<T>(fn: () => T): T {\n        if (!this.db) {\n            throw new Error('Database not open. Call open() first.');\n        }\n        return this.db.transaction(fn)();\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACmDO,IAAM,sBAAN,MAA0D;AAAA,EACpD,OAAO;AAAA,EACR,KAA+C;AAAA,EACtC;AAAA,EACT,SAAS;AAAA,EACR;AAAA,EAET,YAAY,cAAsB,UAAsC,CAAC,GAAG;AACxE,SAAK,OAAO;AACZ,SAAK,UAAU;AAAA,MACX,KAAK;AAAA,MACL,GAAG;AAAA,IACP;AAAA,EACJ;AAAA,EAEA,MAAM,OAAsB;AACxB,QAAI,KAAK,OAAQ;AAGjB,UAAM,YAAY,MAAM,OAAO,gBAAgB,GAAG;AAElD,SAAK,KAAK,IAAI,SAAS,KAAK,MAAM;AAAA,MAC9B,UAAU,KAAK,QAAQ,YAAY;AAAA,MACnC,eAAe,KAAK,QAAQ,iBAAiB;AAAA,MAC7C,SAAS,KAAK,QAAQ,WAAW;AAAA,MACjC,SAAS,KAAK,QAAQ;AAAA,IAC1B,CAAC;AAGD,QAAI,KAAK,QAAQ,OAAO,CAAC,KAAK,QAAQ,UAAU;AAC5C,WAAK,GAAG,OAAO,oBAAoB;AAAA,IACvC;AAEA,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,MAAM,QAAuB;AACzB,QAAI,CAAC,KAAK,GAAI;AAEd,SAAK,GAAG,MAAM;AACd,SAAK,KAAK;AACV,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,MAAM,QAAQ,WAAkC;AAC5C,UAAM,KAAK,KAAK;AAChB,SAAK,GAAI,KAAK,SAAS;AAAA,EAC3B;AAAA,EAEA,MAAM,IAAI,WAAmB,SAAoB,CAAC,GAA6B;AAC3E,UAAM,KAAK,KAAK;AAEhB,UAAM,OAAO,KAAK,GAAI,QAAQ,SAAS;AACvC,UAAM,SAAS,KAAK,IAAI,GAAG,MAAM;AAEjC,WAAO;AAAA,MACH,SAAS,OAAO;AAAA,MAChB,QAAQ,OAAO,oBAAoB,SAAY,OAAO,OAAO,eAAe,IAAI;AAAA,IACpF;AAAA,EACJ;AAAA,EAEA,MAAM,MAAM,WAAmB,SAAoB,CAAC,GAA+B;AAC/E,UAAM,KAAK,KAAK;AAEhB,UAAM,OAAO,KAAK,GAAI,QAAQ,SAAS;AACvC,UAAM,OAAO,KAAK,IAAI,GAAG,MAAM;AAE/B,QAAI,KAAK,WAAW,GAAG;AACnB,aAAO,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAC,EAAE;AAAA,IACrC;AAEA,UAAM,WAAW,KAAK,CAAC;AACvB,UAAM,UAAU,OAAO,KAAK,QAAQ;AACpC,UAAM,eAAe,KAAK,IAAI,CAAC,QAAQ,QAAQ,IAAI,CAAC,QAAQ,IAAI,GAAG,CAAC,CAAC;AAErE,WAAO,EAAE,SAAS,QAAQ,aAAa;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAwD;AACpD,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,YAAe,IAAgB;AAC3B,QAAI,CAAC,KAAK,IAAI;AACV,YAAM,IAAI,MAAM,uCAAuC;AAAA,IAC3D;AACA,WAAO,KAAK,GAAG,YAAY,EAAE,EAAE;AAAA,EACnC;AACJ;","names":[]}