gencow 0.1.143 → 0.1.145

package/core/index.js

@@ -1374,6 +1374,11 @@ var require_node_cron = __commonJS({
   }
 });
 
+// ../core/src/context.ts
+function defineApi(api) {
+  return api;
+}
+
 // ../core/src/document-types.ts
 function normalizeCachePart(value) {
   return value.trim() || "unknown";
@@ -1841,6 +1846,166 @@ function getRegisteredMutations() {
   return [...mutationRegistry];
 }
 
+// ../core/src/procedure.ts
+function hasStandardSchema(schema) {
+  return !!schema && typeof schema === "object" && "~standard" in schema && !!schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+async function validateWithSchema(schema, value) {
+  if (!schema) return value;
+  if (hasStandardSchema(schema)) {
+    const result = await schema["~standard"].validate(value);
+    if ("issues" in result && result.issues.length > 0) {
+      throw new Error(result.issues[0]?.message ?? "Validation failed");
+    }
+    if ("value" in result) {
+      return result.value;
+    }
+    throw new Error("Validation failed");
+  }
+  throw new Error("procQuery/procMutation only supports Standard Schema v1 validators");
+}
+function composeMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
+  return async (initialContext, initialInput) => {
+    let idx = -1;
+    const boundedInputValidationIndex = Math.min(Math.max(0, inputValidationIndex), middlewares.length);
+    const boundedOutputValidationIndex = Math.min(Math.max(0, outputValidationIndex), middlewares.length);
+    const run = async (currentIdx, context, input) => {
+      if (currentIdx <= idx) {
+        throw new Error("next() called multiple times in the same middleware");
+      }
+      idx = currentIdx;
+      let currentInput = input;
+      if (currentIdx === boundedInputValidationIndex) {
+        currentInput = await validateWithSchema(inputSchema, currentInput);
+      }
+      if (currentIdx === middlewares.length) {
+        const output2 = await handler({ context, input: currentInput });
+        if (currentIdx === boundedOutputValidationIndex) {
+          return await validateWithSchema(outputSchema, output2);
+        }
+        return output2;
+      }
+      const middleware = middlewares[currentIdx];
+      const output = await middleware({
+        context,
+        input: currentInput,
+        next: async (overrides) => {
+          return await run(
+            currentIdx + 1,
+            overrides?.context ?? context,
+            overrides?.input ?? currentInput
+          );
+        }
+      });
+      if (currentIdx === boundedOutputValidationIndex) {
+        return await validateWithSchema(outputSchema, output);
+      }
+      return output;
+    };
+    return await run(0, initialContext, initialInput);
+  };
+}
+var GencowProcedureBuilderImpl = class _GencowProcedureBuilderImpl {
+  constructor(kind, procedureName, middlewares = [], inputSchema, outputSchema, inputValidationIndex = -1, outputValidationIndex = -1, isPublic = false) {
+    this.kind = kind;
+    this.procedureName = procedureName;
+    this.middlewares = middlewares;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+    this.inputValidationIndex = inputValidationIndex;
+    this.outputValidationIndex = outputValidationIndex;
+    this.isPublic = isPublic;
+  }
+  name(name) {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      name,
+      this.middlewares,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      this.isPublic
+    );
+  }
+  allowPublic() {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      true
+    );
+  }
+  use(middleware) {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      [...this.middlewares, middleware],
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      this.isPublic
+    );
+  }
+  input(schema) {
+    const nextInputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      schema,
+      this.outputSchema,
+      nextInputValidationIndex,
+      this.outputValidationIndex,
+      this.isPublic
+    );
+  }
+  output(schema) {
+    const nextOutputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      this.inputSchema,
+      schema,
+      this.inputValidationIndex,
+      nextOutputValidationIndex,
+      this.isPublic
+    );
+  }
+  handler(handler) {
+    if (!this.procedureName) {
+      throw new Error("Procedure name is required. Call .name(...) before .handler(...)");
+    }
+    const run = composeMiddlewares(
+      this.middlewares,
+      handler,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex
+    );
+    return {
+      kind: this.kind,
+      name: this.procedureName,
+      isPublic: this.isPublic,
+      middlewares: [...this.middlewares],
+      inputSchema: this.inputSchema,
+      outputSchema: this.outputSchema,
+      inputValidationIndex: this.inputValidationIndex,
+      outputValidationIndex: this.outputValidationIndex,
+      handler: run
+    };
+  }
+};
+var procQuery = new GencowProcedureBuilderImpl("query");
+var procMutation = new GencowProcedureBuilderImpl("mutation");
+
 // ../core/src/http-action.ts
 if (!globalThis.__gencow_httpActionRegistry) globalThis.__gencow_httpActionRegistry = [];
 var httpActionRegistry = globalThis.__gencow_httpActionRegistry;
@@ -2042,10 +2207,17 @@ function createScheduler(options) {
 }
 
 // ../core/src/workflow.ts
-import { sql as sql2 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 
-// ../core/src/workflows-api.ts
+// ../core/src/workflow-json.ts
 import { sql } from "drizzle-orm";
+function workflowJsonb(value) {
+  const json = JSON.stringify(value ?? {});
+  return sql`${json}::text::jsonb`;
+}
+
+// ../core/src/workflows-api.ts
+import { sql as sql2 } from "drizzle-orm";
 
 // ../core/src/v.ts
 var GencowValidationError = class extends Error {
@@ -2203,6 +2375,7 @@ function mapWorkflowSummary(row) {
     derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
     currentStep: row.current_step,
     error: row.error,
+    errorCode: row.error_code,
     retryCount: row.retry_count,
     maxRetries: row.max_retries,
     maxDurationMs: Number(row.max_duration_ms),
@@ -2253,7 +2426,7 @@ function toWorkflowStatusFilter(status) {
 async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
   if (currentToken && currentToken.trim() !== "") return currentToken;
   const nextToken = createWorkflowRealtimeToken();
-  const updateResult = await db.execute(sql`
+  const updateResult = await db.execute(sql2`
         UPDATE _gencow_workflows
         SET realtime_token = ${nextToken}
         WHERE id = ${workflowId}
@@ -2262,7 +2435,7 @@ async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
     `);
   const updatedToken = rowsFromResult(updateResult)[0]?.realtime_token ?? null;
   if (updatedToken && updatedToken.trim() !== "") return updatedToken;
-  const rereadResult = await db.execute(sql`
+  const rereadResult = await db.execute(sql2`
         SELECT realtime_token
         FROM _gencow_workflows
         WHERE id = ${workflowId}
@@ -2272,7 +2445,7 @@ async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
   return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
 }
 async function loadWorkflowSignalTarget(db, workflowId) {
-  const result = await db.execute(sql`
+  const result = await db.execute(sql2`
         SELECT
             id,
             name,
@@ -2282,11 +2455,58 @@ async function loadWorkflowSignalTarget(db, workflowId) {
         FROM _gencow_workflows
         WHERE id = ${workflowId}
         LIMIT 1
-    `);
+  `);
   return rowsFromResult(result)[0] ?? null;
 }
+function isMissingWorkflowV2SignalSchemaError(error) {
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || (code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2") || message.includes('relation "_gencow_workflow_signals_v2" does not exist') || message.includes("relation _gencow_workflow_signals_v2 does not exist") || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist");
+}
+async function tryRecordWorkflowV2Signal(options) {
+  try {
+    await options.db.execute(sql2`
+      WITH inserted AS (
+        INSERT INTO _gencow_workflow_signals_v2 (
+          id,
+          run_id,
+          event_name,
+          payload_json,
+          idempotency_key
+        )
+        VALUES (
+          ${crypto.randomUUID()},
+          ${options.workflowId},
+          ${options.event},
+          ${workflowJsonb(options.payload)},
+          ${crypto.randomUUID()}
+        )
+        RETURNING run_id
+      )
+      UPDATE _gencow_workflow_runs_v2 run
+      SET
+        status = 'queued',
+        runnable_at = NOW(),
+        lease_owner = NULL,
+        lease_expires_at = NULL,
+        heartbeat_at = NULL,
+        updated_at = NOW()
+      FROM inserted
+      WHERE run.id = inserted.run_id
+        AND run.status = 'waiting'
+        AND run.completed_at IS NULL
+        AND run.cancel_requested_at IS NULL
+    `);
+    return true;
+  } catch (error) {
+    if (isMissingWorkflowV2SignalSchemaError(error)) return false;
+    throw error;
+  }
+}
 async function loadWorkflowSnapshot(db, workflowId, options) {
-  const workflowResult = await db.execute(sql`
+  const workflowResult = await db.execute(sql2`
         SELECT
             id,
             name,
@@ -2295,6 +2515,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
             current_step,
             result,
             error,
+            error_code,
             retry_count,
             max_retries,
             max_duration_ms,
@@ -2315,7 +2536,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
   }
   const realtimeToken = await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token);
   if (!realtimeToken) return null;
-  const stepsResult = await db.execute(sql`
+  const stepsResult = await db.execute(sql2`
         SELECT
             step_name,
             status,
@@ -2380,7 +2601,7 @@ function registerWorkflowsApi() {
         };
       }
       const persistedPayload = serializeWorkflowValue(args.payload);
-      await ctx.unsafeDb.execute(sql`
+      await ctx.unsafeDb.execute(sql2`
                 INSERT INTO _gencow_workflow_events (
                     id,
                     workflow_id,
@@ -2391,9 +2612,15 @@ function registerWorkflowsApi() {
                     ${crypto.randomUUID()},
                     ${workflow2.id},
                     ${normalizedEvent},
-                    ${JSON.stringify(persistedPayload)}::jsonb
+                  ${workflowJsonb(persistedPayload)}
                 )
             `);
+      await tryRecordWorkflowV2Signal({
+        db: ctx.unsafeDb,
+        workflowId: workflow2.id,
+        event: normalizedEvent,
+        payload: persistedPayload
+      });
       let scheduledJobId = null;
       if (workflow2.status === "pending" && workflow2.current_step?.startsWith("wait:")) {
         try {
@@ -2422,7 +2649,7 @@ function registerWorkflowsApi() {
       const limit = normalizeListLimit(args.limit);
       const requestedStatus = normalizeDerivedStatus(args.status);
       const status = toWorkflowStatusFilter(requestedStatus);
-      const result = status == null ? await ctx.unsafeDb.execute(sql`
+      const result = status == null ? await ctx.unsafeDb.execute(sql2`
                     SELECT
                         id,
                         name,
@@ -2431,6 +2658,7 @@ function registerWorkflowsApi() {
                         current_step,
                         result,
                         error,
+                        error_code,
                         retry_count,
                         max_retries,
                         max_duration_ms,
@@ -2442,7 +2670,7 @@ function registerWorkflowsApi() {
                     WHERE user_id = ${userId}
                     ORDER BY started_at DESC
                     LIMIT ${limit}
-                `) : await ctx.unsafeDb.execute(sql`
+                `) : await ctx.unsafeDb.execute(sql2`
                     SELECT
                         id,
                         name,
@@ -2451,6 +2679,7 @@ function registerWorkflowsApi() {
                         current_step,
                         result,
                         error,
+                        error_code,
                         retry_count,
                         max_retries,
                         max_duration_ms,
@@ -2526,9 +2755,96 @@ function parseWorkflowDurationMs(raw, label = "workflow duration") {
   }
   return parseDurationString(raw, label);
 }
-function normalizeMaxDurationMs(maxDuration) {
+function normalizeMaxDurationMs(maxDuration, label = "workflow() maxDuration") {
   if (maxDuration == null) return DEFAULT_WORKFLOW_MAX_DURATION_MS;
-  return parseWorkflowDurationMs(maxDuration, "workflow() maxDuration");
+  return parseWorkflowDurationMs(maxDuration, label);
+}
+function normalizeOptionalDurationMs(duration, label) {
+  return duration == null ? null : parseWorkflowDurationMs(duration, label);
+}
+function normalizeConcurrency(concurrency) {
+  if (concurrency == null) return null;
+  if (!Number.isFinite(concurrency) || concurrency <= 0) {
+    throw new Error(`workflow() concurrency must be a positive finite number, got "${concurrency}"`);
+  }
+  return Math.floor(concurrency);
+}
+function isMissingWorkflowV2SchemaError(error) {
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('column "max_active_duration_ms"') || message.includes('column "retry_count"') || message.includes('column "user_id"');
+}
+async function tryInsertWorkflowV2Run(options) {
+  try {
+    await options.db.execute(sql3`
+      WITH inserted_run AS (
+        INSERT INTO _gencow_workflow_runs_v2 (
+          id,
+          workflow_name,
+          workflow_version,
+          args_json,
+          user_id,
+          max_active_duration_ms,
+          lifecycle_deadline_at,
+          retry_count,
+          max_retries,
+          max_attempts
+        )
+        VALUES (
+          ${options.workflowId},
+          ${options.workflowName},
+          ${options.workflowVersion ?? null},
+          ${workflowJsonb(options.args)},
+          ${options.userId},
+          ${options.maxActiveDurationMs},
+          CASE
+            WHEN ${options.lifecycleTimeoutMs}::bigint IS NULL THEN NULL
+            ELSE NOW() + (${options.lifecycleTimeoutMs}::bigint * INTERVAL '1 millisecond')
+          END,
+          0,
+          ${options.maxRetries},
+          ${options.maxRetries + 1}
+        )
+        RETURNING id
+      ),
+      inserted_outbox AS (
+        INSERT INTO _gencow_workflow_outbox_v2 (
+          id,
+          run_id,
+          kind,
+          available_at,
+          status
+        )
+        SELECT
+          'start:' || inserted_run.id,
+          inserted_run.id,
+          'wake_run',
+          NOW(),
+          'pending'
+        FROM inserted_run
+        ON CONFLICT (id) DO NOTHING
+        RETURNING id
+      )
+      SELECT id
+      FROM inserted_run
+    `);
+    return true;
+  } catch (error) {
+    if (isMissingWorkflowV2SchemaError(error)) return false;
+    throw error;
+  }
+}
+async function tryDeleteWorkflowV2Run(db, workflowId) {
+  try {
+    await db.execute(sql3`
+      DELETE FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError(error)) throw error;
+  }
 }
 function getWorkflowResumeActionName(name) {
   return `${WORKFLOW_RESUME_ACTION_PREFIX}.${name}`;
@@ -2547,13 +2863,24 @@ function getRegisteredWorkflows() {
 }
 function workflow(name, options) {
   registerWorkflowsApi();
-  const maxDurationMs = normalizeMaxDurationMs(options.maxDuration);
+  const maxActiveDurationMs = normalizeMaxDurationMs(
+    options.maxActiveDuration ?? options.maxDuration,
+    options.maxActiveDuration == null ? "workflow() maxDuration" : "workflow() maxActiveDuration"
+  );
+  const lifecycleTimeoutMs = normalizeOptionalDurationMs(
+    options.lifecycleTimeout,
+    "workflow() lifecycleTimeout"
+  );
   const maxRetries = clampRetries(options.retries);
   const def = {
     name,
     argsSchema: options.args,
     isPublic: options.public === true,
-    maxDurationMs,
+    version: options.version,
+    maxDurationMs: maxActiveDurationMs,
+    maxActiveDurationMs,
+    lifecycleTimeoutMs,
+    concurrency: normalizeConcurrency(options.concurrency),
     maxRetries,
     handler: options.handler
   };
@@ -2567,7 +2894,7 @@ function workflow(name, options) {
       const ownerId = ctx.auth.getUserIdentity()?.id ?? null;
       const persistedArgs = serializeWorkflowValue(args ?? {});
       const realtimeToken = createWorkflowRealtimeToken();
-      await ctx.unsafeDb.execute(sql2`
+      await ctx.unsafeDb.execute(sql3`
                 INSERT INTO _gencow_workflows (
                     id,
                     name,
@@ -2582,16 +2909,28 @@ function workflow(name, options) {
                 VALUES (
                     ${workflowId},
                     ${name},
-                    ${JSON.stringify(persistedArgs)}::jsonb,
-                    ${realtimeToken},
-                    'pending',
-                    0,
-                    ${maxRetries},
-                    ${maxDurationMs},
-                    ${ownerId}
+                    ${workflowJsonb(persistedArgs)},
+                  ${realtimeToken},
+                  'pending',
+                  0,
+                  ${maxRetries},
+                  ${maxActiveDurationMs},
+                  ${ownerId}
                 )
             `);
+      let insertedWorkflowV2 = false;
       try {
+        insertedWorkflowV2 = await tryInsertWorkflowV2Run({
+          db: ctx.unsafeDb,
+          workflowId,
+          workflowName: name,
+          workflowVersion: options.version ?? null,
+          args: persistedArgs,
+          userId: ownerId,
+          maxActiveDurationMs,
+          lifecycleTimeoutMs,
+          maxRetries
+        });
         const scheduledJobId = ctx.scheduler.runAfter(0, resumeAction, { workflowId });
         return {
           id: workflowId,
@@ -2600,10 +2939,13 @@ function workflow(name, options) {
           scheduledJobId
         };
       } catch (error) {
-        await ctx.unsafeDb.execute(sql2`
+        await ctx.unsafeDb.execute(sql3`
                     DELETE FROM _gencow_workflows
                     WHERE id = ${workflowId}
                 `);
+        if (insertedWorkflowV2) {
+          await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+        }
         throw error;
       }
     }
@@ -2761,7 +3103,7 @@ function defineConfig(config) {
 }
 
 // ../core/src/rls.ts
-import { sql as sql3 } from "drizzle-orm";
+import { sql as sql4 } from "drizzle-orm";
 import { pgPolicy } from "drizzle-orm/pg-core";
 var _ownerRlsRegistry = /* @__PURE__ */ new WeakMap();
 function getOwnerRlsMeta(table) {
@@ -2777,13 +3119,13 @@ function ownerRls(userIdColumn, options) {
       "[ownerRls] userIdColumn must have a .name property. Ensure you pass a valid Drizzle column reference (e.g. t.userId)."
     );
   }
-  const isOwner = sql3`${userIdColumn} = current_setting('app.current_user_id', true)`;
+  const isOwner = sql4`${userIdColumn} = current_setting('app.current_user_id', true)`;
   const meta = {
     columnName: colName,
     readPublic: options?.read === "public"
   };
   const policies = [
-    pgPolicy("rls-select", { for: "select", using: options?.read === "public" ? sql3`true` : isOwner }),
+    pgPolicy("rls-select", { for: "select", using: options?.read === "public" ? sql4`true` : isOwner }),
     pgPolicy("rls-insert", { for: "insert", withCheck: isOwner }),
     pgPolicy("rls-update", { for: "update", using: isOwner, withCheck: isOwner }),
     pgPolicy("rls-delete", { for: "delete", using: isOwner })
@@ -2793,7 +3135,7 @@ function ownerRls(userIdColumn, options) {
 
 // ../core/src/rls-db.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { sql as sql4 } from "drizzle-orm";
+import { sql as sql5 } from "drizzle-orm";
 var gucNameRe = /^app\.[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/;
 var RESERVED_VARS_KEYS = /* @__PURE__ */ new Set(["app.current_user_id", "app.current_user_role", "app.tenant_id"]);
 function assertSafeGucName(key) {
@@ -2853,7 +3195,7 @@ async function applyRlsSessionVars(client, rls) {
   await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
 }
 async function injectRlsVarsOnTx(tx, rls) {
-  await forEachSetConfig(rls, (name, value) => tx.execute(sql4`SELECT set_config(${name}, ${value}, true)`));
+  await forEachSetConfig(rls, (name, value) => tx.execute(sql5`SELECT set_config(${name}, ${value}, true)`));
 }
 async function withRlsLeasedConnection(leased, rls, fn) {
   try {
@@ -3393,6 +3735,7 @@ export {
   createWorkflowRealtimeToken,
   cronJobs,
   crud,
+  defineApi,
   defineAuth,
   defineConfig,
   deregisterClient,
@@ -3424,6 +3767,8 @@ export {
   parseArgs,
   parseFilterNode,
   parseWorkflowDurationMs,
+  procMutation,
+  procQuery,
   query,
   ragChunks,
   ragCorpora,