@fadhilp/stateql 0.12.0 → 0.13.1

package/dist/src/adapters.d.ts

@@ -32,6 +32,7 @@ export interface Adapter {
     readonly confidence: StateConfidence;
     ping(): Promise<void>;
     read(sql: string, params: SqlParameters): Promise<ReadResult>;
+    readAutocommit?(sql: string, params: SqlParameters): Promise<ReadResult>;
     write(sql: string, params: SqlParameters, expectedRows?: 1): Promise<WriteResult>;
     writeAutocommit?(sql: string, params: SqlParameters): Promise<WriteResult>;
     writeBatch(operations: BatchWriteOperation[], isolation: string): Promise<WriteResult[]>;

package/dist/src/adapters.js

@@ -51,6 +51,7 @@ export async function createAdapter(connection, context, input) {
             throw new StateQLError("UNSUPPORTED_DRIVER", "Redis uses the native Redis adapter.");
     }
 }
+const SQLITE_AUTOCOMMIT_STATEMENTS = new Set(["vacuum", "analyze", "reindex"]);
 class SQLiteAdapter {
     source;
     readOnly;
@@ -101,7 +102,14 @@ class SQLiteAdapter {
     async write(sql, params, expectedRows) {
         return this.call("write", [sql, params, expectedRows], true, false);
     }
+    async writeAutocommit(sql, params) {
+        return this.call("writeAutocommit", [sql, params], true, false);
+    }
     async writeBatch(operations, isolation) {
+        const unsupported = operations.find((operation) => SQLITE_AUTOCOMMIT_STATEMENTS.has(operation.statement_type));
+        if (unsupported) {
+            throw new BatchWriteError(`SQLite transactions cannot include ${unsupported.statement_type.toUpperCase()} maintenance statements.`, false);
+        }
         return this.call("writeBatch", [operations, isolation], true, true);
     }
     async signature() {
@@ -590,6 +598,16 @@ class MySqlAdapter {
             throw error;
         }
     }
+    async readAutocommit(sql, params) {
+        const [result, fields] = await this.query(sql, mysqlParams(params), false, false);
+        return {
+            rows: toJsonSafe(mysqlRows(result)),
+            columns: fields.map((field) => ({
+                name: field.name,
+                type: mysqlFieldType(field),
+            })),
+        };
+    }
     async write(sql, params, expectedRows) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
@@ -629,6 +647,35 @@ class MySqlAdapter {
             throw new AdapterWriteError(errorText(error), true);
         }
     }
+    async writeAutocommit(sql, params) {
+        if (this.readOnly)
+            throw new AdapterWriteError("Connection is read-only.", false);
+        let values;
+        try {
+            values = mysqlParams(params);
+            await this.connect();
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        try {
+            const [result] = await this.runQuery(sql, values, true, false);
+            const maintenanceError = mysqlMaintenanceError(result);
+            if (maintenanceError)
+                throw new AdapterWriteError(maintenanceError, false);
+            return {
+                affectedRows: Array.isArray(result) ? 0 : mysqlAffectedRows(result),
+            };
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError || error instanceof AdapterWriteError) {
+                throw error;
+            }
+            throw new AdapterWriteError(errorText(error), true);
+        }
+    }
     async writeBatch(operations, isolation) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
@@ -901,6 +948,7 @@ const MYSQL_ISOLATION_LEVELS = new Set([
 const MYSQL_TRANSACTIONAL_STATEMENTS = new Set([
     "delete",
     "insert",
+    "upsert",
     "replace",
     "update",
 ]);
@@ -927,6 +975,18 @@ function mysqlRows(result) {
     }
     return result;
 }
+function mysqlMaintenanceError(result) {
+    if (!Array.isArray(result))
+        return undefined;
+    for (const row of result) {
+        const typeEntry = Object.entries(row).find(([key]) => key.toLowerCase() === "msg_type");
+        if (String(typeEntry?.[1] ?? "").toLowerCase() !== "error")
+            continue;
+        const textEntry = Object.entries(row).find(([key]) => key.toLowerCase() === "msg_text");
+        return String(textEntry?.[1] ?? "MySQL maintenance failed.");
+    }
+    return undefined;
+}
 function mysqlAffectedRows(result) {
     if (Array.isArray(result) || !("affectedRows" in result)) {
         throw new Error("MySQL statement did not return a write result.");

package/dist/src/sql.d.ts

@@ -1,6 +1,6 @@
 import type { AST } from "node-sql-parser";
 import type { Driver, SqlDriver } from "./types.js";
-export type StatementType = "select" | "insert" | "replace" | "update" | "delete" | "create" | "alter" | "drop" | "truncate" | "explain" | "vacuum" | "analyze" | "reindex" | "cluster";
+export type StatementType = "select" | "insert" | "upsert" | "replace" | "update" | "delete" | "create" | "alter" | "drop" | "truncate" | "values" | "show" | "explain" | "vacuum" | "analyze" | "reindex" | "optimize" | "check" | "cluster";
 export interface SqlAnalysis {
     ast: AST;
     normalized: string;
@@ -12,6 +12,8 @@ export interface SqlAnalysis {
     wrapForLimit: boolean;
     cacheable: boolean;
     requiresAutocommit: boolean;
+    /** Analysis-only SQL with trailing trivia removed when limit wrapping needs it. */
+    limitSql?: string;
 }
 export declare function analyzeSql(sql: string, driver: SqlDriver): SqlAnalysis;
 /** @internal Compatibility for existing connection records during Mongo rollout. */