@tursodatabase/serverless 0.1.0 → 0.1.2

package/dist/client.js

@@ -1,184 +0,0 @@
-import { executeCursor, encodeValue, decodeValue } from './protocol.js';
-function normalizeUrl(url) {
-    return url.replace(/^libsql:\/\//, 'https://');
-}
-function isValidIdentifier(str) {
-    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
-}
-export class Statement {
-    constructor(connection, sql, args = []) {
-        this.connection = connection;
-        this.sql = sql;
-        this.args = args;
-    }
-    async get() {
-        const result = await this.execute();
-        return result.rows[0] || null;
-    }
-    async all() {
-        const result = await this.execute();
-        return result.rows;
-    }
-    async *iterate() {
-        const { response, entries } = await this.connection.executeRaw(this.sql, this.args);
-        let columns = [];
-        for await (const entry of entries) {
-            switch (entry.type) {
-                case 'step_begin':
-                    if (entry.cols) {
-                        columns = entry.cols.map(col => col.name);
-                    }
-                    break;
-                case 'row':
-                    if (entry.row) {
-                        const decodedRow = entry.row.map(decodeValue);
-                        const rowObject = this.connection.createRowObject(decodedRow, columns);
-                        yield rowObject;
-                    }
-                    break;
-                case 'step_error':
-                case 'error':
-                    throw new Error(entry.error?.message || 'SQL execution failed');
-            }
-        }
-    }
-    async execute() {
-        return this.connection.execute(this.sql, this.args);
-    }
-}
-export class Connection {
-    constructor(config) {
-        this.baton = null;
-        this.config = config;
-        this.baseUrl = normalizeUrl(config.url);
-    }
-    prepare(sql, args = []) {
-        return new Statement(this, sql, args);
-    }
-    async execute(sql, args = []) {
-        const { response, entries } = await this.executeRaw(sql, args);
-        const result = await this.processCursorEntries(entries);
-        return result;
-    }
-    async executeRaw(sql, args = []) {
-        const request = {
-            baton: this.baton,
-            batch: {
-                steps: [{
-                        stmt: {
-                            sql,
-                            args: args.map(encodeValue),
-                            want_rows: true
-                        }
-                    }]
-            }
-        };
-        const { response, entries } = await executeCursor(this.baseUrl, this.config.authToken, request);
-        this.baton = response.baton;
-        if (response.base_url) {
-            this.baseUrl = response.base_url;
-        }
-        return { response, entries };
-    }
-    async processCursorEntries(entries) {
-        let columns = [];
-        let columnTypes = [];
-        let rows = [];
-        let rowsAffected = 0;
-        let lastInsertRowid;
-        for await (const entry of entries) {
-            switch (entry.type) {
-                case 'step_begin':
-                    if (entry.cols) {
-                        columns = entry.cols.map(col => col.name);
-                        columnTypes = entry.cols.map(col => col.decltype || '');
-                    }
-                    break;
-                case 'row':
-                    if (entry.row) {
-                        const decodedRow = entry.row.map(decodeValue);
-                        const rowObject = this.createRowObject(decodedRow, columns);
-                        rows.push(rowObject);
-                    }
-                    break;
-                case 'step_end':
-                    if (entry.affected_row_count !== undefined) {
-                        rowsAffected = entry.affected_row_count;
-                    }
-                    if (entry.last_insert_rowid) {
-                        lastInsertRowid = parseInt(entry.last_insert_rowid, 10);
-                    }
-                    break;
-                case 'step_error':
-                case 'error':
-                    throw new Error(entry.error?.message || 'SQL execution failed');
-            }
-        }
-        return {
-            columns,
-            columnTypes,
-            rows,
-            rowsAffected,
-            lastInsertRowid
-        };
-    }
-    createRowObject(values, columns) {
-        const row = [...values];
-        // Add column name properties to the array as non-enumerable
-        // Only add valid identifier names to avoid conflicts
-        columns.forEach((column, index) => {
-            if (column && isValidIdentifier(column)) {
-                Object.defineProperty(row, column, {
-                    value: values[index],
-                    enumerable: false,
-                    writable: false,
-                    configurable: true
-                });
-            }
-        });
-        return row;
-    }
-    async batch(statements, mode) {
-        const request = {
-            baton: this.baton,
-            batch: {
-                steps: statements.map(sql => ({
-                    stmt: {
-                        sql,
-                        args: [],
-                        want_rows: false
-                    }
-                }))
-            }
-        };
-        const { response, entries } = await executeCursor(this.baseUrl, this.config.authToken, request);
-        this.baton = response.baton;
-        if (response.base_url) {
-            this.baseUrl = response.base_url;
-        }
-        let totalRowsAffected = 0;
-        let lastInsertRowid;
-        for await (const entry of entries) {
-            switch (entry.type) {
-                case 'step_end':
-                    if (entry.affected_row_count !== undefined) {
-                        totalRowsAffected += entry.affected_row_count;
-                    }
-                    if (entry.last_insert_rowid) {
-                        lastInsertRowid = parseInt(entry.last_insert_rowid, 10);
-                    }
-                    break;
-                case 'step_error':
-                case 'error':
-                    throw new Error(entry.error?.message || 'Batch execution failed');
-            }
-        }
-        return {
-            rowsAffected: totalRowsAffected,
-            lastInsertRowid
-        };
-    }
-}
-export function connect(config) {
-    return new Connection(config);
-}