@fadhilp/stateql 0.1.2 → 0.2.2

package/dist/src/sqlite-process.js

@@ -0,0 +1,240 @@
+import { existsSync, statSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { hash, parseJson, toJsonSafe } from "./util.js";
+let db;
+let source;
+let readOnly = true;
+process.on("message", (request) => {
+    let response;
+    try {
+        initialize(request);
+        response = { id: request.id, result: execute(request) };
+    }
+    catch (error) {
+        response = {
+            id: request.id,
+            error: {
+                message: errorText(error),
+                ...(error instanceof SQLiteBatchError
+                    ? { outcomeUnknown: error.outcomeUnknown }
+                    : {}),
+            },
+        };
+    }
+    process.send?.(response);
+});
+process.on("disconnect", () => {
+    close();
+    process.exit(0);
+});
+process.on("exit", close);
+function initialize(request) {
+    if (!db) {
+        source = request.source;
+        readOnly = request.readOnly;
+        db = new DatabaseSync(source, {
+            readOnly,
+            enableForeignKeyConstraints: true,
+        });
+    }
+    db.exec(`PRAGMA busy_timeout = ${Math.max(1, request.busyTimeoutMs)}`);
+}
+function execute(request) {
+    const database = db;
+    switch (request.operation) {
+        case "read": {
+            const [sql, params] = request.args;
+            const statement = database.prepare(sql);
+            const rows = bindAll(statement, params);
+            return {
+                rows: toJsonSafe(rows),
+                columns: statement.columns().map((column) => ({
+                    name: column.name,
+                    type: column.type?.toLowerCase() ?? inferType(rows, column.name),
+                })),
+            };
+        }
+        case "write": {
+            if (readOnly)
+                throw new Error("Connection is read-only.");
+            const [sql, params] = request.args;
+            try {
+                database.exec("BEGIN");
+            }
+            catch (error) {
+                throw new SQLiteBatchError(errorText(error), false);
+            }
+            try {
+                const result = bindRun(database.prepare(sql), params);
+                database.exec("COMMIT");
+                return { affectedRows: Number(result.changes) };
+            }
+            catch (error) {
+                try {
+                    database.exec("ROLLBACK");
+                    throw new SQLiteBatchError(errorText(error), false);
+                }
+                catch (rollbackError) {
+                    if (rollbackError instanceof SQLiteBatchError)
+                        throw rollbackError;
+                    throw new SQLiteBatchError(errorText(error), true);
+                }
+            }
+        }
+        case "writeBatch": {
+            if (readOnly)
+                throw new Error("Connection is read-only.");
+            const [operations, isolation] = request.args;
+            if (isolation !== "serializable") {
+                throw new Error(`SQLite does not support isolation level "${isolation}".`);
+            }
+            const results = [];
+            try {
+                database.exec("BEGIN");
+            }
+            catch (error) {
+                throw new SQLiteBatchError(errorText(error), false);
+            }
+            try {
+                for (const operation of operations) {
+                    const result = bindRun(database.prepare(operation.sql), parseJson(operation.parameters, []));
+                    results.push({ affectedRows: Number(result.changes) });
+                }
+            }
+            catch (error) {
+                try {
+                    database.exec("ROLLBACK");
+                }
+                catch {
+                    throw new SQLiteBatchError(errorText(error), true);
+                }
+                throw new SQLiteBatchError(errorText(error), false);
+            }
+            try {
+                database.exec("COMMIT");
+                return results;
+            }
+            catch (error) {
+                try {
+                    database.exec("ROLLBACK");
+                    throw new SQLiteBatchError(errorText(error), false);
+                }
+                catch (rollbackError) {
+                    if (rollbackError instanceof SQLiteBatchError)
+                        throw rollbackError;
+                    throw new SQLiteBatchError(errorText(error), true);
+                }
+            }
+        }
+        case "signature": {
+            if (source === ":memory:")
+                return "memory";
+            const stats = statSync(source, { bigint: true });
+            const walPath = `${source}-wal`;
+            const wal = existsSync(walPath)
+                ? statSync(walPath, { bigint: true })
+                : undefined;
+            return hash({
+                size: stats.size.toString(),
+                modified: stats.mtimeNs.toString(),
+                walSize: wal?.size.toString() ?? "0",
+                walModified: wal?.mtimeNs.toString() ?? "0",
+            });
+        }
+        case "inspect": {
+            const [kind, table] = request.args;
+            return inspect(database, kind, table);
+        }
+    }
+}
+function inspect(database, kind, table) {
+    if (kind === "schema") {
+        const tables = database
+            .prepare(`SELECT name, type
+         FROM sqlite_master
+         WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`)
+            .all();
+        return { schema: "main", tables };
+    }
+    if (!table)
+        throw new Error(`Table is required for inspect ${kind}.`);
+    const quoted = quoteSqliteLiteral(table);
+    const columns = database
+        .prepare(`PRAGMA table_info(${quoted})`)
+        .all();
+    if (columns.length === 0)
+        throw new Error(`Table "${table}" was not found.`);
+    const indexes = database
+        .prepare(`PRAGMA index_list(${quoted})`)
+        .all();
+    const foreignKeys = database
+        .prepare(`PRAGMA foreign_key_list(${quoted})`)
+        .all();
+    if (kind === "columns")
+        return { table, columns };
+    if (kind === "indexes")
+        return { table, indexes };
+    if (kind === "constraints") {
+        return {
+            table,
+            primary_key: columns
+                .filter((column) => Number(column.pk) > 0)
+                .map((column) => column.name),
+            foreign_keys: foreignKeys,
+        };
+    }
+    if (kind !== "table")
+        throw new Error(`Unknown inspection kind "${kind}".`);
+    return {
+        table,
+        schema: "main",
+        columns: columns.map((column) => ({
+            name: column.name,
+            type: String(column.type).toLowerCase(),
+            nullable: column.notnull === 0 && Number(column.pk) === 0,
+            primary_key: Number(column.pk) > 0,
+        })),
+        indexes: indexes.length,
+        foreign_keys: foreignKeys.length,
+    };
+}
+function bindAll(statement, params) {
+    if (Array.isArray(params))
+        return statement.all(...params);
+    return statement.all(params);
+}
+function bindRun(statement, params) {
+    if (Array.isArray(params))
+        return statement.run(...params);
+    return statement.run(params);
+}
+function inferType(rows, name) {
+    const value = rows.find((row) => row[name] !== null)?.[name];
+    if (value === undefined)
+        return "unknown";
+    if (Buffer.isBuffer(value))
+        return "binary";
+    return typeof value;
+}
+function quoteSqliteLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function close() {
+    try {
+        db?.close();
+    }
+    catch {
+        // Process teardown closes the database handle.
+    }
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class SQLiteBatchError extends Error {
+    outcomeUnknown;
+    constructor(message, outcomeUnknown) {
+        super(message);
+        this.outcomeUnknown = outcomeUnknown;
+    }
+}

package/dist/src/stateql.d.ts

@@ -1,4 +1,4 @@
-import type { BatchCommand, BatchOptions, ConnectOptions, ExecOptions, FilterOptions, PlanOptions, ProfileOptions, QueryOptions, Response, RowsOptions, StateQLOptions } from "./types.js";
+import type { BatchCommand, BatchOptions, ConnectOptions, ExecOptions, ExecutionOptions, FilterOptions, HistoryEntry, PlanOptions, ProfileOptions, QueryOptions, Response, RowsOptions, StateQLOptions, StateQLSnapshot } from "./types.js";
 export declare class StateQL {
     private readonly store;
     private readonly sessionName;
@@ -7,6 +7,9 @@ export declare class StateQL {
     private readonly resultTtlSeconds;
     private readonly maxCellCharacters;
     private readonly maxResultRows;
+    private readonly maxResultBytes;
+    private readonly timeoutMs;
+    private readonly signal?;
     private readonly now;
     constructor(options?: StateQLOptions);
     close(): void;
@@ -16,6 +19,9 @@ export declare class StateQL {
     showProfile(name: string): Promise<Response<unknown>>;
     removeProfile(name: string): Promise<Response<unknown>>;
     disconnect(): Promise<Response<unknown>>;
+    snapshot(options?: {
+        historyLimit?: number;
+    }): StateQLSnapshot;
     status(): Promise<Response<unknown>>;
     startSession(name: string): Promise<Response<unknown>>;
     listSessions(): Promise<Response<unknown>>;
@@ -34,21 +40,25 @@ export declare class StateQL {
     receipt(id: string): Promise<Response<unknown>>;
     beginTransaction(isolation?: string): Promise<Response<unknown>>;
     transactionStatus(id?: string): Promise<Response<unknown>>;
-    commitTransaction(id?: string): Promise<Response<unknown>>;
+    commitTransaction(id?: string, options?: ExecutionOptions): Promise<Response<unknown>>;
     rollbackTransaction(id?: string): Promise<Response<unknown>>;
-    inspect(kind: string, table?: string): Promise<Response<unknown>>;
+    inspect(kind: string, table?: string, options?: ExecutionOptions): Promise<Response<unknown>>;
     plan(sql: string, options?: PlanOptions): Promise<Response<unknown>>;
-    apply(planId: string): Promise<Response<unknown>>;
-    history(limit?: number): Promise<Response<unknown>>;
+    apply(planId: string, options?: ExecutionOptions): Promise<Response<unknown>>;
+    history(limit?: number): Promise<Response<{
+        history: HistoryEntry[];
+    }>>;
     capabilities(): Promise<Response<unknown>>;
     executeCommand(command: BatchCommand): Promise<Response<unknown>>;
     batch(commands: Iterable<BatchCommand> | AsyncIterable<BatchCommand>, options?: BatchOptions): AsyncGenerator<Response<unknown>>;
     private performExec;
     private batchFailure;
     private withResult;
+    private rejectDuringStagedTransaction;
     private requireResult;
     private requireConnection;
     private requireActiveTransaction;
+    private executionContext;
     private resultData;
     private cacheValid;
     private run;