@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/chunk-7ILGCUI6.js

@@ -0,0 +1,154 @@
+import { durationMs } from './chunk-LNUQE6D6.js';
+import { explicitRunRetryPolicy, explicitRetryPolicy } from './chunk-PWIUEWC3.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 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 } : {};
+  }
+  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.1029.1";
+
+export { DURABLE_MARKER, MAX_WORKFLOW_TASK_TIMEOUT_MS, SDK_VERSION, continueAsNewRetryOf, interfaceOf, isDurableWorkflow, jsonSchemaOf, optionalMs, runRetryPolicyOf, toMs, workflow };