@smithers-orchestrator/db 0.23.0 → 0.24.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/db",
-  "version": "0.23.0",
+  "version": "0.24.2",
   "description": "SQLite and Drizzle persistence adapter for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -10,6 +10,10 @@
       "import": "./src/index.js",
       "default": "./src/index.js"
     },
+    "./runState": {
+      "import": "./src/runState.js",
+      "default": "./src/runState.js"
+    },
     "./*": {
       "types": "./src/index.d.ts",
       "import": "./src/*.js",
@@ -26,10 +30,10 @@
     "drizzle-zod": "^0.8.3",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.23.0",
-    "@smithers-orchestrator/observability": "0.23.0",
-    "@smithers-orchestrator/graph": "0.23.0",
-    "@smithers-orchestrator/scheduler": "0.23.0"
+    "@smithers-orchestrator/graph": "0.24.2",
+    "@smithers-orchestrator/errors": "0.24.2",
+    "@smithers-orchestrator/scheduler": "0.24.2",
+    "@smithers-orchestrator/observability": "0.24.2"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.5.1",

package/src/adapter.js

@@ -11,6 +11,7 @@
 // @smithers-type-exports-end
 
 import { getTableName } from "drizzle-orm";
+import { getTableColumns } from "drizzle-orm/utils";
 import { Effect, Exit, FiberId, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { getSqlMessageStorage } from "./sql-message-storage.js";
@@ -25,6 +26,7 @@ import { camelToSnake } from "./utils/camelToSnake.js";
 /** @typedef {import("./adapter/AlertStatus.ts").AlertStatus} AlertStatus */
 /** @typedef {import("./adapter/AttemptRow.ts").AttemptRow} AttemptRow */
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
+/** @typedef {import("drizzle-orm").Table} Table */
 /** @typedef {import("./adapter/EventHistoryQuery.ts").EventHistoryQuery} EventHistoryQuery */
 /** @typedef {import("./adapter/HumanRequestRow.ts").HumanRequestRow} HumanRequestRow */
 /** @typedef {import("./output/OutputKey.ts").OutputKey} OutputKey */
@@ -427,6 +429,85 @@ function resolveOutputTableName(table) {
         return "output";
     }
 }
+/**
+ * @param {unknown} db
+ * @param {string} tableName
+ * @returns {unknown | null}
+ */
+function findDrizzleTableByName(db, tableName) {
+    const schema = /** @type {{ _?: { fullSchema?: Record<string, unknown> } }} */ (db)?._?.fullSchema;
+    if (!schema) return null;
+    for (const table of Object.values(schema)) {
+        try {
+            if (getTableName(/** @type {Table} */ (table)) === tableName) return table;
+        }
+        catch {
+            // Ignore non-table schema entries.
+        }
+    }
+    return null;
+}
+/**
+ * @param {unknown} table
+ * @returns {string[]}
+ */
+function getPhysicalBooleanColumnNames(table) {
+    try {
+        const cols = getTableColumns(/** @type {Table} */ (table));
+        const names = [];
+        for (const col of Object.values(cols)) {
+            const c = /** @type {Record<string, unknown> & { config?: { mode?: string }; mapFromDriverValue?: unknown; name?: unknown }} */ (/** @type {unknown} */ (col));
+            const mapFn = /** @type {{ toString?: () => string } | undefined} */ (c?.mapFromDriverValue);
+            if (c?.columnType === "SQLiteBoolean" ||
+                c?.config?.mode === "boolean" ||
+                c?.mode === "boolean" ||
+                c?.dataType === "boolean" ||
+                mapFn?.toString?.().includes("Boolean")) {
+                const name = typeof c.name === "string" ? c.name : null;
+                if (name) names.push(name);
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * @param {Record<string, unknown> | null | undefined} row
+ * @param {readonly string[]} columnNames
+ * @returns {Record<string, unknown> | null | undefined}
+ */
+function coerceRawBooleanColumns(row, columnNames) {
+    if (!row || columnNames.length === 0) return row;
+    const next = { ...row };
+    for (const columnName of columnNames) {
+        const value = next[columnName];
+        if (columnName in next && typeof value !== "boolean") {
+            if (value === 0 || value === 0n || value === "0") next[columnName] = false;
+            else if (value === 1 || value === 1n || value === "1") next[columnName] = true;
+        }
+    }
+    return next;
+}
+/**
+ * @param {unknown} client
+ * @param {string} tableName
+ * @returns {string[]}
+ */
+function getPersistedBooleanColumnNames(client, tableName) {
+    try {
+        const rows = /** @type {{ query: (sql: string) => { all: (...args: unknown[]) => Array<Record<string, unknown>> } }} */ (client)
+            .query(`SELECT column_name FROM _smithers_output_schema_columns WHERE table_name = ? AND kind = 'boolean'`)
+            .all(tableName);
+        return rows
+            .map((row) => row.column_name)
+            .filter((name) => typeof name === "string");
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * @param {unknown} db
  * @returns {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }}
@@ -1191,14 +1272,19 @@ export class SmithersDb {
         return runnableEffect(this.read(`get raw node output ${tableName}`, () => {
             const escaped = tableName.replaceAll(`"`, `""`);
             if (this.internalStorage.dialect === POSTGRES) {
+                const boolColumns = getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName));
                 return this.internalStorage
                     .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? ORDER BY iteration DESC LIMIT 1`, [runId, nodeId])
-                    .then((row) => row ?? null);
+                    .then((row) => coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
             }
             const client = this.db.session.client;
+            const boolColumns = [
+                ...getPersistedBooleanColumnNames(client, tableName),
+                ...getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName)),
+            ];
             const stmt = client.query(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? ORDER BY iteration DESC LIMIT 1`);
             const row = stmt.get(runId, nodeId);
-            return Promise.resolve(row ?? null);
+            return Promise.resolve(coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
         }).pipe(Effect.catchAll(() => Effect.succeed(null))));
     }
     /**
@@ -1208,18 +1294,40 @@ export class SmithersDb {
    * @param {number} iteration
    * @returns {RunnableEffect<Record<string, unknown> | null, SmithersError>}
    */
+    /**
+   * Whether a physical table with this exact name exists in the database.
+   * @param {string} tableName
+   * @returns {RunnableEffect<boolean, SmithersError>}
+   */
+    hasPhysicalTable(tableName) {
+        return runnableEffect(this.read(`has physical table ${tableName}`, () => {
+            if (this.internalStorage.dialect === POSTGRES) {
+                return this.internalStorage
+                    .queryOneRaw(`SELECT 1 AS one FROM information_schema.tables WHERE table_name = ? LIMIT 1`, [tableName])
+                    .then((row) => row != null);
+            }
+            const client = this.db.session.client;
+            const stmt = client.query(`SELECT 1 AS one FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1`);
+            return Promise.resolve(stmt.get(tableName) != null);
+        }).pipe(Effect.catchAll(() => Effect.succeed(false))));
+    }
     getRawNodeOutputForIteration(tableName, runId, nodeId, iteration) {
         return runnableEffect(this.read(`get raw node output ${tableName} iteration ${iteration}`, () => {
             const escaped = tableName.replaceAll(`"`, `""`);
             if (this.internalStorage.dialect === POSTGRES) {
+                const boolColumns = getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName));
                 return this.internalStorage
                     .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`, [runId, nodeId, iteration])
-                    .then((row) => row ?? null);
+                    .then((row) => coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
             }
             const client = this.db.session.client;
+            const boolColumns = [
+                ...getPersistedBooleanColumnNames(client, tableName),
+                ...getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName)),
+            ];
             const stmt = client.query(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`);
             const row = stmt.get(runId, nodeId, iteration);
-            return Promise.resolve(row ?? null);
+            return Promise.resolve(coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
         }).pipe(Effect.catchAll(() => Effect.succeed(null))));
     }
     /**
@@ -2125,6 +2233,34 @@ export class SmithersDb {
          WHERE run_id = ? AND status = ?`, [runId, "requested"], { booleanColumns: ["autoApproved"] }));
     }
     /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovals(runId) {
+        return this.read(`list decided approvals ${runId}`, () => this.internalStorage.queryAll(`SELECT a.*
+         FROM _smithers_approvals a
+         JOIN _smithers_nodes n
+           ON a.run_id = n.run_id
+          AND a.node_id = n.node_id
+          AND a.iteration = n.iteration
+         WHERE a.run_id = ?
+           AND a.status IN ('approved', 'denied')
+           AND n.state = 'pending'`, [runId], { booleanColumns: ["autoApproved"] }));
+    }
+    /**
+   * Returns all decided approvals for a run (approved or denied), regardless of
+   * node state. Used by why-diagnosis so denied gates (node state = 'failed')
+   * are included in the diagnosis output.
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovals(runId) {
+        return this.read(`list all decided approvals ${runId}`, () => this.internalStorage.queryAll(`SELECT *
+         FROM _smithers_approvals
+         WHERE run_id = ?
+           AND status IN ('approved', 'denied')`, [runId], { booleanColumns: ["autoApproved"] }));
+    }
+    /**
    * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
    */
     listAllPendingApprovals() {
@@ -2134,8 +2270,12 @@ export class SmithersDb {
            a.iteration,
            a.status,
            a.requested_at_ms,
+           a.decided_at_ms,
            a.note,
            a.decided_by,
+           a.request_json,
+           a.decision_json,
+           a.auto_approved,
            r.workflow_name,
            r.status AS run_status,
            n.label AS node_label
@@ -2146,7 +2286,7 @@ export class SmithersDb {
           AND a.node_id = n.node_id
           AND a.iteration = n.iteration
          WHERE a.status = ?
-         ORDER BY COALESCE(a.requested_at_ms, 0) ASC, a.run_id, a.node_id, a.iteration`, ["requested"]));
+         ORDER BY COALESCE(a.requested_at_ms, 0) ASC, a.run_id, a.node_id, a.iteration`, ["requested"], { booleanColumns: ["autoApproved"] }));
     }
     /**
    * @param {string} workflowName
@@ -2558,6 +2698,20 @@ export class SmithersDb {
     }
     /**
    * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovalsEffect(runId) {
+        return this.listDecidedApprovals(runId);
+    }
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovalsEffect(runId) {
+        return this.listAllDecidedApprovals(runId);
+    }
+    /**
+   * @param {string} runId
    * @returns {RunnableEffect<FrameRow | undefined, SmithersError>}
    */
     getLastFrameEffect(runId) {

package/src/index.d.ts

@@ -958,6 +958,16 @@ declare class SmithersDb {
    */
     listPendingApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
     /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
    * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
    */
     listAllPendingApprovals(): RunnableEffect<Array<Record<string, unknown>>, SmithersError$1>;
@@ -1179,6 +1189,16 @@ declare class SmithersDb {
     listPendingApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
     /**
    * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
    * @returns {RunnableEffect<FrameRow | undefined, SmithersError>}
    */
     getLastFrameEffect(runId: string): RunnableEffect<FrameRow | undefined, SmithersError$1>;

package/src/zodToCreateTableSQL.js

@@ -18,6 +18,21 @@ function sqliteTypeFor(zodFieldSchema) {
     }
     return "TEXT";
 }
+function sqliteKindFor(zodFieldSchema) {
+    const baseType = unwrapZodType(zodFieldSchema);
+    const baseTypeName = getZodBaseTypeName(baseType);
+    if (baseTypeName === "boolean")
+        return "boolean";
+    if (baseTypeName === "number" ||
+        baseTypeName === "int" ||
+        baseTypeName === "float")
+        return "number";
+    if (baseTypeName === "string" ||
+        baseTypeName === "enum" ||
+        baseTypeName === "literal")
+        return "string";
+    return "json";
+}
 function quoteIdentifier(identifier) {
     return `"${String(identifier).replaceAll(`"`, `""`)}"`;
 }
@@ -29,7 +44,7 @@ export function zodSchemaColumns(schema) {
     const out = [];
     const shape = schema.shape;
     for (const [key] of Object.entries(shape)) {
-        out.push({ name: camelToSnake(key), sqliteType: sqliteTypeFor(shape[key]) });
+        out.push({ name: camelToSnake(key), sqliteType: sqliteTypeFor(shape[key]), kind: sqliteKindFor(shape[key]) });
     }
     return out;
 }
@@ -68,6 +83,18 @@ export function zodToCreateTableSQL(tableName, schema, opts) {
  */
 export function syncZodTableSchema(sqlite, tableName, schema, opts) {
     sqlite.run(zodToCreateTableSQL(tableName, schema, opts));
+    if (!opts?.isInput) {
+        try {
+            sqlite.run(`CREATE TABLE IF NOT EXISTS _smithers_output_schema_columns (table_name TEXT NOT NULL, column_name TEXT NOT NULL, kind TEXT NOT NULL, PRIMARY KEY (table_name, column_name))`);
+            const stmt = sqlite.query(`INSERT INTO _smithers_output_schema_columns (table_name, column_name, kind) VALUES (?, ?, ?) ON CONFLICT(table_name, column_name) DO UPDATE SET kind = excluded.kind`);
+            for (const { name, kind } of zodSchemaColumns(schema)) {
+                stmt.run(tableName, name, kind);
+            }
+        }
+        catch {
+            // Schema metadata is best-effort; table creation remains the source of truth.
+        }
+    }
     let existing;
     const quotedTable = quoteIdentifier(tableName);
     try {