@semics-tech/mongolite 1.0.0 → 1.2.0

package/dist/cjs/changeStream.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeStream = void 0;
+const events_1 = require("events");
+class ChangeStream extends events_1.EventEmitter {
+    constructor(db, collectionName, options = {}) {
+        super();
+        this.db = db;
+        this.collectionName = collectionName;
+        this.options = options;
+        this.closed = false;
+        this.pollInterval = null;
+        this.lastProcessedId = 0;
+        this.buffer = [];
+        this.maxBufferSize = options.maxBufferSize || 1000;
+        this.setupChangeTracking();
+        this.startPolling();
+    }
+    /**
+     * Sets up the change tracking infrastructure
+     */
+    async setupChangeTracking() {
+        await this.ensureChangeLogTable();
+        await this.setupTriggers();
+    }
+    /**
+     * Creates the change log table if it doesn't exist
+     */
+    async ensureChangeLogTable() {
+        const createTableSQL = `
+      CREATE TABLE IF NOT EXISTS __mongolite_changes__ (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+        operation_type TEXT NOT NULL,
+        collection_name TEXT NOT NULL,
+        document_id TEXT NOT NULL,
+        full_document TEXT,
+        full_document_before TEXT,
+        updated_fields TEXT,
+        removed_fields TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+        const createIndexSQL = `
+      CREATE INDEX IF NOT EXISTS idx_mongolite_changes_collection_timestamp 
+      ON __mongolite_changes__ (collection_name, timestamp);
+    `;
+        await this.db.exec(createTableSQL);
+        await this.db.exec(createIndexSQL);
+    }
+    /**
+     * Sets up triggers for tracking changes on the collection
+     */
+    async setupTriggers() {
+        const collectionName = this.collectionName;
+        // Drop existing triggers for this collection
+        await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_insert_trigger"`);
+        await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_update_trigger"`);
+        await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_delete_trigger"`);
+        // Insert trigger
+        const insertTriggerSQL = `
+      CREATE TRIGGER "${collectionName}_insert_trigger"
+      AFTER INSERT ON "${collectionName}"
+      FOR EACH ROW
+      BEGIN
+        INSERT INTO __mongolite_changes__ (
+          operation_type, collection_name, document_id, full_document
+        ) VALUES (
+          'insert', '${collectionName}', NEW._id, NEW.data
+        );
+      END;
+    `;
+        // Update trigger
+        const updateTriggerSQL = `
+      CREATE TRIGGER "${collectionName}_update_trigger"
+      AFTER UPDATE ON "${collectionName}"
+      FOR EACH ROW
+      BEGIN
+        INSERT INTO __mongolite_changes__ (
+          operation_type, collection_name, document_id, 
+          full_document, full_document_before
+        ) VALUES (
+          'update', '${collectionName}', NEW._id, 
+          NEW.data, OLD.data
+        );
+      END;
+    `;
+        // Delete trigger
+        const deleteTriggerSQL = `
+      CREATE TRIGGER "${collectionName}_delete_trigger"
+      AFTER DELETE ON "${collectionName}"
+      FOR EACH ROW
+      BEGIN
+        INSERT INTO __mongolite_changes__ (
+          operation_type, collection_name, document_id, full_document_before
+        ) VALUES (
+          'delete', '${collectionName}', OLD._id, OLD.data
+        );
+      END;
+    `;
+        await this.db.exec(insertTriggerSQL);
+        await this.db.exec(updateTriggerSQL);
+        await this.db.exec(deleteTriggerSQL);
+    }
+    /**
+     * Starts polling for new changes
+     */
+    startPolling() {
+        if (this.closed)
+            return;
+        this.pollInterval = setInterval(async () => {
+            try {
+                await this.pollForChanges();
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }, 100); // Poll every 100ms
+    }
+    /**
+     * Polls for new changes from the change log
+     */
+    async pollForChanges() {
+        if (this.closed)
+            return;
+        const changes = await this.db.all(`SELECT * FROM __mongolite_changes__ 
+       WHERE collection_name = ? AND id > ? 
+       ORDER BY id ASC LIMIT 100`, [this.collectionName, this.lastProcessedId]);
+        for (const change of changes) {
+            if (this.closed)
+                break;
+            const changeDoc = await this.transformChangeEvent(change);
+            if (this.passesFilter(changeDoc)) {
+                this.buffer.push(changeDoc);
+                // Emit the change event
+                this.emit('change', changeDoc);
+                // Clean buffer if it gets too large
+                if (this.buffer.length > this.maxBufferSize) {
+                    this.buffer = this.buffer.slice(-this.maxBufferSize);
+                }
+            }
+            this.lastProcessedId = change.id;
+        }
+    }
+    /**
+     * Transforms a raw change event from the database into a ChangeStreamDocument
+     */
+    async transformChangeEvent(change) {
+        const fullDocument = change.full_document ? JSON.parse(change.full_document) : undefined;
+        const fullDocumentBefore = change.full_document_before
+            ? JSON.parse(change.full_document_before)
+            : undefined;
+        let updateDescription;
+        if (change.operation_type === 'update' && fullDocument && fullDocumentBefore) {
+            updateDescription = this.computeUpdateDescription(fullDocumentBefore, fullDocument);
+        }
+        const changeDoc = {
+            _id: `${change.id}`, // Use the change log ID as the change stream document ID
+            operationType: change.operation_type,
+            clusterTime: new Date(change.timestamp),
+            documentKey: { _id: change.document_id },
+            ns: {
+                db: 'mongolite', // You could make this configurable
+                coll: change.collection_name,
+            },
+        };
+        // Add full document based on options
+        if (this.shouldIncludeFullDocument(change.operation_type)) {
+            changeDoc.fullDocument = fullDocument
+                ? { _id: change.document_id, ...fullDocument }
+                : undefined;
+        }
+        // Add full document before change based on options
+        if (this.shouldIncludeFullDocumentBefore(change.operation_type)) {
+            changeDoc.fullDocumentBeforeChange = fullDocumentBefore
+                ? { _id: change.document_id, ...fullDocumentBefore }
+                : undefined;
+        }
+        if (updateDescription) {
+            changeDoc.updateDescription = updateDescription;
+        }
+        return changeDoc;
+    }
+    /**
+     * Computes the update description by comparing before and after documents
+     */
+    computeUpdateDescription(before, after) {
+        const updatedFields = {};
+        const removedFields = [];
+        // Type guard to ensure we have objects to compare
+        if (typeof before !== 'object' ||
+            before === null ||
+            typeof after !== 'object' ||
+            after === null) {
+            return { updatedFields, removedFields };
+        }
+        // Simple comparison - this could be made more sophisticated
+        const beforeObj = before;
+        const afterObj = after;
+        const allKeys = new Set([...Object.keys(beforeObj), ...Object.keys(afterObj)]);
+        for (const key of allKeys) {
+            if (!(key in afterObj)) {
+                removedFields.push(key);
+            }
+            else if (!(key in beforeObj) ||
+                JSON.stringify(beforeObj[key]) !== JSON.stringify(afterObj[key])) {
+                updatedFields[key] = afterObj[key];
+            }
+        }
+        return { updatedFields, removedFields };
+    }
+    /**
+     * Determines if the full document should be included
+     */
+    shouldIncludeFullDocument(operationType) {
+        const option = this.options.fullDocument || 'default';
+        switch (option) {
+            case 'default':
+                return operationType === 'insert';
+            case 'updateLookup':
+            case 'whenAvailable':
+            case 'required':
+                return (operationType === 'insert' || operationType === 'update' || operationType === 'replace');
+            default:
+                return false;
+        }
+    }
+    /**
+     * Determines if the full document before change should be included
+     */
+    shouldIncludeFullDocumentBefore(operationType) {
+        const option = this.options.fullDocumentBeforeChange || 'off';
+        if (option === 'off')
+            return false;
+        return operationType === 'update' || operationType === 'replace' || operationType === 'delete';
+    }
+    /**
+     * Checks if a change document passes the filter
+     */
+    passesFilter(changeDoc) {
+        if (!this.options.filter)
+            return true;
+        // Simple filter implementation - could be enhanced
+        // For now, just check basic equality filters
+        for (const [key, value] of Object.entries(this.options.filter)) {
+            const docValue = changeDoc[key];
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                // Handle operators like $in, $eq, etc.
+                // This is a simplified implementation
+                continue;
+            }
+            else if (docValue !== value) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Returns an async iterator for the change stream
+     */
+    async *[Symbol.asyncIterator]() {
+        while (!this.closed) {
+            if (this.buffer.length > 0) {
+                yield this.buffer.shift();
+            }
+            else {
+                // Wait for next change
+                await new Promise((resolve) => {
+                    const onChange = () => {
+                        this.removeListener('change', onChange);
+                        this.removeListener('close', onClose);
+                        resolve();
+                    };
+                    const onClose = () => {
+                        this.removeListener('change', onChange);
+                        this.removeListener('close', onClose);
+                        resolve();
+                    };
+                    this.once('change', onChange);
+                    this.once('close', onClose);
+                });
+            }
+        }
+    }
+    /**
+     * Closes the change stream
+     */
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+        this.emit('close');
+        this.removeAllListeners();
+    }
+    /**
+     * Returns the next change document
+     */
+    async next() {
+        if (this.closed) {
+            return { value: {}, done: true };
+        }
+        if (this.buffer.length > 0) {
+            return { value: this.buffer.shift(), done: false };
+        }
+        // Wait for next change
+        return new Promise((resolve) => {
+            const onChange = (changeDoc) => {
+                this.removeListener('change', onChange);
+                this.removeListener('close', onClose);
+                resolve({ value: changeDoc, done: false });
+            };
+            const onClose = () => {
+                this.removeListener('change', onChange);
+                this.removeListener('close', onClose);
+                resolve({ value: {}, done: true });
+            };
+            this.once('change', onChange);
+            this.once('close', onClose);
+        });
+    }
+    /**
+     * Cleanup triggers when the change stream is destroyed
+     */
+    async cleanup() {
+        const collectionName = this.collectionName;
+        try {
+            await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_insert_trigger"`);
+            await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_update_trigger"`);
+            await this.db.exec(`DROP TRIGGER IF EXISTS "${collectionName}_delete_trigger"`);
+        }
+        catch (error) {
+            // Ignore errors during cleanup
+            console.warn('Error during change stream cleanup:', error);
+        }
+    }
+}
+exports.ChangeStream = ChangeStream;

package/dist/cjs/cloudflare.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Cloudflare-safe entry point for MongoLite.
+ *
+ * Import from `@semics-tech/mongolite/cloudflare` inside Cloudflare Workers / Durable Objects.
+ * This module does **not** import `better-sqlite3`, so it bundles cleanly with `wrangler`.
+ *
+ * ## Requirements
+ *
+ * - Enable **Node.js compatibility** in your Worker configuration (e.g. `nodejs_compat`
+ *   flag in `wrangler.toml`/`wrangler.jsonc`). The `ChangeStream` class depends on
+ *   Node's built-in `events` module, which requires this flag even if you don't use
+ *   change streams directly.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { DurableObject } from 'cloudflare:workers';
+ * import { MongoLite, CloudflareDurableObjectAdapter } from '@semics-tech/mongolite/cloudflare';
+ *
+ * export class MyDurableObject extends DurableObject {
+ *   private client: MongoLite;
+ *
+ *   constructor(ctx: DurableObjectState, env: Env) {
+ *     super(ctx, env);
+ *     this.client = new MongoLite(new CloudflareDurableObjectAdapter(ctx.storage.sql));
+ *     ctx.blockConcurrencyWhile(() => this.client.collection('users').ensureTable());
+ *   }
+ * }
+ * ```
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeStream = exports.MongoLiteCollection = exports.CloudflareDurableObjectAdapter = exports.MongoLite = void 0;
+// Core MongoLite class — accepts any IDatabaseAdapter, no better-sqlite3 dependency.
+var mongo_client_js_1 = require("./mongo-client.js");
+Object.defineProperty(exports, "MongoLite", { enumerable: true, get: function () { return mongo_client_js_1.MongoLite; } });
+// Cloudflare-specific adapter
+var cloudflare_js_1 = require("./adapters/cloudflare.js");
+Object.defineProperty(exports, "CloudflareDurableObjectAdapter", { enumerable: true, get: function () { return cloudflare_js_1.CloudflareDurableObjectAdapter; } });
+var collection_js_1 = require("./collection.js");
+Object.defineProperty(exports, "MongoLiteCollection", { enumerable: true, get: function () { return collection_js_1.MongoLiteCollection; } });
+__exportStar(require("./types.js"), exports);
+// Change streams (requires nodejs_compat in Workers)
+var changeStream_js_1 = require("./changeStream.js");
+Object.defineProperty(exports, "ChangeStream", { enumerable: true, get: function () { return changeStream_js_1.ChangeStream; } });