@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-C4F5KJTI.js

@@ -0,0 +1,293 @@
+import { durationMs } from './chunk-LNUQE6D6.js';
+import { explicitRunRetryPolicy, explicitRetryPolicy, ACTIVITY_NAME_PATTERN, TASK_QUEUE_NAME_PATTERN } from './chunk-5HIVIV53.js';
+
+// src/durable/durations.ts
+function toMs(value, what = "duration") {
+  const ms = durationMs(value, "ms");
+  if (ms === void 0) throw new TypeError(`${what} "${String(value)}" is not a duration`);
+  return Math.round(ms);
+}
+function optionalMs(value, what) {
+  return value === void 0 ? void 0 : toMs(value, what);
+}
+
+// src/durable/workflow.ts
+var DURABLE_MARKER = "fluidgrids.durable-workflow";
+var MAX_WORKFLOW_TASK_TIMEOUT_MS = 12e4;
+function checkRunOptions(name, options) {
+  const where = `workflow("${name}")`;
+  for (const key of ["executionTimeout", "runTimeout", "workflowTaskTimeout"]) {
+    const value = options[key];
+    if (value !== void 0) toMs(value, `${where} ${key}`);
+  }
+  if (options.workflowTaskTimeout !== void 0 && toMs(options.workflowTaskTimeout) > MAX_WORKFLOW_TASK_TIMEOUT_MS)
+    throw new TypeError(`${where}: workflowTaskTimeout may be at most 120 s`);
+  if (options.versioningBehavior !== void 0 && options.versioningBehavior !== "PINNED" && options.versioningBehavior !== "AUTO_UPGRADE")
+    throw new TypeError(`${where}: versioningBehavior must be PINNED or AUTO_UPGRADE`);
+  const retry = options.retry;
+  if (retry !== void 0) {
+    checkRunRetryKeys(retry, `${where} retry`);
+    if (retry.maxAttempts !== void 0 && (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1))
+      throw new TypeError(`${where}: retry.maxAttempts must be a positive integer`);
+    if (retry.initialDelay !== void 0) toMs(retry.initialDelay, `${where} retry.initialDelay`);
+    if (retry.maxDelay !== void 0) toMs(retry.maxDelay, `${where} retry.maxDelay`);
+    if (retry.backoffMultiplier !== void 0 && !(Number.isFinite(retry.backoffMultiplier) && retry.backoffMultiplier >= 1))
+      throw new TypeError(`${where}: retry.backoffMultiplier must be at least 1`);
+  }
+}
+var KEY = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+function workflow(name, optionsOrFn, maybeFn) {
+  if (typeof name !== "string" || !KEY.test(name))
+    throw new TypeError(
+      `workflow() needs a key of lowercase letters, digits, "-" and "_" (got "${String(name)}")`
+    );
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`workflow("${name}") needs a function`);
+  checkRunOptions(name, options);
+  return Object.freeze({ __fluidgrids: DURABLE_MARKER, name, options, fn });
+}
+function dynamicWorkflow(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`dynamicWorkflow("${name}") needs a function`);
+  const declared = workflow(
+    name,
+    options,
+    (ctx, input) => fn(ctx, ctx.info.workflowFn, input)
+  );
+  return Object.freeze({ ...declared, dynamic: true });
+}
+function isDurableWorkflow(value) {
+  return typeof value === "object" && value !== null && value.__fluidgrids === DURABLE_MARKER && typeof value.fn === "function";
+}
+function isJsonValue(value, depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      return false;
+    return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+  }
+  return false;
+}
+function jsonSchemaOf(schema) {
+  if (schema === void 0) return void 0;
+  const method = schema.toJSONSchema;
+  if (typeof method === "function") {
+    const produced = method.call(schema);
+    return isJsonValue(produced) && typeof produced === "object" && !Array.isArray(produced) && produced !== null ? produced : void 0;
+  }
+  return isJsonValue(schema) && !Array.isArray(schema) && schema !== null && typeof schema === "object" ? schema : void 0;
+}
+function interfaceOf(definition) {
+  const out = {};
+  const input = jsonSchemaOf(definition.options.input);
+  const output = jsonSchemaOf(definition.options.output);
+  if (input) out.input = input;
+  if (output) out.output = output;
+  const signals = definition.options.signals ?? [];
+  if (signals.length > 0) {
+    out.signals = {};
+    for (const signal of signals) {
+      const entry = {};
+      const payload = jsonSchemaOf(signal.schema);
+      if (payload) entry.payload = payload;
+      if (signal.description !== void 0) entry.description = signal.description;
+      out.signals[signal.name] = entry;
+    }
+  }
+  const queries = definition.options.queries ?? [];
+  if (queries.length > 0) {
+    out.queries = {};
+    for (const query of queries)
+      out.queries[query.name] = query.description !== void 0 ? { description: query.description } : {};
+  }
+  const updates = definition.options.updates ?? [];
+  if (updates.length > 0) {
+    out.updates = {};
+    for (const update of updates)
+      out.updates[update.name] = update.description !== void 0 ? { description: update.description } : {};
+  }
+  const open = definition.options.open;
+  if (open !== void 0) {
+    const flags = {};
+    if (open.signals === true) flags.signals = true;
+    if (open.queries === true) flags.queries = true;
+    if (open.updates === true) flags.updates = true;
+    if (Object.keys(flags).length > 0) out.open = flags;
+  }
+  return out;
+}
+var RUN_RETRY_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "maxAttempts",
+  "initialDelay",
+  "backoffMultiplier",
+  "maxDelay",
+  "nonRetryableErrorTypes"
+]);
+var ACTIVITY_RETRY_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "retryDelay",
+  "maxRetries",
+  "retryOnErrorTypes"
+]);
+function checkRunRetryKeys(retry, where) {
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry))
+    throw new TypeError(`${where} must be an object`);
+  for (const key of Object.keys(retry)) {
+    if (RUN_RETRY_OPTION_KEYS.has(key)) continue;
+    const hint = ACTIVITY_RETRY_ONLY_KEYS.has(key) ? " (that is the activity retry shape; a run-level retry takes maxAttempts, initialDelay, backoffMultiplier, maxDelay and nonRetryableErrorTypes)" : "";
+    throw new TypeError(`${where} has an unknown option "${key}"${hint}`);
+  }
+}
+function runRetryPolicyOf(retry) {
+  checkRunRetryKeys(retry, "retry");
+  const policy = {};
+  if (retry.maxAttempts !== void 0) policy.maxAttempts = retry.maxAttempts;
+  if (retry.initialDelay !== void 0)
+    policy.initialDelayMs = toMs(retry.initialDelay, "retry.initialDelay");
+  if (retry.backoffMultiplier !== void 0) policy.backoffMultiplier = retry.backoffMultiplier;
+  if (retry.maxDelay !== void 0) policy.maxDelayMs = toMs(retry.maxDelay, "retry.maxDelay");
+  if (retry.nonRetryableErrorTypes !== void 0)
+    policy.nonRetryableErrorTypes = [...retry.nonRetryableErrorTypes];
+  return explicitRunRetryPolicy(policy);
+}
+function continueAsNewRetryOf(retry) {
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry))
+    throw new TypeError("continueAsNew retry must be an object");
+  const keys = Object.keys(retry);
+  const legacy = keys.some((key) => ACTIVITY_RETRY_ONLY_KEYS.has(key));
+  if (!legacy) return runRetryPolicyOf(retry);
+  if (keys.includes("maxAttempts") || keys.includes("initialDelay"))
+    throw new TypeError(
+      "continueAsNew retry mixes the activity retry shape (retryDelay, maxRetries) with the run-level one (maxAttempts, initialDelay); use the run-level keys"
+    );
+  return explicitRetryPolicy(retry);
+}
+
+// src/generated/version.ts
+var SDK_VERSION = "2026.1030.1";
+
+// src/durable/interceptors.ts
+var INTERCEPTORS_MARKER = "fluidgrids.workflow-interceptors";
+function workflowInterceptors(factory) {
+  if (typeof factory !== "function")
+    throw new TypeError("workflowInterceptors() needs a factory function");
+  return Object.freeze({ __fluidgrids: INTERCEPTORS_MARKER, factory });
+}
+function interceptorsFactoryOf(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (typeof value === "object" && value !== null && value.__fluidgrids === INTERCEPTORS_MARKER && typeof value.factory === "function")
+    return value.factory;
+  return void 0;
+}
+function resolveWorkflowInterceptors(factories) {
+  const inbound = [];
+  const outbound = [];
+  for (const factory of factories) {
+    const made = factory();
+    if (typeof made !== "object" || made === null)
+      throw new TypeError("An interceptors factory must return { inbound?, outbound? }");
+    const lists = made;
+    if (lists.inbound !== void 0) {
+      if (!Array.isArray(lists.inbound))
+        throw new TypeError("interceptors.inbound must be an array");
+      inbound.push(...lists.inbound);
+    }
+    if (lists.outbound !== void 0) {
+      if (!Array.isArray(lists.outbound))
+        throw new TypeError("interceptors.outbound must be an array");
+      outbound.push(...lists.outbound);
+    }
+  }
+  return { inbound, outbound };
+}
+function compose(interceptors, method, terminal) {
+  let next = terminal;
+  for (let index = interceptors.length - 1; index >= 0; index--) {
+    const interceptor = interceptors[index];
+    const fn = interceptor?.[method];
+    if (typeof fn !== "function") continue;
+    const inner = next;
+    const call = fn;
+    next = (input) => call.call(interceptor, input, inner);
+  }
+  return next;
+}
+
+// src/durable/activities.ts
+var ACTIVITY_MARKER = "fluidgrids.activity";
+var ACTIVITY_IMPL_MARKER = "fluidgrids.activity-impl";
+var ACTIVITY_NAME = new RegExp(ACTIVITY_NAME_PATTERN);
+var TASK_QUEUE_NAME = new RegExp(TASK_QUEUE_NAME_PATTERN);
+var DYNAMIC_ACTIVITY_NAME = "*";
+function checkActivityName(name) {
+  if (typeof name !== "string" || !ACTIVITY_NAME.test(name))
+    throw new TypeError(
+      `An activity name must match ${ACTIVITY_NAME_PATTERN} (got "${String(name)}")`
+    );
+}
+function checkTaskQueueName(queue, what = "taskQueue") {
+  if (typeof queue !== "string" || !TASK_QUEUE_NAME.test(queue))
+    throw new TypeError(`${what} must match ${TASK_QUEUE_NAME_PATTERN} (got "${String(queue)}")`);
+}
+function declareActivity(name, options = {}) {
+  checkActivityName(name);
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({ __fluidgrids: ACTIVITY_MARKER, name, options: { ...options } });
+}
+function implementActivity(definition, fn) {
+  if (!isActivityDefinition(definition))
+    throw new TypeError("implementActivity() needs a declareActivity() value");
+  if (typeof fn !== "function") throw new TypeError("implementActivity() needs a function");
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: definition.name,
+    options: definition.options,
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: false
+  });
+}
+function defineActivity(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+  if (typeof fn !== "function") throw new TypeError(`defineActivity("${name}") needs a function`);
+  return implementActivity(declareActivity(name, options), fn);
+}
+function dynamicActivity(fn, options = {}) {
+  if (typeof fn !== "function") throw new TypeError("dynamicActivity() needs a function");
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: DYNAMIC_ACTIVITY_NAME,
+    options: { ...options },
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: true
+  });
+}
+function isActivityDefinition(value) {
+  return typeof value === "object" && value !== null && value.__fluidgrids === ACTIVITY_MARKER && typeof value.name === "string";
+}
+function isActivityImplementation(value) {
+  return isActivityDefinition(value) && value.implementation === ACTIVITY_IMPL_MARKER && typeof value.fn === "function";
+}
+function findActivityImplementation(implementations, name) {
+  return implementations.find((impl) => !impl.dynamic && impl.name === name) ?? implementations.find((impl) => impl.dynamic);
+}
+function executeActivity(implementation, ctx, args, interceptors = []) {
+  const fn = implementation.fn;
+  const run = compose(
+    interceptors,
+    "execute",
+    async (input) => fn(ctx, input.args)
+  );
+  return run({ args, headers: ctx.info.headers, info: ctx.info });
+}
+
+export { ACTIVITY_IMPL_MARKER, ACTIVITY_MARKER, DURABLE_MARKER, DYNAMIC_ACTIVITY_NAME, INTERCEPTORS_MARKER, MAX_WORKFLOW_TASK_TIMEOUT_MS, SDK_VERSION, checkActivityName, checkTaskQueueName, compose, continueAsNewRetryOf, declareActivity, defineActivity, dynamicActivity, dynamicWorkflow, executeActivity, findActivityImplementation, implementActivity, interceptorsFactoryOf, interfaceOf, isActivityDefinition, isActivityImplementation, isDurableWorkflow, jsonSchemaOf, optionalMs, resolveWorkflowInterceptors, runRetryPolicyOf, toMs, workflow, workflowInterceptors };

package/dist/{chunk-IISBRUWJ.js → chunk-G5H32GIG.js}

@@ -1,4 +1,4 @@
-import { HISTORY_PROTOCOL } from './chunk-DJYMDLV5.js';
+import { HISTORY_PROTOCOL } from './chunk-5HIVIV53.js';
 
 function failedTaskResult(cause, message) {
   return {