@smithers-orchestrator/driver 0.16.0

package/src/index.js

@@ -0,0 +1,31 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./RunOptions.ts").HotReloadOptions} HotReloadOptions */
+/**
+ * @template [Schema=any]
+ * @typedef {import("./OutputAccessor.ts").OutputAccessor<Schema>} OutputAccessor
+ */
+/**
+ * @template T
+ * @typedef {import("./OutputAccessor.ts").InferOutputEntry<T>} InferOutputEntry
+ */
+/** @typedef {import("./OutputKey.ts").OutputKey} OutputKey */
+/** @typedef {import("./OutputSnapshot.ts").OutputSnapshot} OutputSnapshot */
+/** @typedef {import("./RunAuthContext.ts").RunAuthContext} RunAuthContext */
+/** @typedef {import("./RunOptions.ts").RunOptions} RunOptions */
+/** @typedef {import("./RunResult.ts").RunResult} RunResult */
+/** @typedef {import("./RunStatus.ts").RunStatus} RunStatus */
+/** @typedef {import("./SmithersCtxOptions.ts").SmithersCtxOptions} SmithersCtxOptions */
+/**
+ * @template [Schema=unknown]
+ * @typedef {import("./WorkflowDefinition.ts").WorkflowDefinition<Schema>} WorkflowDefinition
+ */
+/**
+ * @template [Schema=unknown]
+ * @typedef {import("./WorkflowDriverOptions.ts").WorkflowDriverOptions<Schema>} WorkflowDriverOptions
+ */
+/** @typedef {import("./WorkflowRuntime.ts").WorkflowRuntime} WorkflowRuntime */
+/** @typedef {import("./WorkflowSession.ts").WorkflowSession} WorkflowSession */
+// @smithers-type-exports-end
+
+export { WorkflowDriver } from "./WorkflowDriver.js";
+export { SmithersCtx } from "./SmithersCtx.js";

package/src/interop.js

@@ -0,0 +1 @@
+export { ignoreSyncError } from "./ignoreSyncError.js";

package/src/normalizeInputRow.js

@@ -0,0 +1,27 @@
+/**
+ * @param {unknown} input
+ * @returns {unknown}
+ */
+export function normalizeInputRow(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const inputObj = /** @type {Record<string, unknown>} */ (input);
+    if (!("payload" in inputObj))
+        return input;
+    const keys = Object.keys(inputObj);
+    const payloadOnly = keys.every((key) => key === "runId" || key === "payload");
+    if (!payloadOnly)
+        return input;
+    const payload = inputObj.payload;
+    if (payload == null)
+        return {};
+    if (typeof payload === "string") {
+        try {
+            return JSON.parse(payload);
+        }
+        catch {
+            return payload;
+        }
+    }
+    return payload;
+}

package/src/task-runtime.js

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("./SmithersTaskRuntime.ts").SmithersTaskRuntime} SmithersTaskRuntime */
+
+const storage = new AsyncLocalStorage();
+/**
+ * @template T
+ * @param {SmithersTaskRuntime} runtime
+ * @param {() => T} execute
+ * @returns {T}
+ */
+export function withTaskRuntime(runtime, execute) {
+    return storage.run(runtime, execute);
+}
+/**
+ * @returns {SmithersTaskRuntime | undefined}
+ */
+export function getTaskRuntime() {
+    return storage.getStore();
+}
+/**
+ * @returns {SmithersTaskRuntime}
+ */
+export function requireTaskRuntime() {
+    const runtime = storage.getStore();
+    if (!runtime) {
+        throw new SmithersError("TASK_RUNTIME_UNAVAILABLE", "Smithers task runtime is only available while a builder step is executing.");
+    }
+    return runtime;
+}

package/src/withAbort.js

@@ -0,0 +1,43 @@
+/**
+ * @returns {Error}
+ */
+function makeAbortError() {
+    const error = new Error("Task aborted");
+    error.name = "AbortError";
+    return error;
+}
+/**
+ * @param {AbortSignal} [signal]
+ */
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw makeAbortError();
+    }
+}
+/**
+ * @param {AbortSignal} [signal]
+ * @returns {Promise<never> | null}
+ */
+function abortPromise(signal) {
+    if (!signal)
+        return null;
+    if (signal.aborted)
+        return Promise.reject(makeAbortError());
+    return new Promise((_, reject) => {
+        signal.addEventListener("abort", () => reject(makeAbortError()), {
+            once: true,
+        });
+    });
+}
+/**
+ * @template T
+ * @param {Promise<T> | T} value
+ * @param {AbortSignal} [signal]
+ * @returns {Promise<T>}
+ */
+export async function withAbort(value, signal) {
+    throwIfAborted(signal);
+    const abort = abortPromise(signal);
+    const promise = Promise.resolve(value);
+    return abort ? Promise.race([promise, abort]) : promise;
+}

package/src/withLogicalIterationShortcuts.js

@@ -0,0 +1,46 @@
+/**
+ * @param {Record<string, number>} [iterations]
+ * @returns {Record<string, number> | undefined}
+ */
+export function withLogicalIterationShortcuts(iterations) {
+    if (!iterations)
+        return iterations;
+    const logicalIdsWithScope = new Set();
+    for (const id of Object.keys(iterations)) {
+        const atIdx = id.indexOf("@@");
+        if (atIdx >= 0) {
+            logicalIdsWithScope.add(id.slice(0, atIdx));
+        }
+    }
+    if (logicalIdsWithScope.size === 0)
+        return iterations;
+    const normalized = { ...iterations };
+    for (const logicalId of logicalIdsWithScope) {
+        normalized[logicalId] = 0;
+    }
+    for (const [id, iter] of Object.entries(iterations)) {
+        const atIdx = id.indexOf("@@");
+        if (atIdx < 0)
+            continue;
+        const logicalId = id.slice(0, atIdx);
+        const scopeSuffix = id.slice(atIdx + 2);
+        let isCurrentScope = true;
+        for (const part of scopeSuffix.split(",")) {
+            const eqIdx = part.indexOf("=");
+            if (eqIdx < 0) {
+                isCurrentScope = false;
+                break;
+            }
+            const ancestorId = part.slice(0, eqIdx);
+            const ancestorIter = Number(part.slice(eqIdx + 1));
+            if (normalized[ancestorId] !== ancestorIter) {
+                isCurrentScope = false;
+                break;
+            }
+        }
+        if (isCurrentScope) {
+            normalized[logicalId] = iter;
+        }
+    }
+    return normalized;
+}

package/src/workflow-types.ts

@@ -0,0 +1,20 @@
+export type {
+  EngineDecision,
+  RenderContext,
+  TaskOutput,
+  WaitReason,
+} from "@smithers-orchestrator/scheduler";
+export type { RunResult } from "@smithers-orchestrator/scheduler";
+export type { ContinueAsNewHandler } from "./ContinueAsNewHandler.ts";
+export type { CreateWorkflowSession } from "./CreateWorkflowSession.ts";
+export type { CreateWorkflowSessionOptions } from "./CreateWorkflowSessionOptions.ts";
+export type { SchedulerWaitHandler } from "./SchedulerWaitHandler.ts";
+export type { TaskExecutor } from "./TaskExecutor.ts";
+export type { TaskExecutorContext } from "./TaskExecutorContext.ts";
+export type { WaitHandler } from "./WaitHandler.ts";
+export type { WorkflowRuntime } from "./WorkflowRuntime.ts";
+export type { WorkflowSession } from "./WorkflowSession.ts";
+export type { WorkflowDriverOptions } from "./WorkflowDriverOptions.ts";
+export type { WorkflowDefinition } from "./WorkflowDefinition.ts";
+export type { WorkflowGraphRenderer } from "./WorkflowGraphRenderer.ts";
+