@sanoma-ai/workflows 0.10.12 → 0.11.1

package/src/login-code.ts

@@ -1,14 +1,15 @@
 import { z } from "zod";
 import { defineWorkflow, type WorkflowDefinition } from "./define.ts";
+import type { Login } from "./config.ts";
 import type { Op } from "./op.ts";
 import { openLoginCode } from "./seal.ts";
 import type { LOGIN_CODE_WORKFLOW } from "./shared.ts";
 
 // The built-in `login-code` workflow: one mail with a sign-in code, through the config's
-// `login.sender`. The app starts it as the runtime's agent `login` (`LOGIN_AGENT`) with the code
-// sealed (`sealLoginCode`), so neither the run's input nor the ledger shows it: the call is
-// recorded with its body as `<text>` (`recorded` in `call.ts`). It is a workflow like any other:
-// the call goes through `ctx`, under the policy, in the ledger.
+// `login.sender`, from its `login.from`. The app starts it as the runtime's agent `login`
+// (`LOGIN_AGENT`) with the code sealed (`sealLoginCode`), so neither the run's input nor the
+// ledger shows it: the call is recorded with its body as `<text>` (`recorded` in `call.ts`). It
+// is a workflow like any other: the call goes through `ctx`, under the policy, in the ledger.
 
 /** An operation on `ctx`. */
 type OpCall = (input: unknown) => Promise<unknown>;
@@ -16,17 +17,26 @@ type OpCall = (input: unknown) => Promise<unknown>;
 /** The workflow's input: to whom, and the code, sealed. */
 const LoginCodeInput = z.object({ to: z.string().min(1), code: z.string().min(1) });
 
-/** What a sign-in code is sent as, for checks before any is: a sender must take it, and the policy is asked about it. */
-export const CODE_MAIL = { to: "person@example.com", subject: "Your sign-in code", text: "<text>" };
+/**
+ * The mail a sign-in code is sent as, from `from`, saying it is `company`'s: the workflow's, and,
+ * with a stand-in `to` and `text`, what is checked before any is sent (a sender must take it, and
+ * the policy is asked about it).
+ */
+export const codeMail = (from: string, company: string, to = "person@example.com", text = "<text>") => ({
+  from,
+  to,
+  subject: `Your ${company} sign-in code`,
+  text,
+});
 
 /** The mail's text: the code, what it is for, and how long it lasts; nothing else, and no link. */
 const textOf = (company: string, code: string) =>
   `Your sign-in code for ${company} is ${code}.\n\n` +
   "It works once, for five minutes. If you did not ask for it, ignore this mail.\n";
 
-/** The login-code workflow for a config: it sends through `sender`, saying it is `company`'s. */
+/** The login-code workflow for a config: it sends through `sender`, from `from`, saying it is `company`'s. */
 export function loginCodeWorkflow(
-  sender: Op,
+  { sender, from }: Login,
   company: string,
 ): WorkflowDefinition<readonly Op[], typeof LoginCodeInput> {
   return defineWorkflow({
@@ -38,11 +48,7 @@ export function loginCodeWorkflow(
     uses: [sender],
     run: async (ctx, input) => {
       const { vendor, resource, name } = sender;
-      const mail = {
-        to: input.to,
-        subject: `Your ${company} sign-in code`,
-        text: textOf(company, openLoginCode(input.code, input.to)),
-      };
+      const mail = codeMail(from, company, input.to, textOf(company, openLoginCode(input.code, input.to)));
       // `ctx` called directly, so the outline places the call.
       return (ctx as unknown as Record<string, Record<string, Record<string, OpCall>>>)[vendor]![resource]![name]!(
         mail,

package/src/op.ts

@@ -530,6 +530,21 @@ export function isOp(x: unknown): x is Op {
   return typeof x === "object" && x !== null && (x as Op).kind === "op";
 }
 
+/**
+ * True when `op`'s input takes `sample` and keeps each of its fields: one that strips a field
+ * takes none of it. A wakeup's `register` and the config's `login.sender` are checked with it.
+ */
+export function keepsInput(op: Op, sample: Record<string, unknown>): boolean {
+  try {
+    const parsed = op.input.safeParse(sample);
+    const data = parsed.data as Record<string, unknown> | undefined;
+    return parsed.success && Object.keys(sample).every((key) => data?.[key] !== undefined);
+  } catch {
+    // An async refinement, which a sync parse cannot run: no input the runtime can check.
+    return false;
+  }
+}
+
 /**
  * What a driver for a connector must implement: every operation, by resource and name. Each
  * function gets the input as the operation's schema parses it and returns what its output

package/src/scenario.ts

@@ -515,6 +515,18 @@ function rulesOf(scope: Scope): { rules: Rule[]; parameterTypes: ParameterTypeSp
         return [c ? { op: c.delete.id, input: { key: name } } : { ...object(resource, name), gone: true }];
       },
     },
+    {
+      kind: "when",
+      source: "{workflow} runs with exactly",
+      takes: TAKES_OBJECT,
+      read: ([name], pickle) => {
+        const { input } = workflowOf(name);
+        return {
+          workflow: name as string,
+          input: input.parse(fieldsFrom(pickle, input, inputOf(name))),
+        };
+      },
+    },
     {
       kind: "when",
       source: "{workflow} runs with",

package/src/wakeup.ts

@@ -1,6 +1,6 @@
 import type { z } from "zod";
 import { hasPath } from "./host.ts";
-import type { Op } from "./op.ts";
+import { keepsInput, type Op } from "./op.ts";
 import type { References, Resource } from "./resource.ts";
 import type { DeclaredResource } from "./resources.ts";
 
@@ -110,21 +110,6 @@ export function checkWakeup(
 /** A registration every register operation must take: the input `checkWakeupOps` tries. */
 const SAMPLE: WakeupRegistration = { at: new Date(0).toISOString() };
 
-/**
- * True when `op`'s input takes `sample` and keeps each of its fields: one that strips a field
- * takes none of it. A wakeup's `register` is checked with it.
- */
-function keepsInput(op: Op, sample: Record<string, unknown>): boolean {
-  try {
-    const parsed = op.input.safeParse(sample);
-    const data = parsed.data as Record<string, unknown> | undefined;
-    return parsed.success && Object.keys(sample).every((key) => data?.[key] !== undefined);
-  } catch {
-    // An async refinement, which a sync parse cannot run: no input the runtime can check.
-    return false;
-  }
-}
-
 /** The host types a wakeup type may name: its `inputs.host` reference's. */
 export const wakeupHostTypes = (type: Pick<Resource, "fields" | "wakeup">): string[] =>
   type.wakeup ? [type.fields.references?.[type.wakeup.inputs.host]?.type ?? []].flat() : [];