mongo.do 0.1.0

package/dist/wire/backend/local-sqlite.js

@@ -0,0 +1,1002 @@
+/**
+ * Local SQLite Backend
+ *
+ * Implements MondoBackend using Bun's native SQLite for local development.
+ * Simplified implementation for wire protocol server.
+ */
+import { Database } from 'bun:sqlite';
+import { ObjectId } from 'bson';
+import { validateFieldPath, safeJsonPath } from '../../utils/sql-safety.js';
+import { sanitizeDatabaseName, validateCollectionName } from './validation.js';
+// Re-export validation functions for backwards compatibility
+export { sanitizeDatabaseName, validateCollectionName } from './validation.js';
+/** Default batch size for cursor results */
+const DEFAULT_BATCH_SIZE = 101;
+/** Cursor timeout in milliseconds (10 minutes) */
+const CURSOR_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Local SQLite Backend
+ */
+export class LocalSQLiteBackend {
+    databases = new Map();
+    cursors = new Map();
+    nextCursorId = 1n;
+    dataDir;
+    constructor(dataDir = '.mongodo') {
+        this.dataDir = dataDir;
+        // Ensure data directory exists
+        const fs = require('fs');
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+        // Start cursor cleanup interval
+        setInterval(() => this.cleanupExpiredCursors(), 60000);
+    }
+    /**
+     * Get or create a database connection
+     */
+    getDatabase(name) {
+        // SECURITY: Validate database name to prevent path traversal attacks
+        const safeName = sanitizeDatabaseName(name);
+        let db = this.databases.get(safeName);
+        if (!db) {
+            const dbPath = `${this.dataDir}/${safeName}.sqlite`;
+            db = new Database(dbPath);
+            this.initializeSchema(db);
+            this.databases.set(safeName, db);
+        }
+        return db;
+    }
+    /**
+     * Initialize the database schema
+     */
+    initializeSchema(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS collections (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        options TEXT DEFAULT '{}'
+      );
+
+      CREATE TABLE IF NOT EXISTS documents (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        collection_id INTEGER NOT NULL,
+        _id TEXT NOT NULL,
+        data TEXT NOT NULL DEFAULT '{}',
+        FOREIGN KEY (collection_id) REFERENCES collections(id) ON DELETE CASCADE,
+        UNIQUE(collection_id, _id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_documents_id ON documents(_id);
+      CREATE INDEX IF NOT EXISTS idx_documents_collection_id ON documents(collection_id, _id);
+
+      CREATE TABLE IF NOT EXISTS indexes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        collection_id INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        key TEXT NOT NULL,
+        options TEXT DEFAULT '{}',
+        FOREIGN KEY (collection_id) REFERENCES collections(id) ON DELETE CASCADE,
+        UNIQUE(collection_id, name)
+      );
+    `);
+    }
+    /**
+     * Get collection ID, creating collection if it doesn't exist
+     */
+    getOrCreateCollectionId(db, name) {
+        // SECURITY: Validate collection name
+        const safeName = validateCollectionName(name);
+        const existing = db.query('SELECT id FROM collections WHERE name = ?').get(safeName);
+        if (existing) {
+            return existing.id;
+        }
+        const result = db.query('INSERT INTO collections (name) VALUES (?) RETURNING id').get(safeName);
+        return result.id;
+    }
+    /**
+     * Get collection ID or null if not found
+     */
+    getCollectionId(db, name) {
+        // SECURITY: Validate collection name
+        const safeName = validateCollectionName(name);
+        const result = db.query('SELECT id FROM collections WHERE name = ?').get(safeName);
+        return result?.id ?? null;
+    }
+    // ============ Database Operations ============
+    async listDatabases() {
+        const fs = require('fs');
+        const path = require('path');
+        let files = [];
+        try {
+            files = fs.readdirSync(this.dataDir);
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        const databases = [];
+        for (const file of files) {
+            if (file.endsWith('.sqlite')) {
+                const name = file.replace('.sqlite', '');
+                const filePath = path.join(this.dataDir, file);
+                const stats = fs.statSync(filePath);
+                databases.push({
+                    name,
+                    sizeOnDisk: stats.size,
+                    empty: stats.size < 1000,
+                });
+            }
+        }
+        // Always include admin database
+        if (!databases.find((d) => d.name === 'admin')) {
+            databases.unshift({ name: 'admin', sizeOnDisk: 0, empty: true });
+        }
+        return databases;
+    }
+    async createDatabase(name) {
+        this.getDatabase(name);
+    }
+    async dropDatabase(name) {
+        // SECURITY: Validate database name to prevent path traversal attacks
+        const safeName = sanitizeDatabaseName(name);
+        const db = this.databases.get(safeName);
+        if (db) {
+            db.close();
+            this.databases.delete(safeName);
+        }
+        const fs = require('fs');
+        const dbPath = `${this.dataDir}/${safeName}.sqlite`;
+        if (fs.existsSync(dbPath)) {
+            fs.unlinkSync(dbPath);
+        }
+    }
+    async databaseExists(name) {
+        // SECURITY: Validate database name to prevent path traversal attacks
+        const safeName = sanitizeDatabaseName(name);
+        const fs = require('fs');
+        return fs.existsSync(`${this.dataDir}/${safeName}.sqlite`);
+    }
+    // ============ Collection Operations ============
+    async listCollections(dbName, filter) {
+        const db = this.getDatabase(dbName);
+        let query = 'SELECT name, options FROM collections';
+        const params = [];
+        if (filter?.name && typeof filter.name === 'string') {
+            query += ' WHERE name = ?';
+            params.push(filter.name);
+        }
+        const rows = db.query(query).all(...params);
+        return rows.map((row) => ({
+            name: row.name,
+            type: 'collection',
+            options: JSON.parse(row.options),
+            info: { readOnly: false },
+        }));
+    }
+    async createCollection(dbName, name, options) {
+        // SECURITY: Validate collection name
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        const optionsJson = JSON.stringify(options || {});
+        db.query('INSERT OR IGNORE INTO collections (name, options) VALUES (?, ?)').run(safeName, optionsJson);
+    }
+    async dropCollection(dbName, name) {
+        // SECURITY: Validate collection name
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        db.query('DELETE FROM collections WHERE name = ?').run(safeName);
+    }
+    async collectionExists(dbName, name) {
+        // SECURITY: Validate collection name
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        const result = db.query('SELECT 1 FROM collections WHERE name = ? LIMIT 1').get(safeName);
+        return result !== null;
+    }
+    async collStats(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return {
+                ns: `${dbName}.${collection}`,
+                count: 0,
+                size: 0,
+                avgObjSize: 0,
+                storageSize: 0,
+                totalIndexSize: 0,
+                nindexes: 1,
+                indexSizes: { _id_: 0 },
+            };
+        }
+        const stats = db
+            .query(`
+        SELECT COUNT(*) as count, COALESCE(SUM(LENGTH(data)), 0) as size
+        FROM documents WHERE collection_id = ?
+      `)
+            .get(collectionId);
+        return {
+            ns: `${dbName}.${collection}`,
+            count: stats.count,
+            size: stats.size,
+            avgObjSize: stats.count > 0 ? stats.size / stats.count : 0,
+            storageSize: stats.size,
+            totalIndexSize: stats.count * 50,
+            nindexes: 1,
+            indexSizes: { _id_: stats.count * 50 },
+        };
+    }
+    async dbStats(dbName) {
+        const db = this.getDatabase(dbName);
+        const collectionStats = db
+            .query('SELECT COUNT(DISTINCT id) as collections FROM collections')
+            .get();
+        const docStats = db
+            .query('SELECT COUNT(*) as objects, COALESCE(SUM(LENGTH(data)), 0) as dataSize FROM documents')
+            .get();
+        return {
+            db: dbName,
+            collections: collectionStats.collections,
+            views: 0,
+            objects: docStats.objects,
+            avgObjSize: docStats.objects > 0 ? docStats.dataSize / docStats.objects : 0,
+            dataSize: docStats.dataSize,
+            storageSize: docStats.dataSize,
+            indexes: collectionStats.collections,
+            indexSize: docStats.objects * 50,
+        };
+    }
+    // ============ CRUD Operations ============
+    async find(dbName, collection, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return { documents: [], cursorId: 0n, hasMore: false };
+        }
+        let sql = 'SELECT _id, data FROM documents WHERE collection_id = ?';
+        const params = [collectionId];
+        // Build filter (simplified)
+        if (options.filter && Object.keys(options.filter).length > 0) {
+            const filterSql = this.buildFilterSql(options.filter, params);
+            if (filterSql) {
+                sql += ` AND (${filterSql})`;
+            }
+        }
+        // Add sorting
+        if (options.sort) {
+            const sortClauses = [];
+            for (const [field, direction] of Object.entries(options.sort)) {
+                const dir = direction === -1 ? 'DESC' : 'ASC';
+                if (field === '_id') {
+                    sortClauses.push(`_id ${dir}`);
+                }
+                else {
+                    // Validate field name to prevent SQL injection
+                    const safePath = safeJsonPath(validateFieldPath(field));
+                    sortClauses.push(`json_extract(data, '${safePath}') ${dir}`);
+                }
+            }
+            if (sortClauses.length > 0) {
+                sql += ` ORDER BY ${sortClauses.join(', ')}`;
+            }
+        }
+        // Add limit and offset
+        if (options.limit && options.limit > 0) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        if (options.skip && options.skip > 0) {
+            sql += ` OFFSET ${options.skip}`;
+        }
+        const rows = db.query(sql).all(...params);
+        let documents = rows.map((row) => {
+            const doc = JSON.parse(row.data);
+            doc._id = this.parseId(row._id);
+            return doc;
+        });
+        // Apply projection
+        if (options.projection) {
+            documents = documents.map((doc) => this.applyProjection(doc, options.projection));
+        }
+        const batchSize = options.batchSize || DEFAULT_BATCH_SIZE;
+        // Handle cursor for large result sets
+        if (documents.length > batchSize) {
+            const cursorId = this.nextCursorId++;
+            this.cursors.set(cursorId, {
+                id: cursorId,
+                namespace: `${dbName}.${collection}`,
+                documents,
+                position: batchSize,
+                batchSize,
+                createdAt: Date.now(),
+            });
+            return {
+                documents: documents.slice(0, batchSize),
+                cursorId,
+                hasMore: true,
+            };
+        }
+        return { documents, cursorId: 0n, hasMore: false };
+    }
+    async insertOne(dbName, collection, doc) {
+        return this.insertMany(dbName, collection, [doc]);
+    }
+    async insertMany(dbName, collection, docs) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getOrCreateCollectionId(db, collection);
+        const insertedIds = new Map();
+        let insertedCount = 0;
+        const stmt = db.prepare('INSERT INTO documents (collection_id, _id, data) VALUES (?, ?, ?)');
+        db.transaction(() => {
+            for (let i = 0; i < docs.length; i++) {
+                const doc = { ...docs[i] };
+                if (!doc._id) {
+                    doc._id = new ObjectId();
+                }
+                const idStr = this.serializeId(doc._id);
+                const dataJson = JSON.stringify(doc);
+                stmt.run(collectionId, idStr, dataJson);
+                insertedIds.set(i, doc._id);
+                insertedCount++;
+            }
+        })();
+        return { acknowledged: true, insertedIds, insertedCount };
+    }
+    async updateOne(dbName, collection, filter, update, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId && !options?.upsert) {
+            return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        // Find the document
+        let sql = 'SELECT id, _id, data FROM documents WHERE collection_id = ?';
+        const params = [collectionId || 0];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+            sql += ` AND (${filterSql})`;
+        }
+        sql += ' LIMIT 1';
+        const row = db.query(sql).get(...params);
+        if (!row) {
+            if (options?.upsert) {
+                const cid = this.getOrCreateCollectionId(db, collection);
+                const newDoc = { ...filter };
+                const updatedDoc = this.applyUpdate(newDoc, update);
+                if (!updatedDoc._id) {
+                    updatedDoc._id = new ObjectId();
+                }
+                const idStr = this.serializeId(updatedDoc._id);
+                db.query('INSERT INTO documents (collection_id, _id, data) VALUES (?, ?, ?)').run(cid, idStr, JSON.stringify(updatedDoc));
+                return {
+                    acknowledged: true,
+                    matchedCount: 0,
+                    modifiedCount: 0,
+                    upsertedId: updatedDoc._id,
+                    upsertedCount: 1,
+                };
+            }
+            return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        const doc = JSON.parse(row.data);
+        doc._id = this.parseId(row._id);
+        const updatedDoc = this.applyUpdate(doc, update);
+        db.query('UPDATE documents SET data = ? WHERE id = ?').run(JSON.stringify(updatedDoc), row.id);
+        return { acknowledged: true, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 };
+    }
+    async updateMany(dbName, collection, filter, update, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            if (options?.upsert) {
+                const result = await this.updateOne(dbName, collection, filter, update, options);
+                return result;
+            }
+            return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        let sql = 'SELECT id, _id, data FROM documents WHERE collection_id = ?';
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+            sql += ` AND (${filterSql})`;
+        }
+        const rows = db.query(sql).all(...params);
+        if (rows.length === 0 && options?.upsert) {
+            const result = await this.updateOne(dbName, collection, filter, update, options);
+            return result;
+        }
+        const stmt = db.prepare('UPDATE documents SET data = ? WHERE id = ?');
+        db.transaction(() => {
+            for (const row of rows) {
+                const doc = JSON.parse(row.data);
+                doc._id = this.parseId(row._id);
+                const updatedDoc = this.applyUpdate(doc, update);
+                stmt.run(JSON.stringify(updatedDoc), row.id);
+            }
+        })();
+        return {
+            acknowledged: true,
+            matchedCount: rows.length,
+            modifiedCount: rows.length,
+            upsertedCount: 0,
+        };
+    }
+    async deleteOne(dbName, collection, filter) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        // Find one document first
+        let sql = 'SELECT id FROM documents WHERE collection_id = ?';
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+            sql += ` AND (${filterSql})`;
+        }
+        sql += ' LIMIT 1';
+        const row = db.query(sql).get(...params);
+        if (!row) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        db.query('DELETE FROM documents WHERE id = ?').run(row.id);
+        return { acknowledged: true, deletedCount: 1 };
+    }
+    async deleteMany(dbName, collection, filter) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        let sql = 'DELETE FROM documents WHERE collection_id = ?';
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+            sql += ` AND (${filterSql})`;
+        }
+        const result = db.query(sql).run(...params);
+        return { acknowledged: true, deletedCount: result.changes };
+    }
+    // ============ Count & Distinct ============
+    async count(dbName, collection, query) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return 0;
+        }
+        let sql = 'SELECT COUNT(*) as count FROM documents WHERE collection_id = ?';
+        const params = [collectionId];
+        if (query && Object.keys(query).length > 0) {
+            const filterSql = this.buildFilterSql(query, params);
+            if (filterSql) {
+                sql += ` AND (${filterSql})`;
+            }
+        }
+        const result = db.query(sql).get(...params);
+        return result.count;
+    }
+    async distinct(dbName, collection, field, query) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return [];
+        }
+        let sql;
+        if (field === '_id') {
+            sql = 'SELECT DISTINCT _id as value FROM documents WHERE collection_id = ?';
+        }
+        else {
+            // Validate field name to prevent SQL injection
+            const safePath = safeJsonPath(validateFieldPath(field));
+            sql = `SELECT DISTINCT json_extract(data, '${safePath}') as value FROM documents WHERE collection_id = ?`;
+        }
+        const params = [collectionId];
+        if (query && Object.keys(query).length > 0) {
+            const filterSql = this.buildFilterSql(query, params);
+            if (filterSql) {
+                sql += ` AND (${filterSql})`;
+            }
+        }
+        const rows = db.query(sql).all(...params);
+        return rows.map((r) => r.value).filter((v) => v !== null);
+    }
+    // ============ Aggregation ============
+    async aggregate(dbName, collection, pipeline, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+            return { documents: [], cursorId: 0n, hasMore: false };
+        }
+        // Get all documents for in-memory processing
+        const rows = db
+            .query('SELECT _id, data FROM documents WHERE collection_id = ?')
+            .all(collectionId);
+        let documents = rows.map((row) => {
+            const doc = JSON.parse(row.data);
+            doc._id = this.parseId(row._id);
+            return doc;
+        });
+        // Apply pipeline stages
+        documents = this.applyPipeline(documents, pipeline);
+        const batchSize = options?.batchSize || DEFAULT_BATCH_SIZE;
+        if (documents.length > batchSize) {
+            const cursorId = this.nextCursorId++;
+            this.cursors.set(cursorId, {
+                id: cursorId,
+                namespace: `${dbName}.${collection}`,
+                documents,
+                position: batchSize,
+                batchSize,
+                createdAt: Date.now(),
+            });
+            return {
+                documents: documents.slice(0, batchSize),
+                cursorId,
+                hasMore: true,
+            };
+        }
+        return { documents, cursorId: 0n, hasMore: false };
+    }
+    // ============ Index Operations ============
+    async listIndexes(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        const indexes = [{ v: 2, key: { _id: 1 }, name: '_id_' }];
+        if (!collectionId) {
+            return indexes;
+        }
+        const rows = db
+            .query('SELECT name, key, options FROM indexes WHERE collection_id = ?')
+            .all(collectionId);
+        for (const row of rows) {
+            indexes.push({
+                v: 2,
+                key: JSON.parse(row.key),
+                name: row.name,
+                ...JSON.parse(row.options),
+            });
+        }
+        return indexes;
+    }
+    async createIndexes(dbName, collection, indexes) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getOrCreateCollectionId(db, collection);
+        const createdNames = [];
+        const stmt = db.prepare('INSERT OR IGNORE INTO indexes (collection_id, name, key, options) VALUES (?, ?, ?, ?)');
+        for (const spec of indexes) {
+            const name = spec.name || this.generateIndexName(spec.key);
+            const keyJson = JSON.stringify(spec.key);
+            const options = {};
+            if (spec.unique)
+                options.unique = true;
+            if (spec.sparse)
+                options.sparse = true;
+            const result = stmt.run(collectionId, name, keyJson, JSON.stringify(options));
+            if (result.changes > 0) {
+                createdNames.push(name);
+            }
+        }
+        return createdNames;
+    }
+    async dropIndex(dbName, collection, indexName) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (collectionId) {
+            db.query('DELETE FROM indexes WHERE collection_id = ? AND name = ?').run(collectionId, indexName);
+        }
+    }
+    async dropIndexes(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (collectionId) {
+            db.query("DELETE FROM indexes WHERE collection_id = ? AND name != '_id_'").run(collectionId);
+        }
+    }
+    // ============ Cursor Management ============
+    createCursor(state) {
+        this.cursors.set(state.id, state);
+    }
+    getCursor(id) {
+        return this.cursors.get(id);
+    }
+    advanceCursor(id, count) {
+        const cursor = this.cursors.get(id);
+        if (!cursor) {
+            return [];
+        }
+        const start = cursor.position;
+        const end = Math.min(start + count, cursor.documents.length);
+        cursor.position = end;
+        return cursor.documents.slice(start, end);
+    }
+    closeCursor(id) {
+        return this.cursors.delete(id);
+    }
+    cleanupExpiredCursors() {
+        const now = Date.now();
+        for (const [id, cursor] of this.cursors) {
+            if (now - cursor.createdAt > CURSOR_TIMEOUT_MS) {
+                this.cursors.delete(id);
+            }
+        }
+    }
+    // ============ Helper Methods ============
+    serializeId(id) {
+        if (id instanceof ObjectId) {
+            return id.toHexString();
+        }
+        if (typeof id === 'object' && id !== null && '$oid' in id) {
+            return id.$oid;
+        }
+        return String(id);
+    }
+    parseId(idStr) {
+        if (/^[0-9a-f]{24}$/i.test(idStr)) {
+            return new ObjectId(idStr);
+        }
+        return idStr;
+    }
+    generateIndexName(key) {
+        return Object.entries(key)
+            .map(([field, dir]) => `${field}_${dir}`)
+            .join('_');
+    }
+    /**
+     * Build simplified SQL filter from MongoDB query
+     */
+    buildFilterSql(filter, params) {
+        const conditions = [];
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === '_id') {
+                params.push(this.serializeId(value));
+                conditions.push('_id = ?');
+            }
+            else if (key === '$and' && Array.isArray(value)) {
+                const subConditions = value
+                    .map((sub) => this.buildFilterSql(sub, params))
+                    .filter(Boolean);
+                if (subConditions.length > 0) {
+                    conditions.push(`(${subConditions.join(' AND ')})`);
+                }
+            }
+            else if (key === '$or' && Array.isArray(value)) {
+                const subConditions = value
+                    .map((sub) => this.buildFilterSql(sub, params))
+                    .filter(Boolean);
+                if (subConditions.length > 0) {
+                    conditions.push(`(${subConditions.join(' OR ')})`);
+                }
+            }
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                // Handle operators
+                // Validate field name to prevent SQL injection
+                const safePath = safeJsonPath(validateFieldPath(key));
+                for (const [op, opValue] of Object.entries(value)) {
+                    const path = `json_extract(data, '${safePath}')`;
+                    switch (op) {
+                        case '$eq':
+                            params.push(opValue);
+                            conditions.push(`${path} = ?`);
+                            break;
+                        case '$ne':
+                            params.push(opValue);
+                            conditions.push(`${path} != ?`);
+                            break;
+                        case '$gt':
+                            params.push(opValue);
+                            conditions.push(`${path} > ?`);
+                            break;
+                        case '$gte':
+                            params.push(opValue);
+                            conditions.push(`${path} >= ?`);
+                            break;
+                        case '$lt':
+                            params.push(opValue);
+                            conditions.push(`${path} < ?`);
+                            break;
+                        case '$lte':
+                            params.push(opValue);
+                            conditions.push(`${path} <= ?`);
+                            break;
+                        case '$exists':
+                            conditions.push(opValue ? `${path} IS NOT NULL` : `${path} IS NULL`);
+                            break;
+                        case '$in':
+                            if (Array.isArray(opValue) && opValue.length > 0) {
+                                const placeholders = opValue.map(() => '?').join(', ');
+                                params.push(...opValue);
+                                conditions.push(`${path} IN (${placeholders})`);
+                            }
+                            break;
+                    }
+                }
+            }
+            else {
+                // Direct equality
+                // Validate field name to prevent SQL injection
+                const safePath = safeJsonPath(validateFieldPath(key));
+                const sqlValue = typeof value === 'boolean' ? (value ? 1 : 0) : value;
+                params.push(sqlValue);
+                conditions.push(`json_extract(data, '${safePath}') = ?`);
+            }
+        }
+        return conditions.join(' AND ');
+    }
+    applyProjection(doc, projection) {
+        const includeFields = new Set();
+        const excludeFields = new Set();
+        let isInclusion = false;
+        for (const [field, value] of Object.entries(projection)) {
+            if (field === '_id' && (value === 0 || value === false)) {
+                excludeFields.add('_id');
+                continue;
+            }
+            if (value === 1 || value === true) {
+                includeFields.add(field);
+                isInclusion = true;
+            }
+            else if (value === 0 || value === false) {
+                excludeFields.add(field);
+            }
+        }
+        if (isInclusion) {
+            const result = {};
+            if (!excludeFields.has('_id')) {
+                result._id = doc._id;
+            }
+            for (const field of includeFields) {
+                if (field in doc) {
+                    result[field] = doc[field];
+                }
+            }
+            return result;
+        }
+        const result = { ...doc };
+        for (const field of excludeFields) {
+            delete result[field];
+        }
+        return result;
+    }
+    applyUpdate(doc, update) {
+        const result = { ...doc };
+        if (update.$set) {
+            Object.assign(result, update.$set);
+        }
+        if (update.$unset) {
+            for (const key of Object.keys(update.$unset)) {
+                delete result[key];
+            }
+        }
+        if (update.$inc) {
+            for (const [key, value] of Object.entries(update.$inc)) {
+                const current = result[key] || 0;
+                result[key] = current + value;
+            }
+        }
+        if (update.$push) {
+            for (const [key, value] of Object.entries(update.$push)) {
+                const current = result[key] || [];
+                if (typeof value === 'object' && value !== null && '$each' in value) {
+                    current.push(...value.$each);
+                }
+                else {
+                    current.push(value);
+                }
+                result[key] = current;
+            }
+        }
+        // Handle replacement (no operators)
+        const hasOperators = Object.keys(update).some((k) => k.startsWith('$'));
+        if (!hasOperators) {
+            const id = result._id;
+            for (const key of Object.keys(result)) {
+                if (key !== '_id')
+                    delete result[key];
+            }
+            Object.assign(result, update);
+            result._id = id;
+        }
+        return result;
+    }
+    applyPipeline(documents, pipeline) {
+        let result = [...documents];
+        for (const stage of pipeline) {
+            const entry = Object.entries(stage)[0];
+            if (!entry)
+                continue;
+            const [op, value] = entry;
+            switch (op) {
+                case '$match':
+                    result = result.filter((doc) => this.matchDocument(doc, value));
+                    break;
+                case '$project':
+                    result = result.map((doc) => this.applyProjection(doc, value));
+                    break;
+                case '$sort':
+                    result = this.sortDocuments(result, value);
+                    break;
+                case '$limit':
+                    result = result.slice(0, value);
+                    break;
+                case '$skip':
+                    result = result.slice(value);
+                    break;
+                case '$count':
+                    result = [{ [value]: result.length }];
+                    break;
+                case '$sample':
+                    const size = value.size || 100;
+                    result = this.shuffleArray(result).slice(0, size);
+                    break;
+                case '$group':
+                    result = this.groupDocuments(result, value);
+                    break;
+            }
+        }
+        return result;
+    }
+    matchDocument(doc, query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (key === '$and') {
+                if (!value.every((q) => this.matchDocument(doc, q))) {
+                    return false;
+                }
+                continue;
+            }
+            if (key === '$or') {
+                if (!value.some((q) => this.matchDocument(doc, q))) {
+                    return false;
+                }
+                continue;
+            }
+            const docValue = doc[key];
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case '$eq':
+                            if (docValue !== opValue)
+                                return false;
+                            break;
+                        case '$ne':
+                            if (docValue === opValue)
+                                return false;
+                            break;
+                        case '$gt':
+                            if (!(docValue > opValue))
+                                return false;
+                            break;
+                        case '$gte':
+                            if (!(docValue >= opValue))
+                                return false;
+                            break;
+                        case '$lt':
+                            if (!(docValue < opValue))
+                                return false;
+                            break;
+                        case '$lte':
+                            if (!(docValue <= opValue))
+                                return false;
+                            break;
+                        case '$in':
+                            if (!opValue.includes(docValue))
+                                return false;
+                            break;
+                        case '$exists':
+                            if ((opValue && docValue === undefined) || (!opValue && docValue !== undefined))
+                                return false;
+                            break;
+                    }
+                }
+            }
+            else {
+                if (docValue !== value)
+                    return false;
+            }
+        }
+        return true;
+    }
+    sortDocuments(documents, sort) {
+        return [...documents].sort((a, b) => {
+            for (const [field, direction] of Object.entries(sort)) {
+                const aVal = a[field];
+                const bVal = b[field];
+                const dir = direction === -1 ? -1 : 1;
+                if (aVal === bVal)
+                    continue;
+                if (aVal === undefined || aVal === null)
+                    return dir;
+                if (bVal === undefined || bVal === null)
+                    return -dir;
+                if (aVal < bVal)
+                    return -dir;
+                if (aVal > bVal)
+                    return dir;
+            }
+            return 0;
+        });
+    }
+    shuffleArray(array) {
+        const result = [...array];
+        for (let i = result.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            const temp = result[i];
+            result[i] = result[j];
+            result[j] = temp;
+        }
+        return result;
+    }
+    groupDocuments(documents, groupSpec) {
+        const groups = new Map();
+        const idSpec = groupSpec._id;
+        for (const doc of documents) {
+            let groupKey;
+            if (idSpec === null) {
+                groupKey = '__all__';
+            }
+            else if (typeof idSpec === 'string' && idSpec.startsWith('$')) {
+                groupKey = JSON.stringify(doc[idSpec.slice(1)]);
+            }
+            else {
+                groupKey = JSON.stringify(idSpec);
+            }
+            if (!groups.has(groupKey)) {
+                groups.set(groupKey, []);
+            }
+            groups.get(groupKey).push(doc);
+        }
+        const result = [];
+        for (const [key, docs] of groups) {
+            const grouped = { _id: key === '__all__' ? null : JSON.parse(key) };
+            for (const [field, spec] of Object.entries(groupSpec)) {
+                if (field === '_id')
+                    continue;
+                if (typeof spec === 'object' && spec !== null) {
+                    const [op, value] = Object.entries(spec)[0];
+                    const fieldPath = typeof value === 'string' && value.startsWith('$') ? value.slice(1) : null;
+                    switch (op) {
+                        case '$sum':
+                            if (value === 1) {
+                                grouped[field] = docs.length;
+                            }
+                            else if (fieldPath) {
+                                grouped[field] = docs.reduce((sum, doc) => sum + (doc[fieldPath] || 0), 0);
+                            }
+                            break;
+                        case '$avg':
+                            if (fieldPath) {
+                                const values = docs.map((doc) => doc[fieldPath]).filter((v) => typeof v === 'number');
+                                grouped[field] = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : null;
+                            }
+                            break;
+                        case '$first':
+                            if (fieldPath && docs.length > 0) {
+                                const firstDoc = docs[0];
+                                if (firstDoc) {
+                                    grouped[field] = firstDoc[fieldPath];
+                                }
+                            }
+                            break;
+                        case '$last':
+                            if (fieldPath && docs.length > 0) {
+                                const lastDoc = docs[docs.length - 1];
+                                if (lastDoc) {
+                                    grouped[field] = lastDoc[fieldPath];
+                                }
+                            }
+                            break;
+                    }
+                }
+            }
+            result.push(grouped);
+        }
+        return result;
+    }
+    /**
+     * Close all database connections
+     */
+    close() {
+        for (const db of this.databases.values()) {
+            db.close();
+        }
+        this.databases.clear();
+        this.cursors.clear();
+    }
+}
+//# sourceMappingURL=local-sqlite.js.map