zitejs 0.9.131 → 0.9.132

package/dist/esm/start/workflowModules.js

@@ -0,0 +1,3 @@
+// Replaced at build by zite() with a lazy import of every app module that
+// mentions createWorkflow. Empty wherever the plugin didn't build the app.
+export const workflowModules = {};

package/dist/esm/start/workflowRun.d.ts

@@ -0,0 +1,80 @@
+import { type Workflow } from "./workflow.js";
+export type TriggerReport = {
+    handled: string[];
+    cursor?: string;
+};
+export type WorkflowRunResult = {
+    ok: true;
+    output: unknown;
+    trigger?: TriggerReport;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+    trigger?: TriggerReport;
+};
+/**
+ * Splits the platform's state out of the input. A poll or a provider delivery
+ * with a cursor gets `seen`, `handled` and `advance`. Handled ids are reported
+ * whether or not the run throws, so an item acted on is never acted on again;
+ * the staged cursor only on success. Only ids the incoming `seen` lacked are
+ * reported: billing reads an empty list as a run that found nothing new.
+ */
+export declare function triggerContext(workflow: Workflow, rawInput: unknown): {
+    input: unknown;
+    trigger?: undefined;
+    report?: undefined;
+} | {
+    input: {
+        [x: string]: unknown;
+    };
+    trigger: {
+        provider: string;
+        deliveryId?: string | undefined;
+        headers: Record<string, unknown>;
+    } | {
+        headers?: undefined;
+    } | {
+        headers: {};
+    };
+    report?: undefined;
+} | {
+    input: {
+        [x: string]: unknown;
+    };
+    trigger: {
+        provider: string;
+        deliveryId?: string | undefined;
+        headers: Record<string, unknown>;
+        cursor: string | null;
+        seen: (id: string) => boolean;
+        handled: (id: string) => void;
+        advance: (cursor: string) => void;
+    } | {
+        headers?: undefined;
+        cursor: string | null;
+        seen: (id: string) => boolean;
+        handled: (id: string) => void;
+        advance: (cursor: string) => void;
+    } | {
+        headers: {};
+        cursor: string | null;
+        seen: (id: string) => boolean;
+        handled: (id: string) => void;
+        advance: (cursor: string) => void;
+    };
+    report: (succeeded: boolean) => TriggerReport;
+};
+/** Runs the handler in a workflow access scope: no user, and data calls allowed. */
+export declare function runWorkflow(workflow: Workflow, rawInput: unknown): Promise<WorkflowRunResult>;
+export type LoadedWorkflow = {
+    id: string;
+    file: string;
+    workflow: Workflow;
+};
+/** Every exported workflow in the app, by export name. */
+export declare function loadWorkflows(modules?: Record<string, () => Promise<Record<string, unknown>>>): Promise<LoadedWorkflow[]>;
+/** The input as the run log keeps it: a trigger's `seen` list can hold thousands of ids. */
+export declare const loggedInput: (rawInput: unknown) => unknown;

package/dist/esm/start/workflowRun.js

@@ -0,0 +1,107 @@
+// Server-only: runs a workflow the host invoked. Takes the same platform input
+// as classic triggered endpoints (`__cron`, `__poll`, `__webhook`), so the
+// runner's schedules, polls and provider deliveries work unchanged.
+import { errorOf } from "./runLog.js";
+import { runInScope } from "./scope.js";
+import { isWorkflow } from "./workflow.js";
+import { workflowModules } from "./workflowModules.js";
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+const idOf = (id) => {
+    if (typeof id !== "string" && typeof id !== "number")
+        throw new TypeError(`trigger ids must be strings, got ${typeof id}`);
+    const value = String(id);
+    if (value.length === 0 || value.length > 512)
+        throw new TypeError("trigger ids must be 1 to 512 characters");
+    return value;
+};
+/**
+ * Splits the platform's state out of the input. A poll or a provider delivery
+ * with a cursor gets `seen`, `handled` and `advance`. Handled ids are reported
+ * whether or not the run throws, so an item acted on is never acted on again;
+ * the staged cursor only on success. Only ids the incoming `seen` lacked are
+ * reported: billing reads an empty list as a run that found nothing new.
+ */
+export function triggerContext(workflow, rawInput) {
+    const raw = asRecord(rawInput);
+    const { __cron, __poll, __webhook, ...input } = raw ?? {};
+    const declared = workflow.config.trigger;
+    if (!declared)
+        return { input: raw ? input : rawInput };
+    const poll = asRecord(__poll);
+    const webhook = asRecord(__webhook);
+    const delivery = typeof webhook?.provider === "string" ? webhook : null;
+    // A run with no trigger state, such as a manual one, still gets a trigger: an empty one.
+    const info = delivery
+        ? {
+            headers: asRecord(delivery.headers) ?? {},
+            ...(typeof delivery.deliveryId === "string" ? { deliveryId: delivery.deliveryId } : {}),
+            provider: delivery.provider,
+        }
+        : declared.every
+            ? {}
+            : { headers: {} };
+    if (!poll && declared.events)
+        return { input, trigger: info };
+    const state = poll ?? delivery ?? {};
+    const known = new Set(Array.isArray(state.seen) ? state.seen.map(String) : []);
+    const handled = [];
+    let staged;
+    const trigger = {
+        cursor: typeof state.cursor === "string" ? state.cursor : null,
+        seen: (id) => known.has(String(id)),
+        handled: (id) => {
+            const value = idOf(id);
+            if (known.has(value))
+                return;
+            known.add(value);
+            handled.push(value);
+        },
+        advance: (cursor) => {
+            if (typeof cursor !== "string" || cursor.length > 4096) {
+                throw new TypeError("trigger.advance takes a string of at most 4096 characters");
+            }
+            staged = cursor;
+        },
+        ...info,
+    };
+    const report = (succeeded) => ({
+        handled: handled.slice(-2000),
+        ...(succeeded && staged !== undefined ? { cursor: staged } : {}),
+    });
+    return { input, trigger, report };
+}
+/** Runs the handler in a workflow access scope: no user, and data calls allowed. */
+export async function runWorkflow(workflow, rawInput) {
+    const { input, trigger, report } = triggerContext(workflow, rawInput);
+    const args = { input, ...(trigger ? { trigger } : {}) };
+    try {
+        const output = await runInScope({ kind: "workflow", user: null }, () => workflow.handler(args));
+        return { ok: true, output, ...(report ? { trigger: report(true) } : {}) };
+    }
+    catch (error) {
+        return { ok: false, error: errorOf(error), ...(report ? { trigger: report(false) } : {}) };
+    }
+}
+/** Every exported workflow in the app, by export name. */
+export async function loadWorkflows(modules = workflowModules) {
+    const found = [];
+    for (const [file, load] of Object.entries(modules)) {
+        for (const [id, value] of Object.entries(await load()))
+            if (isWorkflow(value))
+                found.push({ id, file, workflow: value });
+    }
+    return found;
+}
+/** The input as the run log keeps it: a trigger's `seen` list can hold thousands of ids. */
+export const loggedInput = (rawInput) => {
+    const raw = asRecord(rawInput);
+    if (!raw)
+        return rawInput;
+    const out = { ...raw };
+    for (const key of ["__poll", "__webhook"]) {
+        const state = asRecord(raw[key]);
+        if (state && Array.isArray(state.seen))
+            out[key] = { ...state, seen: `[${state.seen.length} ids]` };
+    }
+    return out;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.131",
+  "version": "0.9.132",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,