pomegranate-db 0.1.0

package/dist/adapters/loki/LokiAdapter.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * LokiJS Adapter.
+ *
+ * In-memory database adapter using LokiJS, suitable for web and testing.
+ * Supports running LokiJS in a Web Worker for better UI performance.
+ *
+ * Architecture:
+ * - Direct mode (default): LokiExecutor runs in the main thread.
+ * - Worker mode: All operations are dispatched via postMessage to a Web Worker
+ *   (or SynchronousWorker for testing) that runs LokiExecutor internally.
+ *
+ * ```
+ * LokiAdapter  ──▶  LokiExecutor (direct mode)
+ *       │
+ *       └──▶  LokiDispatcher  ──▶  [Worker]  ──▶  LokiExecutor (worker mode)
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiAdapter = void 0;
+const LokiExecutor_1 = require("./worker/LokiExecutor");
+const LokiDispatcher_1 = require("./worker/LokiDispatcher");
+// Re-export for consumers
+// ─── LokiJS Adapter ──────────────────────────────────────────────────────
+class LokiAdapter {
+    _executor = null;
+    _dispatcher = null;
+    _config;
+    _initialized = false;
+    constructor(config) {
+        this._config = config;
+        if (config.worker) {
+            this._dispatcher = new LokiDispatcher_1.LokiDispatcher(config.worker);
+        }
+    }
+    // ─── Initialize ──────────────────────────────────────────────────────
+    async initialize(schema) {
+        if (this._initialized)
+            return;
+        if (this._dispatcher) {
+            // Worker mode: send serializable config + schema to the worker
+            await this._dispatcher.call('setUp', [
+                {
+                    databaseName: this._config.databaseName,
+                    saveStrategy: this._config.saveStrategy,
+                    autosaveInterval: this._config.autosaveInterval,
+                },
+                schema,
+            ]);
+        }
+        else {
+            // Direct mode: create executor locally
+            this._executor = new LokiExecutor_1.LokiExecutor({
+                databaseName: this._config.databaseName,
+                saveStrategy: this._config.saveStrategy,
+                autosaveInterval: this._config.autosaveInterval,
+                persistenceAdapter: this._config.persistenceAdapter,
+                lokiInstance: this._config.lokiInstance,
+            });
+            await this._executor.initialize(schema);
+        }
+        this._initialized = true;
+    }
+    // ─── Delegation helper ──────────────────────────────────────────────
+    /**
+     * Route a command to either the local executor or the remote worker.
+     * In worker mode, arguments are serialized via postMessage (structured cloning).
+     * In direct mode, the executor method is called directly.
+     */
+    _call(method, args) {
+        if (this._dispatcher) {
+            return this._dispatcher.call(method, args);
+        }
+        if (!this._executor)
+            throw new Error('Database not initialized');
+        return this._executor[method](...args);
+    }
+    // ─── Query ──────────────────────────────────────────────────────────
+    async find(query) {
+        return this._call('find', [query]);
+    }
+    async count(query) {
+        return this._call('count', [query]);
+    }
+    async findById(table, id) {
+        return this._call('findById', [table, id]);
+    }
+    // ─── Insert / Update / Delete ────────────────────────────────────────
+    async insert(table, raw) {
+        return this._call('insert', [table, raw]);
+    }
+    async update(table, raw) {
+        return this._call('update', [table, raw]);
+    }
+    async markAsDeleted(table, id) {
+        return this._call('markAsDeleted', [table, id]);
+    }
+    async destroyPermanently(table, id) {
+        return this._call('destroyPermanently', [table, id]);
+    }
+    // ─── Batch ──────────────────────────────────────────────────────────
+    async batch(operations) {
+        return this._call('batch', [operations]);
+    }
+    // ─── Search ──────────────────────────────────────────────────────────
+    async search(descriptor) {
+        return this._call('search', [descriptor]);
+    }
+    // ─── Sync helpers ──────────────────────────────────────────────────
+    async getLocalChanges(tables) {
+        return this._call('getLocalChanges', [tables]);
+    }
+    async applyRemoteChanges(changes) {
+        return this._call('applyRemoteChanges', [changes]);
+    }
+    async markAsSynced(table, ids) {
+        return this._call('markAsSynced', [table, ids]);
+    }
+    // ─── Schema version ──────────────────────────────────────────────────
+    async getSchemaVersion() {
+        return this._call('getSchemaVersion', []);
+    }
+    // ─── Migration ──────────────────────────────────────────────────────
+    async migrate(migrations) {
+        return this._call('migrate', [migrations]);
+    }
+    // ─── Reset ──────────────────────────────────────────────────────────
+    async reset() {
+        return this._call('reset', []);
+    }
+    // ─── Close ──────────────────────────────────────────────────────────
+    async close() {
+        if (this._dispatcher) {
+            await this._dispatcher.call('close', []);
+            this._dispatcher.terminate();
+        }
+        else if (this._executor) {
+            await this._executor.close();
+        }
+        this._initialized = false;
+    }
+}
+exports.LokiAdapter = LokiAdapter;
+//# sourceMappingURL=LokiAdapter.js.map

package/dist/adapters/loki/index.d.ts

@@ -0,0 +1,6 @@
+export { LokiAdapter } from './LokiAdapter';
+export type { LokiAdapterConfig, LokiExecutorConfig } from './LokiAdapter';
+export { LokiExecutor } from './worker/LokiExecutor';
+export { LokiDispatcher } from './worker/LokiDispatcher';
+export { SynchronousWorker } from './worker/SynchronousWorker';
+export type { WorkerInterface, WorkerCommandType, WorkerAction, WorkerResponse, } from './worker/types';

package/dist/adapters/loki/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynchronousWorker = exports.LokiDispatcher = exports.LokiExecutor = exports.LokiAdapter = void 0;
+var LokiAdapter_1 = require("./LokiAdapter");
+Object.defineProperty(exports, "LokiAdapter", { enumerable: true, get: function () { return LokiAdapter_1.LokiAdapter; } });
+var LokiExecutor_1 = require("./worker/LokiExecutor");
+Object.defineProperty(exports, "LokiExecutor", { enumerable: true, get: function () { return LokiExecutor_1.LokiExecutor; } });
+var LokiDispatcher_1 = require("./worker/LokiDispatcher");
+Object.defineProperty(exports, "LokiDispatcher", { enumerable: true, get: function () { return LokiDispatcher_1.LokiDispatcher; } });
+var SynchronousWorker_1 = require("./worker/SynchronousWorker");
+Object.defineProperty(exports, "SynchronousWorker", { enumerable: true, get: function () { return SynchronousWorker_1.SynchronousWorker; } });
+//# sourceMappingURL=index.js.map

package/dist/adapters/loki/worker/LokiDispatcher.d.ts

@@ -0,0 +1,21 @@
+/**
+ * LokiJS Dispatcher.
+ *
+ * Main-thread proxy that sends commands to a Web Worker (or SynchronousWorker)
+ * and matches responses to resolve/reject the corresponding Promises.
+ *
+ * All responses are assumed to arrive in FIFO order (the worker processes
+ * one command at a time). An ID-based sanity check catches any ordering bugs.
+ */
+import type { WorkerCommandType, WorkerInterface } from './types';
+export declare class LokiDispatcher {
+    private _worker;
+    private _pendingCalls;
+    private _nextId;
+    constructor(worker: WorkerInterface);
+    /** Send a command to the worker and return a Promise for the result. */
+    call(type: WorkerCommandType, payload: unknown[]): Promise<unknown>;
+    /** Terminate the worker and reject all pending calls. */
+    terminate(): void;
+    private _onMessage;
+}

package/dist/adapters/loki/worker/LokiDispatcher.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * LokiJS Dispatcher.
+ *
+ * Main-thread proxy that sends commands to a Web Worker (or SynchronousWorker)
+ * and matches responses to resolve/reject the corresponding Promises.
+ *
+ * All responses are assumed to arrive in FIFO order (the worker processes
+ * one command at a time). An ID-based sanity check catches any ordering bugs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiDispatcher = void 0;
+class LokiDispatcher {
+    _worker;
+    _pendingCalls = [];
+    _nextId = 1;
+    constructor(worker) {
+        this._worker = worker;
+        this._worker.onmessage = this._onMessage.bind(this);
+    }
+    /** Send a command to the worker and return a Promise for the result. */
+    call(type, payload) {
+        return new Promise((resolve, reject) => {
+            const id = this._nextId++;
+            this._pendingCalls.push({ id, resolve, reject });
+            const action = { id, type, payload };
+            this._worker.postMessage(action);
+        });
+    }
+    /** Terminate the worker and reject all pending calls. */
+    terminate() {
+        this._worker.terminate?.();
+        for (const pending of this._pendingCalls) {
+            pending.reject(new Error('Worker terminated'));
+        }
+        this._pendingCalls = [];
+    }
+    _onMessage(event) {
+        const response = event.data;
+        const pending = this._pendingCalls.shift();
+        if (!pending) {
+            console.error('[LokiDispatcher] Received response with no pending call');
+            return;
+        }
+        if (pending.id !== response.id) {
+            console.error(`[LokiDispatcher] Response ID mismatch: expected ${pending.id}, got ${response.id}`);
+            pending.reject(new Error('Worker response ID mismatch'));
+            return;
+        }
+        if ('error' in response.result) {
+            const err = response.result.error;
+            const error = new Error(err.message);
+            if (err.stack)
+                error.stack = err.stack;
+            pending.reject(error);
+        }
+        else {
+            pending.resolve(response.result.value);
+        }
+    }
+}
+exports.LokiDispatcher = LokiDispatcher;
+//# sourceMappingURL=LokiDispatcher.js.map

package/dist/adapters/loki/worker/LokiExecutor.d.ts

@@ -0,0 +1,96 @@
+/**
+ * LokiJS Executor.
+ *
+ * Contains all actual database operations using LokiJS.
+ * Runs either in the main thread (direct mode) or inside a Web Worker.
+ */
+import type { Migration } from '../../types';
+import type { QueryDescriptor, SearchDescriptor, BatchOperation } from '../../../query/types';
+import type { DatabaseSchema, RawRecord } from '../../../schema/types';
+interface LokiCollection<T extends object = any> {
+    insert(doc: T): T;
+    findOne(query: object): T | null;
+    find(query?: object): T[];
+    update(doc: T): void;
+    remove(doc: T | T[]): void;
+    count(query?: object): number;
+    chain(): LokiResultset<T>;
+    clear(): void;
+}
+interface LokiResultset<T extends object = any> {
+    find(query: object): LokiResultset<T>;
+    where(fn: (doc: T) => boolean): LokiResultset<T>;
+    simplesort(field: string, options?: {
+        desc?: boolean;
+    }): LokiResultset<T>;
+    offset(n: number): LokiResultset<T>;
+    limit(n: number): LokiResultset<T>;
+    data(): T[];
+    count(): number;
+}
+interface LokiDb {
+    addCollection<T extends object>(name: string, options?: object): LokiCollection<T>;
+    getCollection<T extends object>(name: string): LokiCollection<T> | null;
+    removeCollection(name: string): void;
+    listCollections(): Array<{
+        name: string;
+    }>;
+    saveDatabase(callback?: (err: unknown) => void): void;
+    close(callback?: () => void): void;
+}
+export interface LokiExecutorConfig {
+    databaseName: string;
+    saveStrategy?: 'immediate' | 'auto';
+    autosaveInterval?: number;
+    /** Pre-constructed persistence adapter (direct mode only, not serializable). */
+    persistenceAdapter?: unknown;
+    /** Pre-constructed LokiJS instance (direct mode only, not serializable). */
+    lokiInstance?: LokiDb;
+}
+export declare class LokiExecutor {
+    private _db;
+    private _config;
+    private _schemaVersion;
+    private _initialized;
+    constructor(config: LokiExecutorConfig);
+    initialize(schema: DatabaseSchema): Promise<void>;
+    private _createLokiDb;
+    private _getCollection;
+    /**
+     * Persist to storage adapter.
+     * No-op when: no persistence configured, or saveStrategy is 'auto' (timer handles it).
+     */
+    private _save;
+    private _doInsert;
+    private _doUpdate;
+    private _doMarkAsDeleted;
+    private _doDestroyPermanently;
+    find(query: QueryDescriptor): Promise<RawRecord[]>;
+    count(query: QueryDescriptor): Promise<number>;
+    findById(table: string, id: string): Promise<RawRecord | null>;
+    insert(table: string, raw: RawRecord): Promise<void>;
+    update(table: string, raw: RawRecord): Promise<void>;
+    markAsDeleted(table: string, id: string): Promise<void>;
+    destroyPermanently(table: string, id: string): Promise<void>;
+    batch(operations: BatchOperation[]): Promise<void>;
+    search(descriptor: SearchDescriptor): Promise<{
+        records: RawRecord[];
+        total: number;
+    }>;
+    getLocalChanges(tables: string[]): Promise<Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>>;
+    applyRemoteChanges(changes: Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>): Promise<void>;
+    markAsSynced(table: string, ids: string[]): Promise<void>;
+    getSchemaVersion(): Promise<number>;
+    migrate(migrations: Migration[]): Promise<void>;
+    reset(): Promise<void>;
+    close(): Promise<void>;
+}
+export {};