@tursodatabase/serverless 1.1.1 → 1.1.2-pre.1

package/package.json

@@ -1,26 +1,41 @@
 {
   "name": "@tursodatabase/serverless",
-  "version": "1.1.1",
+  "version": "1.1.2-pre.1",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md"
   ],
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./compat": {
-      "import": "./dist/compat/index.js",
-      "types": "./dist/compat/index.d.ts"
-    }
+      "import": {
+        "types": "./dist/compat/index.d.ts",
+        "default": "./dist/compat/index.js"
+      },
+      "require": {
+        "types": "./dist/compat/index.d.cts",
+        "default": "./dist/compat/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "dev": "tsup --watch",
     "test": "ava integration-tests/*.test.mjs"
   },
   "keywords": [],
@@ -30,6 +45,7 @@
   "devDependencies": {
     "@types/node": "^24.0.13",
     "ava": "^6.4.1",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.2"
   }
 }

package/dist/async-lock.d.ts

@@ -1,6 +0,0 @@
-export declare class AsyncLock {
-    private locked;
-    private queue;
-    acquire(): Promise<void>;
-    release(): void;
-}

package/dist/async-lock.js

@@ -1,22 +0,0 @@
-export class AsyncLock {
-    constructor() {
-        this.locked = false;
-        this.queue = [];
-    }
-    async acquire() {
-        if (!this.locked) {
-            this.locked = true;
-            return;
-        }
-        return new Promise(resolve => { this.queue.push(resolve); });
-    }
-    release() {
-        const next = this.queue.shift();
-        if (next) {
-            next();
-        }
-        else {
-            this.locked = false;
-        }
-    }
-}

package/dist/compat.js

@@ -1,395 +0,0 @@
-import { Session } from './session.js';
-import { AsyncLock } from './async-lock.js';
-import { DatabaseError } from './error.js';
-/**
- * libSQL-compatible error class with error codes.
- */
-export class LibsqlError extends Error {
-    constructor(message, code, extendedCode, rawCode, cause) {
-        super(message);
-        this.name = 'LibsqlError';
-        this.code = code;
-        this.extendedCode = extendedCode;
-        this.rawCode = rawCode;
-        this.cause = cause;
-    }
-}
-class LibSQLClient {
-    constructor(config) {
-        this.execLock = new AsyncLock();
-        this._closed = false;
-        this._defaultSafeIntegers = false;
-        this.validateConfig(config);
-        const sessionConfig = {
-            url: config.url,
-            authToken: config.authToken || '',
-            remoteEncryptionKey: config.remoteEncryptionKey
-        };
-        this.sessionConfig = sessionConfig;
-        this.session = new Session(sessionConfig);
-    }
-    validateConfig(config) {
-        // Check for unsupported config options
-        const unsupportedOptions = [];
-        if (config.encryptionKey !== undefined) {
-            unsupportedOptions.push({ key: 'encryptionKey', value: config.encryptionKey });
-        }
-        if (config.syncUrl !== undefined) {
-            unsupportedOptions.push({ key: 'syncUrl', value: config.syncUrl });
-        }
-        if (config.syncInterval !== undefined) {
-            unsupportedOptions.push({ key: 'syncInterval', value: config.syncInterval });
-        }
-        if (config.readYourWrites !== undefined) {
-            unsupportedOptions.push({ key: 'readYourWrites', value: config.readYourWrites });
-        }
-        if (config.offline !== undefined) {
-            unsupportedOptions.push({ key: 'offline', value: config.offline });
-        }
-        if (config.tls !== undefined) {
-            unsupportedOptions.push({ key: 'tls', value: config.tls });
-        }
-        if (config.intMode !== undefined) {
-            unsupportedOptions.push({ key: 'intMode', value: config.intMode });
-        }
-        if (config.fetch !== undefined) {
-            unsupportedOptions.push({ key: 'fetch', value: config.fetch });
-        }
-        if (config.concurrency !== undefined) {
-            unsupportedOptions.push({ key: 'concurrency', value: config.concurrency });
-        }
-        if (unsupportedOptions.length > 0) {
-            const optionsList = unsupportedOptions.map(opt => `'${opt.key}'`).join(', ');
-            throw new LibsqlError(`Unsupported configuration options: ${optionsList}. Only 'url', 'authToken', and 'remoteEncryptionKey' are supported in the serverless compatibility layer.`, "UNSUPPORTED_CONFIG");
-        }
-        // Validate required options
-        if (!config.url) {
-            throw new LibsqlError("Missing required 'url' configuration option", "MISSING_URL");
-        }
-    }
-    get closed() {
-        return this._closed;
-    }
-    get protocol() {
-        return "http";
-    }
-    normalizeStatement(stmt) {
-        if (typeof stmt === 'string') {
-            return { sql: stmt, args: [] };
-        }
-        const args = stmt.args || [];
-        if (Array.isArray(args)) {
-            return { sql: stmt.sql, args };
-        }
-        // Convert named args to positional args (simplified)
-        return { sql: stmt.sql, args: Object.values(args) };
-    }
-    convertResult(result) {
-        const resultSet = {
-            columns: result.columns || [],
-            columnTypes: result.columnTypes || [],
-            rows: result.rows || [],
-            rowsAffected: result.rowsAffected || 0,
-            lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid) : undefined,
-            toJSON() {
-                return {
-                    columns: this.columns,
-                    columnTypes: this.columnTypes,
-                    rows: this.rows,
-                    rowsAffected: this.rowsAffected,
-                    lastInsertRowid: this.lastInsertRowid?.toString()
-                };
-            }
-        };
-        return resultSet;
-    }
-    async execute(stmtOrSql, args) {
-        await this.execLock.acquire();
-        try {
-            if (this._closed) {
-                throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
-            }
-            let normalizedStmt;
-            if (typeof stmtOrSql === 'string') {
-                const normalizedArgs = args ? (Array.isArray(args) ? args : Object.values(args)) : [];
-                normalizedStmt = { sql: stmtOrSql, args: normalizedArgs };
-            }
-            else {
-                normalizedStmt = this.normalizeStatement(stmtOrSql);
-            }
-            const result = await this.session.execute(normalizedStmt.sql, normalizedStmt.args, this._defaultSafeIntegers);
-            return this.convertResult(result);
-        }
-        catch (error) {
-            if (error instanceof LibsqlError) {
-                throw error;
-            }
-            throw mapDatabaseError(error, "EXECUTE_ERROR");
-        }
-        finally {
-            this.execLock.release();
-        }
-    }
-    async batch(stmts, mode) {
-        await this.execLock.acquire();
-        try {
-            if (this._closed) {
-                throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
-            }
-            const sqlStatements = stmts.map(stmt => {
-                const normalized = this.normalizeStatement(stmt);
-                return normalized.sql; // For now, ignore args in batch
-            });
-            const result = await this.session.batch(sqlStatements);
-            // Return array of result sets (simplified - actual implementation would be more complex)
-            return [this.convertResult(result)];
-        }
-        catch (error) {
-            if (error instanceof LibsqlError) {
-                throw error;
-            }
-            throw mapDatabaseError(error, "BATCH_ERROR");
-        }
-        finally {
-            this.execLock.release();
-        }
-    }
-    async migrate(stmts) {
-        // For now, just call batch - in a real implementation this would disable foreign keys
-        return this.batch(stmts, "write");
-    }
-    modeToBeginSql(mode) {
-        switch (mode) {
-            case "write":
-                return "BEGIN IMMEDIATE";
-            case "deferred":
-                return "BEGIN DEFERRED";
-            case "read":
-            default:
-                return "BEGIN";
-        }
-    }
-    async transaction(mode) {
-        await this.execLock.acquire();
-        if (this._closed) {
-            this.execLock.release();
-            throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
-        }
-        const txSession = new Session(this.sessionConfig);
-        let txClosed = false;
-        let cleanupStarted = false;
-        const ensureOpen = () => {
-            if (txClosed) {
-                throw new LibsqlError("Transaction is closed", "TRANSACTION_CLOSED");
-            }
-        };
-        const closeTx = async () => {
-            if (cleanupStarted)
-                return;
-            cleanupStarted = true;
-            txClosed = true;
-            try {
-                await txSession.close();
-            }
-            finally {
-                this.execLock.release();
-            }
-        };
-        const executeInTx = async (stmt) => {
-            ensureOpen();
-            const normalized = this.normalizeStatement(stmt);
-            try {
-                const result = await txSession.execute(normalized.sql, normalized.args, this._defaultSafeIntegers);
-                return this.convertResult(result);
-            }
-            catch (error) {
-                throw mapDatabaseError(error, "EXECUTE_ERROR");
-            }
-        };
-        try {
-            await txSession.sequence(this.modeToBeginSql(mode));
-        }
-        catch (error) {
-            await closeTx();
-            throw mapDatabaseError(error, "BEGIN_ERROR");
-        }
-        return {
-            execute: async (stmtOrSql, args) => {
-                if (typeof stmtOrSql === "string") {
-                    const normalizedArgs = args ? (Array.isArray(args) ? args : Object.values(args)) : [];
-                    return executeInTx({ sql: stmtOrSql, args: normalizedArgs });
-                }
-                return executeInTx(stmtOrSql);
-            },
-            batch: async (stmts) => {
-                ensureOpen();
-                const results = [];
-                for (const stmt of stmts) {
-                    results.push(await executeInTx(stmt));
-                }
-                return results;
-            },
-            executeMultiple: async (sql) => {
-                ensureOpen();
-                try {
-                    await txSession.sequence(sql);
-                }
-                catch (error) {
-                    throw mapDatabaseError(error, "EXECUTE_MULTIPLE_ERROR");
-                }
-            },
-            commit: async () => {
-                ensureOpen();
-                try {
-                    await txSession.sequence("COMMIT");
-                }
-                catch (error) {
-                    throw mapDatabaseError(error, "COMMIT_ERROR");
-                }
-                finally {
-                    await closeTx();
-                }
-            },
-            rollback: async () => {
-                ensureOpen();
-                try {
-                    await txSession.sequence("ROLLBACK");
-                }
-                catch (error) {
-                    throw mapDatabaseError(error, "ROLLBACK_ERROR");
-                }
-                finally {
-                    await closeTx();
-                }
-            },
-            close: () => {
-                if (txClosed)
-                    return;
-                txClosed = true;
-                void txSession.sequence("ROLLBACK")
-                    .catch(() => undefined)
-                    .finally(() => {
-                    void closeTx();
-                });
-            },
-            get closed() {
-                return txClosed;
-            },
-        };
-    }
-    async executeMultiple(sql) {
-        await this.execLock.acquire();
-        try {
-            if (this._closed) {
-                throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
-            }
-            await this.session.sequence(sql);
-        }
-        catch (error) {
-            if (error instanceof LibsqlError) {
-                throw error;
-            }
-            throw mapDatabaseError(error, "EXECUTE_MULTIPLE_ERROR");
-        }
-        finally {
-            this.execLock.release();
-        }
-    }
-    async sync() {
-        throw new LibsqlError("Sync not supported for remote databases", "NOT_SUPPORTED");
-    }
-    close() {
-        this._closed = true;
-        // Note: The libSQL client interface expects synchronous close,
-        // but our underlying session needs async close. We'll fire and forget.
-        this.session.close().catch(error => {
-            console.error('Error closing session:', error);
-        });
-    }
-}
-/**
- * Create a libSQL-compatible client for Turso database access.
- *
- * This function provides compatibility with the standard libSQL client API
- * while using the Turso serverless driver under the hood.
- *
- * @param config - Configuration object (only url and authToken are supported)
- * @returns A Client instance compatible with libSQL API
- * @throws LibsqlError if unsupported configuration options are provided
- *
- * @example
- * ```typescript
- * import { createClient } from "@tursodatabase/serverless/compat";
- *
- * const client = createClient({
- *   url: process.env.TURSO_DATABASE_URL,
- *   authToken: process.env.TURSO_AUTH_TOKEN
- * });
- *
- * const result = await client.execute("SELECT * FROM users");
- * console.log(result.rows);
- * ```
- */
-export function createClient(config) {
-    return new LibSQLClient(config);
-}
-// Known SQLite base error code names, used to split extended codes like
-// "SQLITE_CONSTRAINT_PRIMARYKEY" into base ("SQLITE_CONSTRAINT") and extended.
-const sqliteBaseErrorCodes = new Set([
-    "SQLITE_ERROR",
-    "SQLITE_INTERNAL",
-    "SQLITE_PERM",
-    "SQLITE_ABORT",
-    "SQLITE_BUSY",
-    "SQLITE_LOCKED",
-    "SQLITE_NOMEM",
-    "SQLITE_READONLY",
-    "SQLITE_INTERRUPT",
-    "SQLITE_IOERR",
-    "SQLITE_CORRUPT",
-    "SQLITE_NOTFOUND",
-    "SQLITE_FULL",
-    "SQLITE_CANTOPEN",
-    "SQLITE_PROTOCOL",
-    "SQLITE_EMPTY",
-    "SQLITE_SCHEMA",
-    "SQLITE_TOOBIG",
-    "SQLITE_CONSTRAINT",
-    "SQLITE_MISMATCH",
-    "SQLITE_MISUSE",
-    "SQLITE_NOLFS",
-    "SQLITE_AUTH",
-    "SQLITE_FORMAT",
-    "SQLITE_RANGE",
-    "SQLITE_NOTADB",
-    "SQLITE_NOTICE",
-    "SQLITE_WARNING",
-]);
-/**
- * Parse a protocol error code into base and extended codes.
- *
- * The server may send either a base code ("SQLITE_CONSTRAINT") or an extended
- * code ("SQLITE_CONSTRAINT_PRIMARYKEY"). This function splits them so that
- * `code` is always the base code and `extendedCode` carries the full detail.
- */
-function parseErrorCode(serverCode) {
-    if (sqliteBaseErrorCodes.has(serverCode)) {
-        return { code: serverCode };
-    }
-    // Try to find a base code prefix (e.g. "SQLITE_CONSTRAINT" in "SQLITE_CONSTRAINT_PRIMARYKEY")
-    for (const base of sqliteBaseErrorCodes) {
-        if (serverCode.startsWith(base + "_")) {
-            return { code: base, extendedCode: serverCode };
-        }
-    }
-    // Unknown code — return as-is
-    return { code: serverCode };
-}
-function mapDatabaseError(error, fallbackCode) {
-    if (error instanceof DatabaseError && error.code) {
-        const { code, extendedCode } = parseErrorCode(error.code);
-        return new LibsqlError(error.message, code, extendedCode, error.rawCode, error);
-    }
-    const cause = error instanceof Error ? error : undefined;
-    return new LibsqlError(error.message ?? String(error), fallbackCode, undefined, undefined, cause);
-}

package/dist/connection.d.ts

@@ -1,197 +0,0 @@
-import { type SessionConfig } from './session.js';
-import { Statement } from './statement.js';
-import { type QueryOptions } from './protocol.js';
-/**
- * Configuration options for connecting to a Turso database.
- */
-export interface Config extends SessionConfig {
-}
-/**
- * A connection to a Turso database.
- *
- * Provides methods for executing SQL statements and managing prepared statements.
- * Uses the SQL over HTTP protocol with streaming cursor support.
- *
- * ## Concurrency model
- *
- * A Connection is **single-stream**: it can only run one statement at a time.
- * This is not an implementation quirk — it follows from the SQL over HTTP protocol,
- * where each request carries a baton from the previous response to sequence operations
- * on the server. Concurrent calls on the same connection would race on that baton
- * and corrupt the stream. This is the same model as SQLite itself (one execution
- * at a time per connection).
- *
- * If you call `execute()` while another is in flight, the call automatically
- * waits for the previous one to finish — just like the native
- * `@tursodatabase/database` binding.
- *
- * ## Parallel queries
- *
- * For parallelism, create multiple connections. `connect()` is cheap — it just
- * allocates a config object. No TCP connection is opened until the first `execute()`,
- * and the underlying `fetch()` runtime automatically pools and reuses TCP/TLS
- * connections to the same origin.
- *
- * ```typescript
- * import { connect } from "@tursodatabase/serverless";
- *
- * const config = { url: process.env.TURSO_URL, authToken: process.env.TURSO_TOKEN };
- *
- * // Option 1: one connection per parallel query
- * const [users, orders] = await Promise.all([
- *   connect(config).execute("SELECT * FROM users WHERE active = 1"),
- *   connect(config).execute("SELECT * FROM orders WHERE status = 'pending'"),
- * ]);
- *
- * // Option 2: reusable pool for repeated parallel work
- * const pool = Array.from({ length: 4 }, () => connect(config));
- * const results = await Promise.all(
- *   queries.map((sql, i) => pool[i % pool.length].execute(sql))
- * );
- * ```
- */
-export declare class Connection {
-    private config;
-    private session;
-    private isOpen;
-    private defaultSafeIntegerMode;
-    private _inTransaction;
-    private execLock;
-    constructor(config: Config);
-    /**
-     * Whether the database is currently in a transaction.
-     */
-    get inTransaction(): boolean;
-    /**
-     * Prepare a SQL statement for execution.
-     *
-     * Prepared statements created from a Connection use the same underlying session so transaction boundaries are preserved.
-     * This method fetches column metadata using the describe functionality.
-     *
-     * @param sql - The SQL statement to prepare
-     * @returns A Promise that resolves to a Statement object with column metadata
-     *
-     * @example
-     * ```typescript
-     * const stmt = await client.prepare("SELECT * FROM users WHERE id = ?");
-     * const columns = stmt.columns();
-     * const user = await stmt.get([123]);
-     * ```
-     */
-    prepare(sql: string): Promise<Statement>;
-    /**
-     * Execute a SQL statement and return all results.
-     *
-     * @param sql - The SQL statement to execute
-     * @param args - Optional array of parameter values
-     * @returns Promise resolving to the complete result set
-     *
-     * @example
-     * ```typescript
-     * const result = await client.execute("SELECT * FROM users WHERE id = ?", [123]);
-     * console.log(result.rows);
-     * ```
-     */
-    execute(sql: string, args?: any[], queryOptions?: QueryOptions): Promise<any>;
-    /**
-     * Execute a SQL statement and return all results.
-     *
-     * @param sql - The SQL statement to execute
-     * @returns Promise resolving to the complete result set
-     *
-     * @example
-     * ```typescript
-     * const result = await client.exec("SELECT * FROM users");
-     * console.log(result.rows);
-     * ```
-     */
-    exec(sql: string, queryOptions?: QueryOptions): Promise<any>;
-    /**
-     * Execute multiple SQL statements in a batch.
-     *
-     * @param statements - Array of SQL statements to execute
-     * @param mode - Optional transaction mode (currently unused)
-     * @returns Promise resolving to batch execution results
-     *
-     * @example
-     * ```typescript
-     * await client.batch([
-     *   "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)",
-     *   "INSERT INTO users (name) VALUES ('Alice')",
-     *   "INSERT INTO users (name) VALUES ('Bob')"
-     * ]);
-     * ```
-     */
-    batch(statements: string[], mode?: string, queryOptions?: QueryOptions): Promise<any>;
-    /**
-     * Execute a pragma.
-     *
-     * @param pragma - The pragma to execute
-     * @returns Promise resolving to the result of the pragma
-     */
-    pragma(pragma: string, queryOptions?: QueryOptions): Promise<any>;
-    /**
-     * Sets the default safe integers mode for all statements from this connection.
-     *
-     * @param toggle - Whether to use safe integers by default.
-     */
-    defaultSafeIntegers(toggle?: boolean): void;
-    /**
-     * Returns a function that executes the given function in a transaction.
-     *
-     * @param fn - The function to wrap in a transaction
-     * @returns A function that will execute fn within a transaction
-     *
-     * @example
-     * ```typescript
-     * const insert = await client.prepare("INSERT INTO users (name) VALUES (?)");
-     * const insertMany = client.transaction((users) => {
-     *   for (const user of users) {
-     *     insert.run([user]);
-     *   }
-     * });
-     *
-     * await insertMany(['Alice', 'Bob', 'Charlie']);
-     * ```
-     */
-    transaction(fn: (...args: any[]) => any): any;
-    /**
-     * Close the connection.
-     *
-     * This sends a close request to the server to properly clean up the stream.
-     */
-    close(): Promise<void>;
-    reconnect(): Promise<void>;
-}
-/**
- * Create a new connection to a Turso database.
- *
- * This is a lightweight operation — it only allocates a config object. No network
- * I/O happens until the first query. The underlying `fetch()` implementation
- * automatically pools TCP/TLS connections to the same origin, so creating many
- * connections is cheap.
- *
- * Each connection is single-stream: concurrent calls on the same connection are
- * automatically serialized. For true parallelism, create multiple connections:
- *
- * ```typescript
- * import { connect } from "@tursodatabase/serverless";
- *
- * const config = { url: process.env.TURSO_URL, authToken: process.env.TURSO_TOKEN };
- *
- * // Sequential (single connection is fine)
- * const conn = connect(config);
- * const a = await conn.execute("SELECT 1");
- * const b = await conn.execute("SELECT 2");
- *
- * // Parallel (use separate connections)
- * const [x, y] = await Promise.all([
- *   connect(config).execute("SELECT 1"),
- *   connect(config).execute("SELECT 2"),
- * ]);
- * ```
- *
- * @param config - Configuration object with database URL and auth token
- * @returns A new Connection instance
- */
-export declare function connect(config: Config): Connection;