@sanoma-ai/workflows 0.9.0 → 0.9.1

package/src/cucumber.ts

@@ -173,7 +173,8 @@ const literal = (path: string) => path.replaceAll(/[*?[\]()+@]/g, "[$&]").replac
  * examples row at that line. `makeWorld` makes each scenario's World, given the report so far
  * (every file and pickle, read before the first scenario starts). A dry run matches the steps
  * and runs none. A step's error that is a bug in code (`isBug`) is rethrown once the run is
- * over, rather than reported as the step's failure.
+ * over, rather than reported as the step's failure. `timeoutMs` is how long a step may take
+ * (Cucumber's 5 s by default).
  */
 export async function runFeatures(
   library: ISupportCodeLibrary,
@@ -184,7 +185,15 @@ export async function runFeatures(
     line,
     dryRun = false,
     isBug,
-  }: { cwd: string; files: string[]; line?: number; dryRun?: boolean; isBug: (err: unknown) => boolean },
+    timeoutMs,
+  }: {
+    cwd: string;
+    files: string[];
+    line?: number;
+    dryRun?: boolean;
+    isBug: (err: unknown) => boolean;
+    timeoutMs?: number;
+  },
 ): Promise<Report> {
   const report: Report = { query: new Query(), texts: new Map(), parseErrors: [] };
   let bug: unknown;
@@ -200,7 +209,11 @@ export async function runFeatures(
   }
   const configuration: IRunOptions = {
     sources: { defaultDialect: "en", paths: files.map(literal), names: [], tagExpression: "", order: "defined" },
-    support: { ...library, World } as ISupportCodeLibrary,
+    support: {
+      ...library,
+      World,
+      ...(timeoutMs !== undefined && { defaultTimeout: timeoutMs }),
+    } as ISupportCodeLibrary,
     runtime: {
       dryRun,
       failFast: false,

package/src/resource.ts

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { checkDatabase, type DatabaseSpec } from "./database.ts";
+import { isRunControlError } from "./errors.ts";
 import { checkHost, type HostSpec } from "./host.ts";
 import { type Connector, type OpSpec, RESOURCE, VENDOR } from "./op.ts";
 import { isSanomaSecret, isSecret, type Secret } from "./secret.ts";
+import { errorMessage } from "./shared.ts";
 import { checkWakeup, type WakeupSpec } from "./wakeup.ts";
 
 /** Which fields of a resource are flagged, by dotted path (`pages.html_url`; a list's items have no index). */
@@ -123,6 +125,47 @@ export interface AfterCreate {
   until?: (output: any) => boolean;
 }
 
+/** How long apply waits between calls of an `afterCreate` operation with `until`, and how many calls it makes. */
+export const AFTER_CREATE_SECONDS = 5;
+export const AFTER_CREATE_CALLS = 120;
+/** How long an `afterCreate` operation may be polled, in all, in milliseconds. */
+export const AFTER_CREATE_MS = AFTER_CREATE_SECONDS * AFTER_CREATE_CALLS * 1000;
+
+/** Why an `afterCreate` operation with `until` did not pass: the time it was given, and its last call's error if that failed. */
+export const afterCreateStuck = (op: string, failed: unknown): string =>
+  `${op} did not pass in ${AFTER_CREATE_MS / 60_000} minutes` +
+  (failed === undefined ? "" : `; its last call failed: ${errorMessage(failed)}`);
+
+/**
+ * Calls one `afterCreate` operation for a new object as apply does: with `until`, again every
+ * few seconds until its output passes, a call that fails meanwhile being one that did not pass;
+ * without, once, a failure thrown. Returns why it did not pass, if it did not. Apply inlines the
+ * same loop in its `run`, which may not close over its `ctx`; an operation's own test calls this.
+ */
+export async function callAfterCreate(
+  hook: AfterCreate,
+  made: { id: string; export: string },
+  call: (op: string, input: unknown) => Promise<unknown>,
+  sleep: (seconds: number) => Promise<void>,
+): Promise<string | undefined> {
+  const given = hook.input(made);
+  let output: unknown;
+  let failed: unknown;
+  for (let n = 0; n < AFTER_CREATE_CALLS && (n === 0 || (hook.until && !hook.until(output))); n++) {
+    if (n > 0) await sleep(AFTER_CREATE_SECONDS);
+    try {
+      output = await call(hook.op, given);
+      failed = undefined;
+    } catch (err) {
+      if (isRunControlError(err) || !hook.until) throw err;
+      output = undefined;
+      failed = err;
+    }
+  }
+  if (hook.until && !hook.until(output)) return afterCreateStuck(hook.op, failed);
+  return undefined;
+}
+
 /**
  * Where a declared resource keeps its brand, its type's `<vendor>.<type>`: a symbol, so a field
  * holding a resource is told from data; a registered one (`Symbol.for`), so a copy of this

package/src/sandbox.ts

@@ -109,7 +109,11 @@ export async function seedSandbox(run: Run, name: string): Promise<void> {
         });
       }
       const fakes = new Map([...state.fakes].map(([vendor, make]) => [vendor, make()]));
-      const drivers = indexDrivers([...Array.from(fakes.values(), (f) => f.driver), ...sandboxDrivers], state.ops);
+      // The built-ins first, so a connector's fake that implements one of their operations wins.
+      const drivers = indexDrivers(
+        [...sandboxDrivers(state.ops), ...Array.from(fakes.values(), (f) => f.driver)],
+        state.ops,
+      );
       const uses = opIdsOf(state.workflows.get(run.workflow)!);
       const seeding = scenario.given.flatMap((g) => ("op" in g ? [g.op] : []));
       const missing = [...new Set([...uses, ...seeding])].filter((id) => !drivers.has(id));

package/src/scenario.ts

@@ -34,7 +34,7 @@ import type { LedgerRecord } from "./ledger.ts";
 import type { Driver, Op } from "./op.ts";
 import { type OutlineNode, outlineWorkflow } from "./outline.ts";
 import { isDirectory, kindDirs, SCENARIOS_DIR } from "./paths.ts";
-import { isObject } from "./resource.ts";
+import { AFTER_CREATE_MS, callAfterCreate, isObject } from "./resource.ts";
 import { admit, type DeclaredPeople, readPeople } from "./resources.ts";
 import { memorySecrets } from "./secret.ts";
 import {
@@ -903,11 +903,19 @@ function viewOf(records: readonly LedgerRecord[]): RunView {
   return { records, calls, seeded, made: (op) => [...seeded(op), ...calls(op)] };
 }
 
+/** How long a step of an operation's own test may take live: a `Given` may seed an object as apply makes it, its `afterCreate` polled. */
+export const FEATURE_STEP_MS = AFTER_CREATE_MS + 60_000;
+
 /** Where an operation's own test makes its calls: an operation's driver, live, replayed or a fake's, and the fake. */
 export interface FeatureTarget {
   driver: Driver;
   /** The fake whose driver it is: a scenario's faults need one. */
   fake?: Fake<any, any>;
+  /**
+   * The driver calls the vendor: a seed's `afterCreate` waits between its calls as apply's do,
+   * and a step may take `FEATURE_STEP_MS`. Replayed or on a fake, the calls answer at once.
+   */
+  live?: boolean;
 }
 
 /** Why no step, or two, match a step's text. */
@@ -1030,12 +1038,13 @@ function checkWorld(built: Built, workflow: string, view: RunView, verdicts: Map
  * A World for an operation's own test: `Given` steps seed through the target, `When` steps call
  * its operations directly (no worker, no policy), and `Then` steps fail when they do not hold.
  */
-function testWorld(built: Built, { driver, fake }: FeatureTarget) {
+function testWorld(built: Built, { driver, fake, live }: FeatureTarget) {
   return (report: Report): SanomaWorld => {
     // What the steps named (`as`), and the calls made, as a run's ledger would hold them.
     const values = new Map<string, unknown>();
     const records: LedgerRecord[] = [];
     let runId = "";
+    let calls = 0;
     // The test's own secrets, in memory: a driver resolves `secret()` markers against them.
     const secrets = memorySecrets();
     /** A record of the test, as a run's ledger would hold it. */
@@ -1051,7 +1060,8 @@ function testWorld(built: Built, { driver, fake }: FeatureTarget) {
       const input = op.input.parse(resolve(given, values));
       const fn = driver.ops[`${op.resource}.${op.name}`];
       if (!fn) throw new Error(`the driver under test does not implement ${id}`);
-      const context = { idempotencyKey: `${runId}:${records.length}`, runId, opId: id, attempt: 1, secrets };
+      // A key of its own per call: a fake answers a repeated key with its remembered reply.
+      const context = { idempotencyKey: `${runId}:${++calls}`, runId, opId: id, attempt: 1, secrets };
       return { op, input, output: () => fn(input, context) };
     };
     return {
@@ -1076,6 +1086,37 @@ function testWorld(built: Built, { driver, fake }: FeatureTarget) {
               const output = await made.output();
               if (item.as !== undefined) values.set(item.as, output);
               seeds.push({ op: item.op, input: made.input, output });
+              // A resource type's create seeds the object as apply makes it: the type's `afterCreate`
+              // calls follow, each polled as apply polls it, the seed's name (else the type's) its export.
+              const type =
+                made.op.name === "create" ? built.scope.types.get(`${made.op.vendor}.${made.op.resource}`) : undefined;
+              const id = (output as { id?: unknown } | undefined)?.id;
+              if (type?.afterCreate?.length && typeof id !== "string") {
+                throw new Error(`"${text}": ${item.op} returned no id for its afterCreate`);
+              }
+              for (const hook of type?.afterCreate ?? []) {
+                // One the target cannot call fails at once: polled, its error would read as not passing yet.
+                const polled = built.scope.ops.get(hook.op);
+                if (!polled || !driver.ops[`${polled.resource}.${polled.name}`]) {
+                  throw new Error(
+                    `"${text}": the driver under test does not implement ${hook.op}, an afterCreate of ${item.op}`,
+                  );
+                }
+                const stuck = await callAfterCreate(
+                  hook,
+                  { id: id as string, export: item.as ?? made.op.resource },
+                  async (op, input) => {
+                    const after = call(op, input);
+                    const out = await after.output();
+                    seeds.push({ op, input: after.input, output: out });
+                    return out;
+                  },
+                  async (seconds) => {
+                    if (live) await delay(seconds * 1000);
+                  },
+                );
+                if (stuck !== undefined) throw new Error(`"${text}": ${stuck}`);
+              }
             }
             if (seeds.length) record({ type: "scenario.seeded", scenario: "", seeds });
             return;
@@ -1442,6 +1483,7 @@ export async function testFeature(scope: Scope, file: string, line: number, targ
     files: [name],
     line,
     isBug,
+    timeoutMs: target.live ? FEATURE_STEP_MS : undefined,
   });
   if (report.parseErrors.length) throw new Error(report.parseErrors.map(parseErrorOf).join("\n"));
   const results = stepResults(report);

package/src/source.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import { z } from "zod";
 import type { PermissionsGrid } from "./grid.ts";
@@ -155,6 +156,19 @@ export const sourceDriver = defineDriver(sourceOps, {
 
 const COMMIT = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
 
+/**
+ * The fake of `sanoma.source.resolve`, which a sandbox run calls (`sandboxDrivers`): no git and no
+ * network, a full commit id is itself as the driver has it, and any other ref the SHA-1 of
+ * `<url>#<ref>`, so a scenario's revisions are the same on every run.
+ */
+export const fakeSourceDriver = defineDriver(sourceOps, {
+  source: {
+    resolve: async ({ url, ref }) => ({
+      revision: COMMIT.test(ref) ? ref : createHash("sha1").update(`${url}#${ref}`).digest("hex"),
+    }),
+  },
+});
+
 /** The commit `ref` (a branch, a tag, `HEAD`, a full ref or a commit id) names in the repository at `url`. */
 export async function resolveRevision(url: string, ref: string): Promise<string> {
   if (COMMIT.test(ref)) return ref;

package/src/steps.ts

@@ -14,7 +14,9 @@ type AnyOp<I = any, O = any> = Op<string, string, string, I, O>;
  * What a `Given` step sets up before the run: a call through an operation of the run's fake,
  * with the fields of its input to set (the rest is made up), or a fault to inject into its next
  * call. `as` names a call's output, so a later step's table of an operation's own test can use
- * its fields: `$draft.id`.
+ * its fields: `$draft.id`. In an operation's own test, a resource type's `create` seeds the object
+ * as apply makes it: the type's `afterCreate` calls follow, each polled as apply polls it, the
+ * seed's name (else the type's) as the export.
  */
 export type Seed =
   | { op: AnyOp; input: Record<string, unknown>; as?: string }