pomegranate-db 0.1.0

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

@@ -0,0 +1,462 @@
+"use strict";
+/**
+ * LokiJS Executor.
+ *
+ * Contains all actual database operations using LokiJS.
+ * Runs either in the main thread (direct mode) or inside a Web Worker.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiExecutor = void 0;
+// ─── LokiJS Executor ─────────────────────────────────────────────────────
+class LokiExecutor {
+    _db = null;
+    _config;
+    _schemaVersion = 0;
+    _initialized = false;
+    constructor(config) {
+        this._config = config;
+    }
+    // ─── Initialize ──────────────────────────────────────────────────────
+    async initialize(schema) {
+        if (this._initialized)
+            return;
+        if (this._config.lokiInstance) {
+            this._db = this._config.lokiInstance;
+        }
+        else {
+            this._db = await this._createLokiDb();
+        }
+        let metaCollection = this._db.getCollection('__pomegranate_metadata');
+        if (!metaCollection) {
+            metaCollection = this._db.addCollection('__pomegranate_metadata', { unique: ['key'] });
+        }
+        const versionDoc = metaCollection.findOne({ key: 'schema_version' });
+        const existingVersion = versionDoc ? Number.parseInt(versionDoc.value, 10) : 0;
+        if (existingVersion === 0) {
+            for (const table of schema.tables) {
+                if (!this._db.getCollection(table.name)) {
+                    const indices = table.columns.filter((c) => c.isIndexed).map((c) => c.name);
+                    this._db.addCollection(table.name, {
+                        unique: ['id'],
+                        indices: ['_status', ...indices],
+                    });
+                }
+            }
+            const existing = metaCollection.findOne({ key: 'schema_version' });
+            if (existing) {
+                existing.value = String(schema.version);
+                metaCollection.update(existing);
+            }
+            else {
+                metaCollection.insert({ key: 'schema_version', value: String(schema.version) });
+            }
+        }
+        this._schemaVersion = schema.version;
+        this._initialized = true;
+    }
+    async _createLokiDb() {
+        const { default: Loki } = await Promise.resolve().then(() => __importStar(require('lokijs')));
+        const hasPersistence = !!this._config.persistenceAdapter;
+        const options = {};
+        if (hasPersistence) {
+            options.adapter = this._config.persistenceAdapter;
+            const strategy = this._config.saveStrategy ?? 'immediate';
+            if (strategy === 'auto') {
+                options.autosave = true;
+                options.autosaveinterval = this._config.autosaveInterval ?? 500;
+            }
+        }
+        return new Promise((resolve, reject) => {
+            if (hasPersistence) {
+                options.autoload = true;
+                options.autoloadCallback = (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(db);
+                };
+            }
+            const db = new Loki(this._config.databaseName || 'pomegranate.db', options);
+            if (!hasPersistence) {
+                resolve(db);
+            }
+        });
+    }
+    _getCollection(table) {
+        if (!this._db)
+            throw new Error('Database not initialized');
+        const col = this._db.getCollection(table);
+        if (!col)
+            throw new Error(`Collection "${table}" not found`);
+        return col;
+    }
+    /**
+     * Persist to storage adapter.
+     * No-op when: no persistence configured, or saveStrategy is 'auto' (timer handles it).
+     */
+    async _save() {
+        if (!this._db || !this._config.persistenceAdapter)
+            return;
+        if ((this._config.saveStrategy ?? 'immediate') !== 'immediate')
+            return;
+        return new Promise((resolve, reject) => {
+            this._db.saveDatabase((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    // ─── Core sync operations (for batch optimization) ──────────────────
+    _doInsert(table, raw) {
+        const col = this._getCollection(table);
+        col.insert({ ...raw });
+    }
+    _doUpdate(table, raw) {
+        const col = this._getCollection(table);
+        const existing = col.findOne({ id: raw.id });
+        if (!existing)
+            throw new Error(`Record not found: ${table}/${raw.id}`);
+        for (const [key, value] of Object.entries(raw)) {
+            existing[key] = value;
+        }
+        col.update(existing);
+    }
+    _doMarkAsDeleted(table, id) {
+        const col = this._getCollection(table);
+        const doc = col.findOne({ id });
+        if (doc) {
+            doc._status = 'deleted';
+            col.update(doc);
+        }
+    }
+    _doDestroyPermanently(table, id) {
+        const col = this._getCollection(table);
+        const doc = col.findOne({ id });
+        if (doc) {
+            col.remove(doc);
+        }
+    }
+    // ─── Query ──────────────────────────────────────────────────────────
+    async find(query) {
+        const col = this._getCollection(query.table);
+        let chain = col.chain();
+        if (query.conditions.length > 0) {
+            const lokiQuery = conditionsToLoki(query.conditions);
+            chain = chain.find(lokiQuery);
+        }
+        for (const ob of query.orderBy) {
+            chain = chain.simplesort(ob.column, { desc: ob.order === 'desc' });
+        }
+        if (query.offset !== undefined) {
+            chain = chain.offset(query.offset);
+        }
+        if (query.limit !== undefined) {
+            chain = chain.limit(query.limit);
+        }
+        return stripLokiMeta(chain.data());
+    }
+    async count(query) {
+        const col = this._getCollection(query.table);
+        if (query.conditions.length > 0) {
+            const lokiQuery = conditionsToLoki(query.conditions);
+            return col.chain().find(lokiQuery).count();
+        }
+        return col.count();
+    }
+    async findById(table, id) {
+        const col = this._getCollection(table);
+        const doc = col.findOne({ id });
+        return doc ? stripLokiMetaSingle(doc) : null;
+    }
+    // ─── Insert / Update / Delete ────────────────────────────────────────
+    async insert(table, raw) {
+        this._doInsert(table, raw);
+        await this._save();
+    }
+    async update(table, raw) {
+        this._doUpdate(table, raw);
+        await this._save();
+    }
+    async markAsDeleted(table, id) {
+        this._doMarkAsDeleted(table, id);
+        await this._save();
+    }
+    async destroyPermanently(table, id) {
+        this._doDestroyPermanently(table, id);
+        await this._save();
+    }
+    // ─── Batch (single save at end) ─────────────────────────────────────
+    async batch(operations) {
+        for (const op of operations) {
+            switch (op.type) {
+                case 'create':
+                    this._doInsert(op.table, op.rawRecord);
+                    break;
+                case 'update':
+                    this._doUpdate(op.table, op.rawRecord);
+                    break;
+                case 'delete':
+                    this._doMarkAsDeleted(op.table, op.id);
+                    break;
+                case 'destroyPermanently':
+                    this._doDestroyPermanently(op.table, op.id);
+                    break;
+            }
+        }
+        await this._save();
+    }
+    // ─── Search ──────────────────────────────────────────────────────────
+    async search(descriptor) {
+        const col = this._getCollection(descriptor.table);
+        const term = descriptor.term.toLowerCase();
+        let results = col.chain().where((doc) => {
+            return descriptor.fields.some((field) => {
+                const val = doc[field];
+                return typeof val === 'string' && val.toLowerCase().includes(term);
+            });
+        });
+        if (descriptor.conditions.length > 0) {
+            const lokiQuery = conditionsToLoki(descriptor.conditions);
+            results = results.find(lokiQuery);
+        }
+        const total = results.count();
+        for (const ob of descriptor.orderBy) {
+            results = results.simplesort(ob.column, { desc: ob.order === 'desc' });
+        }
+        const data = results.offset(descriptor.offset).limit(descriptor.limit).data();
+        return {
+            records: stripLokiMeta(data),
+            total,
+        };
+    }
+    // ─── Sync helpers ──────────────────────────────────────────────────
+    async getLocalChanges(tables) {
+        const result = {};
+        for (const table of tables) {
+            const col = this._getCollection(table);
+            const created = col.find({ _status: 'created' });
+            const updated = col.find({ _status: 'updated' });
+            const deleted = col.find({ _status: 'deleted' });
+            result[table] = {
+                created: stripLokiMeta(created),
+                updated: stripLokiMeta(updated),
+                deleted: deleted.map((d) => d.id),
+            };
+        }
+        return result;
+    }
+    async applyRemoteChanges(changes) {
+        for (const [table, tableChanges] of Object.entries(changes)) {
+            const col = this._getCollection(table);
+            for (const raw of tableChanges.created) {
+                const existing = col.findOne({ id: raw.id });
+                if (existing) {
+                    for (const [key, value] of Object.entries(raw)) {
+                        existing[key] = value;
+                    }
+                    existing._status = 'synced';
+                    existing._changed = '';
+                    col.update(existing);
+                }
+                else {
+                    col.insert({ ...raw, _status: 'synced', _changed: '' });
+                }
+            }
+            for (const raw of tableChanges.updated) {
+                const existing = col.findOne({ id: raw.id });
+                if (existing) {
+                    for (const [key, value] of Object.entries(raw)) {
+                        existing[key] = value;
+                    }
+                    existing._status = 'synced';
+                    existing._changed = '';
+                    col.update(existing);
+                }
+                else {
+                    col.insert({ ...raw, _status: 'synced', _changed: '' });
+                }
+            }
+            for (const id of tableChanges.deleted) {
+                const doc = col.findOne({ id });
+                if (doc)
+                    col.remove(doc);
+            }
+        }
+    }
+    async markAsSynced(table, ids) {
+        const col = this._getCollection(table);
+        for (const id of ids) {
+            const doc = col.findOne({ id });
+            if (doc) {
+                doc._status = 'synced';
+                doc._changed = '';
+                col.update(doc);
+            }
+        }
+    }
+    // ─── Schema version ──────────────────────────────────────────────────
+    async getSchemaVersion() {
+        return this._schemaVersion;
+    }
+    // ─── Migration ──────────────────────────────────────────────────────
+    async migrate(migrations) {
+        for (const migration of migrations) {
+            for (const step of migration.steps) {
+                switch (step.type) {
+                    case 'createTable':
+                        if (!this._db.getCollection(step.schema.name)) {
+                            this._db.addCollection(step.schema.name, { unique: ['id'] });
+                        }
+                        break;
+                    case 'destroyTable':
+                        this._db.removeCollection(step.table);
+                        break;
+                }
+            }
+        }
+    }
+    // ─── Reset ──────────────────────────────────────────────────────────
+    async reset() {
+        if (!this._db)
+            return;
+        const collections = this._db.listCollections();
+        for (const col of collections) {
+            const collection = this._db.getCollection(col.name);
+            if (collection)
+                collection.clear();
+        }
+        this._initialized = false;
+    }
+    // ─── Close ──────────────────────────────────────────────────────────
+    async close() {
+        if (this._db) {
+            await new Promise((resolve) => {
+                this._db.close(() => resolve());
+            });
+        }
+    }
+}
+exports.LokiExecutor = LokiExecutor;
+// ─── Loki Query Translation ──────────────────────────────────────────────
+function conditionsToLoki(conditions) {
+    if (conditions.length === 1) {
+        return conditionToLoki(conditions[0]);
+    }
+    return { $and: conditions.map(conditionToLoki) };
+}
+function conditionToLoki(condition) {
+    switch (condition.type) {
+        case 'where': {
+            const w = condition;
+            return { [w.column]: operatorToLoki(w.operator, w.value) };
+        }
+        case 'and':
+            return { $and: condition.conditions.map(conditionToLoki) };
+        case 'or':
+            return { $or: condition.conditions.map(conditionToLoki) };
+        case 'not': {
+            const inner = conditionToLoki(condition.condition);
+            const negated = {};
+            for (const [key, val] of Object.entries(inner)) {
+                if (typeof val === 'object' && val !== null) {
+                    negated[key] = { $not: val };
+                }
+                else {
+                    negated[key] = { $ne: val };
+                }
+            }
+            return negated;
+        }
+        default:
+            throw new Error(`Unknown condition type: ${condition.type}`);
+    }
+}
+function operatorToLoki(op, value) {
+    const normalizedValue = typeof value === 'boolean' ? (value ? 1 : 0) : value;
+    switch (op) {
+        case 'eq':
+            return { $eq: normalizedValue };
+        case 'neq':
+            return { $ne: normalizedValue };
+        case 'gt':
+            return { $gt: normalizedValue };
+        case 'gte':
+            return { $gte: normalizedValue };
+        case 'lt':
+            return { $lt: normalizedValue };
+        case 'lte':
+            return { $lte: normalizedValue };
+        case 'in':
+            return {
+                $in: Array.isArray(value)
+                    ? value.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v))
+                    : value,
+            };
+        case 'notIn':
+            return {
+                $nin: Array.isArray(value)
+                    ? value.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v))
+                    : value,
+            };
+        case 'like':
+            return { $regex: new RegExp(String(value).replaceAll('%', '.*').replaceAll('_', '.'), 'i') };
+        case 'notLike':
+            return {
+                $not: { $regex: new RegExp(String(value).replaceAll('%', '.*').replaceAll('_', '.'), 'i') },
+            };
+        case 'between': {
+            const [low, high] = value;
+            return { $between: [low, high] };
+        }
+        case 'isNull':
+            return { $eq: null };
+        case 'isNotNull':
+            return { $ne: null };
+        default:
+            throw new Error(`Unknown operator: ${op}`);
+    }
+}
+// ─── Strip LokiJS internal metadata ($loki, meta) ────────────────────────
+function stripLokiMeta(docs) {
+    return docs.map(stripLokiMetaSingle);
+}
+function stripLokiMetaSingle(doc) {
+    const { $loki, meta, ...rest } = doc;
+    return rest;
+}
+//# sourceMappingURL=LokiExecutor.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * Synchronous Worker.
+ *
+ * Simulates the Web Worker API entirely in-process. Used for:
+ * - Testing the worker message protocol without actual threading
+ * - Environments where Web Workers are not available (e.g. Node.js tests)
+ *
+ * Internally creates a LokiExecutor and processes messages sequentially,
+ * cloning data via JSON round-trip to simulate structured cloning.
+ */
+import type { WorkerInterface } from './types';
+export declare class SynchronousWorker implements WorkerInterface {
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    private _executor;
+    private _queue;
+    private _isProcessing;
+    postMessage(data: unknown): void;
+    terminate(): void;
+    private _processNext;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Synchronous Worker.
+ *
+ * Simulates the Web Worker API entirely in-process. Used for:
+ * - Testing the worker message protocol without actual threading
+ * - Environments where Web Workers are not available (e.g. Node.js tests)
+ *
+ * Internally creates a LokiExecutor and processes messages sequentially,
+ * cloning data via JSON round-trip to simulate structured cloning.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynchronousWorker = void 0;
+const LokiExecutor_1 = require("./LokiExecutor");
+class SynchronousWorker {
+    onmessage = null;
+    _executor = null;
+    _queue = [];
+    _isProcessing = false;
+    postMessage(data) {
+        // Clone the data to simulate structured cloning across worker boundary
+        const action = JSON.parse(JSON.stringify(data));
+        this._queue.push(action);
+        if (!this._isProcessing) {
+            void this._processNext();
+        }
+    }
+    terminate() {
+        this._queue = [];
+        this._executor = null;
+    }
+    async _processNext() {
+        if (this._queue.length === 0) {
+            this._isProcessing = false;
+            return;
+        }
+        this._isProcessing = true;
+        const action = this._queue[0];
+        let result;
+        try {
+            if (action.type === 'setUp') {
+                const [setupPayload, schema] = action.payload;
+                this._executor = new LokiExecutor_1.LokiExecutor({
+                    databaseName: setupPayload.databaseName,
+                    saveStrategy: setupPayload.saveStrategy,
+                    autosaveInterval: setupPayload.autosaveInterval,
+                });
+                await this._executor.initialize(schema);
+                result = { value: undefined };
+            }
+            else if (this._executor) {
+                const method = this._executor[action.type];
+                if (typeof method !== 'function') {
+                    throw new TypeError(`Unknown command: ${action.type}`);
+                }
+                const value = await method.call(this._executor, ...action.payload);
+                result = { value };
+            }
+            else {
+                throw new Error('Worker not initialized — call setUp first');
+            }
+        }
+        catch (error_) {
+            const error = error_ instanceof Error ? error_ : new Error(String(error_));
+            result = { error: { message: error.message, stack: error.stack } };
+        }
+        const response = { id: action.id, result };
+        // Clone the response to simulate structured cloning
+        const clonedResponse = JSON.parse(JSON.stringify(response));
+        this.onmessage?.({ data: clonedResponse });
+        this._queue.shift();
+        await this._processNext();
+    }
+}
+exports.SynchronousWorker = SynchronousWorker;
+//# sourceMappingURL=SynchronousWorker.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * LokiJS Web Worker entry point.
+ *
+ * Minimal bootstrap — creates a LokiExecutor and processes commands
+ * sequentially via the message queue. Designed to be loaded as a
+ * Web Worker by the browser's Worker constructor.
+ *
+ * @example
+ * // In your app (bundler must support worker URLs):
+ * const worker = new Worker(
+ *   new URL('pomegranate-db/dist/adapters/loki/worker/loki.worker.js', import.meta.url),
+ * );
+ */
+export {};

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

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * LokiJS Web Worker entry point.
+ *
+ * Minimal bootstrap — creates a LokiExecutor and processes commands
+ * sequentially via the message queue. Designed to be loaded as a
+ * Web Worker by the browser's Worker constructor.
+ *
+ * @example
+ * // In your app (bundler must support worker URLs):
+ * const worker = new Worker(
+ *   new URL('pomegranate-db/dist/adapters/loki/worker/loki.worker.js', import.meta.url),
+ * );
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const LokiExecutor_1 = require("./LokiExecutor");
+const ctx = self;
+let executor = null;
+const actionQueue = [];
+let isProcessing = false;
+ctx.onmessage = (event) => {
+    actionQueue.push(event.data);
+    if (!isProcessing) {
+        void processNext();
+    }
+};
+async function processNext() {
+    if (actionQueue.length === 0) {
+        isProcessing = false;
+        return;
+    }
+    isProcessing = true;
+    const action = actionQueue[0];
+    let result;
+    try {
+        if (action.type === 'setUp') {
+            const [setupPayload, schema] = action.payload;
+            // Auto-create IncrementalIDBAdapter for browser persistence
+            let persistenceAdapter;
+            try {
+                const { default: IncrementalIDBAdapter } = await Promise.resolve().then(() => __importStar(require('lokijs/src/incremental-indexeddb-adapter')));
+                persistenceAdapter = new IncrementalIDBAdapter();
+            }
+            catch {
+                // IndexedDB not available — fall back to memory-only
+            }
+            executor = new LokiExecutor_1.LokiExecutor({
+                databaseName: setupPayload.databaseName,
+                saveStrategy: setupPayload.saveStrategy,
+                autosaveInterval: setupPayload.autosaveInterval,
+                persistenceAdapter,
+            });
+            await executor.initialize(schema);
+            result = { value: undefined };
+        }
+        else if (executor) {
+            const method = executor[action.type];
+            if (typeof method !== 'function') {
+                throw new TypeError(`Unknown command: ${action.type}`);
+            }
+            const value = await method.call(executor, ...action.payload);
+            result = { value };
+        }
+        else {
+            throw new Error('Worker not initialized — call setUp first');
+        }
+    }
+    catch (error_) {
+        const error = error_ instanceof Error ? error_ : new Error(String(error_));
+        // Log for worker-side debugging (stack traces are lost across postMessage)
+        console.error(`[LokiWorker] Error in ${action.type}:`, error);
+        result = { error: { message: error.message, stack: error.stack } };
+    }
+    const response = { id: action.id, result };
+    ctx.postMessage(response);
+    actionQueue.shift();
+    await processNext();
+}
+//# sourceMappingURL=loki.worker.js.map