@contractspec/example.workflow-system 3.7.6 → 3.8.2

package/dist/entities/index.js

@@ -113,82 +113,160 @@ var ApprovalCommentEntity = defineEntity({
   indexes: [index.on(["approvalRequestId", "createdAt"])]
 });
 
-// src/entities/workflow.ts
+// src/entities/instance.ts
 import {
   defineEntity as defineEntity2,
   defineEntityEnum as defineEntityEnum2,
   field as field2,
   index as index2
 } from "@contractspec/lib.schema";
-var WorkflowStatusEnum = defineEntityEnum2({
-  name: "WorkflowStatus",
-  values: ["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"],
+var InstanceStatusEnum = defineEntityEnum2({
+  name: "InstanceStatus",
+  values: [
+    "PENDING",
+    "RUNNING",
+    "WAITING",
+    "PAUSED",
+    "COMPLETED",
+    "CANCELLED",
+    "FAILED",
+    "TIMEOUT"
+  ],
   schema: "workflow",
-  description: "Status of a workflow definition."
+  description: "Status of a workflow instance."
 });
-var WorkflowTriggerTypeEnum = defineEntityEnum2({
-  name: "WorkflowTriggerType",
-  values: ["MANUAL", "EVENT", "SCHEDULED", "API"],
+var StepExecutionStatusEnum = defineEntityEnum2({
+  name: "StepExecutionStatus",
+  values: [
+    "PENDING",
+    "ACTIVE",
+    "COMPLETED",
+    "SKIPPED",
+    "FAILED",
+    "TIMEOUT"
+  ],
   schema: "workflow",
-  description: "What triggers workflow instantiation."
+  description: "Status of a step execution."
 });
-var WorkflowDefinitionEntity = defineEntity2({
-  name: "WorkflowDefinition",
-  description: "A workflow blueprint that defines the process structure.",
+var WorkflowInstanceEntity = defineEntity2({
+  name: "WorkflowInstance",
+  description: "A running instance of a workflow definition.",
   schema: "workflow",
-  map: "workflow_definition",
+  map: "workflow_instance",
   fields: {
-    id: field2.id({ description: "Unique workflow definition ID" }),
-    name: field2.string({ description: "Human-readable workflow name" }),
-    key: field2.string({
-      description: 'Unique key for referencing (e.g., "purchase_approval")'
+    id: field2.id({ description: "Unique instance ID" }),
+    workflowDefinitionId: field2.foreignKey(),
+    referenceId: field2.string({
+      isOptional: true,
+      description: "External reference (e.g., order ID)"
     }),
-    description: field2.string({
+    referenceType: field2.string({
       isOptional: true,
-      description: "Detailed description"
+      description: 'Type of reference (e.g., "Order")'
     }),
-    version: field2.int({
-      default: 1,
-      description: "Version number for versioning definitions"
+    status: field2.enum("InstanceStatus", { default: "PENDING" }),
+    currentStepId: field2.string({
+      isOptional: true,
+      description: "Current step being executed"
+    }),
+    contextData: field2.json({ description: "Data context for this instance" }),
+    triggeredBy: field2.foreignKey({
+      description: "User who triggered the workflow"
     }),
-    status: field2.enum("WorkflowStatus", { default: "DRAFT" }),
-    triggerType: field2.enum("WorkflowTriggerType", { default: "MANUAL" }),
-    triggerConfig: field2.json({
+    triggerSource: field2.string({
       isOptional: true,
-      description: "Trigger-specific configuration"
+      description: 'Source of trigger (e.g., "api", "ui")'
+    }),
+    organizationId: field2.foreignKey(),
+    priority: field2.int({
+      default: 0,
+      description: "Processing priority (higher = more urgent)"
     }),
-    initialStepId: field2.string({
+    dueAt: field2.dateTime({
       isOptional: true,
-      description: "First step when workflow starts"
+      description: "When this instance should complete"
     }),
-    featureFlagKey: field2.string({
+    outcome: field2.string({
       isOptional: true,
-      description: "Feature flag to control availability"
+      description: 'Final outcome (e.g., "approved", "rejected")'
     }),
-    settings: field2.json({
+    resultData: field2.json({
       isOptional: true,
-      description: "Workflow-wide settings"
+      description: "Final result data"
     }),
-    metadata: field2.json({ isOptional: true, description: "Custom metadata" }),
-    organizationId: field2.foreignKey({ description: "Owning organization" }),
-    createdBy: field2.foreignKey({
-      description: "User who created this workflow"
+    errorMessage: field2.string({
+      isOptional: true,
+      description: "Error message if failed"
     }),
     createdAt: field2.createdAt(),
     updatedAt: field2.updatedAt(),
-    publishedAt: field2.dateTime({
+    startedAt: field2.dateTime({ isOptional: true }),
+    completedAt: field2.dateTime({ isOptional: true }),
+    workflowDefinition: field2.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"]),
+    currentStep: field2.belongsTo("WorkflowStep", ["currentStepId"], ["id"]),
+    stepExecutions: field2.hasMany("StepExecution"),
+    approvalRequests: field2.hasMany("ApprovalRequest")
+  },
+  indexes: [
+    index2.on(["organizationId", "status"]),
+    index2.on(["workflowDefinitionId", "status"]),
+    index2.on(["referenceType", "referenceId"]),
+    index2.on(["triggeredBy", "status"]),
+    index2.on(["status", "dueAt"]),
+    index2.on(["createdAt"])
+  ],
+  enums: [InstanceStatusEnum]
+});
+var StepExecutionEntity = defineEntity2({
+  name: "StepExecution",
+  description: "Execution record of a step within a workflow instance.",
+  schema: "workflow",
+  map: "step_execution",
+  fields: {
+    id: field2.id({ description: "Unique execution ID" }),
+    workflowInstanceId: field2.foreignKey(),
+    workflowStepId: field2.foreignKey(),
+    status: field2.enum("StepExecutionStatus", { default: "PENDING" }),
+    executionOrder: field2.int({
+      default: 0,
+      description: "Order of execution within instance"
+    }),
+    inputData: field2.json({
       isOptional: true,
-      description: "When workflow was activated"
+      description: "Data when entering step"
+    }),
+    outputData: field2.json({
+      isOptional: true,
+      description: "Data when exiting step"
+    }),
+    actionTaken: field2.string({
+      isOptional: true,
+      description: 'Action that caused transition (e.g., "approve")'
     }),
-    steps: field2.hasMany("WorkflowStep"),
-    instances: field2.hasMany("WorkflowInstance")
+    transitionedTo: field2.string({
+      isOptional: true,
+      description: "Step key transitioned to"
+    }),
+    executedBy: field2.string({
+      isOptional: true,
+      description: "User who completed this step"
+    }),
+    errorMessage: field2.string({ isOptional: true }),
+    errorDetails: field2.json({ isOptional: true }),
+    retryCount: field2.int({ default: 0 }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    startedAt: field2.dateTime({ isOptional: true }),
+    completedAt: field2.dateTime({ isOptional: true }),
+    workflowInstance: field2.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
+    workflowStep: field2.belongsTo("WorkflowStep", ["workflowStepId"], ["id"])
   },
   indexes: [
-    index2.unique(["organizationId", "key", "version"]),
-    index2.on(["organizationId", "status"]),
-    index2.on(["key", "version"])
+    index2.on(["workflowInstanceId", "executionOrder"]),
+    index2.on(["workflowInstanceId", "workflowStepId"]),
+    index2.on(["status"])
   ],
-  enums: [WorkflowStatusEnum, WorkflowTriggerTypeEnum]
+  enums: [StepExecutionStatusEnum]
 });
 
 // src/entities/step.ts
@@ -311,160 +389,82 @@ var WorkflowStepEntity = defineEntity3({
   enums: [StepTypeEnum, ApprovalModeEnum]
 });
 
-// src/entities/instance.ts
+// src/entities/workflow.ts
 import {
   defineEntity as defineEntity4,
   defineEntityEnum as defineEntityEnum4,
   field as field4,
   index as index4
 } from "@contractspec/lib.schema";
-var InstanceStatusEnum = defineEntityEnum4({
-  name: "InstanceStatus",
-  values: [
-    "PENDING",
-    "RUNNING",
-    "WAITING",
-    "PAUSED",
-    "COMPLETED",
-    "CANCELLED",
-    "FAILED",
-    "TIMEOUT"
-  ],
+var WorkflowStatusEnum = defineEntityEnum4({
+  name: "WorkflowStatus",
+  values: ["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"],
   schema: "workflow",
-  description: "Status of a workflow instance."
+  description: "Status of a workflow definition."
 });
-var StepExecutionStatusEnum = defineEntityEnum4({
-  name: "StepExecutionStatus",
-  values: [
-    "PENDING",
-    "ACTIVE",
-    "COMPLETED",
-    "SKIPPED",
-    "FAILED",
-    "TIMEOUT"
-  ],
+var WorkflowTriggerTypeEnum = defineEntityEnum4({
+  name: "WorkflowTriggerType",
+  values: ["MANUAL", "EVENT", "SCHEDULED", "API"],
   schema: "workflow",
-  description: "Status of a step execution."
+  description: "What triggers workflow instantiation."
 });
-var WorkflowInstanceEntity = defineEntity4({
-  name: "WorkflowInstance",
-  description: "A running instance of a workflow definition.",
+var WorkflowDefinitionEntity = defineEntity4({
+  name: "WorkflowDefinition",
+  description: "A workflow blueprint that defines the process structure.",
   schema: "workflow",
-  map: "workflow_instance",
+  map: "workflow_definition",
   fields: {
-    id: field4.id({ description: "Unique instance ID" }),
-    workflowDefinitionId: field4.foreignKey(),
-    referenceId: field4.string({
-      isOptional: true,
-      description: "External reference (e.g., order ID)"
-    }),
-    referenceType: field4.string({
-      isOptional: true,
-      description: 'Type of reference (e.g., "Order")'
+    id: field4.id({ description: "Unique workflow definition ID" }),
+    name: field4.string({ description: "Human-readable workflow name" }),
+    key: field4.string({
+      description: 'Unique key for referencing (e.g., "purchase_approval")'
     }),
-    status: field4.enum("InstanceStatus", { default: "PENDING" }),
-    currentStepId: field4.string({
+    description: field4.string({
       isOptional: true,
-      description: "Current step being executed"
+      description: "Detailed description"
     }),
-    contextData: field4.json({ description: "Data context for this instance" }),
-    triggeredBy: field4.foreignKey({
-      description: "User who triggered the workflow"
+    version: field4.int({
+      default: 1,
+      description: "Version number for versioning definitions"
     }),
-    triggerSource: field4.string({
+    status: field4.enum("WorkflowStatus", { default: "DRAFT" }),
+    triggerType: field4.enum("WorkflowTriggerType", { default: "MANUAL" }),
+    triggerConfig: field4.json({
       isOptional: true,
-      description: 'Source of trigger (e.g., "api", "ui")'
-    }),
-    organizationId: field4.foreignKey(),
-    priority: field4.int({
-      default: 0,
-      description: "Processing priority (higher = more urgent)"
+      description: "Trigger-specific configuration"
     }),
-    dueAt: field4.dateTime({
+    initialStepId: field4.string({
       isOptional: true,
-      description: "When this instance should complete"
+      description: "First step when workflow starts"
     }),
-    outcome: field4.string({
+    featureFlagKey: field4.string({
       isOptional: true,
-      description: 'Final outcome (e.g., "approved", "rejected")'
+      description: "Feature flag to control availability"
     }),
-    resultData: field4.json({
+    settings: field4.json({
       isOptional: true,
-      description: "Final result data"
+      description: "Workflow-wide settings"
     }),
-    errorMessage: field4.string({
-      isOptional: true,
-      description: "Error message if failed"
+    metadata: field4.json({ isOptional: true, description: "Custom metadata" }),
+    organizationId: field4.foreignKey({ description: "Owning organization" }),
+    createdBy: field4.foreignKey({
+      description: "User who created this workflow"
     }),
     createdAt: field4.createdAt(),
     updatedAt: field4.updatedAt(),
-    startedAt: field4.dateTime({ isOptional: true }),
-    completedAt: field4.dateTime({ isOptional: true }),
-    workflowDefinition: field4.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"]),
-    currentStep: field4.belongsTo("WorkflowStep", ["currentStepId"], ["id"]),
-    stepExecutions: field4.hasMany("StepExecution"),
-    approvalRequests: field4.hasMany("ApprovalRequest")
-  },
-  indexes: [
-    index4.on(["organizationId", "status"]),
-    index4.on(["workflowDefinitionId", "status"]),
-    index4.on(["referenceType", "referenceId"]),
-    index4.on(["triggeredBy", "status"]),
-    index4.on(["status", "dueAt"]),
-    index4.on(["createdAt"])
-  ],
-  enums: [InstanceStatusEnum]
-});
-var StepExecutionEntity = defineEntity4({
-  name: "StepExecution",
-  description: "Execution record of a step within a workflow instance.",
-  schema: "workflow",
-  map: "step_execution",
-  fields: {
-    id: field4.id({ description: "Unique execution ID" }),
-    workflowInstanceId: field4.foreignKey(),
-    workflowStepId: field4.foreignKey(),
-    status: field4.enum("StepExecutionStatus", { default: "PENDING" }),
-    executionOrder: field4.int({
-      default: 0,
-      description: "Order of execution within instance"
-    }),
-    inputData: field4.json({
-      isOptional: true,
-      description: "Data when entering step"
-    }),
-    outputData: field4.json({
-      isOptional: true,
-      description: "Data when exiting step"
-    }),
-    actionTaken: field4.string({
+    publishedAt: field4.dateTime({
       isOptional: true,
-      description: 'Action that caused transition (e.g., "approve")'
-    }),
-    transitionedTo: field4.string({
-      isOptional: true,
-      description: "Step key transitioned to"
-    }),
-    executedBy: field4.string({
-      isOptional: true,
-      description: "User who completed this step"
+      description: "When workflow was activated"
     }),
-    errorMessage: field4.string({ isOptional: true }),
-    errorDetails: field4.json({ isOptional: true }),
-    retryCount: field4.int({ default: 0 }),
-    createdAt: field4.createdAt(),
-    updatedAt: field4.updatedAt(),
-    startedAt: field4.dateTime({ isOptional: true }),
-    completedAt: field4.dateTime({ isOptional: true }),
-    workflowInstance: field4.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
-    workflowStep: field4.belongsTo("WorkflowStep", ["workflowStepId"], ["id"])
+    steps: field4.hasMany("WorkflowStep"),
+    instances: field4.hasMany("WorkflowInstance")
   },
   indexes: [
-    index4.on(["workflowInstanceId", "executionOrder"]),
-    index4.on(["workflowInstanceId", "workflowStepId"]),
-    index4.on(["status"])
+    index4.unique(["organizationId", "key", "version"]),
+    index4.on(["organizationId", "status"]),
+    index4.on(["key", "version"])
   ],
-  enums: [StepExecutionStatusEnum]
+  enums: [WorkflowStatusEnum, WorkflowTriggerTypeEnum]
 });
 // src/entities/index.ts
 var workflowSystemEntities = [

package/dist/example.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/index.js

@@ -55,9 +55,19 @@ function rowToApproval(row) {
   };
 }
 function createWorkflowHandlers(db) {
+  function normalizeSql(sql) {
+    let placeholderIndex = 0;
+    return sql.replace(/\?/g, () => `$${++placeholderIndex}`);
+  }
+  async function queryRows(sql, params = []) {
+    return (await db.query(normalizeSql(sql), params)).rows;
+  }
+  async function execute(sql, params = []) {
+    await db.execute(normalizeSql(sql), params);
+  }
   async function listDefinitions(input) {
     const { projectId, status, search, limit = 20, offset = 0 } = input;
-    let whereClause = "WHERE projectId = ?";
+    let whereClause = 'WHERE "projectId" = ?';
     const params = [projectId];
     if (status && status !== "all") {
       whereClause += " AND status = ?";
@@ -67,9 +77,9 @@ function createWorkflowHandlers(db) {
       whereClause += " AND name LIKE ?";
       params.push(`%${search}%`);
     }
-    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_definition ${whereClause}`, params)).rows;
+    const countResult = await queryRows(`SELECT COUNT(*) as count FROM workflow_definition ${whereClause}`, params);
     const total = countResult[0]?.count ?? 0;
-    const rows = (await db.query(`SELECT * FROM workflow_definition ${whereClause} ORDER BY updatedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_definition ${whereClause} ORDER BY "updatedAt" DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
     return {
       definitions: rows.map(rowToDefinition),
       total
@@ -78,7 +88,7 @@ function createWorkflowHandlers(db) {
   async function createDefinition(input, context) {
     const id = generateId("wfdef");
     const now = new Date().toISOString();
-    await db.execute(`INSERT INTO workflow_definition (id, projectId, organizationId, name, description, type, status, createdAt, updatedAt)
+    await execute(`INSERT INTO workflow_definition (id, "projectId", "organizationId", name, description, type, status, "createdAt", "updatedAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       context.projectId,
@@ -90,15 +100,15 @@ function createWorkflowHandlers(db) {
       now,
       now
     ]);
-    const rows = (await db.query(`SELECT * FROM workflow_definition WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_definition WHERE id = ?`, [id]);
     return rowToDefinition(rows[0]);
   }
   async function addStep(input) {
     const id = generateId("wfstep");
     const now = new Date().toISOString();
-    const maxOrderResult = (await db.query(`SELECT MAX(stepOrder) as maxOrder FROM workflow_step WHERE definitionId = ?`, [input.definitionId])).rows;
+    const maxOrderResult = await queryRows(`SELECT MAX("stepOrder") as maxOrder FROM workflow_step WHERE "definitionId" = ?`, [input.definitionId]);
     const nextOrder = (maxOrderResult[0]?.maxOrder ?? 0) + 1;
-    await db.execute(`INSERT INTO workflow_step (id, definitionId, name, description, stepOrder, type, requiredRoles, autoApproveCondition, timeoutHours, createdAt)
+    await execute(`INSERT INTO workflow_step (id, "definitionId", name, description, "stepOrder", type, "requiredRoles", "autoApproveCondition", "timeoutHours", "createdAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       input.definitionId,
@@ -111,11 +121,11 @@ function createWorkflowHandlers(db) {
       input.timeoutHours ?? null,
       now
     ]);
-    const rows = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_step WHERE id = ?`, [id]);
     return rowToStep(rows[0]);
   }
   async function getSteps(definitionId) {
-    const rows = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder`, [definitionId])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? ORDER BY "stepOrder"`, [definitionId]);
     return rows.map(rowToStep);
   }
   async function listInstances(input) {
@@ -127,10 +137,10 @@ function createWorkflowHandlers(db) {
       limit = 20,
       offset = 0
     } = input;
-    let whereClause = "WHERE projectId = ?";
+    let whereClause = 'WHERE "projectId" = ?';
     const params = [projectId];
     if (definitionId) {
-      whereClause += " AND definitionId = ?";
+      whereClause += ' AND "definitionId" = ?';
       params.push(definitionId);
     }
     if (status && status !== "all") {
@@ -138,12 +148,12 @@ function createWorkflowHandlers(db) {
       params.push(status);
     }
     if (requestedBy) {
-      whereClause += " AND requestedBy = ?";
+      whereClause += ' AND "requestedBy" = ?';
       params.push(requestedBy);
     }
-    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_instance ${whereClause}`, params)).rows;
+    const countResult = await queryRows(`SELECT COUNT(*) as count FROM workflow_instance ${whereClause}`, params);
     const total = countResult[0]?.count ?? 0;
-    const rows = (await db.query(`SELECT * FROM workflow_instance ${whereClause} ORDER BY startedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_instance ${whereClause} ORDER BY "startedAt" DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
     return {
       instances: rows.map(rowToInstance),
       total
@@ -152,9 +162,9 @@ function createWorkflowHandlers(db) {
   async function startInstance(input, context) {
     const id = generateId("wfinst");
     const now = new Date().toISOString();
-    const steps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder LIMIT 1`, [input.definitionId])).rows;
+    const steps = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? ORDER BY "stepOrder" LIMIT 1`, [input.definitionId]);
     const firstStepId = steps[0]?.id ?? null;
-    await db.execute(`INSERT INTO workflow_instance (id, projectId, definitionId, status, currentStepId, data, requestedBy, startedAt)
+    await execute(`INSERT INTO workflow_instance (id, "projectId", "definitionId", status, "currentStepId", data, "requestedBy", "startedAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       context.projectId,
@@ -166,36 +176,32 @@ function createWorkflowHandlers(db) {
       now
     ]);
     if (firstStepId) {
-      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+      await execute(`INSERT INTO workflow_approval (id, "instanceId", "stepId", status, "createdAt")
          VALUES (?, ?, ?, ?, ?)`, [generateId("wfappr"), id, firstStepId, "PENDING", now]);
     }
-    const rows = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [id]);
     return rowToInstance(rows[0]);
   }
   async function approveStep(input, context) {
     const now = new Date().toISOString();
-    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const instances = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     if (!instances[0]) {
       throw new Error("NOT_FOUND");
     }
     const instance = instances[0];
-    await db.execute(`UPDATE workflow_approval SET status = 'APPROVED', actorId = ?, comment = ?, decidedAt = ? 
-       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+    await execute(`UPDATE workflow_approval SET status = 'APPROVED', "actorId" = ?, comment = ?, "decidedAt" = ? 
+       WHERE "instanceId" = ? AND "stepId" = ? AND status = 'PENDING'`, [
       context.actorId,
       input.comment ?? null,
       now,
       input.instanceId,
       instance.currentStepId
     ]);
-    const currentStep = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [
-      instance.currentStepId
-    ])).rows;
-    const nextSteps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? AND stepOrder > ? ORDER BY stepOrder LIMIT 1`, [instance.definitionId, currentStep[0]?.stepOrder ?? 0])).rows;
+    const currentStep = await queryRows(`SELECT * FROM workflow_step WHERE id = ?`, [instance.currentStepId]);
+    const nextSteps = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? AND "stepOrder" > ? ORDER BY "stepOrder" LIMIT 1`, [instance.definitionId, currentStep[0]?.stepOrder ?? 0]);
     if (nextSteps[0]) {
-      await db.execute(`UPDATE workflow_instance SET currentStepId = ? WHERE id = ?`, [nextSteps[0].id, input.instanceId]);
-      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+      await execute(`UPDATE workflow_instance SET "currentStepId" = ? WHERE id = ?`, [nextSteps[0].id, input.instanceId]);
+      await execute(`INSERT INTO workflow_approval (id, "instanceId", "stepId", status, "createdAt")
          VALUES (?, ?, ?, ?, ?)`, [
         generateId("wfappr"),
         input.instanceId,
@@ -204,37 +210,31 @@ function createWorkflowHandlers(db) {
         now
       ]);
     } else {
-      await db.execute(`UPDATE workflow_instance SET status = 'COMPLETED', currentStepId = NULL, completedAt = ? WHERE id = ?`, [now, input.instanceId]);
+      await execute(`UPDATE workflow_instance SET status = 'COMPLETED', "currentStepId" = NULL, "completedAt" = ? WHERE id = ?`, [now, input.instanceId]);
     }
-    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const updated = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     return rowToInstance(updated[0]);
   }
   async function rejectStep(input, context) {
     const now = new Date().toISOString();
-    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const instances = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     if (!instances[0]) {
       throw new Error("NOT_FOUND");
     }
-    await db.execute(`UPDATE workflow_approval SET status = 'REJECTED', actorId = ?, comment = ?, decidedAt = ? 
-       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+    await execute(`UPDATE workflow_approval SET status = 'REJECTED', "actorId" = ?, comment = ?, "decidedAt" = ? 
+       WHERE "instanceId" = ? AND "stepId" = ? AND status = 'PENDING'`, [
       context.actorId,
       input.reason,
       now,
       input.instanceId,
       instances[0].currentStepId
     ]);
-    await db.execute(`UPDATE workflow_instance SET status = 'REJECTED', completedAt = ? WHERE id = ?`, [now, input.instanceId]);
-    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    await execute(`UPDATE workflow_instance SET status = 'REJECTED', "completedAt" = ? WHERE id = ?`, [now, input.instanceId]);
+    const updated = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     return rowToInstance(updated[0]);
   }
   async function getApprovals(instanceId) {
-    const rows = (await db.query(`SELECT * FROM workflow_approval WHERE instanceId = ? ORDER BY createdAt`, [instanceId])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_approval WHERE "instanceId" = ? ORDER BY "createdAt"`, [instanceId]);
     return rows.map(rowToApproval);
   }
   return {