@pineliner/odb-client 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -1,7 +1,22 @@
 "use strict";
 // The require scope
 var __webpack_require__ = {};
-/************************************************************************/ // webpack/runtime/define_property_getters
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
 (()=>{
     __webpack_require__.d = function(exports1, definition) {
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -33,25 +48,31 @@ var __webpack_require__ = {};
 __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-    identifier: ()=>/* binding */ src_identifier,
+    fragment: ()=>/* reexport */ fragment,
     HTTPClient: ()=>/* reexport */ HTTPClient,
     default: ()=>/* reexport */ odblite,
-    ServiceClient: ()=>/* reexport */ ServiceClient,
+    identifier: ()=>/* binding */ src_identifier,
+    ODBLiteAdapter: ()=>/* reexport */ ODBLiteAdapter,
+    BunSQLiteAdapter: ()=>/* reexport */ BunSQLiteAdapter,
     raw: ()=>/* binding */ src_raw,
-    sql: ()=>/* reexport */ sql_parser_sql,
     insertValues: ()=>/* binding */ src_insertValues,
+    sql: ()=>/* reexport */ sql_parser_sql,
     where: ()=>/* binding */ src_where,
+    DatabaseManager: ()=>/* reexport */ DatabaseManager,
+    LibSQLAdapter: ()=>/* reexport */ LibSQLAdapter,
     updateSet: ()=>/* binding */ src_updateSet,
     ODBLiteClient: ()=>/* reexport */ ODBLiteClient,
     ODBLiteTransaction: ()=>/* reexport */ ODBLiteTransaction,
     join: ()=>/* binding */ src_join,
     ODBLiteError: ()=>/* reexport */ ODBLiteError,
+    parseSQL: ()=>/* reexport */ parseSQL,
     ConnectionError: ()=>/* reexport */ ConnectionError,
     SQLParser: ()=>/* reexport */ sql_parser_SQLParser,
     SimpleTransaction: ()=>/* reexport */ SimpleTransaction,
     odblite: ()=>/* reexport */ odblite,
+    splitSQLStatements: ()=>/* reexport */ splitSQLStatements,
     QueryError: ()=>/* reexport */ types_QueryError,
-    fragment: ()=>/* reexport */ fragment
+    ServiceClient: ()=>/* reexport */ ServiceClient
 });
 // Core types for the ODBLite client
 // Error types
@@ -913,19 +934,20 @@ ODBLiteClient.join;
    * Create a new database
    *
    * @param name - Database name (should be unique)
-   * @param nodeId - ID of the node to host the database
+   * @param nodeId - ID of the node to host the database (optional - server will select if null)
    * @returns Created database object with hash
    */ async createDatabase(name, nodeId) {
+        const body = {
+            name
+        };
+        if (nodeId) body.nodeId = nodeId;
         const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify({
-                name,
-                nodeId
-            })
+            body: JSON.stringify(body)
         });
         const result = await response.json();
         if (!result.success) throw new Error(result.error || 'Failed to create database');
@@ -1053,9 +1075,738 @@ ODBLiteClient.join;
         this.databaseCache.set(cacheKey, hash);
     }
 }
+const external_bun_sqlite_namespaceObject = require("bun:sqlite");
+/**
+ * Bun SQLite adapter for DatabaseManager
+ * Wraps bun:sqlite with Connection interface
+ */ class BunSQLiteAdapter {
+    type = 'bun-sqlite';
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    async connect(config) {
+        const db = new external_bun_sqlite_namespaceObject.Database(config.databasePath, {
+            readonly: config.readonly,
+            create: config.create ?? true
+        });
+        return new BunSQLiteConnection(db);
+    }
+    async disconnect(tenantId) {
+    // bun:sqlite doesn't require explicit disconnection
+    // File handles are cleaned up by GC
+    }
+    async isHealthy() {
+        try {
+            const db = new external_bun_sqlite_namespaceObject.Database(this.config.databasePath, {
+                readonly: true,
+                create: false
+            });
+            db.query('SELECT 1').get();
+            db.close();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+/**
+ * Connection implementation for Bun SQLite
+ */ class BunSQLiteConnection {
+    db;
+    inTransaction = false;
+    constructor(db){
+        this.db = db;
+    }
+    /**
+   * Template tag query (postgres.js-like)
+   */ async query(strings, ...values) {
+        // Build SQL from template
+        const sql = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
+        return this.execute(sql, values);
+    }
+    /**
+   * Execute SQL with parameters
+   */ async execute(sql, params = []) {
+        try {
+            const stmt = this.db.query(sql);
+            const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+            if (isSelect) {
+                const rows = stmt.all(...params);
+                return {
+                    rows: rows,
+                    rowsAffected: 0
+                };
+            }
+            {
+                const result = stmt.run(...params);
+                return {
+                    rows: [],
+                    rowsAffected: result.changes || 0,
+                    lastInsertRowid: result.lastInsertRowid
+                };
+            }
+        } catch (error) {
+            throw new Error(`SQL execution failed: ${error.message}`);
+        }
+    }
+    /**
+   * Prepare statement for repeated execution
+   */ prepare(sql) {
+        const stmt = this.db.query(sql);
+        return {
+            execute: async (params = [])=>{
+                const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+                if (isSelect) {
+                    const rows = stmt.all(...params);
+                    return {
+                        rows: rows,
+                        rowsAffected: 0
+                    };
+                }
+                {
+                    const result = stmt.run(...params);
+                    return {
+                        rows: [],
+                        rowsAffected: result.changes || 0,
+                        lastInsertRowid: result.lastInsertRowid
+                    };
+                }
+            },
+            all: async (params = [])=>stmt.all(...params),
+            get: async (params = [])=>stmt.get(...params)
+        };
+    }
+    /**
+   * Execute function in transaction
+   */ async transaction(fn) {
+        if (this.inTransaction) // Nested transaction - just execute the function
+        return fn(this);
+        this.inTransaction = true;
+        try {
+            await this.execute('BEGIN');
+            const result = await fn(this);
+            await this.execute('COMMIT');
+            return result;
+        } catch (error) {
+            await this.execute('ROLLBACK');
+            throw error;
+        } finally{
+            this.inTransaction = false;
+        }
+    }
+    /**
+   * Close connection
+   */ async close() {
+        this.db.close();
+    }
+}
+const external_libsql_client_namespaceObject = require("@libsql/client");
+/**
+ * LibSQL adapter for DatabaseManager
+ * Wraps @libsql/client with Connection interface
+ */ class LibSQLAdapter {
+    type = 'libsql';
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    async connect(config) {
+        const client = (0, external_libsql_client_namespaceObject.createClient)({
+            url: config.url,
+            authToken: config.authToken,
+            encryptionKey: config.encryptionKey
+        });
+        return new LibSQLConnection(client);
+    }
+    async disconnect(tenantId) {
+    // LibSQL clients don't require explicit disconnection
+    // Connections are pooled internally
+    }
+    async isHealthy() {
+        try {
+            const client = (0, external_libsql_client_namespaceObject.createClient)({
+                url: this.config.url,
+                authToken: this.config.authToken
+            });
+            await client.execute('SELECT 1');
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+/**
+ * Connection implementation for LibSQL
+ */ class LibSQLConnection {
+    client;
+    txClient;
+    constructor(client){
+        this.client = client;
+    }
+    /**
+   * Template tag query (postgres.js-like)
+   */ async query(strings, ...values) {
+        // Build SQL from template
+        const sql = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
+        return this.execute(sql, values);
+    }
+    /**
+   * Execute SQL with parameters
+   * Supports both formats: execute(sql, params) and execute({sql, args})
+   */ async execute(sql, params = []) {
+        try {
+            const target = this.txClient || this.client;
+            // Support both execute(sql, params) and execute({sql, args}) formats
+            let query;
+            query = 'string' == typeof sql ? {
+                sql,
+                args: params
+            } : {
+                sql: sql.sql,
+                args: sql.args || []
+            };
+            const result = await target.execute(query);
+            return {
+                rows: result.rows,
+                rowsAffected: Number(result.rowsAffected),
+                lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid.toString()) : void 0
+            };
+        } catch (error) {
+            throw new Error(`SQL execution failed: ${error.message}`);
+        }
+    }
+    /**
+   * Prepare statement for repeated execution
+   */ prepare(sql) {
+        return {
+            execute: async (params = [])=>this.execute(sql, params),
+            all: async (params = [])=>{
+                const result = await this.execute(sql, params);
+                return result.rows;
+            },
+            get: async (params = [])=>{
+                const result = await this.execute(sql, params);
+                return result.rows[0] || null;
+            }
+        };
+    }
+    /**
+   * Execute function in transaction
+   */ async transaction(fn) {
+        if (this.txClient) // Nested transaction - just execute the function
+        return fn(this);
+        // Use manual BEGIN/COMMIT/ROLLBACK for simplicity
+        try {
+            await this.execute('BEGIN');
+            const result = await fn(this);
+            await this.execute('COMMIT');
+            return result;
+        } catch (error) {
+            await this.execute('ROLLBACK');
+            throw error;
+        }
+    }
+    /**
+   * Close connection
+   */ async close() {
+    // LibSQL client.close() if available in future versions
+    // For now, connections are managed by the client pool
+    }
+}
+/**
+ * ODB-Lite adapter for DatabaseManager
+ * Wraps ServiceClient and ODBLiteClient with Connection interface
+ */ class ODBLiteAdapter {
+    type = 'odblite';
+    config;
+    serviceClient;
+    constructor(config){
+        this.config = config;
+        this.serviceClient = new ServiceClient({
+            baseUrl: config.serviceUrl,
+            apiKey: config.apiKey
+        });
+    }
+    async connect(config) {
+        const databaseName = config.databaseName || 'default';
+        // Ensure database exists
+        const dbInfo = await this.serviceClient.getDatabaseByName(databaseName);
+        if (!dbInfo) // Create database - pass nodeId from config if provided, otherwise server selects
+        await this.serviceClient.createDatabase(databaseName, this.config.nodeId);
+        // Get fresh database info
+        const db = await this.serviceClient.getDatabaseByName(databaseName);
+        if (!db) throw new Error(`Database ${databaseName} not found after creation`);
+        // Create ODBLiteClient for this database
+        const client = new ODBLiteClient({
+            baseUrl: this.config.serviceUrl,
+            apiKey: this.config.apiKey,
+            databaseId: db.hash
+        });
+        return new ODBLiteConnection(client, this.serviceClient, databaseName);
+    }
+    async disconnect(tenantId) {
+        if (tenantId) {
+            const prefix = 'pipeline_tenant_' // TODO: make configurable
+            ;
+            const databaseName = `${prefix}${tenantId}`;
+            try {
+                await this.serviceClient.deleteDatabase(databaseName);
+            } catch (error) {
+                console.warn(`Failed to delete database ${databaseName}:`, error.message);
+            }
+        }
+    }
+    async isHealthy() {
+        try {
+            await this.serviceClient.listDatabases();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+/**
+ * Connection implementation for ODB-Lite
+ */ class ODBLiteConnection {
+    client;
+    serviceClient;
+    databaseName;
+    inTransaction = false;
+    constructor(client, serviceClient, databaseName){
+        this.client = client;
+        this.serviceClient = serviceClient;
+        this.databaseName = databaseName;
+    }
+    /**
+   * Template tag query (postgres.js-like)
+   */ async query(strings, ...values) {
+        // ODBLiteClient.sql is a function that returns a Promise
+        const result = await this.client.sql(strings, ...values);
+        return {
+            rows: result.rows,
+            rowsAffected: result.rowsAffected || 0
+        };
+    }
+    /**
+   * Execute SQL with parameters
+   */ async execute(sql, params = []) {
+        try {
+            const result = await this.client.sql.execute(sql, params);
+            return {
+                rows: result.rows,
+                rowsAffected: result.rowsAffected || 0
+            };
+        } catch (error) {
+            throw new Error(`SQL execution failed: ${error.message}`);
+        }
+    }
+    /**
+   * Prepare statement for repeated execution
+   */ prepare(sql) {
+        return {
+            execute: async (params = [])=>this.execute(sql, params),
+            all: async (params = [])=>{
+                const result = await this.execute(sql, params);
+                return result.rows;
+            },
+            get: async (params = [])=>{
+                const result = await this.execute(sql, params);
+                return result.rows[0] || null;
+            }
+        };
+    }
+    /**
+   * Execute function in transaction
+   */ async transaction(fn) {
+        if (this.inTransaction) // Nested transaction - just execute the function
+        return fn(this);
+        this.inTransaction = true;
+        try {
+            await this.execute('BEGIN');
+            const result = await fn(this);
+            await this.execute('COMMIT');
+            return result;
+        } catch (error) {
+            await this.execute('ROLLBACK');
+            throw error;
+        } finally{
+            this.inTransaction = false;
+        }
+    }
+    /**
+   * Close connection
+   */ async close() {
+    // ODBLiteClient connections are stateless HTTP requests
+    // No explicit close needed
+    }
+}
+const external_node_sql_parser_namespaceObject = require("node-sql-parser");
+/**
+ * Parse SQL file into statements, separating PRAGMA from regular SQL
+ * Uses node-sql-parser for robust SQL parsing
+ */ function parseSQL(sqlContent, options = {}) {
+    const separatePragma = options.separatePragma ?? true;
+    // Use node-sql-parser to properly split SQL statements
+    const statements = splitStatementsWithParser(sqlContent);
+    if (!separatePragma) return {
+        pragmaStatements: [],
+        regularStatements: statements
+    };
+    const pragmaStatements = [];
+    const regularStatements = [];
+    for (const statement of statements){
+        const trimmed = statement.trim().toUpperCase();
+        if (trimmed.startsWith('PRAGMA')) pragmaStatements.push(statement);
+        else regularStatements.push(statement);
+    }
+    return {
+        pragmaStatements,
+        regularStatements
+    };
+}
+/**
+ * Split SQL content using node-sql-parser (more robust than custom parser)
+ * Falls back to simple split if parser fails
+ */ function splitStatementsWithParser(sqlContent) {
+    try {
+        const parser = new external_node_sql_parser_namespaceObject.Parser();
+        // node-sql-parser supports splitting multiple statements
+        // Try to use it, but have fallback for edge cases
+        const opt = {
+            database: 'sqlite',
+            type: 'table'
+        };
+        // Split by semicolons first to handle parser limitations with very large files
+        const roughStatements = sqlContent.split(/;[\s\n]*/).map((s)=>s.trim()).filter((s)=>s.length > 0);
+        const validStatements = [];
+        for (const stmt of roughStatements){
+            // Add semicolon back
+            const fullStmt = stmt + ';';
+            // Skip comments-only statements
+            if (!stmt.trim().startsWith('--') && '' !== stmt.trim()) // Validate with parser (but don't fail if it can't parse complex statements)
+            try {
+                parser.astify(fullStmt, opt);
+                validStatements.push(fullStmt);
+            } catch (parseError) {
+                // If parser can't handle it, include it anyway if it looks like valid SQL
+                // This handles complex statements like CREATE TRIGGER, CREATE VIEW with subqueries
+                if (stmt.match(/^(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|SELECT|PRAGMA)/i)) validStatements.push(fullStmt);
+                else console.warn(`Skipping potentially invalid statement: ${stmt.substring(0, 50)}...`);
+            }
+        }
+        return validStatements;
+    } catch (error) {
+        console.warn('node-sql-parser failed, using fallback parser:', error);
+        // Fallback to original simple parser
+        return splitStatements(sqlContent);
+    }
+}
+/**
+ * Split SQL content into individual statements
+ * Handles comments, quotes, and semicolons properly
+ */ function splitStatements(sqlContent) {
+    const statements = [];
+    let currentStatement = '';
+    let inQuote = false;
+    let quoteChar = '';
+    const lines = sqlContent.split('\n');
+    for (const line of lines){
+        let processedLine = '';
+        for(let i = 0; i < line.length; i++){
+            const char = line[i];
+            const prevChar = i > 0 ? line[i - 1] : '';
+            const nextChar = i < line.length - 1 ? line[i + 1] : '';
+            // Handle single-line comments
+            if (!inQuote && '-' === char && '-' === nextChar) break; // Skip rest of line
+            // Track quotes
+            if (("'" === char || '"' === char) && '\\' !== prevChar) {
+                if (inQuote) {
+                    if (char === quoteChar) {
+                        inQuote = false;
+                        quoteChar = '';
+                    }
+                } else {
+                    inQuote = true;
+                    quoteChar = char;
+                }
+            }
+            processedLine += char;
+            // Split on semicolon when not in quotes
+            if (';' === char && !inQuote) {
+                currentStatement += processedLine;
+                const stmt = currentStatement.trim();
+                if (stmt) statements.push(stmt);
+                currentStatement = '';
+                processedLine = '';
+            }
+        }
+        if (processedLine.trim()) currentStatement += `${processedLine}\n`;
+    }
+    // Handle remaining statement
+    const finalStmt = currentStatement.trim();
+    if (finalStmt) statements.push(finalStmt);
+    return statements;
+}
+/**
+ * Simple split for systems that don't need PRAGMA separation
+ */ function splitSQLStatements(sqlContent) {
+    const { pragmaStatements, regularStatements } = parseSQL(sqlContent);
+    return [
+        ...pragmaStatements,
+        ...regularStatements
+    ];
+}
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+/**
+ * Database factory for creating and managing multiple databases
+ *
+ * Features:
+ * - Creates multiple databases from single manager instance
+ * - Supports libsql, bun:sqlite, and ODB-Lite backends
+ * - Connection pooling with LRU eviction
+ * - Automatic schema migrations
+ *
+ * @example
+ * ```ts
+ * const dbManager = new DatabaseManager({
+ *   backend: 'libsql',
+ *   databasePath: './data'
+ * })
+ *
+ * // Create databases
+ * await dbManager.createDatabase('identity', { schemaContent })
+ * await dbManager.createDatabase('analytics', { schemaContent })
+ *
+ * // Get connections
+ * const identityDB = await dbManager.getConnection('identity')
+ * const analyticsDB = await dbManager.getConnection('analytics')
+ * ```
+ */ class DatabaseManager {
+    config;
+    adapter;
+    connections = new Map();
+    // Connection pool management (LRU)
+    connectionTimestamps = new Map();
+    maxConnections;
+    constructor(config){
+        this.config = config;
+        this.maxConnections = config.connectionPoolSize || 10;
+        // Create appropriate adapter based on backend
+        switch(config.backend){
+            case 'bun-sqlite':
+                this.adapter = new BunSQLiteAdapter({
+                    databasePath: config.databasePath,
+                    create: true
+                });
+                break;
+            case 'libsql':
+                this.adapter = new LibSQLAdapter({
+                    url: `file:${config.databasePath}`,
+                    ...config.libsql
+                });
+                break;
+            case 'odblite':
+                if (!config.odblite) throw new Error('odblite config required for odblite backend');
+                this.adapter = new ODBLiteAdapter(config.odblite);
+                break;
+            default:
+                throw new Error(`Unknown backend type: ${config.backend}`);
+        }
+    }
+    /**
+   * Create a new database
+   * @param name - Database name (becomes filename or ODB-Lite database name)
+   * @param options - Optional creation options
+   */ async createDatabase(name, options) {
+        console.log(`📦 Creating database: ${name}`);
+        // Build database-specific config
+        const dbConfig = this.getDatabaseConfig(name);
+        // Create connection
+        const conn = await this.adapter.connect(dbConfig);
+        // Run migrations if schema provided
+        if (options?.schemaContent) await this.runMigrations(conn, {
+            schemaContent: options.schemaContent
+        });
+        // Store connection
+        this.connections.set(name, conn);
+        this.connectionTimestamps.set(name, Date.now());
+        // Evict LRU if pool is full
+        if (this.connections.size > this.maxConnections) await this.evictLRU();
+        console.log(`✅ Database created: ${name}`);
+    }
+    /**
+   * Check if a database exists
+   * @param name - Database name
+   * @returns true if database exists, false otherwise
+   *
+   * Note: For local backends (libsql, bun-sqlite), checks file existence.
+   * For ODB-Lite, checks if database is in connection cache.
+   */ async databaseExists(name) {
+        // Check if already in connection cache
+        if (this.connections.has(name)) return true;
+        // For local file-based backends, check if file exists
+        switch(this.config.backend){
+            case 'bun-sqlite':
+                {
+                    const dbPath = `${this.config.databasePath}/${name}.db`;
+                    return external_node_fs_default().existsSync(dbPath);
+                }
+            case 'libsql':
+                {
+                    const dbPath = `${this.config.databasePath}/${name}.db`;
+                    return external_node_fs_default().existsSync(dbPath);
+                }
+            case 'odblite':
+                // For ODB-Lite, only return true if in cache
+                // (no way to check remote database existence without connecting)
+                return false;
+            default:
+                return false;
+        }
+    }
+    /**
+   * Get connection to a database
+   * @param name - Database name
+   *
+   * If database exists on disk but not in cache, it will be connected automatically.
+   * If database doesn't exist at all, an error will be thrown.
+   */ async getConnection(name) {
+        // Check if connection exists in cache
+        let conn = this.connections.get(name);
+        if (conn) {
+            this.connectionTimestamps.set(name, Date.now());
+            return conn;
+        }
+        // Check if database exists on disk
+        const exists = await this.databaseExists(name);
+        if (exists) {
+            // Connect to existing database
+            const dbConfig = this.getDatabaseConfig(name);
+            conn = await this.adapter.connect(dbConfig);
+            // Store connection
+            this.connections.set(name, conn);
+            this.connectionTimestamps.set(name, Date.now());
+            // Evict LRU if pool is full
+            if (this.connections.size > this.maxConnections) await this.evictLRU();
+            return conn;
+        }
+        // If database doesn't exist, throw error
+        throw new Error(`Database "${name}" not found. Call createDatabase("${name}", { schemaContent }) first.`);
+    }
+    /**
+   * Delete a database
+   * @param name - Database name
+   */ async deleteDatabase(name) {
+        console.log(`🗑️  Deleting database: ${name}`);
+        // Close connection if exists
+        const conn = this.connections.get(name);
+        if (conn) {
+            await conn.close();
+            this.connections.delete(name);
+            this.connectionTimestamps.delete(name);
+        }
+        // Backend-specific deletion
+        await this.adapter.disconnect(name);
+        console.log(`✅ Database deleted: ${name}`);
+    }
+    /**
+   * Execute SQL content on a database connection
+   * Useful for running migrations or initial schema
+   * @param name - Database name
+   * @param sqlContent - SQL content to execute
+   */ async executeSQLFile(name, sqlContent) {
+        const conn = await this.getConnection(name);
+        await this.runMigrations(conn, {
+            schemaContent: sqlContent
+        });
+    }
+    /**
+   * List all managed databases
+   */ async listDatabases() {
+        return Array.from(this.connections.keys());
+    }
+    /**
+   * Close all connections
+   */ async close() {
+        console.log(`🔌 Closing all database connections...`);
+        for (const [name, conn] of this.connections)await conn.close();
+        this.connections.clear();
+        this.connectionTimestamps.clear();
+        console.log(`✅ All connections closed`);
+    }
+    /**
+   * Run migrations on a connection
+   */ async runMigrations(conn, config) {
+        // Parse SQL statements
+        const { pragmaStatements, regularStatements } = parseSQL(config.schemaContent);
+        // Execute PRAGMA statements first
+        for (const pragma of pragmaStatements)try {
+            await conn.execute(pragma);
+        } catch (error) {
+            // Ignore PRAGMA errors (they might not be supported on all backends)
+            console.log(`⚠️  PRAGMA note: ${error.message}`);
+        }
+        // Execute regular statements
+        for (const statement of regularStatements)try {
+            await conn.execute(statement);
+        } catch (error) {
+            // Ignore "already exists" errors for idempotency
+            if (error.message?.includes('already exists') || error.message?.includes('no such column') || error.message?.includes('no such table')) {
+                console.log(`  ⚠️  Skipping: ${error.message}`);
+                continue;
+            }
+            console.error(`❌ Migration failed: ${statement.substring(0, 100)}...`);
+            throw error;
+        }
+        console.log(`✅ Migrations completed (${regularStatements.length} statements)`);
+    }
+    /**
+   * Get database-specific configuration
+   */ getDatabaseConfig(name) {
+        switch(this.config.backend){
+            case 'bun-sqlite':
+                return {
+                    databasePath: `${this.config.databasePath}/${name}.db`,
+                    create: true
+                };
+            case 'libsql':
+                return {
+                    url: `file:${this.config.databasePath}/${name}.db`,
+                    ...this.config.libsql
+                };
+            case 'odblite':
+                return {
+                    databaseName: `${this.config.databasePath}_${name}`,
+                    ...this.config.odblite
+                };
+            default:
+                throw new Error(`Unknown backend: ${this.config.backend}`);
+        }
+    }
+    /**
+   * Evict least recently used connection
+   */ async evictLRU() {
+        let oldestKey = null;
+        let oldestTime = 1 / 0;
+        for (const [key, timestamp] of this.connectionTimestamps)if (timestamp < oldestTime) {
+            oldestTime = timestamp;
+            oldestKey = key;
+        }
+        if (oldestKey) {
+            const conn = this.connections.get(oldestKey);
+            if (conn) await conn.close();
+            this.connections.delete(oldestKey);
+            this.connectionTimestamps.delete(oldestKey);
+            console.log(`♻️  Evicted LRU connection: ${oldestKey}`);
+        }
+    }
+}
 // Main entry point for ODB Client
 // Core query client exports (postgres.js-like interface)
 // Service management exports (high-level tenant database management)
+// Database Manager exports (unified multi-backend database abstraction)
 // Export error classes
 // Export static utility functions for easy access
 const { raw: src_raw, identifier: src_identifier, where: src_where, insertValues: src_insertValues, updateSet: src_updateSet, join: src_join } = ODBLiteClient;