mongo.do 0.1.0 → 0.1.1

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

@@ -1,1002 +0,0 @@
-/**
- * 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