@pineliner/odb-client 1.1.4 → 1.2.0

package/dist/index.cjs

@@ -412,6 +412,12 @@ var __webpack_modules__ = {
         function createORM(db) {
             return new ORM(db);
         }
+    },
+    async_hooks (module) {
+        module.exports = require("async_hooks");
+    },
+    "node:async_hooks" (module) {
+        module.exports = require("node:async_hooks");
     }
 };
 var __webpack_module_cache__ = {};
@@ -540,12 +546,15 @@ var __webpack_exports__ = {};
             };
             if ('string' == typeof this.config.baseUrl) this.config.baseUrl = this.config.baseUrl.replace(/\/$/, '');
         }
-        async query(sql, params = []) {
+        async query(sql, params = [], opts) {
             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
+                params,
+                ...opts?.txId ? {
+                    txId: opts.txId
+                } : {}
             };
             try {
                 const response = await this.makeRequest(url, {
@@ -555,7 +564,7 @@ var __webpack_exports__ = {};
                         Authorization: `Bearer ${this.config.apiKey}`
                     },
                     body: JSON.stringify(body)
-                });
+                }, opts?.maxRetries);
                 const data = await response.json();
                 if (!data.success) throw new types_QueryError(data.error || 'Query failed', sql, params);
                 let rows = [];
@@ -634,9 +643,10 @@ var __webpack_exports__ = {};
         setDatabase(databaseId) {
             this.config.databaseId = databaseId;
         }
-        async makeRequest(url, options) {
+        async makeRequest(url, options, maxRetries) {
             let lastError;
-            for(let attempt = 1; attempt <= (this.config.retries || 3); attempt++)try {
+            const retries = maxRetries ?? this.config.retries ?? 3;
+            for(let attempt = 1; attempt <= retries; attempt++)try {
                 const controller = new AbortController();
                 const timeoutId = setTimeout(()=>controller.abort(), this.config.timeout);
                 const response = await fetch(url, {
@@ -660,12 +670,12 @@ var __webpack_exports__ = {};
             } catch (error) {
                 lastError = error instanceof Error ? error : new Error('Unknown error');
                 if (error instanceof ConnectionError && error.message.includes('HTTP 4')) throw error;
-                if (attempt < (this.config.retries || 3)) {
+                if (attempt < retries) {
                     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);
+            throw new ConnectionError(`Failed after ${retries} attempts: ${lastError?.message}`, lastError);
         }
         configure(updates) {
             return new HTTPClient({
@@ -1138,10 +1148,10 @@ var __webpack_exports__ = {};
             };
             sqlFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
             sqlFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
-            sqlFunction.query = async (sql, params = [])=>await this.httpClient.query(sql, params);
-            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 || []);
+            sqlFunction.query = async (sql, params = [], opts)=>await this.httpClient.query(sql, params, opts);
+            sqlFunction.execute = async (sql, args, opts)=>{
+                if ('string' == typeof sql) return await this.httpClient.query(sql, args || [], opts);
+                return await this.httpClient.query(sql.sql, sql.args || [], opts);
             };
             sqlFunction.batch = async (statements)=>await this.httpClient.batch(statements);
             sqlFunction.begin = async (modeOrCallback, callback)=>{
@@ -1885,6 +1895,25 @@ var __webpack_exports__ = {};
             return createORM(this);
         }
     }
+    let AsyncLocalStorageCtor = null;
+    try {
+        AsyncLocalStorageCtor = __webpack_require__("node:async_hooks").AsyncLocalStorage;
+    } catch  {
+        try {
+            AsyncLocalStorageCtor = __webpack_require__("async_hooks").AsyncLocalStorage;
+        } catch  {
+            AsyncLocalStorageCtor = null;
+        }
+    }
+    let txCounter = 0;
+    function newTxId() {
+        try {
+            const c = globalThis.crypto;
+            if (c?.randomUUID) return `tx_${c.randomUUID()}`;
+        } catch  {}
+        txCounter = (txCounter + 1) % Number.MAX_SAFE_INTEGER;
+        return `tx_${Date.now().toString(36)}_${txCounter.toString(36)}`;
+    }
     function odblite_parseJsonColumns(rows, jsonColumns) {
         if (!jsonColumns || 0 === jsonColumns.length) return rows;
         return rows.map((row)=>{
@@ -1959,7 +1988,8 @@ var __webpack_exports__ = {};
     class ODBLiteConnection {
         client;
         serviceClient;
-        inTransaction = false;
+        txStorage = AsyncLocalStorageCtor ? new AsyncLocalStorageCtor() : null;
+        fallbackTxId;
         databaseName;
         databaseHash;
         sql;
@@ -1994,11 +2024,22 @@ var __webpack_exports__ = {};
         async query(sql, params = [], options) {
             return this.execute(sql, params, options);
         }
+        activeTxId() {
+            return this.txStorage ? this.txStorage.getStore()?.txId : this.fallbackTxId;
+        }
+        requestOpts() {
+            const txId = this.activeTxId();
+            return txId ? {
+                txId,
+                maxRetries: 1
+            } : void 0;
+        }
         async execute(sql, params = [], options) {
             try {
                 let rows;
                 let rowsAffected;
                 let lastInsertRowid;
+                const reqOpts = this.requestOpts();
                 if ('object' == typeof sql) {
                     if (process.env.DEBUG_SQL) {
                         console.log('[ODBLite] Executing SQL:', sql.sql);
@@ -2006,7 +2047,7 @@ var __webpack_exports__ = {};
                     }
                     let args = sql.args || [];
                     if (options?.stringifyParams) args = odblite_stringifyJsonParams(args, options.stringifyParams);
-                    const result = await this.client.sql.execute(sql.sql, args);
+                    const result = await this.client.sql.execute(sql.sql, args, reqOpts);
                     rows = result.rows;
                     rowsAffected = result.rowsAffected || 0;
                     lastInsertRowid = result.lastInsertRowid;
@@ -2017,7 +2058,7 @@ var __webpack_exports__ = {};
                     }
                     let args = params;
                     if (options?.stringifyParams) args = odblite_stringifyJsonParams(args, options.stringifyParams);
-                    const result = await this.client.sql.execute(sql, args);
+                    const result = await this.client.sql.execute(sql, args, reqOpts);
                     rows = result.rows;
                     rowsAffected = result.rowsAffected || 0;
                     lastInsertRowid = result.lastInsertRowid;
@@ -2046,27 +2087,34 @@ var __webpack_exports__ = {};
             };
         }
         async transaction(fn) {
-            if (this.inTransaction) return fn(this);
-            this.inTransaction = true;
-            try {
-                await this.execute('BEGIN');
+            if (this.activeTxId()) return fn(this);
+            const txId = newTxId();
+            const run = async ()=>{
+                const prevFallback = this.fallbackTxId;
+                if (!this.txStorage) this.fallbackTxId = txId;
                 try {
-                    const result = await fn(this);
-                    await this.execute('COMMIT');
-                    return result;
-                } catch (error) {
-                    await this.execute('ROLLBACK').catch(()=>{});
-                    throw error;
+                    await this.execute('BEGIN');
+                    try {
+                        const result = await fn(this);
+                        await this.execute('COMMIT');
+                        return result;
+                    } catch (error) {
+                        await this.execute('ROLLBACK').catch(()=>{});
+                        throw error;
+                    }
+                } finally{
+                    if (!this.txStorage) this.fallbackTxId = prevFallback;
                 }
-            } finally{
-                this.inTransaction = false;
-            }
+            };
+            return this.txStorage ? this.txStorage.run({
+                txId
+            }, run) : run();
         }
         async begin(fn) {
             return this.transaction(fn);
         }
         async savepoint(fn) {
-            if (!this.inTransaction) return this.transaction(fn);
+            if (!this.activeTxId()) return this.transaction(fn);
             const name = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
             try {
                 await this.execute(`SAVEPOINT ${name}`);
@@ -2090,6 +2138,417 @@ var __webpack_exports__ = {};
             return this.client.httpClient.getNamespaces();
         }
     }
+    function toHrana(v) {
+        if (null == v) return {
+            type: 'null'
+        };
+        if ('bigint' == typeof v) return {
+            type: 'integer',
+            value: v.toString()
+        };
+        if ('number' == typeof v) return Number.isInteger(v) ? {
+            type: 'integer',
+            value: String(v)
+        } : {
+            type: 'float',
+            value: v
+        };
+        if ('string' == typeof v) return {
+            type: 'text',
+            value: v
+        };
+        if (v instanceof Uint8Array) return {
+            type: 'blob',
+            base64: Buffer.from(v).toString('base64')
+        };
+        if ('boolean' == typeof v) return {
+            type: 'integer',
+            value: v ? '1' : '0'
+        };
+        return {
+            type: 'text',
+            value: String(v)
+        };
+    }
+    function fromHrana(v) {
+        switch(v.type){
+            case 'null':
+                return null;
+            case 'integer':
+                {
+                    const n = Number(v.value);
+                    return Number.isSafeInteger(n) ? n : BigInt(v.value);
+                }
+            case 'float':
+                return v.value;
+            case 'text':
+                return v.value;
+            case 'blob':
+                return new Uint8Array(Buffer.from(v.base64, 'base64'));
+        }
+    }
+    function toBatch(steps) {
+        return {
+            steps: steps.map((s, i)=>({
+                    condition: 0 === i ? void 0 : {
+                        type: 'ok',
+                        step: i - 1
+                    },
+                    stmt: {
+                        sql: s.sql,
+                        args: (s.params ?? []).map(toHrana)
+                    },
+                    expect: s.expect ? {
+                        affected: s.expect
+                    } : void 0
+                }))
+        };
+    }
+    class FrameWriter {
+        socket;
+        pending = Buffer.alloc(0);
+        constructor(socket){
+            this.socket = socket;
+        }
+        send(payload) {
+            const header = Buffer.allocUnsafe(4);
+            header.writeUInt32LE(payload.length, 0);
+            const frame = Buffer.concat([
+                header,
+                payload
+            ]);
+            this.pending = this.pending.length ? Buffer.concat([
+                this.pending,
+                frame
+            ]) : frame;
+            this.flush();
+        }
+        flush() {
+            while(this.pending.length > 0){
+                const n = this.socket.write(this.pending);
+                if (n <= 0) return;
+                this.pending = n < this.pending.length ? this.pending.subarray(n) : Buffer.alloc(0);
+            }
+        }
+    }
+    class FrameReader {
+        buf = Buffer.alloc(0);
+        push(chunk) {
+            this.buf = this.buf.length ? Buffer.concat([
+                this.buf,
+                chunk
+            ]) : chunk;
+            const out = [];
+            while(this.buf.length >= 4){
+                const len = this.buf.readUInt32LE(0);
+                if (this.buf.length < 4 + len) break;
+                out.push(this.buf.subarray(4, 4 + len));
+                this.buf = this.buf.subarray(4 + len);
+            }
+            return out;
+        }
+    }
+    class SocketClient {
+        target;
+        socket;
+        reader = new FrameReader();
+        writer;
+        pending = new Map();
+        nextId = 1;
+        ready;
+        constructor(target){
+            this.target = target;
+            this.ready = this.connect();
+            this.ready.catch(()=>{});
+        }
+        async connect() {
+            const Bun = globalThis.Bun;
+            if (!Bun?.connect) throw new Error('odblite-socket backend requires Bun (Bun.connect)');
+            const opts = this.target.unix ? {
+                unix: this.target.unix
+            } : {
+                hostname: this.target.hostname ?? '127.0.0.1',
+                port: this.target.port ?? 8787
+            };
+            this.socket = await Bun.connect({
+                ...opts,
+                socket: {
+                    data: (_s, chunk)=>{
+                        for (const frame of this.reader.push(chunk)){
+                            const msg = JSON.parse(frame.toString('utf8'));
+                            const resolve = this.pending.get(msg.id);
+                            if (resolve) {
+                                this.pending.delete(msg.id);
+                                resolve(msg.results);
+                            }
+                        }
+                    },
+                    drain: (_s)=>this.writer.flush(),
+                    close: ()=>{
+                        this.socket = void 0;
+                    }
+                }
+            });
+            this.writer = new FrameWriter(this.socket);
+        }
+        async pipeline(tenant, requests) {
+            if (!this.socket) {
+                this.ready = this.connect();
+                this.ready.catch(()=>{});
+            }
+            await this.ready;
+            const id = this.nextId++;
+            return new Promise((resolve)=>{
+                this.pending.set(id, resolve);
+                this.writer.send(Buffer.from(JSON.stringify({
+                    id,
+                    tenant,
+                    requests
+                }), 'utf8'));
+            });
+        }
+        close() {
+            this.socket?.end?.();
+            this.socket = void 0;
+        }
+    }
+    function toQueryResult(res) {
+        if ('error' === res.type) throw new Error(res.error.message);
+        const r = res.response.result;
+        const rows = r.rows.map((row)=>{
+            const obj = {};
+            r.cols.forEach((c, i)=>{
+                obj[c.name ?? `c${i}`] = fromHrana(row[i] ?? {
+                    type: 'null'
+                });
+            });
+            return obj;
+        });
+        return {
+            rows,
+            rowsAffected: r.affected_row_count,
+            lastInsertRowid: r.last_insert_rowid ? Number(r.last_insert_rowid) : void 0
+        };
+    }
+    class OdbliteSocketConnection {
+        client;
+        tenant;
+        databaseName;
+        databaseHash;
+        sql;
+        buffer;
+        constructor(client, tenant, buffer){
+            this.client = client;
+            this.tenant = tenant;
+            this.databaseName = tenant;
+            this.databaseHash = tenant;
+            this.buffer = buffer;
+            const self = this;
+            this.sql = function(strings, ...values) {
+                if (strings && 'object' == typeof strings && 'raw' in strings) {
+                    const text = strings.reduce((a, s, i)=>a + s + (i < values.length ? '?' : ''), '');
+                    const returns = /^\s*SELECT/i.test(text) || /\bRETURNING\b/i.test(text);
+                    return (returns ? self.query(text, values) : self.execute(text, values)).then((r)=>r.rows);
+                }
+                throw new Error('sql() fragment helper not implemented in odblite-socket');
+            };
+        }
+        async one(requests) {
+            const [res] = await this.client.pipeline(this.tenant, requests);
+            if (!res) throw new Error('odblite-socket: empty pipeline response');
+            return res;
+        }
+        async query(sql, params = []) {
+            return toQueryResult(await this.one([
+                {
+                    type: 'execute',
+                    stmt: {
+                        sql,
+                        args: params.map(toHrana)
+                    }
+                }
+            ]));
+        }
+        async execute(sql, params = []) {
+            const s = 'string' == typeof sql ? sql : sql.sql;
+            const p = 'string' == typeof sql ? params : sql.args ?? [];
+            if (this.buffer) {
+                this.buffer.push({
+                    sql: s,
+                    params: p
+                });
+                return {
+                    rows: [],
+                    rowsAffected: 0
+                };
+            }
+            return toQueryResult(await this.one([
+                {
+                    type: 'execute',
+                    stmt: {
+                        sql: s,
+                        args: p.map(toHrana)
+                    }
+                }
+            ]));
+        }
+        async atomic(steps) {
+            const res = await this.one([
+                {
+                    type: 'batch',
+                    batch: toBatch(steps)
+                }
+            ]);
+            if ('error' === res.type) throw new Error(res.error.message);
+            return res.response.result;
+        }
+        prepare(sql) {
+            return {
+                execute: async (params = [])=>this.execute(sql, params),
+                all: async (params = [])=>(await this.query(sql, params)).rows,
+                get: async (params = [])=>(await this.query(sql, params)).rows[0] ?? null
+            };
+        }
+        async transaction(fn) {
+            if (this.buffer) return fn(this);
+            const buffer = [];
+            const out = await fn(new OdbliteSocketConnection(this.client, this.tenant, buffer));
+            if (buffer.length) {
+                const res = await this.atomic(buffer.map((b)=>({
+                        sql: b.sql,
+                        params: b.params
+                    })));
+                const err = res.step_errors?.find((e)=>e);
+                if (err) throw new Error(`transaction batch failed: ${err.message}`);
+            }
+            return out;
+        }
+        begin(fn) {
+            return this.transaction(fn);
+        }
+        savepoint(fn) {
+            return this.transaction(fn);
+        }
+        async ensureNamespaces(namespaces) {
+            return {
+                success: true,
+                databaseName: this.tenant,
+                namespaces
+            };
+        }
+        async getNamespaces() {
+            const ns = (await this.query("SELECT name FROM pragma_database_list WHERE name != 'main'")).rows.map((r)=>r.name);
+            return {
+                success: true,
+                databaseName: this.tenant,
+                exists: true,
+                namespaces: ns,
+                registered: true,
+                registeredNamespaces: ns
+            };
+        }
+        async close() {}
+    }
+    class OdbliteSocketAdapter {
+        type = 'odblite-socket';
+        client;
+        constructor(config){
+            this.client = new SocketClient(config);
+        }
+        async connect(config) {
+            const tenant = config?.databaseHash ?? config?.databaseName;
+            if (!tenant) throw new Error('odblite-socket: databaseHash (or databaseName) required');
+            return new OdbliteSocketConnection(this.client, String(tenant));
+        }
+        async disconnect() {
+            this.client.close();
+        }
+        async isHealthy() {
+            try {
+                await Promise.race([
+                    this.client.pipeline('_health', [
+                        {
+                            type: 'get_autocommit'
+                        }
+                    ]),
+                    new Promise((_, rej)=>setTimeout(()=>rej(new Error('probe timeout')), 1500))
+                ]);
+                return true;
+            } catch  {
+                return false;
+            }
+        }
+    }
+    const DEFAULT_UNIX_SOCKET = '/tmp/odblite.sock';
+    function parseSocketTarget(s) {
+        const v = (s ?? '').trim();
+        if (!v) return {
+            unix: DEFAULT_UNIX_SOCKET
+        };
+        if (v.includes('/')) return {
+            unix: v
+        };
+        const m = v.match(/^(?:([^:]+):)?(\d+)$/);
+        if (m) return {
+            hostname: m[1] || '127.0.0.1',
+            port: Number(m[2])
+        };
+        return {
+            unix: v
+        };
+    }
+    class OdbliteAutoAdapter {
+        type = 'odblite';
+        chosen;
+        constructor(opts){
+            this.chosen = this.pick(opts);
+        }
+        async pick(opts) {
+            const hasBun = void 0 !== globalThis.Bun && !!globalThis.Bun.connect;
+            if (hasBun) for (const target of this.candidates(opts))try {
+                const socket = new OdbliteSocketAdapter(target);
+                if (await socket.isHealthy()) {
+                    console.log(`[odb-client] transport → SOCKET (router_v2 @ ${target.unix ?? `${target.hostname}:${target.port}`})`);
+                    return socket;
+                }
+                await socket.disconnect();
+            } catch  {}
+            console.log('[odb-client] transport → HTTP (no router_v2 socket reachable)');
+            return new ODBLiteAdapter(opts.http);
+        }
+        candidates(opts) {
+            if (opts.socket?.unix || opts.socket?.port) return [
+                opts.socket
+            ];
+            const env = globalThis.process?.env?.ODB_SOCKET;
+            if (env) return [
+                parseSocketTarget(env)
+            ];
+            const out = [
+                {
+                    unix: DEFAULT_UNIX_SOCKET
+                }
+            ];
+            try {
+                const host = new URL(opts.http?.serviceUrl).hostname;
+                const port = Number(globalThis.process?.env?.ODB_SOCKET_PORT ?? 8787);
+                if (host) out.push({
+                    hostname: host,
+                    port
+                });
+            } catch  {}
+            return out;
+        }
+        async connect(config) {
+            return (await this.chosen).connect(config);
+        }
+        async disconnect(tenantId) {
+            return (await this.chosen).disconnect(tenantId);
+        }
+        async isHealthy() {
+            return (await this.chosen).isHealthy();
+        }
+    }
     function parseSQL(sqlContent, options = {}) {
         const separatePragma = options.separatePragma ?? true;
         const statements = splitStatements(sqlContent);
@@ -2115,6 +2574,8 @@ var __webpack_exports__ = {};
         let inQuote = false;
         let quoteChar = '';
         let beginEndDepth = 0;
+        let inCte = false;
+        let cteParenDepth = 0;
         const lines = sqlContent.split('\n');
         for (const line of lines){
             let processedLine = '';
@@ -2128,6 +2589,15 @@ var __webpack_exports__ = {};
                     if (beginEndDepth < 0) beginEndDepth = 0;
                 }
             }
+            if (!inQuote && lineWithoutComments.trim()) {
+                const withMatch = lineWithoutComments.match(/\bWITH\b.*\bAS\b/i);
+                if (withMatch) inCte = true;
+                if (inCte) for (const char of lineWithoutComments){
+                    if ('(' === char) cteParenDepth++;
+                    if (')' === char) cteParenDepth--;
+                    if (0 === cteParenDepth && ')' === char) inCte = false;
+                }
+            }
             for(let i = 0; i < line.length; i++){
                 const char = line[i];
                 const prevChar = i > 0 ? line[i - 1] : '';
@@ -2143,7 +2613,7 @@ var __webpack_exports__ = {};
                     quoteChar = char;
                 }
                 processedLine += char;
-                if (';' === char && !inQuote && 0 === beginEndDepth) {
+                if (';' === char && !inQuote && 0 === beginEndDepth && !inCte) {
                     currentStatement += processedLine;
                     const stmt = currentStatement.trim();
                     if (stmt && !stmt.startsWith('--')) statements.push(stmt);
@@ -2190,7 +2660,14 @@ var __webpack_exports__ = {};
                     break;
                 case 'odblite':
                     if (!config.odblite) throw new Error('odblite config required for odblite backend');
-                    this.adapter = new ODBLiteAdapter(config.odblite);
+                    this.adapter = new OdbliteAutoAdapter({
+                        socket: config.odbliteSocket,
+                        http: config.odblite
+                    });
+                    break;
+                case 'odblite-socket':
+                    if (!config.odbliteSocket) throw new Error('odbliteSocket config required for odblite-socket backend');
+                    this.adapter = new OdbliteSocketAdapter(config.odbliteSocket);
                     break;
                 default:
                     throw new Error(`Unknown backend type: ${config.backend}`);
@@ -2308,6 +2785,12 @@ var __webpack_exports__ = {};
                         databaseName: `${this.config.databasePath}_${name}`,
                         ...this.config.odblite
                     };
+                case 'odblite-socket':
+                    return {
+                        databaseName: name,
+                        databaseHash: name,
+                        ...this.config.odbliteSocket
+                    };
                 default:
                     throw new Error(`Unknown backend: ${this.config.backend}`);
             }