@semics-tech/mongolite 1.0.0 → 1.2.0

package/dist/cjs/db.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteDB = exports.DEFAULT_BUSY_TIMEOUT_MS = void 0;
+exports.sharedConnectionCount = sharedConnectionCount;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const node_path_1 = __importDefault(require("node:path"));
+const connection_registry_js_1 = require("./utils/connection-registry.js");
+Object.defineProperty(exports, "DEFAULT_BUSY_TIMEOUT_MS", { enumerable: true, get: function () { return connection_registry_js_1.DEFAULT_BUSY_TIMEOUT_MS; } });
+/** Shared `better-sqlite3` handles for this process, keyed by connection identity. */
+const sharedConnections = new connection_registry_js_1.ConnectionRegistry();
+/** Exposed for tests and diagnostics. */
+function sharedConnectionCount() {
+    return sharedConnections.size;
+}
+/**
+ * SQLiteDB class provides a wrapper around the better-sqlite3 library
+ * to simplify database operations.
+ */
+class SQLiteDB {
+    /**
+     * Creates an instance of SQLiteDB.
+     * @param {string | MongoLiteOptions} dbPathOrOptions - The path to the SQLite database file or an options object.
+     * Use ':memory:' for an in-memory database.
+     */
+    constructor(dbPathOrOptions) {
+        this.db = null;
+        this.openPromise = null;
+        let shared;
+        if (typeof dbPathOrOptions === 'string') {
+            this.filePath = dbPathOrOptions;
+            this.verbose = false;
+            this.readOnly = false;
+            this.WAL = true;
+            this.busyTimeout = connection_registry_js_1.DEFAULT_BUSY_TIMEOUT_MS;
+            shared = false;
+        }
+        else {
+            this.filePath = dbPathOrOptions.filePath;
+            this.verbose = dbPathOrOptions.verbose || false;
+            this.readOnly = dbPathOrOptions.readOnly || false;
+            this.WAL = dbPathOrOptions.WAL ?? true;
+            this.busyTimeout = dbPathOrOptions.busyTimeout ?? connection_registry_js_1.DEFAULT_BUSY_TIMEOUT_MS;
+            shared = dbPathOrOptions.shared ?? false;
+        }
+        this.shareKey =
+            shared && (0, connection_registry_js_1.isShareablePath)(this.filePath)
+                ? (0, connection_registry_js_1.buildConnectionKey)({
+                    backend: 'better-sqlite3',
+                    filePath: node_path_1.default.resolve(this.filePath),
+                    readOnly: this.readOnly,
+                    WAL: this.WAL,
+                    busyTimeout: this.busyTimeout,
+                    verbose: this.verbose,
+                })
+                : null;
+    }
+    /**
+     * Opens the database connection if it's not already open.
+     * @returns {Promise<void>} A promise that resolves when the connection is open.
+     */
+    async connect() {
+        if (this.db && this.openPromise) {
+            return this.openPromise;
+        }
+        if (this.db) {
+            // Already connected and openPromise is null (should not happen with proper logic)
+            return Promise.resolve();
+        }
+        this.openPromise = new Promise((resolve, reject) => {
+            try {
+                // Only runs on a genuinely new connection — when sharing, an existing
+                // handle already has its pragmas and UDFs applied.
+                const openConnection = () => {
+                    const options = {
+                        readonly: this.readOnly,
+                        verbose: this.verbose ? console.log : undefined,
+                    };
+                    const db = new better_sqlite3_1.default(this.filePath, options);
+                    // Enable Write-Ahead Logging if requested
+                    if (this.WAL && !this.readOnly) {
+                        db.pragma('journal_mode = WAL');
+                    }
+                    // Wait rather than immediately throwing SQLITE_BUSY when another
+                    // connection (often another process) holds a lock.
+                    if (this.busyTimeout > 0) {
+                        db.pragma(`busy_timeout = ${this.busyTimeout}`);
+                    }
+                    // Register regexp UDF for $regex operator support.
+                    // WARNING: Patterns are compiled via JavaScript RegExp. User-supplied patterns that are
+                    // not validated for catastrophic backtracking (ReDoS) could block the event loop.
+                    // Avoid using untrusted/unvalidated patterns with $regex in security-sensitive contexts.
+                    db.function('regexp', { deterministic: true }, (pattern, value) => {
+                        if (typeof pattern !== 'string' || value === null || value === undefined)
+                            return 0;
+                        try {
+                            return new RegExp(pattern).test(String(value)) ? 1 : 0;
+                        }
+                        catch {
+                            return 0;
+                        }
+                    });
+                    // Register regexp_flags UDF for $regex with $options support
+                    db.function('regexp_flags', { deterministic: true }, (pattern, flags, value) => {
+                        if (typeof pattern !== 'string' || value === null || value === undefined)
+                            return 0;
+                        try {
+                            const f = typeof flags === 'string' ? flags : '';
+                            return new RegExp(pattern, f).test(String(value)) ? 1 : 0;
+                        }
+                        catch {
+                            return 0;
+                        }
+                    });
+                    if (this.verbose) {
+                        console.log(`SQLite database opened: ${this.filePath}`);
+                    }
+                    return db;
+                };
+                this.db = this.shareKey
+                    ? sharedConnections.acquire(this.shareKey, openConnection)
+                    : openConnection();
+                resolve();
+            }
+            catch (err) {
+                console.error(`Error opening database ${this.filePath}:`, err.message);
+                this.db = null;
+                this.openPromise = null;
+                reject(err);
+            }
+        });
+        return this.openPromise;
+    }
+    /**
+     * Ensures the database connection is open before performing an operation.
+     * @private
+     * @returns {Promise<Database.Database>} The active database instance.
+     * @throws {Error} If the database is not connected.
+     */
+    async ensureConnected() {
+        if (!this.db || !this.openPromise) {
+            await this.connect();
+        }
+        else {
+            await this.openPromise; // Wait for any ongoing connection attempt
+        }
+        if (!this.db) {
+            // This should ideally not be reached if connect() works correctly
+            throw new Error('Database is not connected. Connection attempt failed.');
+        }
+        return this.db;
+    }
+    /**
+     * Executes a SQL query that does not return rows (e.g., INSERT, UPDATE, DELETE, CREATE).
+     * @param {string} sql - The SQL query string.
+     * @param {any[]} [params=[]] - Parameters for the SQL query.
+     * @returns {Promise<{ lastID: number, changes: number }>} Result of the execution.
+     */
+    async run(sql, params = []) {
+        const dbInstance = await this.ensureConnected();
+        try {
+            const result = dbInstance.prepare(sql).run(...params);
+            return {
+                lastID: result.lastInsertRowid,
+                changes: result.changes,
+            };
+        }
+        catch (err) {
+            console.error(`Error running SQL: ${sql}`, err);
+            throw err;
+        }
+    }
+    /**
+     * Executes a SQL query that returns a single row.
+     * @param {string} sql - The SQL query string.
+     * @param {any[]} [params=[]] - Parameters for the SQL query.
+     * @returns {Promise<T | undefined>} The first row found, or undefined.
+     */
+    async get(sql, params = []) {
+        const dbInstance = await this.ensureConnected();
+        try {
+            return dbInstance.prepare(sql).get(...params);
+        }
+        catch (err) {
+            console.error(`Error getting SQL: ${sql}`, err);
+            throw err;
+        }
+    }
+    /**
+     * Executes a SQL query that returns multiple rows.
+     * @param {string} sql - The SQL query string.
+     * @param {any[]} [params=[]] - Parameters for the SQL query.
+     * @returns {Promise<T[]>} An array of rows.
+     */
+    async all(sql, params = []) {
+        const dbInstance = await this.ensureConnected();
+        try {
+            return dbInstance.prepare(sql).all(...params);
+        }
+        catch (err) {
+            console.error(`Error getting all SQL: ${sql}`, err);
+            throw err;
+        }
+    }
+    /**
+     * Executes multiple SQL statements.
+     * @param {string} sql - SQL string with multiple statements.
+     * @returns {Promise<void>}
+     */
+    async exec(sql) {
+        const dbInstance = await this.ensureConnected();
+        try {
+            dbInstance.exec(sql);
+            return Promise.resolve();
+        }
+        catch (err) {
+            console.error(`Error executing SQL: ${sql}`, err);
+            throw err;
+        }
+    }
+    /**
+     * Closes the database connection.
+     * @returns {Promise<void>} A promise that resolves when the connection is closed.
+     */
+    async close() {
+        if (this.openPromise) {
+            await this.openPromise; // Ensure any pending connection attempt is finished
+        }
+        if (this.db) {
+            try {
+                // When shared, only the last holder actually closes the handle.
+                const isLastHolder = this.shareKey
+                    ? sharedConnections.release(this.shareKey, this.db)
+                    : true;
+                if (isLastHolder) {
+                    this.db.close();
+                }
+                if (this.verbose) {
+                    console.log(isLastHolder
+                        ? `SQLite database closed: ${this.filePath}`
+                        : `SQLite database released (still in use): ${this.filePath}`);
+                }
+            }
+            catch (err) {
+                console.error(`Error closing database ${this.filePath}:`, err.message);
+                throw err; // Re-throw the error to indicate failure
+            }
+            finally {
+                this.db = null;
+                this.openPromise = null;
+            }
+        }
+        else {
+            // If db is null, it's already considered closed or was never opened.
+            this.db = null;
+            this.openPromise = null;
+        }
+    }
+    /**
+     * Gets the underlying better-sqlite3 Database instance.
+     * Useful for operations not covered by this wrapper, like transactions.
+     * @returns {Promise<Database.Database>} The raw database object.
+     * @throws {Error} If the database is not connected.
+     */
+    async getDbInstance() {
+        return this.ensureConnected();
+    }
+    /**
+     * Prepares a SQL statement for later execution.
+     * @param {string} sql - The SQL query string.
+     * @returns {Promise<Statement>} A prepared statement that can be executed multiple times.
+     */
+    async prepare(sql) {
+        const dbInstance = await this.ensureConnected();
+        return dbInstance.prepare(sql);
+    }
+    /**
+     * Begins a transaction.
+     * @returns {Promise<void>}
+     */
+    async beginTransaction() {
+        const dbInstance = await this.ensureConnected();
+        dbInstance.prepare('BEGIN').run();
+        return Promise.resolve();
+    }
+    /**
+     * Commits a transaction.
+     * @returns {Promise<void>}
+     */
+    async commitTransaction() {
+        const dbInstance = await this.ensureConnected();
+        dbInstance.prepare('COMMIT').run();
+        return Promise.resolve();
+    }
+    /**
+     * Rolls back a transaction.
+     * @returns {Promise<void>}
+     */
+    async rollbackTransaction() {
+        const dbInstance = await this.ensureConnected();
+        dbInstance.prepare('ROLLBACK').run();
+        return Promise.resolve();
+    }
+}
+exports.SQLiteDB = SQLiteDB;

package/dist/cjs/debugger/query-debugger.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryDebugger = void 0;
+const index_js_1 = require("../index.js");
+const findCursor_js_1 = require("../cursors/findCursor.js");
+const readline = __importStar(require("readline"));
+const path_1 = __importDefault(require("path"));
+class QueryDebugger {
+    constructor(options = {}) {
+        this.currentCollection = null;
+        this.lastFilter = null;
+        this.lastSqlQuery = null;
+        const dbPath = options.database || path_1.default.join(process.cwd(), 'mongolite.db');
+        this.client = new index_js_1.MongoLite(dbPath, { verbose: options.verbose });
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: 'mongolite-debug> ',
+        });
+        if (options.collection) {
+            this.currentCollection = options.collection;
+        }
+    }
+    async start() {
+        console.log('Commands:');
+        console.log('  .help                     - Show this help');
+        console.log('  .collections              - List all collections');
+        console.log('  .use <collection>         - Select a collection to work with');
+        console.log('  .find <filter>            - Convert find filter to SQL and execute');
+        console.log('  .sql <query>              - Execute raw SQL query');
+        console.log('  .last                     - Show last generated SQL');
+        console.log('  .sample [count]           - Show sample documents from current collection');
+        console.log('  .exit                     - Exit the debugger');
+        console.log('');
+        try {
+            await this.client.connect();
+            console.log('✅ Connected to database.');
+        }
+        catch (error) {
+            console.error('❌ Failed to connect to database:', error instanceof Error ? error.message : error);
+            throw error;
+        }
+        if (this.currentCollection) {
+            console.log(`Current collection: ${this.currentCollection}`);
+        }
+        this.rl.prompt();
+        this.rl.on('line', async (input) => {
+            const trimmed = input.trim();
+            if (trimmed === '.exit') {
+                await this.cleanup();
+                return;
+            }
+            try {
+                await this.handleCommand(trimmed);
+            }
+            catch (error) {
+                console.error('Error:', error instanceof Error ? error.message : error);
+            }
+            this.rl.prompt();
+        });
+        this.rl.on('close', async () => {
+            await this.cleanup();
+        });
+    }
+    async handleCommand(input) {
+        if (input === '.help') {
+            this.showHelp();
+            return;
+        }
+        if (input === '.collections') {
+            await this.listCollections();
+            return;
+        }
+        if (input.startsWith('.use ')) {
+            const collection = input.slice(5).trim();
+            this.currentCollection = collection;
+            console.log(`Switched to collection: ${collection}`);
+            return;
+        }
+        if (input.startsWith('.find ')) {
+            await this.handleFindCommand(input.slice(6).trim());
+            return;
+        }
+        if (input.startsWith('.sql ')) {
+            await this.handleSqlCommand(input.slice(5).trim());
+            return;
+        }
+        if (input === '.last') {
+            this.showLastQuery();
+            return;
+        }
+        if (input.startsWith('.sample')) {
+            const parts = input.split(' ');
+            const count = parts.length > 1 ? parseInt(parts[1]) || 5 : 5;
+            await this.showSample(count);
+            return;
+        }
+        console.log('Unknown command. Type .help for available commands.');
+    }
+    showHelp() {
+        console.log('');
+        console.log('Available commands:');
+        console.log('  .help                     - Show this help');
+        console.log('  .collections              - List all collections');
+        console.log('  .use <collection>         - Select a collection to work with');
+        console.log('  .find <filter>            - Convert find filter to SQL and execute');
+        console.log('  .sql <query>              - Execute raw SQL query');
+        console.log('  .last                     - Show last generated SQL');
+        console.log('  .sample [count]           - Show sample documents from current collection');
+        console.log('  .exit                     - Exit the debugger');
+        console.log('');
+        console.log('Examples:');
+        console.log('  .use users');
+        console.log('  .find {"age": {"$gt": 25}}');
+        console.log('  .find {"name": "John", "age": {"$in": [25, 30, 35]}}');
+        console.log('  .sql SELECT * FROM users WHERE json_extract(data, "$.age") > 25');
+        console.log('');
+    }
+    async listCollections() {
+        try {
+            const collections = await this.client.listCollections().toArray();
+            if (collections.length === 0) {
+                console.log('No collections found.');
+            }
+            else {
+                console.log('Collections:');
+                collections.forEach((collection) => {
+                    const marker = collection === this.currentCollection ? ' (current)' : '';
+                    console.log(`  - ${collection}${marker}`);
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error listing collections:', error instanceof Error ? error.message : error);
+        }
+    }
+    async handleFindCommand(filterStr) {
+        if (!this.currentCollection) {
+            console.log('No collection selected. Use .use <collection> first.');
+            return;
+        }
+        let filter;
+        try {
+            filter = JSON.parse(filterStr);
+        }
+        catch (error) {
+            console.log('Invalid JSON filter:', error instanceof Error ? error.message : error);
+            return;
+        }
+        this.lastFilter = filter;
+        // Create a collection and a find cursor to extract the SQL
+        const collection = this.client.collection(this.currentCollection);
+        // We need to access the internal SQL generation. Let's create a custom cursor
+        // that exposes the SQL generation logic
+        const debugCursor = new DebugFindCursor(collection.db, this.currentCollection, filter, { verbose: true });
+        this.lastSqlQuery = debugCursor.getSQL();
+        console.log('');
+        console.log('📝 Generated SQL:');
+        console.log('Query:', this.lastSqlQuery.sql);
+        console.log('Parameters:', JSON.stringify(this.lastSqlQuery.params));
+        console.log('');
+        // Execute the query and show results
+        try {
+            const results = await debugCursor.toArray();
+            console.log(`📊 Results (${results.length} documents):`);
+            if (results.length > 0) {
+                results.forEach((doc, index) => {
+                    console.log(`[${index}]`, JSON.stringify(doc, null, 2));
+                });
+            }
+            else {
+                console.log('No documents found.');
+            }
+        }
+        catch (error) {
+            console.error('Execution error:', error instanceof Error ? error.message : error);
+        }
+    }
+    async handleSqlCommand(sqlQuery) {
+        if (!this.currentCollection) {
+            console.log('No collection selected. Use .use <collection> first.');
+            return;
+        }
+        try {
+            // Get the database instance to execute raw SQL
+            const db = this.client.db;
+            console.log('');
+            console.log('🔧 Executing SQL:');
+            console.log(sqlQuery);
+            console.log('');
+            const results = await db.all(sqlQuery);
+            console.log(`📊 Results (${results.length} rows):`);
+            if (results.length > 0) {
+                results.forEach((row, index) => {
+                    console.log(`[${index}]`, JSON.stringify(row, null, 2));
+                });
+            }
+            else {
+                console.log('No rows returned.');
+            }
+        }
+        catch (error) {
+            console.error('SQL execution error:', error instanceof Error ? error.message : error);
+        }
+    }
+    showLastQuery() {
+        if (!this.lastSqlQuery) {
+            console.log('No previous query to show.');
+            return;
+        }
+        console.log('');
+        console.log('📝 Last Generated SQL:');
+        console.log('Query:', this.lastSqlQuery.sql);
+        console.log('Parameters:', JSON.stringify(this.lastSqlQuery.params));
+        if (this.lastFilter) {
+            console.log('Original Filter:', JSON.stringify(this.lastFilter, null, 2));
+        }
+        console.log('');
+    }
+    async showSample(count) {
+        if (!this.currentCollection) {
+            console.log('No collection selected. Use .use <collection> first.');
+            return;
+        }
+        try {
+            const collection = this.client.collection(this.currentCollection);
+            const results = await collection.find({}).limit(count).toArray();
+            console.log('');
+            console.log(`📋 Sample documents from "${this.currentCollection}" (${results.length} of ${count} requested):`);
+            if (results.length > 0) {
+                results.forEach((doc, index) => {
+                    console.log(`[${index}]`, JSON.stringify(doc, null, 2));
+                });
+            }
+            else {
+                console.log('Collection is empty.');
+            }
+            console.log('');
+        }
+        catch (error) {
+            console.error('Error fetching sample:', error instanceof Error ? error.message : error);
+        }
+    }
+    async cleanup() {
+        console.log('\nClosing database connection...');
+        await this.client.close();
+        this.rl.close();
+        process.exit(0);
+    }
+}
+exports.QueryDebugger = QueryDebugger;
+// Extended FindCursor that exposes SQL generation
+class DebugFindCursor extends findCursor_js_1.FindCursor {
+    constructor(db, collectionName, filter, options = {}) {
+        super(db, collectionName, filter, options);
+    }
+    getSQL() {
+        // Access the private queryParts property
+        return this.queryParts;
+    }
+}

package/dist/cjs/index.js

@@ -0,0 +1,65 @@
+"use strict";
+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.MongoLite = exports.NodeSqliteAdapter = exports.BrowserSqliteAdapter = exports.CloudflareDurableObjectAdapter = exports.ChangeStream = exports.MongoLiteCollection = void 0;
+const node_sqlite_js_1 = require("./adapters/node-sqlite.js");
+const mongo_client_js_1 = require("./mongo-client.js");
+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);
+var changeStream_js_1 = require("./changeStream.js");
+Object.defineProperty(exports, "ChangeStream", { enumerable: true, get: function () { return changeStream_js_1.ChangeStream; } });
+var cloudflare_js_1 = require("./adapters/cloudflare.js");
+Object.defineProperty(exports, "CloudflareDurableObjectAdapter", { enumerable: true, get: function () { return cloudflare_js_1.CloudflareDurableObjectAdapter; } });
+var browser_js_1 = require("./adapters/browser.js");
+Object.defineProperty(exports, "BrowserSqliteAdapter", { enumerable: true, get: function () { return browser_js_1.BrowserSqliteAdapter; } });
+var node_sqlite_js_2 = require("./adapters/node-sqlite.js");
+Object.defineProperty(exports, "NodeSqliteAdapter", { enumerable: true, get: function () { return node_sqlite_js_2.NodeSqliteAdapter; } });
+/**
+ * MongoLite class is the main entry point for interacting with the SQLite-backed database.
+ *
+ * You can construct it with:
+ * - A file path string — uses the built-in `node:sqlite` adapter (`NodeSqliteAdapter`).
+ *   Requires Node.js 22.5.0+; for older runtimes, import `MongoLite` from
+ *   `@semics-tech/mongolite/better-sqlite3` instead.
+ * - A `MongoLiteClientOptions` object — uses the built-in adapter with options.
+ * - An `IDatabaseAdapter` instance — use a custom adapter such as
+ *   `CloudflareDurableObjectAdapter` for Cloudflare Durable Objects.
+ */
+class MongoLite extends mongo_client_js_1.MongoLite {
+    /**
+     * Creates a new MongoLite client instance.
+     * @param dbPathOrOptions Path to the SQLite database file, an options object,
+     *                        or an `IDatabaseAdapter` for custom backends.
+     */
+    constructor(dbPathOrOptions, options = {}) {
+        if (dbPathOrOptions &&
+            typeof dbPathOrOptions === 'object' &&
+            typeof dbPathOrOptions.connect === 'function' &&
+            typeof dbPathOrOptions.run === 'function' &&
+            typeof dbPathOrOptions.get === 'function' &&
+            typeof dbPathOrOptions.all === 'function' &&
+            typeof dbPathOrOptions.exec === 'function' &&
+            typeof dbPathOrOptions.close === 'function') {
+            // Custom adapter (e.g. CloudflareDurableObjectAdapter)
+            super(dbPathOrOptions, options);
+        }
+        else {
+            super(new node_sqlite_js_1.NodeSqliteAdapter(dbPathOrOptions), options);
+        }
+    }
+}
+exports.MongoLite = MongoLite;