@pineliner/odb-client 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1052 @@
+"use strict";
+// The require scope
+var __webpack_require__ = {};
+/************************************************************************/ // 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, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// webpack/runtime/make_namespace_object
+(()=>{
+    // define __esModule on exports
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+/************************************************************************/ var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+    identifier: ()=>/* binding */ src_identifier,
+    HTTPClient: ()=>/* reexport */ HTTPClient,
+    default: ()=>/* reexport */ odblite,
+    ServiceClient: ()=>/* reexport */ ServiceClient,
+    raw: ()=>/* binding */ src_raw,
+    sql: ()=>/* reexport */ sql_parser_sql,
+    insertValues: ()=>/* binding */ src_insertValues,
+    where: ()=>/* binding */ src_where,
+    updateSet: ()=>/* binding */ src_updateSet,
+    ODBLiteClient: ()=>/* reexport */ ODBLiteClient,
+    ODBLiteTransaction: ()=>/* reexport */ ODBLiteTransaction,
+    join: ()=>/* binding */ src_join,
+    ODBLiteError: ()=>/* reexport */ ODBLiteError,
+    ConnectionError: ()=>/* reexport */ ConnectionError,
+    SQLParser: ()=>/* reexport */ sql_parser_SQLParser,
+    SimpleTransaction: ()=>/* reexport */ SimpleTransaction,
+    odblite: ()=>/* reexport */ odblite,
+    QueryError: ()=>/* reexport */ types_QueryError,
+    fragment: ()=>/* reexport */ fragment
+});
+// Core types for the ODBLite client
+// Error types
+class ODBLiteError extends Error {
+    code;
+    query;
+    params;
+    constructor(message, code, query, params){
+        super(message), this.code = code, this.query = query, this.params = params;
+        this.name = 'ODBLiteError';
+    }
+}
+class ConnectionError extends ODBLiteError {
+    originalError;
+    constructor(message, originalError){
+        super(message, 'CONNECTION_ERROR'), this.originalError = originalError;
+        this.name = 'ConnectionError';
+    }
+}
+class types_QueryError extends ODBLiteError {
+    originalError;
+    constructor(message, query, params, originalError){
+        super(message, 'QUERY_ERROR', query, params), this.originalError = originalError;
+        this.name = 'QueryError';
+    }
+}
+/**
+ * HTTP client for communicating with ODBLite service
+ */ class HTTPClient {
+    config;
+    constructor(config){
+        this.config = {
+            timeout: 30000,
+            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 = []) {
+        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 = {
+            sql,
+            params
+        };
+        try {
+            const response = await this.makeRequest(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`
+                },
+                body: JSON.stringify(body)
+            });
+            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;
+            else if (Array.isArray(data.rows)) rows = data.rows;
+            return {
+                rows: rows,
+                rowsAffected: data.rowsAffected || data.data?.rowsAffected || 0,
+                executionTime: data.executionTime || data.data?.executionTime || 0,
+                databaseName: data.databaseName || data.data?.databaseName
+            };
+        } catch (error) {
+            if (error instanceof types_QueryError || error instanceof ConnectionError) throw error;
+            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() {
+        if (!this.config.databaseId) return false;
+        try {
+            const url = `${this.config.baseUrl}/api/db/${this.config.databaseId}/health`;
+            const response = await this.makeRequest(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.config.apiKey}`
+                }
+            });
+            const data = await response.json();
+            return 'healthy' === data.status;
+        } catch  {
+            return false;
+        }
+    }
+    /**
+   * Get database information
+   */ 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, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`
+            }
+        });
+        const data = await response.json();
+        if (!data.success) throw new ConnectionError(data.error || 'Failed to get database info');
+        return data;
+    }
+    /**
+   * Set the database ID for subsequent queries
+   */ setDatabase(databaseId) {
+        this.config.databaseId = databaseId;
+    }
+    /**
+   * Make HTTP request with retry logic
+   */ async makeRequest(url, options) {
+        let lastError;
+        for(let attempt = 1; attempt <= (this.config.retries || 3); attempt++)try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(()=>controller.abort(), this.config.timeout);
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorData;
+                try {
+                    errorData = JSON.parse(errorText);
+                } catch  {
+                    errorData = {
+                        error: errorText
+                    };
+                }
+                throw new ConnectionError(`HTTP ${response.status}: ${errorData.error || response.statusText}`);
+            }
+            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));
+            }
+        }
+        throw new ConnectionError(`Failed after ${this.config.retries} attempts: ${lastError?.message}`, lastError);
+    }
+    /**
+   * Create a new HTTPClient with updated config
+   */ configure(updates) {
+        return new HTTPClient({
+            ...this.config,
+            ...updates
+        });
+    }
+    /**
+   * Get current configuration
+   */ 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)
+        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) {
+        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 {
+                    sql: insertResult.text,
+                    params: insertResult.values
+                };
+            }
+            // Array of primitives - assume it's for IN clause
+            const placeholders = input.map(()=>'?').join(', ');
+            return {
+                sql: `(${placeholders})`,
+                params: input.map((v)=>this.convertValue(v))
+            };
+        }
+        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 {
+                    sql: whereResult.text,
+                    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
+            const insertResult = this.insertValues(input);
+            return {
+                sql: insertResult.text,
+                params: insertResult.values
+            };
+        }
+        // Fallback for other types
+        return {
+            sql: '?',
+            params: [
+                this.convertValue(input)
+            ]
+        };
+    }
+    /**
+   * Build a SET clause for UPDATE statements
+   */ static buildSetClause(data) {
+        const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
+        if (0 === entries.length) return {
+            sql: '',
+            params: []
+        };
+        const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
+        const values = entries.map(([, value])=>this.convertValue(value));
+        return {
+            sql: setClauses,
+            params: values
+        };
+    }
+    /**
+   * Parse template string SQL into LibSQL format
+   */ static parseTemplateString(sql, values) {
+        const fragments = [
+            ...sql
+        ];
+        const params = [];
+        let query = '';
+        for(let i = 0; i < fragments.length; i++){
+            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 {
+                    // Regular parameter
+                    query += '?';
+                    params.push(this.convertValue(value));
+                }
+            }
+        }
+        return {
+            sql: query.trim(),
+            params
+        };
+    }
+    /**
+   * Create a raw SQL fragment (not parameterized)
+   */ static raw(text) {
+        return `__RAW__${text}`;
+    }
+    /**
+   * Create an identifier (table name, column name, etc.)
+   */ static identifier(name) {
+        return this.escapeIdentifier(name);
+    }
+    /**
+   * Escape SQL identifiers (table names, column names)
+   */ static escapeIdentifier(identifier) {
+        // SQLite uses double quotes for identifiers
+        return `"${identifier.replace(/"/g, '""')}"`;
+    }
+    /**
+   * Convert JavaScript values to LibSQL-compatible values
+   */ 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);
+        return value;
+    }
+    /**
+   * Create a SQL fragment for building complex queries
+   */ 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 = ' ') {
+        const text = fragments.map((f)=>f.text).join(separator);
+        const values = fragments.flatMap((f)=>f.values);
+        return {
+            text,
+            values
+        };
+    }
+    /**
+   * Helper for building WHERE clauses from objects
+   */ static where(conditions) {
+        const entries = Object.entries(conditions).filter(([, value])=>void 0 !== value);
+        if (0 === entries.length) return {
+            text: '',
+            values: []
+        };
+        const clauses = entries.map(([key, value])=>{
+            if (null === value) return `${this.escapeIdentifier(key)} IS NULL`;
+            if (Array.isArray(value)) {
+                const placeholders = value.map(()=>'?').join(', ');
+                return `${this.escapeIdentifier(key)} IN (${placeholders})`;
+            }
+            return `${this.escapeIdentifier(key)} = ?`;
+        });
+        const values = entries.flatMap(([, value])=>{
+            if (null === value) return [];
+            if (Array.isArray(value)) return value.map((v)=>this.convertValue(v));
+            return [
+                this.convertValue(value)
+            ];
+        });
+        return {
+            text: clauses.join(' AND '),
+            values
+        };
+    }
+    /**
+   * Helper for building INSERT VALUES from objects
+   */ static insertValues(data) {
+        const records = Array.isArray(data) ? data : [
+            data
+        ];
+        if (0 === records.length) throw new Error('No data provided for insert');
+        const keys = Object.keys(records[0]);
+        const columns = keys.map((key)=>this.escapeIdentifier(key)).join(', ');
+        const valueClauses = records.map((record)=>{
+            const placeholders = keys.map(()=>'?').join(', ');
+            return `(${placeholders})`;
+        }).join(', ');
+        const values = records.flatMap((record)=>keys.map((key)=>this.convertValue(record[key])));
+        return {
+            text: `(${columns}) VALUES ${valueClauses}`,
+            values
+        };
+    }
+    /**
+   * Helper for building UPDATE SET clauses from objects
+   */ 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(', ');
+        const values = entries.map(([, value])=>this.convertValue(value));
+        return {
+            text: setClauses,
+            values
+        };
+    }
+}
+// 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);
+const fragment = sql_parser_SQLParser.fragment.bind(sql_parser_SQLParser);
+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 {
+    httpClient;
+    isCommitted = false;
+    isRolledBack = false;
+    queries = [];
+    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) {
+        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() {
+        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
+            }
+            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() {
+        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() {
+        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) {
+        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) {
+    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 {
+    httpClient;
+    isActive = true;
+    constructor(httpClient){
+        this.httpClient = httpClient;
+    }
+    async sql(sql, ...values) {
+        if (!this.isActive) throw new types_QueryError('Transaction is no longer active');
+        const parsed = sql_parser_SQLParser.parse(sql, values);
+        return await this.httpClient.query(parsed.sql, parsed.params);
+    }
+    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 {
+    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
+            return createSimpleTransaction(this.httpClient);
+        };
+        sqlFunction.ping = async ()=>await this.httpClient.ping();
+        sqlFunction.end = async ()=>{
+        // No-op for HTTP-based client
+        };
+        sqlFunction.setDatabase = (databaseId)=>{
+            this.httpClient.setDatabase(databaseId);
+            this.config.databaseId = databaseId;
+            return sqlFunction;
+        };
+        sqlFunction.getDatabaseInfo = async ()=>await this.httpClient.getDatabaseInfo();
+        sqlFunction.configure = (updates)=>{
+            const newConfig = {
+                ...this.config,
+                ...updates
+            };
+            return new ODBLiteClient(newConfig).sql;
+        };
+        this.sql = sqlFunction;
+    }
+    /**
+   * Execute a transaction with callback (postgres.js style)
+   */ 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 = []) {
+        return await this.httpClient.query(sql, params);
+    }
+    /**
+   * Begin a transaction
+   * Note: Uses simple transaction model suitable for HTTP-based access
+   */ async begin() {
+        return createSimpleTransaction(this.httpClient);
+    }
+    /**
+   * Health check
+   */ 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) {
+        this.httpClient.setDatabase(databaseId);
+        this.config.databaseId = databaseId;
+        return this;
+    }
+    /**
+   * Get database information
+   */ async getDatabaseInfo() {
+        return await this.httpClient.getDatabaseInfo();
+    }
+    /**
+   * Create a new client instance with updated configuration
+   */ 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) {
+        return sql_parser_SQLParser.raw(text);
+    }
+    /**
+   * Escape identifier (table/column names)
+   * Usage: sql`SELECT * FROM ${identifier('user-table')}`
+   */ 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) {
+        return sql_parser_SQLParser.where(conditions);
+    }
+    /**
+   * Build INSERT VALUES from object(s)
+   * Usage: const insertClause = ODBLiteClient.insertValues({ name: 'John', age: 30 });
+   */ 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) {
+        return sql_parser_SQLParser.updateSet(data);
+    }
+    /**
+   * Join SQL fragments
+   * Usage: const query = ODBLiteClient.join([baseQuery, whereClause], ' WHERE ');
+   */ static join(fragments, separator = ' ') {
+        return sql_parser_SQLParser.join(fragments, separator);
+    }
+}
+function odblite(configOrBaseUrl, apiKey, databaseId) {
+    const client = 'string' == typeof configOrBaseUrl ? new ODBLiteClient({
+        baseUrl: configOrBaseUrl,
+        apiKey: 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 {
+    apiUrl;
+    apiKey;
+    databaseCache;
+    constructor(config){
+        this.apiUrl = config.baseUrl;
+        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) {
+        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 databases = await this.listDatabases();
+            const existing = databases.find((db)=>db.name === cacheKey);
+            if (existing) {
+                console.log(`✅ Database already exists: ${cacheKey} (${existing.hash})`);
+                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}`);
+            const database = await this.createDatabase(cacheKey, node.nodeId);
+            console.log(`✅ Database created successfully: ${database.hash}`);
+            this.databaseCache.set(cacheKey, database.hash);
+            return database.hash;
+        } catch (error) {
+            console.error(`❌ Error ensuring database for ${cacheKey}:`, error.message);
+            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() {
+        const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`
+            }
+        });
+        const result = await response.json();
+        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
+   * @returns Created database object with hash
+   */ async createDatabase(name, 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
+            })
+        });
+        const result = await response.json();
+        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) {
+        const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`
+            }
+        });
+        const result = await response.json();
+        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) {
+        const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
+            method: 'DELETE',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`
+            }
+        });
+        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() {
+        const response = await fetch(`${this.apiUrl}/api/tenant/nodes`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`
+            }
+        });
+        const result = await response.json();
+        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 = []) {
+        const response = await fetch(`${this.apiUrl}/query/${databaseHash}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                sql,
+                params
+            })
+        });
+        const result = await response.json();
+        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() {
+        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) {
+        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) {
+        const cacheKey = `${prefix}_${tenantId}`;
+        this.databaseCache.set(cacheKey, hash);
+    }
+}
+// Main entry point for ODB Client
+// Core query client exports (postgres.js-like interface)
+// Service management exports (high-level tenant database management)
+// 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;
+// Default export for convenient usage
+var __webpack_export_target__ = exports;
+for(var i in __webpack_exports__)__webpack_export_target__[i] = __webpack_exports__[i];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});