@pineliner/odb-client 1.0.6 → 1.0.7

package/dist/index.js

@@ -1,8 +1,367 @@
-import * as __WEBPACK_EXTERNAL_MODULE_bun_sqlite__ from "bun:sqlite";
-import * as __WEBPACK_EXTERNAL_MODULE__libsql_client__ from "@libsql/client";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
-// Core types for the ODBLite client
-// Error types
+import { Database } from "bun:sqlite";
+import { createClient } from "@libsql/client";
+import node_fs from "node:fs";
+var __webpack_modules__ = {
+    "./src/orm/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            ORM: ()=>ORM,
+            and: ()=>and,
+            createORM: ()=>createORM,
+            eq: ()=>eq,
+            gt: ()=>gt,
+            gte: ()=>gte,
+            inArray: ()=>inArray,
+            isNotNull: ()=>isNotNull,
+            isNull: ()=>isNull,
+            like: ()=>like,
+            lt: ()=>lt,
+            lte: ()=>lte,
+            ne: ()=>ne,
+            or: ()=>or
+        });
+        function eq(field, value) {
+            return {
+                sql: `${field} = ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function ne(field, value) {
+            return {
+                sql: `${field} != ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function gt(field, value) {
+            return {
+                sql: `${field} > ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function gte(field, value) {
+            return {
+                sql: `${field} >= ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function lt(field, value) {
+            return {
+                sql: `${field} < ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function lte(field, value) {
+            return {
+                sql: `${field} <= ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function like(field, pattern) {
+            return {
+                sql: `${field} LIKE ?`,
+                params: [
+                    pattern
+                ]
+            };
+        }
+        function inArray(field, values) {
+            const placeholders = values.map(()=>'?').join(', ');
+            return {
+                sql: `${field} IN (${placeholders})`,
+                params: values
+            };
+        }
+        function isNull(field) {
+            return {
+                sql: `${field} IS NULL`,
+                params: []
+            };
+        }
+        function isNotNull(field) {
+            return {
+                sql: `${field} IS NOT NULL`,
+                params: []
+            };
+        }
+        function and(...conditions) {
+            const sql = conditions.map((c)=>`(${c.sql})`).join(' AND ');
+            const params = conditions.flatMap((c)=>c.params);
+            return {
+                sql,
+                params
+            };
+        }
+        function or(...conditions) {
+            const sql = conditions.map((c)=>`(${c.sql})`).join(' OR ');
+            const params = conditions.flatMap((c)=>c.params);
+            return {
+                sql,
+                params
+            };
+        }
+        class SelectBuilder {
+            db;
+            tableName;
+            selectFields = [
+                '*'
+            ];
+            whereConditions = [];
+            orderByField;
+            orderByDir = 'ASC';
+            limitValue;
+            offsetValue;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            select(fields = {}) {
+                if (0 === Object.keys(fields).length) this.selectFields = [
+                    '*'
+                ];
+                else this.selectFields = Object.keys(fields);
+                return this;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            orderBy(field, direction = 'ASC') {
+                this.orderByField = field;
+                this.orderByDir = direction;
+                return this;
+            }
+            limit(value) {
+                this.limitValue = value;
+                return this;
+            }
+            offset(value) {
+                this.offsetValue = value;
+                return this;
+            }
+            async execute() {
+                const fields = this.selectFields.join(', ');
+                const params = [];
+                let sql = `SELECT ${fields} FROM ${this.tableName}`;
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                if (this.orderByField) sql += ` ORDER BY ${this.orderByField} ${this.orderByDir}`;
+                if (void 0 !== this.limitValue) {
+                    sql += " LIMIT ?";
+                    params.push(this.limitValue);
+                }
+                if (void 0 !== this.offsetValue) {
+                    sql += " OFFSET ?";
+                    params.push(this.offsetValue);
+                }
+                const result = await this.db.execute(sql, params);
+                return result.rows;
+            }
+        }
+        class InsertBuilder {
+            db;
+            tableName;
+            insertValues = {};
+            shouldReturn = false;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            values(data) {
+                this.insertValues = data;
+                return this;
+            }
+            returning() {
+                this.shouldReturn = true;
+                return this;
+            }
+            async execute() {
+                const fields = Object.keys(this.insertValues);
+                const placeholders = fields.map(()=>'?').join(', ');
+                const values = fields.map((f)=>this.insertValues[f]);
+                let sql = `
+      INSERT INTO ${this.tableName} (${fields.join(', ')})
+      VALUES (${placeholders})
+    `;
+                await this.db.execute(sql, values);
+                if (this.shouldReturn) {
+                    const selectSql = `SELECT * FROM ${this.tableName} ORDER BY id DESC LIMIT 1`;
+                    const result = await this.db.execute(selectSql, []);
+                    return result.rows;
+                }
+                return [];
+            }
+        }
+        class UpdateBuilder {
+            db;
+            tableName;
+            updateValues = {};
+            whereConditions = [];
+            shouldReturn = false;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            set(data) {
+                this.updateValues = data;
+                return this;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            returning() {
+                this.shouldReturn = true;
+                return this;
+            }
+            async execute() {
+                const fields = Object.keys(this.updateValues);
+                const setClause = fields.map((f)=>`${f} = ?`).join(', ');
+                const values = fields.map((f)=>this.updateValues[f]);
+                let sql = `UPDATE ${this.tableName} SET ${setClause}`;
+                const params = [
+                    ...values
+                ];
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                await this.db.execute(sql, params);
+                if (this.shouldReturn && this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    const selectSql = `SELECT * FROM ${this.tableName} WHERE ${combinedCondition.sql}`;
+                    const result = await this.db.execute(selectSql, combinedCondition.params);
+                    return result.rows;
+                }
+                return [];
+            }
+        }
+        class DeleteBuilder {
+            db;
+            tableName;
+            whereConditions = [];
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            async execute() {
+                let sql = `DELETE FROM ${this.tableName}`;
+                const params = [];
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                await this.db.execute(sql, params);
+            }
+        }
+        class TableQueryBuilder {
+            db;
+            tableName;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            select(fields) {
+                const builder = new SelectBuilder(this.db, this.tableName);
+                if (fields) builder.select(fields);
+                return builder;
+            }
+            insert() {
+                return new InsertBuilder(this.db, this.tableName);
+            }
+            update() {
+                return new UpdateBuilder(this.db, this.tableName);
+            }
+            delete() {
+                return new DeleteBuilder(this.db, this.tableName);
+            }
+        }
+        class ORM {
+            db;
+            constructor(db){
+                this.db = db;
+            }
+            table(tableName) {
+                return new TableQueryBuilder(this.db, tableName);
+            }
+            select(fields) {
+                return {
+                    from: (tableName)=>{
+                        const builder = new SelectBuilder(this.db, tableName);
+                        if (fields) builder.select(fields);
+                        return builder;
+                    }
+                };
+            }
+            insert(tableName) {
+                return new InsertBuilder(this.db, tableName);
+            }
+            update(tableName) {
+                return new UpdateBuilder(this.db, tableName);
+            }
+            delete(tableName) {
+                return new DeleteBuilder(this.db, tableName);
+            }
+            execute(sql, params) {
+                return this.db.execute(sql, params);
+            }
+        }
+        function createORM(db) {
+            return new ORM(db);
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
 class ODBLiteError extends Error {
     code;
     query;
@@ -26,9 +385,7 @@ class types_QueryError extends ODBLiteError {
         this.name = 'QueryError';
     }
 }
-/**
- * HTTP client for communicating with ODBLite service
- */ class HTTPClient {
+class HTTPClient {
     config;
     constructor(config){
         this.config = {
@@ -36,12 +393,9 @@ class types_QueryError extends ODBLiteError {
             retries: 3,
             ...config
         };
-        // Ensure baseUrl doesn't end with slash
         if ('string' == typeof this.config.baseUrl) this.config.baseUrl = this.config.baseUrl.replace(/\/$/, '');
     }
-    /**
-   * Execute a query against the ODBLite service
-   */ async query(sql, params = []) {
+    async query(sql, params = []) {
         if (!this.config.databaseId) throw new ConnectionError('No database ID configured. Use setDatabase() first.');
         const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
         const body = {
@@ -59,7 +413,6 @@ class types_QueryError extends ODBLiteError {
             });
             const data = await response.json();
             if (!data.success) throw new types_QueryError(data.error || 'Query failed', sql, params);
-            // Handle nested data structure: { success: true, data: { rows: [...] } }
             let rows = [];
             if (data.data && 'object' == typeof data.data && 'rows' in data.data) rows = data.data.rows;
             else if (Array.isArray(data.data)) rows = data.data;
@@ -67,6 +420,7 @@ class types_QueryError extends ODBLiteError {
             return {
                 rows: rows,
                 rowsAffected: data.rowsAffected || data.data?.rowsAffected || 0,
+                lastInsertRowid: data.lastInsertRowid || data.data?.lastInsertRowid,
                 executionTime: data.executionTime || data.data?.executionTime || 0,
                 databaseName: data.databaseName || data.data?.databaseName
             };
@@ -75,9 +429,7 @@ class types_QueryError extends ODBLiteError {
             throw new types_QueryError(error instanceof Error ? error.message : 'Unknown error occurred', sql, params, error instanceof Error ? error : void 0);
         }
     }
-    /**
-   * Check database health
-   */ async ping() {
+    async ping() {
         if (!this.config.databaseId) return false;
         try {
             const url = `${this.config.baseUrl}/api/db/${this.config.databaseId}/health`;
@@ -93,9 +445,7 @@ class types_QueryError extends ODBLiteError {
             return false;
         }
     }
-    /**
-   * Get database information
-   */ async getDatabaseInfo() {
+    async getDatabaseInfo() {
         if (!this.config.databaseId) throw new ConnectionError('No database ID configured');
         const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
         const response = await this.makeRequest(url, {
@@ -108,14 +458,10 @@ class types_QueryError extends ODBLiteError {
         if (!data.success) throw new ConnectionError(data.error || 'Failed to get database info');
         return data;
     }
-    /**
-   * Set the database ID for subsequent queries
-   */ setDatabase(databaseId) {
+    setDatabase(databaseId) {
         this.config.databaseId = databaseId;
     }
-    /**
-   * Make HTTP request with retry logic
-   */ async makeRequest(url, options) {
+    async makeRequest(url, options) {
         let lastError;
         for(let attempt = 1; attempt <= (this.config.retries || 3); attempt++)try {
             const controller = new AbortController();
@@ -140,9 +486,7 @@ class types_QueryError extends ODBLiteError {
             return response;
         } catch (error) {
             lastError = error instanceof Error ? error : new Error('Unknown error');
-            // Don't retry on client errors (4xx)
             if (error instanceof ConnectionError && error.message.includes('HTTP 4')) throw error;
-            // Wait before retry (exponential backoff)
             if (attempt < (this.config.retries || 3)) {
                 const delay = Math.min(1000 * 2 ** (attempt - 1), 10000);
                 await new Promise((resolve)=>setTimeout(resolve, delay));
@@ -150,41 +494,25 @@ class types_QueryError extends ODBLiteError {
         }
         throw new ConnectionError(`Failed after ${this.config.retries} attempts: ${lastError?.message}`, lastError);
     }
-    /**
-   * Create a new HTTPClient with updated config
-   */ configure(updates) {
+    configure(updates) {
         return new HTTPClient({
             ...this.config,
             ...updates
         });
     }
-    /**
-   * Get current configuration
-   */ getConfig() {
+    getConfig() {
         return {
             ...this.config
         };
     }
 }
-/**
- * SQL template string parser that converts postgres.js-style template strings
- * into LibSQL-compatible parameterized queries
- */ class sql_parser_SQLParser {
-    /**
-   * Parse input that can be template strings, objects, or arrays
-   * Context-aware like postgres.js
-   */ static parse(sql, values) {
-        // Handle template string arrays (have the raw property or look like template strings)
+class sql_parser_SQLParser {
+    static parse(sql, values) {
         if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && void 0 !== values)) return this.parseTemplateString(sql, values || []);
-        // Handle direct object/array inputs (context detection)
         return this.parseContextualInput(sql, values);
     }
-    /**
-   * Parse contextual input (objects, arrays, etc.)
-   * Uses heuristics to detect the intended context
-   */ static parseContextualInput(input, values, context) {
+    static parseContextualInput(input, values, context) {
         if (Array.isArray(input)) {
-            // Check if this is an array of objects (for INSERT VALUES)
             if (input.length > 0 && input[0] && 'object' == typeof input[0] && input[0].constructor === Object) {
                 const insertResult = this.insertValues(input);
                 return {
@@ -192,7 +520,6 @@ class types_QueryError extends ODBLiteError {
                     params: insertResult.values
                 };
             }
-            // Array of primitives - assume it's for IN clause
             const placeholders = input.map(()=>'?').join(', ');
             return {
                 sql: `(${placeholders})`,
@@ -200,20 +527,14 @@ class types_QueryError extends ODBLiteError {
             };
         }
         if (input && 'object' == typeof input && input.constructor === Object) {
-            // Plain object - try to detect context based on structure and usage patterns
             const entries = Object.entries(input).filter(([, value])=>void 0 !== value);
             if (0 === entries.length) return {
                 sql: '',
                 params: []
             };
-            // Analyze the object structure to determine intent
             const hasNullValues = entries.some(([, value])=>null === value);
             const hasArrayValues = entries.some(([, value])=>Array.isArray(value));
             const hasComplexValues = entries.some(([, value])=>null !== value && 'object' == typeof value && !Array.isArray(value));
-            // Strong indicators for WHERE clauses:
-            // - null values (for IS NULL checks)
-            // - array values (for IN clauses)
-            // - complex nested objects
             if (hasNullValues || hasArrayValues || hasComplexValues) {
                 const whereResult = this.where(input);
                 return {
@@ -221,20 +542,13 @@ class types_QueryError extends ODBLiteError {
                     params: whereResult.values
                 };
             }
-            // For simple objects with primitive values, we need to guess context
-            // This is inherently ambiguous - could be SET or VALUES
-            // We'll default to a flexible format that works for both
-            // If single object, more likely to be SET clause
-            if (entries.length <= 3 && !Array.isArray(input)) // Return SET format by default
-            return this.buildSetClause(input);
-            // For larger objects or arrays of objects, likely INSERT VALUES
+            if (entries.length <= 3 && !Array.isArray(input)) return this.buildSetClause(input);
             const insertResult = this.insertValues(input);
             return {
                 sql: insertResult.text,
                 params: insertResult.values
             };
         }
-        // Fallback for other types
         return {
             sql: '?',
             params: [
@@ -242,9 +556,7 @@ class types_QueryError extends ODBLiteError {
             ]
         };
     }
-    /**
-   * Build a SET clause for UPDATE statements
-   */ static buildSetClause(data) {
+    static buildSetClause(data) {
         const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
         if (0 === entries.length) return {
             sql: '',
@@ -257,9 +569,7 @@ class types_QueryError extends ODBLiteError {
             params: values
         };
     }
-    /**
-   * Parse template string SQL into LibSQL format
-   */ static parseTemplateString(sql, values) {
+    static parseTemplateString(sql, values) {
         const fragments = [
             ...sql
         ];
@@ -269,21 +579,16 @@ class types_QueryError extends ODBLiteError {
             query += fragments[i];
             if (i < values.length) {
                 const value = values[i];
-                // Handle different value types using context detection
                 if (Array.isArray(value)) {
-                    // Handle IN clauses: sql`SELECT * FROM users WHERE id IN ${[1, 2, 3]}`
                     const placeholders = value.map(()=>"?").join(', ');
                     query += `(${placeholders})`;
                     params.push(...value.map((v)=>this.convertValue(v)));
                 } else if (value && 'object' == typeof value && value.constructor === Object) {
-                    // Use context detection for objects
                     const contextResult = this.parseContextualInput(value);
                     query += contextResult.sql;
                     params.push(...contextResult.params);
-                } else if ('string' == typeof value && value.startsWith('__RAW__')) // Handle raw SQL: sql`SELECT * FROM ${raw('users')}`
-                query += value.slice(7); // Remove __RAW__ prefix
+                } else if ('string' == typeof value && value.startsWith('__RAW__')) query += value.slice(7);
                 else {
-                    // Regular parameter
                     query += '?';
                     params.push(this.convertValue(value));
                 }
@@ -294,50 +599,32 @@ class types_QueryError extends ODBLiteError {
             params
         };
     }
-    /**
-   * Create a raw SQL fragment (not parameterized)
-   */ static raw(text) {
+    static raw(text) {
         return `__RAW__${text}`;
     }
-    /**
-   * Create an identifier (table name, column name, etc.)
-   */ static identifier(name) {
+    static identifier(name) {
         return this.escapeIdentifier(name);
     }
-    /**
-   * Escape SQL identifiers (table names, column names)
-   */ static escapeIdentifier(identifier) {
-        // SQLite uses double quotes for identifiers
+    static escapeIdentifier(identifier) {
         return `"${identifier.replace(/"/g, '""')}"`;
     }
-    /**
-   * Convert JavaScript values to LibSQL-compatible values
-   */ static convertValue(value) {
+    static convertValue(value) {
         if (null == value) return null;
-        if (value instanceof Date) // Convert Date to ISO string for SQLite
-        return value.toISOString();
-        if (value instanceof Buffer) // Convert Buffer to Uint8Array for LibSQL
-        return new Uint8Array(value);
-        if ('boolean' == typeof value) // SQLite uses 0/1 for booleans
-        return value ? 1 : 0;
-        if ('bigint' == typeof value) // Convert BigInt to string to avoid precision loss
-        return value.toString();
-        if ('object' == typeof value) // Serialize objects as JSON
-        return JSON.stringify(value);
+        if (value instanceof Date) return value.toISOString();
+        if (value instanceof Buffer) return new Uint8Array(value);
+        if ('boolean' == typeof value) return value ? 1 : 0;
+        if ('bigint' == typeof value) return value.toString();
+        if ('object' == typeof value) return JSON.stringify(value);
         return value;
     }
-    /**
-   * Create a SQL fragment for building complex queries
-   */ static fragment(sql, ...values) {
+    static fragment(sql, ...values) {
         const parsed = this.parse(sql, values);
         return {
             text: parsed.sql,
             values: parsed.params
         };
     }
-    /**
-   * Join multiple SQL fragments
-   */ static join(fragments, separator = ' ') {
+    static join(fragments, separator = ' ') {
         const text = fragments.map((f)=>f.text).join(separator);
         const values = fragments.flatMap((f)=>f.values);
         return {
@@ -345,9 +632,7 @@ class types_QueryError extends ODBLiteError {
             values
         };
     }
-    /**
-   * Helper for building WHERE clauses from objects
-   */ static where(conditions) {
+    static where(conditions) {
         const entries = Object.entries(conditions).filter(([, value])=>void 0 !== value);
         if (0 === entries.length) return {
             text: '',
@@ -373,9 +658,7 @@ class types_QueryError extends ODBLiteError {
             values
         };
     }
-    /**
-   * Helper for building INSERT VALUES from objects
-   */ static insertValues(data) {
+    static insertValues(data) {
         const records = Array.isArray(data) ? data : [
             data
         ];
@@ -392,9 +675,7 @@ class types_QueryError extends ODBLiteError {
             values
         };
     }
-    /**
-   * Helper for building UPDATE SET clauses from objects
-   */ static updateSet(data) {
+    static updateSet(data) {
         const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
         if (0 === entries.length) throw new Error('No data provided for update');
         const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
@@ -405,7 +686,6 @@ class types_QueryError extends ODBLiteError {
         };
     }
 }
-// Export convenience functions
 const sql_parser_sql = sql_parser_SQLParser.parse.bind(sql_parser_SQLParser);
 sql_parser_SQLParser.raw.bind(sql_parser_SQLParser);
 sql_parser_SQLParser.identifier.bind(sql_parser_SQLParser);
@@ -414,12 +694,7 @@ sql_parser_SQLParser.join.bind(sql_parser_SQLParser);
 sql_parser_SQLParser.where.bind(sql_parser_SQLParser);
 sql_parser_SQLParser.insertValues.bind(sql_parser_SQLParser);
 sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
-/**
- * Transaction implementation for ODBLite
- * Note: SQLite transactions are simulated at the client level since ODBLite
- * operates on individual queries. This provides a familiar API but doesn't
- * provide true ACID guarantees across multiple HTTP requests.
- */ class ODBLiteTransaction {
+class ODBLiteTransaction {
     httpClient;
     isCommitted = false;
     isRolledBack = false;
@@ -427,136 +702,95 @@ sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
     constructor(httpClient){
         this.httpClient = httpClient;
     }
-    /**
-   * Execute a query within the transaction
-   * For SQLite, we'll queue queries and execute them in batch on commit
-   */ async sql(sql, ...values) {
+    async sql(sql, ...values) {
         this.checkTransactionState();
         const parsed = sql_parser_SQLParser.parse(sql, values);
-        // For read queries, execute immediately
         if (this.isReadQuery(parsed.sql)) return await this.httpClient.query(parsed.sql, parsed.params);
-        // For write queries, queue them for batch execution
         this.queries.push(parsed);
-        // Return a placeholder result for queued queries
         return {
             rows: [],
             rowsAffected: 0,
             executionTime: 0
         };
     }
-    /**
-   * Commit the transaction by executing all queued queries
-   */ async commit() {
+    async commit() {
         this.checkTransactionState();
         try {
-            // Execute BEGIN
             await this.httpClient.query('BEGIN');
-            // Execute all queued queries
             for (const query of this.queries)await this.httpClient.query(query.sql, query.params);
-            // Commit the transaction
             await this.httpClient.query('COMMIT');
             this.isCommitted = true;
         } catch (error) {
-            // Rollback on any error
             try {
                 await this.httpClient.query('ROLLBACK');
-            } catch (rollbackError) {
-            // Ignore rollback errors
-            }
+            } catch (rollbackError) {}
             this.isRolledBack = true;
             throw new types_QueryError(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`, void 0, void 0, error instanceof Error ? error : void 0);
         }
     }
-    /**
-   * Rollback the transaction
-   */ async rollback() {
+    async rollback() {
         this.checkTransactionState();
         try {
-            // If we have any queries, we need to actually rollback
             if (this.queries.length > 0) await this.httpClient.query('ROLLBACK');
         } finally{
             this.isRolledBack = true;
         }
     }
-    /**
-   * Check if transaction is still active
-   */ checkTransactionState() {
+    checkTransactionState() {
         if (this.isCommitted) throw new types_QueryError('Transaction has already been committed');
         if (this.isRolledBack) throw new types_QueryError('Transaction has been rolled back');
     }
-    /**
-   * Determine if a query is a read operation
-   */ isReadQuery(sql) {
+    isReadQuery(sql) {
         const trimmed = sql.trim().toUpperCase();
         return trimmed.startsWith('SELECT') || trimmed.startsWith('WITH') || trimmed.startsWith('EXPLAIN') || trimmed.startsWith('PRAGMA');
     }
 }
-/**
- * Create a simple transaction function that executes immediately
- * This is more suitable for HTTP-based databases where true transactions
- * across multiple requests are not practical
- */ function createSimpleTransaction(httpClient) {
+function createSimpleTransaction(httpClient) {
     let isActive = true;
-    // Create the callable transaction function with context awareness
     const txFunction = (sql, ...values)=>{
         if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        // Handle template string queries (returns Promise)
         if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && values.length >= 0)) {
             const parsed = sql_parser_SQLParser.parse(sql, values);
             return httpClient.query(parsed.sql, parsed.params);
         }
-        // Handle direct object/array inputs (returns SQLFragment for composing)
         const parsed = sql_parser_SQLParser.parse(sql, values);
         return {
             text: parsed.sql,
             values: parsed.params
         };
     };
-    // Attach utility methods to the transaction function
     txFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
     txFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
-    // Add execute method for compatibility
     txFunction.execute = async (sql, args)=>{
         if (!isActive) throw new types_QueryError('Transaction is no longer active');
         if ('string' == typeof sql) return await httpClient.query(sql, args || []);
         return await httpClient.query(sql.sql, sql.args || []);
     };
-    // Add query method for compatibility
     txFunction.query = async (sql, params = [])=>{
         if (!isActive) throw new types_QueryError('Transaction is no longer active');
         return await httpClient.query(sql, params);
     };
     txFunction.commit = async ()=>{
         isActive = false;
-    // No-op for simple transactions
     };
     txFunction.rollback = async ()=>{
         isActive = false;
-    // No-op for simple transactions - individual queries are atomic
     };
     txFunction.savepoint = async (callback)=>{
         if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        // Create a nested transaction for the savepoint
         const savepointTx = createSimpleTransaction(httpClient);
         try {
-            // Execute the callback with the savepoint transaction
             const result = await callback(savepointTx);
-            // Commit the savepoint (no-op for simple transactions)
             await savepointTx.commit();
             return result;
         } catch (error) {
-            // Rollback the savepoint on error
             await savepointTx.rollback();
             throw error;
         }
     };
     return txFunction;
 }
-/**
- * Simple transaction implementation that executes immediately
- * This is more suitable for HTTP-based databases where true transactions
- * across multiple requests are not practical
- */ class SimpleTransaction {
+class SimpleTransaction {
     httpClient;
     isActive = true;
     constructor(httpClient){
@@ -569,60 +803,43 @@ sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
     }
     async commit() {
         this.isActive = false;
-    // No-op for simple transactions
     }
     async rollback() {
         this.isActive = false;
-    // No-op for simple transactions - individual queries are atomic
     }
 }
-/**
- * Main ODBLite client that provides postgres.js-like interface
- */ class ODBLiteClient {
+class ODBLiteClient {
     httpClient;
     config;
     sql;
     constructor(config){
         this.config = config;
         this.httpClient = new HTTPClient(config);
-        // Create the callable sql function with attached utility methods
         const sqlFunction = (sql, ...values)=>{
-            // Handle template string queries (returns Promise)
             if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && values.length >= 0)) {
                 const parsed = sql_parser_SQLParser.parse(sql, values);
                 return this.httpClient.query(parsed.sql, parsed.params);
             }
-            // Handle direct object/array inputs (returns SQLFragment for composing)
             const parsed = sql_parser_SQLParser.parse(sql, values);
             return {
                 text: parsed.sql,
                 values: parsed.params
             };
         };
-        // Attach minimal utility methods to the function
         sqlFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
         sqlFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
-        // Attach client methods to the function
         sqlFunction.query = async (sql, params = [])=>await this.httpClient.query(sql, params);
-        // libsql-compatible execute method (for backward compatibility)
         sqlFunction.execute = async (sql, args)=>{
             if ('string' == typeof sql) return await this.httpClient.query(sql, args || []);
             return await this.httpClient.query(sql.sql, sql.args || []);
         };
-        // Enhanced begin method with callback support
         sqlFunction.begin = async (modeOrCallback, callback)=>{
-            // Determine if this is callback-style or traditional
-            if ('function' == typeof modeOrCallback) // begin(callback)
-            return this.executeTransactionWithCallback(modeOrCallback);
-            if ('string' == typeof modeOrCallback && callback) // begin(mode, callback)
-            return this.executeTransactionWithCallback(callback, modeOrCallback);
-            // begin() - traditional style
+            if ('function' == typeof modeOrCallback) return this.executeTransactionWithCallback(modeOrCallback);
+            if ('string' == typeof modeOrCallback && callback) return this.executeTransactionWithCallback(callback, modeOrCallback);
             return createSimpleTransaction(this.httpClient);
         };
         sqlFunction.ping = async ()=>await this.httpClient.ping();
-        sqlFunction.end = async ()=>{
-        // No-op for HTTP-based client
-        };
+        sqlFunction.end = async ()=>{};
         sqlFunction.setDatabase = (databaseId)=>{
             this.httpClient.setDatabase(databaseId);
             this.config.databaseId = databaseId;
@@ -638,99 +855,58 @@ sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
         };
         this.sql = sqlFunction;
     }
-    /**
-   * Execute a transaction with callback (postgres.js style)
-   */ async executeTransactionWithCallback(callback, mode) {
+    async executeTransactionWithCallback(callback, mode) {
         const tx = createSimpleTransaction(this.httpClient);
         try {
-            // Execute the callback with the transaction
             const result = await callback(tx);
-            // Commit the transaction
             await tx.commit();
             return result;
         } catch (error) {
-            // Rollback on any error
             await tx.rollback();
             throw error;
         }
     }
-    /**
-   * Raw query method
-   * Usage: client.query('SELECT * FROM users WHERE id = ?', [123])
-   */ async query(sql, params = []) {
+    async query(sql, params = []) {
         return await this.httpClient.query(sql, params);
     }
-    /**
-   * Begin a transaction
-   * Note: Uses simple transaction model suitable for HTTP-based access
-   */ async begin() {
+    async begin() {
         return createSimpleTransaction(this.httpClient);
     }
-    /**
-   * Health check
-   */ async ping() {
+    async ping() {
         return await this.httpClient.ping();
     }
-    /**
-   * Close connection (no-op for HTTP client)
-   */ async end() {
-    // No-op for HTTP-based client
-    }
-    /**
-   * Set the database ID for queries
-   */ setDatabase(databaseId) {
+    async end() {}
+    setDatabase(databaseId) {
         this.httpClient.setDatabase(databaseId);
         this.config.databaseId = databaseId;
         return this;
     }
-    /**
-   * Get database information
-   */ async getDatabaseInfo() {
+    async getDatabaseInfo() {
         return await this.httpClient.getDatabaseInfo();
     }
-    /**
-   * Create a new client instance with updated configuration
-   */ configure(updates) {
+    configure(updates) {
         const newConfig = {
             ...this.config,
             ...updates
         };
         return new ODBLiteClient(newConfig);
     }
-    /**
-   * Create raw SQL that won't be parameterized
-   * Usage: sql`SELECT * FROM ${raw('users')}`
-   */ static raw(text) {
+    static raw(text) {
         return sql_parser_SQLParser.raw(text);
     }
-    /**
-   * Escape identifier (table/column names)
-   * Usage: sql`SELECT * FROM ${identifier('user-table')}`
-   */ static identifier(name) {
+    static identifier(name) {
         return sql_parser_SQLParser.identifier(name);
     }
-    /**
-   * Build WHERE clause from object
-   * Usage: const whereClause = ODBLiteClient.where({ id: 1, name: 'John' });
-   */ static where(conditions) {
+    static where(conditions) {
         return sql_parser_SQLParser.where(conditions);
     }
-    /**
-   * Build INSERT VALUES from object(s)
-   * Usage: const insertClause = ODBLiteClient.insertValues({ name: 'John', age: 30 });
-   */ static insertValues(data) {
+    static insertValues(data) {
         return sql_parser_SQLParser.insertValues(data);
     }
-    /**
-   * Build UPDATE SET clause from object
-   * Usage: const setClause = ODBLiteClient.updateSet({ name: 'John', age: 30 });
-   */ static updateSet(data) {
+    static updateSet(data) {
         return sql_parser_SQLParser.updateSet(data);
     }
-    /**
-   * Join SQL fragments
-   * Usage: const query = ODBLiteClient.join([baseQuery, whereClause], ' WHERE ');
-   */ static join(fragments, separator = ' ') {
+    static join(fragments, separator = ' ') {
         return sql_parser_SQLParser.join(fragments, separator);
     }
 }
@@ -742,43 +918,13 @@ function odblite(configOrBaseUrl, apiKey, databaseId) {
     }) : new ODBLiteClient(configOrBaseUrl);
     return client.sql;
 }
-// Export static utility functions
 ODBLiteClient.raw;
 ODBLiteClient.identifier;
 ODBLiteClient.where;
 ODBLiteClient.insertValues;
 ODBLiteClient.updateSet;
 ODBLiteClient.join;
-/**
- * Service Client - High-level client for managing tenant databases via ODB-Lite Tenant API
- *
- * This client provides automatic database provisioning and management for multi-tenant applications.
- * It handles:
- * - Automatic database creation on first use
- * - Database hash caching for performance
- * - Tenant API integration with ODB-Lite
- * - Query execution via ODB-Lite's query API
- *
- * @example
- * ```typescript
- * const service = new ServiceClient({
- *   baseUrl: 'http://localhost:8671',
- *   apiKey: 'odblite_tenant_key'
- * });
- *
- * // Automatically creates database if it doesn't exist
- * const dbHash = await service.ensureDatabaseForTenant('wallet', 'tenant-123');
- *
- * // Execute queries
- * const result = await service.query(dbHash, 'SELECT * FROM wallets', []);
- * ```
- */ /**
- * Service Client for managing tenant databases in ODB-Lite
- *
- * This is a higher-level client that sits on top of the base ODB client.
- * It provides automatic database provisioning and management for services
- * that need per-tenant database isolation.
- */ class ServiceClient {
+class ServiceClient {
     apiUrl;
     apiKey;
     databaseCache;
@@ -787,35 +933,15 @@ ODBLiteClient.join;
         this.apiKey = config.apiKey;
         this.databaseCache = new Map();
     }
-    /**
-   * Get or create a database for a tenant
-   *
-   * This is the main method used by services. It will:
-   * 1. Check the cache for an existing database hash
-   * 2. Query ODB-Lite to see if the database exists
-   * 3. Create the database if it doesn't exist
-   * 4. Cache and return the database hash
-   *
-   * @param prefix - Database name prefix (e.g., 'wallet', 'tracking')
-   * @param tenantId - Tenant identifier
-   * @returns Database hash for querying
-   *
-   * @example
-   * ```typescript
-   * const hash = await service.ensureDatabaseForTenant('wallet', 'tenant-123');
-   * // Returns hash for database named 'wallet_tenant-123'
-   * ```
-   */ async ensureDatabaseForTenant(prefix, tenantId) {
+    async ensureDatabaseForTenant(prefix, tenantId) {
         const cacheKey = `${prefix}_${tenantId}`;
         console.log(`📊 Ensuring database for ${cacheKey}`);
-        // Check cache first
         const cached = this.databaseCache.get(cacheKey);
         if (cached) {
             console.log(`✅ Found cached database hash: ${cached}`);
             return cached;
         }
         try {
-            // Check if database already exists
             console.log(`🔍 Checking if database exists: ${cacheKey}`);
             const existing = await this.getDatabaseByName(cacheKey);
             if (existing) {
@@ -823,12 +949,10 @@ ODBLiteClient.join;
                 this.databaseCache.set(cacheKey, existing.hash);
                 return existing.hash;
             }
-            // Create new database
             console.log(`🆕 Creating new database: ${cacheKey}`);
             const nodes = await this.listNodes();
             console.log(`📡 Available nodes: ${nodes.length}`);
             if (0 === nodes.length) throw new Error('No available nodes to create database');
-            // Use first healthy node
             const node = nodes.find((n)=>'healthy' === n.status) || nodes[0];
             if (!node) throw new Error('No available nodes to create database');
             console.log(`🎯 Using node: ${node.nodeId}`);
@@ -841,13 +965,7 @@ ODBLiteClient.join;
             throw error;
         }
     }
-    /**
-   * List all databases owned by this tenant
-   *
-   * Queries ODB-Lite's tenant API to get all databases accessible with the current API key.
-   *
-   * @returns Array of database objects
-   */ async listDatabases() {
+    async listDatabases() {
         const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`
@@ -857,13 +975,7 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Failed to list databases');
         return result.databases;
     }
-    /**
-   * Create a new database
-   *
-   * @param name - Database name (should be unique)
-   * @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) {
+    async createDatabase(name, nodeId) {
         const body = {
             name
         };
@@ -880,12 +992,7 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Failed to create database');
         return result.database;
     }
-    /**
-   * Get database details by hash
-   *
-   * @param hash - Database hash
-   * @returns Database object
-   */ async getDatabase(hash) {
+    async getDatabase(hash) {
         const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`
@@ -895,12 +1002,7 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Failed to get database');
         return result.database;
     }
-    /**
-   * Get database details by name
-   *
-   * @param name - Database name
-   * @returns Database object or null if not found
-   */ async getDatabaseByName(name) {
+    async getDatabaseByName(name) {
         const response = await fetch(`${this.apiUrl}/api/tenant/databases/by-name/${name}`, {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`
@@ -911,11 +1013,7 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Failed to get database');
         return result.database;
     }
-    /**
-   * Delete a database
-   *
-   * @param hash - Database hash to delete
-   */ async deleteDatabase(hash) {
+    async deleteDatabase(hash) {
         const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
             method: 'DELETE',
             headers: {
@@ -924,17 +1022,12 @@ ODBLiteClient.join;
         });
         const result = await response.json();
         if (!result.success) throw new Error(result.error || 'Failed to delete database');
-        // Remove from cache
         for (const [key, cachedHash] of this.databaseCache.entries())if (cachedHash === hash) {
             this.databaseCache.delete(key);
             break;
         }
     }
-    /**
-   * List available nodes
-   *
-   * @returns Array of node objects
-   */ async listNodes() {
+    async listNodes() {
         const response = await fetch(`${this.apiUrl}/api/tenant/nodes`, {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`
@@ -944,18 +1037,7 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Failed to list nodes');
         return result.nodes;
     }
-    /**
-   * Execute a query on a specific database
-   *
-   * This is a low-level query method. For most use cases, you should use
-   * the full ODB client (`odblite()` function) instead, which provides
-   * template tag support and better ergonomics.
-   *
-   * @param databaseHash - Hash of the database to query
-   * @param sql - SQL query string
-   * @param params - Query parameters
-   * @returns Query result
-   */ async query(databaseHash, sql, params = []) {
+    async query(databaseHash, sql, params = []) {
         const response = await fetch(`${this.apiUrl}/query/${databaseHash}`, {
             method: 'POST',
             headers: {
@@ -971,60 +1053,174 @@ ODBLiteClient.join;
         if (!result.success) throw new Error(result.error || 'Query failed');
         return result.data;
     }
-    /**
-   * Clear the database hash cache
-   *
-   * Useful when database mappings have changed or for testing.
-   */ clearCache() {
+    clearCache() {
         this.databaseCache.clear();
     }
-    /**
-   * Get cached database hash for a specific tenant (if exists)
-   *
-   * @param prefix - Database name prefix
-   * @param tenantId - Tenant identifier
-   * @returns Cached hash or undefined
-   */ getCachedHash(prefix, tenantId) {
+    getCachedHash(prefix, tenantId) {
         const cacheKey = `${prefix}_${tenantId}`;
         return this.databaseCache.get(cacheKey);
     }
-    /**
-   * Pre-cache a database hash
-   *
-   * Useful when you know the mapping ahead of time and want to avoid
-   * the initial lookup.
-   *
-   * @param prefix - Database name prefix
-   * @param tenantId - Tenant identifier
-   * @param hash - Database hash
-   */ setCachedHash(prefix, tenantId, hash) {
+    setCachedHash(prefix, tenantId, hash) {
         const cacheKey = `${prefix}_${tenantId}`;
         this.databaseCache.set(cacheKey, hash);
     }
 }
-/**
- * Bun SQLite adapter for DatabaseManager
- * Wraps bun:sqlite with Connection interface
- */ class BunSQLiteAdapter {
+function convertTemplateToQuery(strings, values) {
+    let sql = '';
+    const args = [];
+    for(let i = 0; i < strings.length; i++){
+        sql += strings[i];
+        if (i < values.length) {
+            const value = values[i];
+            if (isSqlFragment(value)) {
+                sql += value.sql;
+                args.push(...value.args);
+            } else if (Array.isArray(value)) if (value.length > 0 && Array.isArray(value[0])) {
+                const rowPlaceholders = value.map((row)=>`(${row.map(()=>'?').join(', ')})`).join(', ');
+                sql += rowPlaceholders;
+                args.push(...value.flat());
+            } else {
+                const placeholders = value.map(()=>'?').join(', ');
+                sql += `(${placeholders})`;
+                args.push(...value);
+            }
+            else {
+                sql += '?';
+                args.push(value);
+            }
+        }
+    }
+    return {
+        sql,
+        args
+    };
+}
+function isSqlFragment(value) {
+    return value && 'object' == typeof value && true === value._isSqlFragment;
+}
+function sql_template_sql(value, ...keys) {
+    let columnKeys = [];
+    if (keys.length > 0) columnKeys = Array.isArray(keys[0]) ? keys[0] : keys;
+    if ('string' == typeof value && 0 === columnKeys.length) return {
+        _isSqlFragment: true,
+        sql: value,
+        args: []
+    };
+    if (Array.isArray(value) && value.length > 0 && 'string' == typeof value[0]) return {
+        _isSqlFragment: true,
+        sql: value.join(', '),
+        args: []
+    };
+    if (Array.isArray(value) && value.length > 0 && 'object' == typeof value[0] && !Array.isArray(value[0])) {
+        if (0 === columnKeys.length) columnKeys = Object.keys(value[0]);
+        const allValues = [];
+        const rowPlaceholders = [];
+        for (const obj of value){
+            const rowValues = columnKeys.map((key)=>obj[key]);
+            allValues.push(...rowValues);
+            rowPlaceholders.push(`(${columnKeys.map(()=>'?').join(', ')})`);
+        }
+        return {
+            _isSqlFragment: true,
+            sql: `(${columnKeys.join(', ')}) VALUES ${rowPlaceholders.join(', ')}`,
+            args: allValues
+        };
+    }
+    if (value && 'object' == typeof value && !Array.isArray(value)) {
+        if (0 === columnKeys.length) columnKeys = Object.keys(value);
+        const values = columnKeys.map((key)=>value[key]);
+        const placeholders = columnKeys.map(()=>'?').join(', ');
+        return {
+            _isSqlFragment: true,
+            sql: `(${columnKeys.join(', ')}) VALUES (${placeholders})`,
+            args: values
+        };
+    }
+    if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+        const rowPlaceholders = value.map((row)=>`(${row.map(()=>'?').join(', ')})`).join(', ');
+        return {
+            _isSqlFragment: true,
+            sql: rowPlaceholders,
+            args: value.flat()
+        };
+    }
+    return {
+        _isSqlFragment: true,
+        sql: '',
+        args: []
+    };
+}
+function empty() {
+    return {
+        _isSqlFragment: true,
+        sql: '',
+        args: []
+    };
+}
+function sql_template_raw(value) {
+    return {
+        _isSqlFragment: true,
+        sql: value,
+        args: []
+    };
+}
+function sql_template_fragment(strings, ...values) {
+    const query = convertTemplateToQuery(strings, values);
+    return {
+        _isSqlFragment: true,
+        ...query
+    };
+}
+function sql_template_join(fragments, separator = ', ') {
+    if (0 === fragments.length) return empty();
+    const sql = fragments.map((f)=>f.sql).join(separator);
+    const args = fragments.flatMap((f)=>f.args);
+    return {
+        _isSqlFragment: true,
+        sql,
+        args
+    };
+}
+function set(data, ...keys) {
+    let columns;
+    columns = keys.length > 0 ? keys : Object.keys(data);
+    if (0 === columns.length) return empty();
+    const setClauses = columns.map((key)=>`${key} = ?`);
+    const values = columns.map((key)=>data[key]);
+    return {
+        _isSqlFragment: true,
+        sql: setClauses.join(', '),
+        args: values
+    };
+}
+function sql_template_where(conditions) {
+    const entries = Object.entries(conditions);
+    if (0 === entries.length) return empty();
+    const whereClauses = entries.map(([key])=>`${key} = ?`);
+    const values = entries.map(([, value])=>value);
+    return {
+        _isSqlFragment: true,
+        sql: whereClauses.join(' AND '),
+        args: values
+    };
+}
+class BunSQLiteAdapter {
     type = 'bun-sqlite';
     config;
     constructor(config){
         this.config = config;
     }
     async connect(config) {
-        const db = new __WEBPACK_EXTERNAL_MODULE_bun_sqlite__.Database(config.databasePath, {
+        const db = new 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 disconnect(tenantId) {}
     async isHealthy() {
         try {
-            const db = new __WEBPACK_EXTERNAL_MODULE_bun_sqlite__.Database(this.config.databasePath, {
+            const db = new Database(this.config.databasePath, {
                 readonly: true,
                 create: false
             });
@@ -1036,37 +1232,54 @@ ODBLiteClient.join;
         }
     }
 }
-/**
- * Connection implementation for Bun SQLite
- */ class BunSQLiteConnection {
+class BunSQLiteConnection {
     db;
     inTransaction = false;
+    sql;
     constructor(db){
         this.db = db;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(strings, ...values) {
-        // Build SQL from template
-        const sqlStr = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
-        return this.execute(sqlStr, values);
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
+        const self = this;
+        this.sql = function(stringsOrValue, ...values) {
+            if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+            {
+                const query = convertTemplateToQuery(stringsOrValue, values);
+                const thenableFragment = {
+                    _isSqlFragment: true,
+                    sql: query.sql,
+                    args: query.args
+                };
+                thenableFragment['then'] = function(onFulfilled, onRejected) {
+                    return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                };
+                return thenableFragment;
+            }
+        };
+        this.sql.empty = empty;
+        this.sql.raw = sql_template_raw;
+        this.sql.fragment = sql_template_fragment;
+        this.sql.join = sql_template_join;
+        this.sql.set = set;
+        this.sql.where = sql_template_where;
+    }
+    async query(sql, params = []) {
         return this.execute(sql, params);
     }
-    /**
-   * Execute SQL with parameters
-   */ async execute(sql, params = []) {
+    async execute(sql, params = []) {
         try {
-            // Handle object format { sql, args }
             let sqlStr;
             let sqlParams;
             if ('object' == typeof sql) {
+                if (process.env.DEBUG_SQL) {
+                    console.log('[BunSQLite] Executing SQL:', sql.sql);
+                    console.log('[BunSQLite] With args:', sql.args);
+                }
                 sqlStr = sql.sql;
                 sqlParams = sql.args || [];
             } else {
+                if (process.env.DEBUG_SQL) {
+                    console.log('[BunSQLite] Executing SQL:', sql);
+                    console.log('[BunSQLite] With params:', params);
+                }
                 sqlStr = sql;
                 sqlParams = params;
             }
@@ -1088,12 +1301,10 @@ ODBLiteClient.join;
                 };
             }
         } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
+            throw error;
         }
     }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
+    prepare(sql) {
         const stmt = this.db.query(sql);
         return {
             execute: async (params = [])=>{
@@ -1118,11 +1329,8 @@ ODBLiteClient.join;
             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);
+    async transaction(fn) {
+        if (this.inTransaction) return fn(this);
         this.inTransaction = true;
         try {
             await this.execute('BEGIN');
@@ -1136,41 +1344,35 @@ ODBLiteClient.join;
             this.inTransaction = false;
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
+    async begin(fn) {
         return this.transaction(fn);
     }
-    /**
-   * Close connection
-   */ async close() {
+    async close() {
         this.db.close();
     }
+    createORM() {
+        const { createORM } = __webpack_require__("./src/orm/index.ts");
+        return createORM(this);
+    }
 }
-/**
- * LibSQL adapter for DatabaseManager
- * Wraps @libsql/client with Connection interface
- */ class LibSQLAdapter {
+class LibSQLAdapter {
     type = 'libsql';
     config;
     constructor(config){
         this.config = config;
     }
     async connect(config) {
-        const client = (0, __WEBPACK_EXTERNAL_MODULE__libsql_client__.createClient)({
+        const client = 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 disconnect(tenantId) {}
     async isHealthy() {
         try {
-            const client = (0, __WEBPACK_EXTERNAL_MODULE__libsql_client__.createClient)({
+            const client = createClient({
                 url: this.config.url,
                 authToken: this.config.authToken
             });
@@ -1181,41 +1383,61 @@ ODBLiteClient.join;
         }
     }
 }
-/**
- * Connection implementation for LibSQL
- */ class LibSQLConnection {
+class LibSQLConnection {
     client;
     txClient;
+    sql;
     constructor(client){
         this.client = client;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(strings, ...values) {
-        // Build SQL from template
-        const sqlStr = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
-        return this.execute(sqlStr, values);
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
+        const self = this;
+        this.sql = function(stringsOrValue, ...values) {
+            if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+            {
+                const query = convertTemplateToQuery(stringsOrValue, values);
+                const thenableFragment = {
+                    _isSqlFragment: true,
+                    sql: query.sql,
+                    args: query.args
+                };
+                thenableFragment['then'] = function(onFulfilled, onRejected) {
+                    return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                };
+                return thenableFragment;
+            }
+        };
+        this.sql.empty = empty;
+        this.sql.raw = sql_template_raw;
+        this.sql.fragment = sql_template_fragment;
+        this.sql.join = sql_template_join;
+        this.sql.set = set;
+        this.sql.where = sql_template_where;
+    }
+    async query(sql, params = []) {
         return this.execute(sql, params);
     }
-    /**
-   * Execute SQL with parameters
-   * Supports both formats: execute(sql, params) and execute({sql, args})
-   */ async execute(sql, params = []) {
+    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 || []
-            };
+            if ('string' == typeof sql) {
+                if (process.env.DEBUG_SQL) {
+                    console.log('[LibSQL] Executing SQL:', sql);
+                    console.log('[LibSQL] With params:', params);
+                }
+                query = {
+                    sql,
+                    args: params
+                };
+            } else {
+                if (process.env.DEBUG_SQL) {
+                    console.log('[LibSQL] Executing SQL:', sql.sql);
+                    console.log('[LibSQL] With args:', sql.args);
+                }
+                query = {
+                    sql: sql.sql,
+                    args: sql.args || []
+                };
+            }
             const result = await target.execute(query);
             return {
                 rows: result.rows,
@@ -1223,12 +1445,10 @@ ODBLiteClient.join;
                 lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid.toString()) : void 0
             };
         } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
+            throw error;
         }
     }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
+    prepare(sql) {
         return {
             execute: async (params = [])=>this.execute(sql, params),
             all: async (params = [])=>{
@@ -1241,12 +1461,8 @@ ODBLiteClient.join;
             }
         };
     }
-    /**
-   * 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
+    async transaction(fn) {
+        if (this.txClient) return fn(this);
         try {
             await this.execute('BEGIN');
             const result = await fn(this);
@@ -1257,22 +1473,16 @@ ODBLiteClient.join;
             throw error;
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
+    async begin(fn) {
         return this.transaction(fn);
     }
-    /**
-   * Close connection
-   */ async close() {
-    // LibSQL client.close() if available in future versions
-    // For now, connections are managed by the client pool
+    async close() {}
+    createORM() {
+        const { createORM } = __webpack_require__("./src/orm/index.ts");
+        return createORM(this);
     }
 }
-/**
- * ODB-Lite adapter for DatabaseManager
- * Wraps ServiceClient and ODBLiteClient with Connection interface
- */ class ODBLiteAdapter {
+class ODBLiteAdapter {
     type = 'odblite';
     config;
     serviceClient;
@@ -1285,14 +1495,17 @@ ODBLiteClient.join;
     }
     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 databaseHash = config.databaseHash;
+        if (databaseHash) {
+            const client = new ODBLiteClient({
+                baseUrl: this.config.serviceUrl,
+                apiKey: this.config.apiKey,
+                databaseId: databaseHash
+            });
+            return new ODBLiteConnection(client, this.serviceClient, databaseName, databaseHash);
+        }
         const db = await this.serviceClient.getDatabaseByName(databaseName);
-        if (!db) throw new Error(`Database ${databaseName} not found after creation`);
-        // Create ODBLiteClient for this database
+        if (!db) throw new Error(`Database ${databaseName} not found. Please create it first using the admin API.`);
         const client = new ODBLiteClient({
             baseUrl: this.config.serviceUrl,
             apiKey: this.config.apiKey,
@@ -1302,8 +1515,7 @@ ODBLiteClient.join;
     }
     async disconnect(tenantId) {
         if (tenantId) {
-            const prefix = 'pipeline_tenant_' // TODO: make configurable
-            ;
+            const prefix = 'pipeline_tenant_';
             const databaseName = `${prefix}${tenantId}`;
             try {
                 await this.serviceClient.deleteDatabase(databaseName);
@@ -1321,61 +1533,73 @@ ODBLiteClient.join;
         }
     }
 }
-/**
- * Connection implementation for ODB-Lite
- */ class ODBLiteConnection {
+class ODBLiteConnection {
     client;
     serviceClient;
     inTransaction = false;
-    // Public metadata fields
     databaseName;
     databaseHash;
+    sql;
     constructor(client, serviceClient, databaseName, databaseHash){
         this.client = client;
         this.serviceClient = serviceClient;
         this.databaseName = databaseName;
         this.databaseHash = databaseHash;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(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
+        const self = this;
+        this.sql = function(stringsOrValue, ...values) {
+            if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+            {
+                const query = convertTemplateToQuery(stringsOrValue, values);
+                const thenableFragment = {
+                    _isSqlFragment: true,
+                    sql: query.sql,
+                    args: query.args
+                };
+                thenableFragment['then'] = function(onFulfilled, onRejected) {
+                    return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                };
+                return thenableFragment;
+            }
         };
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
+        this.sql.empty = empty;
+        this.sql.raw = sql_template_raw;
+        this.sql.fragment = sql_template_fragment;
+        this.sql.join = sql_template_join;
+        this.sql.set = set;
+        this.sql.where = sql_template_where;
+    }
+    async query(sql, params = []) {
         return this.execute(sql, params);
     }
-    /**
-   * Execute SQL with parameters
-   */ async execute(sql, params = []) {
+    async execute(sql, params = []) {
         try {
-            // Handle object format { sql, args }
             if ('object' == typeof sql) {
+                if (process.env.DEBUG_SQL) {
+                    console.log('[ODBLite] Executing SQL:', sql.sql);
+                    console.log('[ODBLite] With args:', sql.args);
+                }
                 const result = await this.client.sql.execute(sql.sql, sql.args || []);
                 return {
                     rows: result.rows,
-                    rowsAffected: result.rowsAffected || 0
+                    rowsAffected: result.rowsAffected || 0,
+                    lastInsertRowid: result.lastInsertRowid
                 };
             }
-            // Handle string format
+            if (process.env.DEBUG_SQL) {
+                console.log('[ODBLite] Executing SQL:', sql);
+                console.log('[ODBLite] With params:', params);
+            }
             const result = await this.client.sql.execute(sql, params);
             return {
                 rows: result.rows,
-                rowsAffected: result.rowsAffected || 0
+                rowsAffected: result.rowsAffected || 0,
+                lastInsertRowid: result.lastInsertRowid
             };
         } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
+            throw error;
         }
     }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
+    prepare(sql) {
         return {
             execute: async (params = [])=>this.execute(sql, params),
             all: async (params = [])=>{
@@ -1388,11 +1612,8 @@ ODBLiteClient.join;
             }
         };
     }
-    /**
-   * Execute function in transaction
-   */ async transaction(fn) {
-        if (this.inTransaction) // Nested transaction - just execute the function
-        return fn(this);
+    async transaction(fn) {
+        if (this.inTransaction) return fn(this);
         this.inTransaction = true;
         try {
             await this.execute('BEGIN');
@@ -1406,24 +1627,17 @@ ODBLiteClient.join;
             this.inTransaction = false;
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
+    async begin(fn) {
         return this.transaction(fn);
     }
-    /**
-   * Close connection
-   */ async close() {
-    // ODBLiteClient connections are stateless HTTP requests
-    // No explicit close needed
+    async close() {}
+    createORM() {
+        const { createORM } = __webpack_require__("./src/orm/index.ts");
+        return createORM(this);
     }
 }
-/**
- * Parse SQL file into statements, separating PRAGMA from regular SQL
- * Uses custom parser that handles BEGIN...END blocks
- */ function parseSQL(sqlContent, options = {}) {
+function parseSQL(sqlContent, options = {}) {
     const separatePragma = options.separatePragma ?? true;
-    // Split SQL statements manually
     const statements = splitStatements(sqlContent);
     if (!separatePragma) return {
         pragmaStatements: [],
@@ -1441,10 +1655,7 @@ ODBLiteClient.join;
         regularStatements
     };
 }
-/**
- * Split SQL content into individual statements
- * Handles comments, quotes, semicolons, and BEGIN...END blocks properly
- */ function splitStatements(sqlContent) {
+function splitStatements(sqlContent) {
     const statements = [];
     let currentStatement = '';
     let inQuote = false;
@@ -1454,7 +1665,6 @@ ODBLiteClient.join;
     for (const line of lines){
         let processedLine = '';
         const lineWithoutComments = line.replace(/--.*$/, '');
-        // Track BEGIN...END depth for this line BEFORE processing characters
         if (!inQuote && lineWithoutComments.trim()) {
             const beginMatches = lineWithoutComments.match(/\bBEGIN\b/gi);
             const endMatches = lineWithoutComments.match(/\bEND\b/gi);
@@ -1468,22 +1678,17 @@ ODBLiteClient.join;
             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;
+            if (!inQuote && '-' === char && '-' === nextChar) break;
+            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 AND not inside BEGIN...END
             if (';' === char && !inQuote && 0 === beginEndDepth) {
                 currentStatement += processedLine;
                 const stmt = currentStatement.trim();
@@ -1494,55 +1699,26 @@ ODBLiteClient.join;
         }
         if (processedLine.trim()) currentStatement += `${processedLine}\n`;
     }
-    // Handle remaining statement
     const finalStmt = currentStatement.trim();
     if (finalStmt && !finalStmt.startsWith('--')) statements.push(finalStmt);
     return statements;
 }
-/**
- * Simple split for systems that don't need PRAGMA separation
- */ function splitSQLStatements(sqlContent) {
+function splitSQLStatements(sqlContent) {
     const { pragmaStatements, regularStatements } = parseSQL(sqlContent);
     return [
         ...pragmaStatements,
         ...regularStatements
     ];
 }
-/**
- * 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 {
+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({
@@ -1564,147 +1740,92 @@ ODBLiteClient.join;
                 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
-   * @returns Connection object (contains databaseHash for ODB-Lite)
-   */ async createDatabase(name, 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}`);
-        // Return connection so caller can access metadata (e.g., databaseHash for ODB-Lite)
         return conn;
     }
-    /**
-   * 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
+    async databaseExists(name) {
         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 __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(dbPath);
+                    return node_fs.existsSync(dbPath);
                 }
             case 'libsql':
                 {
                     const dbPath = `${this.config.databasePath}/${name}.db`;
-                    return __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(dbPath);
+                    return node_fs.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
+    async getConnection(name) {
         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) {
+    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) {
+    async executeSQLFile(name, sqlContent) {
         const conn = await this.getConnection(name);
         await this.runMigrations(conn, {
             schemaContent: sqlContent
         });
     }
-    /**
-   * List all managed databases
-   */ async listDatabases() {
+    async listDatabases() {
         return Array.from(this.connections.keys());
     }
-    /**
-   * Close all connections
-   */ async close() {
+    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
+    async runMigrations(conn, config) {
         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;
@@ -1714,9 +1835,7 @@ ODBLiteClient.join;
         }
         console.log(`✅ Migrations completed (${regularStatements.length} statements)`);
     }
-    /**
-   * Get database-specific configuration
-   */ getDatabaseConfig(name) {
+    getDatabaseConfig(name) {
         switch(this.config.backend){
             case 'bun-sqlite':
                 return {
@@ -1737,9 +1856,7 @@ ODBLiteClient.join;
                 throw new Error(`Unknown backend: ${this.config.backend}`);
         }
     }
-    /**
-   * Evict least recently used connection
-   */ async evictLRU() {
+    async evictLRU() {
         let oldestKey = null;
         let oldestTime = 1 / 0;
         for (const [key, timestamp] of this.connectionTimestamps)if (timestamp < oldestTime) {
@@ -1755,11 +1872,20 @@ ODBLiteClient.join;
         }
     }
 }
-// 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
+var orm = __webpack_require__("./src/orm/index.ts");
 const { raw: src_raw, identifier: src_identifier, where: src_where, insertValues: src_insertValues, updateSet: src_updateSet, join: src_join } = ODBLiteClient;
-export { BunSQLiteAdapter, ConnectionError, DatabaseManager, HTTPClient, LibSQLAdapter, ODBLiteAdapter, ODBLiteClient, ODBLiteError, ODBLiteTransaction, types_QueryError as QueryError, sql_parser_SQLParser as SQLParser, ServiceClient, SimpleTransaction, odblite as default, fragment, src_identifier as identifier, src_insertValues as insertValues, src_join as join, odblite, parseSQL, src_raw as raw, splitSQLStatements, sql_parser_sql as sql, src_updateSet as updateSet, src_where as where };
+var __webpack_exports__ORM = orm.ORM;
+var __webpack_exports__and = orm.and;
+var __webpack_exports__createORM = orm.createORM;
+var __webpack_exports__eq = orm.eq;
+var __webpack_exports__gt = orm.gt;
+var __webpack_exports__gte = orm.gte;
+var __webpack_exports__inArray = orm.inArray;
+var __webpack_exports__isNotNull = orm.isNotNull;
+var __webpack_exports__isNull = orm.isNull;
+var __webpack_exports__like = orm.like;
+var __webpack_exports__lt = orm.lt;
+var __webpack_exports__lte = orm.lte;
+var __webpack_exports__ne = orm.ne;
+var __webpack_exports__or = orm.or;
+export { BunSQLiteAdapter, ConnectionError, DatabaseManager, HTTPClient, LibSQLAdapter, ODBLiteAdapter, ODBLiteClient, ODBLiteError, ODBLiteTransaction, types_QueryError as QueryError, sql_parser_SQLParser as SQLParser, ServiceClient, SimpleTransaction, convertTemplateToQuery, odblite as default, empty, fragment, src_identifier as identifier, src_insertValues as insertValues, src_join as join, odblite, parseSQL, src_raw as raw, sql_template_raw as rawSQL, set, splitSQLStatements, sql_parser_sql as sql, sql_template_fragment as sqlFragment, sql_template_join as sqlJoin, sql_template_sql as sqlTemplate, sql_template_where as sqlWhere, src_updateSet as updateSet, src_where as where, __webpack_exports__ORM as ORM, __webpack_exports__and as and, __webpack_exports__createORM as createORM, __webpack_exports__eq as eq, __webpack_exports__gt as gt, __webpack_exports__gte as gte, __webpack_exports__inArray as inArray, __webpack_exports__isNotNull as isNotNull, __webpack_exports__isNull as isNull, __webpack_exports__like as like, __webpack_exports__lt as lt, __webpack_exports__lte as lte, __webpack_exports__ne as ne, __webpack_exports__or as or };