@workglow/task-graph 0.3.1 → 0.3.2

package/dist/bun.js

@@ -1278,14 +1278,14 @@ import { EventEmitter as EventEmitter4, uuid4 as uuid45 } from "@workglow/util";
 import { DirectedAcyclicGraph } from "@workglow/util/graph";
 
 // src/task/GraphAsTask.ts
-import { getLogger as getLogger7 } from "@workglow/util";
+import { getLogger as getLogger6 } from "@workglow/util";
 import { CycleError } from "@workglow/util/graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
-  getLogger as getLogger6,
+  getLogger as getLogger5,
   getTelemetryProvider as getTelemetryProvider2,
   globalServiceRegistry as globalServiceRegistry3,
   ResourceScope as ResourceScope2,
@@ -1630,7 +1630,7 @@ function hasStructuredOutput(schema) {
 }
 
 // src/task/Task.ts
-import { deepEqual, EventEmitter as EventEmitter3, getLogger as getLogger2, uuid4 as uuid42 } from "@workglow/util";
+import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid42 } from "@workglow/util";
 import { compileSchema } from "@workglow/util/schema";
 
 // src/task/TaskRunner.ts
@@ -1901,6 +1901,7 @@ class TaskRunContext {
   telemetrySpan;
   timeoutTimer;
   pendingTimeoutError;
+  terminated = false;
   parentSignalCleanup;
   constructor(parentSignal) {
     this.abortController = new AbortController;
@@ -1955,9 +1956,9 @@ class TaskRunner {
     const ownsScope = config.resourceScope === undefined;
     const effectiveConfig = ownsScope ? { ...config, resourceScope: new ResourceScope({ strategy: config.disposeStrategy }) } : config;
     this.ownsResourceScope = ownsScope;
+    let ctx;
     try {
-      await this.handleStart(effectiveConfig);
-      const ctx = this.currentCtx;
+      ctx = await this.handleStart(effectiveConfig);
       const proto = Object.getPrototypeOf(this.task);
       if (proto.execute === Task.prototype.execute && typeof proto.executeStream !== "function" && proto.executePreview !== Task.prototype.executePreview) {
         throw new TaskConfigurationError(`Task "${this.task.type}" implements only executePreview() and cannot be run via run(). ` + `After the run/runPreview split, run() requires execute() (or executeStream()). ` + `See docs/technical/02-dual-mode-execution.md.`);
@@ -1971,7 +1972,7 @@ class TaskRunner {
           throw new TaskInvalidInputError("Invalid input data");
         }
         if (ctx.abortController.signal.aborted) {
-          await this.handleAbort();
+          await this.handleAbort(ctx);
           throw new TaskAbortedError("Promise for task created and aborted before run");
         }
         const isStreamable = isTaskStreamable(this.task);
@@ -1990,7 +1991,7 @@ class TaskRunner {
           }
           policy = { kind: "none" };
         }
-        this.currentCtx?.telemetrySpan?.setAttributes({
+        ctx.telemetrySpan?.setAttributes({
           "workglow.task.cache_policy": policy.kind
         });
         const keyInputs = await this.cacheCoordinator.buildKeyForPolicy(inputs, this.cacheRegistry, policy);
@@ -2006,12 +2007,30 @@ class TaskRunner {
           await this.cacheCoordinator.saveByPolicy(keyInputs, outputs, this.cacheRegistry, policy);
           this.task.runOutputData = outputs ?? {};
         }
-        await this.handleComplete();
+        await this.handleComplete(ctx);
         return this.task.runOutputData;
       } catch (err) {
-        await this.handleError(err);
+        await this.handleError(err, ctx);
         throw this.task.error instanceof TaskTimeoutError ? this.task.error : err;
       }
+    } catch (err) {
+      if (ctx === undefined) {
+        const partial = this.currentCtx;
+        if (partial) {
+          await this.handleError(err, partial);
+        } else {
+          this.task.status = TaskStatus.FAILED;
+          this.task.error = err instanceof TaskError ? err : new TaskFailedError(`Task "${this.task.type}" (${this.task.id}): ${err?.message || "Task failed"}`);
+          if (this.task.error instanceof TaskError) {
+            this.task.error.taskType ??= this.task.type;
+            this.task.error.taskId ??= this.task.id;
+          }
+          this.task.emit("error", this.task.error);
+          this.task.emit("status", this.task.status);
+        }
+        this.running = false;
+      }
+      throw err;
     } finally {
       if (ownsScope) {
         await effectiveConfig.resourceScope.runComplete();
@@ -2195,7 +2214,7 @@ class TaskRunner {
     const ctx = new TaskRunContext(config.signal);
     this.currentCtx = ctx;
     ctx.abortController.signal.addEventListener("abort", () => {
-      this.handleAbort();
+      this.handleAbort(ctx);
     });
     if (config.registry) {
       this.registry = config.registry;
@@ -2227,12 +2246,12 @@ class TaskRunner {
       await this.resourceScope.runStart();
     }
     if (ctx.abortController.signal.aborted)
-      return;
+      return ctx;
     const timeout = this.task.config.timeout;
     if (timeout !== undefined && timeout > 0) {
       ctx.pendingTimeoutError = new TaskTimeoutError(timeout);
       ctx.timeoutTimer = setTimeout(() => {
-        this.abort();
+        ctx.abortController.abort();
       }, timeout);
     }
     const telemetry = getTelemetryProvider();
@@ -2247,27 +2266,27 @@ class TaskRunner {
     }
     this.task.emit("start");
     this.task.emit("status", this.task.status);
+    return ctx;
   }
   updateProgress = async (_task, _progress, _message, ..._args) => {};
   async handleStartPreview() {
     this.previewRunning = true;
   }
-  clearTimeoutTimer() {
-    const ctx = this.currentCtx;
-    if (ctx?.timeoutTimer !== undefined) {
+  clearTimeoutTimer(ctx) {
+    if (ctx.timeoutTimer !== undefined) {
       clearTimeout(ctx.timeoutTimer);
       ctx.timeoutTimer = undefined;
     }
   }
-  async handleAbort() {
-    if (this.task.status === TaskStatus.ABORTING)
+  async handleAbort(ctx) {
+    if (ctx.terminated)
       return;
-    this.clearTimeoutTimer();
-    const ctx = this.currentCtx;
+    ctx.terminated = true;
+    this.clearTimeoutTimer(ctx);
     this.task.status = TaskStatus.ABORTING;
     await this.handleProgress(100);
-    this.task.error = ctx?.pendingTimeoutError ?? new TaskAbortedError;
-    if (ctx?.telemetrySpan) {
+    this.task.error = ctx.pendingTimeoutError ?? new TaskAbortedError;
+    if (ctx.telemetrySpan) {
       ctx.telemetrySpan.setStatus(SpanStatusCode.ERROR, "aborted");
       ctx.telemetrySpan.addEvent("workglow.task.aborted", {
         "workglow.task.error": this.task.error.message
@@ -2279,28 +2298,30 @@ class TaskRunner {
         await this.task.cleanup();
       } catch {}
     }
-    ctx?.dispose();
-    this.currentCtx = undefined;
+    ctx.dispose();
+    if (this.currentCtx === ctx)
+      this.currentCtx = undefined;
     this.task.emit("abort", this.task.error);
     this.task.emit("status", this.task.status);
   }
   async handleAbortPreview() {
     this.previewRunning = false;
   }
-  async handleComplete() {
-    if (this.task.status === TaskStatus.COMPLETED)
+  async handleComplete(ctx) {
+    if (ctx.terminated)
       return;
-    this.clearTimeoutTimer();
-    const ctx = this.currentCtx;
+    ctx.terminated = true;
+    this.clearTimeoutTimer(ctx);
     this.task.completedAt = new Date;
     this.task.status = TaskStatus.COMPLETED;
     await this.handleProgress(100);
-    if (ctx?.telemetrySpan) {
+    if (ctx.telemetrySpan) {
       ctx.telemetrySpan.setStatus(SpanStatusCode.OK);
       ctx.telemetrySpan.end();
     }
-    ctx?.dispose();
-    this.currentCtx = undefined;
+    ctx.dispose();
+    if (this.currentCtx === ctx)
+      this.currentCtx = undefined;
     this.task.emit("complete");
     this.task.emit("status", this.task.status);
   }
@@ -2308,8 +2329,10 @@ class TaskRunner {
     this.previewRunning = false;
   }
   async handleDisable(ctx) {
-    if (this.task.status === TaskStatus.DISABLED)
+    if (ctx?.terminated || this.task.status === TaskStatus.DISABLED)
       return;
+    if (ctx)
+      ctx.terminated = true;
     this.task.status = TaskStatus.DISABLED;
     await this.handleProgress(100);
     this.task.completedAt = new Date;
@@ -2322,13 +2345,13 @@ class TaskRunner {
   async disable() {
     await this.handleDisable(this.currentCtx);
   }
-  async handleError(err) {
+  async handleError(err, ctx) {
     if (err instanceof TaskAbortedError)
-      return this.handleAbort();
-    if (this.task.status === TaskStatus.FAILED)
+      return this.handleAbort(ctx);
+    if (ctx.terminated)
       return;
-    this.clearTimeoutTimer();
-    const ctx = this.currentCtx;
+    ctx.terminated = true;
+    this.clearTimeoutTimer(ctx);
     if (this.task.hasChildren()) {
       this.task.subGraph.abort();
     }
@@ -2344,13 +2367,14 @@ class TaskRunner {
     }
     this.task.status = TaskStatus.FAILED;
     await this.handleProgress(100);
-    if (ctx?.telemetrySpan) {
+    if (ctx.telemetrySpan) {
       ctx.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
       ctx.telemetrySpan.setAttributes({ "workglow.task.error": this.task.error.message });
       ctx.telemetrySpan.end();
     }
-    ctx?.dispose();
-    this.currentCtx = undefined;
+    ctx.dispose();
+    if (this.currentCtx === ctx)
+      this.currentCtx = undefined;
     this.task.emit("error", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -2379,7 +2403,6 @@ class Task {
   static isGraphOutput = false;
   static isPassthrough = false;
   static hasDynamicEntitlements = false;
-  static __cacheableDeprecationWarned = new Set;
   static entitlements() {
     return EMPTY_ENTITLEMENTS;
   }
@@ -2479,17 +2502,11 @@ class Task {
   }
   getCachePolicy(_inputs) {
     const ctor = this.constructor;
-    const hasLegacyOverride = Object.prototype.hasOwnProperty.call(ctor, "cacheable") && ctor.cacheable === false;
-    const hasPolicyOverride = Object.prototype.hasOwnProperty.call(ctor, "cachePolicy");
-    if (hasLegacyOverride && !hasPolicyOverride) {
-      if (!Task.__cacheableDeprecationWarned.has(ctor.type)) {
-        Task.__cacheableDeprecationWarned.add(ctor.type);
-        getLogger2().warn(`Task "${ctor.type}": static \`cacheable = false\` is deprecated. ` + `Use \`static cachePolicy: CachePolicy = { kind: "none" }\` instead.`);
-      }
-      return { kind: "none" };
-    }
     if (this.runConfig?.cacheable === false || this.config?.cacheable === false)
       return { kind: "none" };
+    if (Object.prototype.hasOwnProperty.call(ctor, "cacheable") && ctor.cacheable === false && !Object.prototype.hasOwnProperty.call(ctor, "cachePolicy")) {
+      return { kind: "none" };
+    }
     return ctor.cachePolicy ?? DEFAULT_CACHE_POLICY;
   }
   defaults;
@@ -2917,9 +2934,12 @@ class Task {
     this.events.emit("regenerate");
   }
 }
+function __resetCacheableDeprecationWarnings() {
+  Task.__cacheableDeprecationWarned.clear();
+}
 
 // src/task-graph/EdgeMaterializer.ts
-import { getLogger as getLogger3 } from "@workglow/util";
+import { getLogger as getLogger2 } from "@workglow/util";
 import { previewSource } from "@workglow/util/media";
 class EdgeMaterializer {
   graph;
@@ -2983,7 +3003,7 @@ class EdgeMaterializer {
       } else {
         const resultsKeys = Object.keys(results);
         if (resultsKeys.length > 0) {
-          getLogger3().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+          getLogger2().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
             dataflowId: dataflow.id,
             compatibility,
             resultsKeys
@@ -3079,10 +3099,10 @@ class RunContext {
 }
 
 // src/task-graph/RunScheduler.ts
-import { getLogger as getLogger5 } from "@workglow/util";
+import { getLogger as getLogger4 } from "@workglow/util";
 
 // src/task/ConditionalTask.ts
-import { getLogger as getLogger4 } from "@workglow/util";
+import { getLogger as getLogger3 } from "@workglow/util";
 
 // src/task/ConditionUtils.ts
 function evaluateCondition(fieldValue, operator, compareValue) {
@@ -3240,7 +3260,7 @@ class ConditionalTask extends Task {
           }
         }
       } catch (error) {
-        getLogger4().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
+        getLogger3().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
       }
     }
     if (this.activeBranches.size === 0 && defaultBranch) {
@@ -3512,7 +3532,7 @@ class RunScheduler {
         ctx.inProgressFunctions.set(Symbol(task.id), runAsync());
       }
     } catch (err) {
-      getLogger5().error("Error running graph", { error: err });
+      getLogger4().error("Error running graph", { error: err });
     }
     await Promise.allSettled(Array.from(ctx.inProgressTasks.values()));
     await Promise.allSettled(Array.from(ctx.inProgressFunctions.values()));
@@ -3915,7 +3935,7 @@ class TaskGraphRunner {
         try {
           await runPrivateToClean.clearRun();
         } catch (e) {
-          getLogger6().warn("RunPrivateCacheRepo.clearRun failed", { error: e });
+          getLogger5().warn("RunPrivateCacheRepo.clearRun failed", { error: e });
         }
       }
       return this.filterLeafResults(results);
@@ -3989,7 +4009,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.OK);
         previewSpan.end();
-        getLogger6().debug("task graph runPreview timings", {
+        getLogger5().debug("task graph runPreview timings", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings
@@ -4007,7 +4027,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.ERROR, message);
         previewSpan.end();
-        getLogger6().debug("task graph runPreview failed", {
+        getLogger5().debug("task graph runPreview failed", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings,
@@ -4140,7 +4160,7 @@ class TaskGraphRunner {
           const repo = checkRegistry.private;
           if (!TaskGraphRunner.__durabilityWarnedRepos.has(repo)) {
             TaskGraphRunner.__durabilityWarnedRepos.add(repo);
-            getLogger6().warn("TaskGraphRunner: private cache repo may be used but is non-durable \u2014 " + "restart-survival will not work. Ensure the CacheRegistry 'private' " + "slot is backed by a durable storage backend.");
+            getLogger5().warn("TaskGraphRunner: private cache repo may be used but is non-durable \u2014 " + "restart-survival will not work. Ensure the CacheRegistry 'private' " + "slot is backed by a durable storage backend.");
           }
         }
       }
@@ -4455,7 +4475,7 @@ class GraphAsTask extends Task {
         const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
         this._inputSchemaNode = schemaNode;
       } catch (error) {
-        getLogger7().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
+        getLogger6().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
         this._inputSchemaNode = compileSchema2({});
       }
     }
@@ -5372,7 +5392,7 @@ function autoConnect(graph, sourceTask, targetTask, options) {
 }
 
 // src/task-graph/LoopBuilderContext.ts
-import { getLogger as getLogger8 } from "@workglow/util";
+import { getLogger as getLogger7 } from "@workglow/util";
 function runLoopAutoConnect(parentGraph, pending) {
   const { parent, iteratorTask } = pending;
   if (parentGraph.getTargetDataflows(parent.id).length !== 0)
@@ -5386,7 +5406,7 @@ function runLoopAutoConnect(parentGraph, pending) {
   const result = autoConnect(parentGraph, parent, iteratorTask, { earlierTasks });
   if (result.error) {
     const message = result.error + " Task not added.";
-    getLogger8().error(message);
+    getLogger7().error(message);
     parentGraph.removeTask(iteratorTask.id);
     return message;
   }
@@ -5425,7 +5445,7 @@ class LoopBuilderContext {
 }
 
 // src/task-graph/WorkflowBuilder.ts
-import { getLogger as getLogger9, uuid4 as uuid47 } from "@workglow/util";
+import { getLogger as getLogger8, uuid4 as uuid47 } from "@workglow/util";
 
 // src/task-graph/ConditionalBuilder.ts
 import { uuid4 as uuid46 } from "@workglow/util";
@@ -5584,7 +5604,7 @@ class WorkflowBuilder {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger9().error(this._error);
+          getLogger8().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -5609,10 +5629,10 @@ class WorkflowBuilder {
       if (result.error) {
         if (this._loopContext !== undefined) {
           this._error = result.error;
-          getLogger9().warn(this._error);
+          getLogger8().warn(this._error);
         } else {
           this._error = result.error + " Task not added.";
-          getLogger9().error(this._error);
+          getLogger8().error(this._error);
           this._facade.graph.removeTask(task.id);
         }
       }
@@ -5635,7 +5655,7 @@ class WorkflowBuilder {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger9().error(this._error);
+          getLogger8().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -5687,7 +5707,7 @@ class WorkflowBuilder {
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
       this._error = errorMsg;
-      getLogger9().error(this._error);
+      getLogger8().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const lastNode = nodes[nodes.length + index];
@@ -5696,13 +5716,13 @@ class WorkflowBuilder {
       if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
         const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
         this._error = errorMsg;
-        getLogger9().error(this._error);
+        getLogger8().error(this._error);
         throw new WorkflowError(errorMsg);
       }
     } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
       const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
       this._error = errorMsg;
-      getLogger9().error(this._error);
+      getLogger8().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const df = new Dataflow(lastNode.id, source, undefined, target);
@@ -5715,7 +5735,7 @@ class WorkflowBuilder {
     const parent = getLastTask(this._facade);
     if (!parent) {
       this._error = "onError() requires a preceding task in the workflow";
-      getLogger9().error(this._error);
+      getLogger8().error(this._error);
       throw new WorkflowError(this._error);
     }
     const handlerTask = ensureTask(handler);
@@ -5729,7 +5749,7 @@ class WorkflowBuilder {
     const nodes = this._facade.graph.getTasks();
     if (nodes.length === 0) {
       this._error = "No tasks to remove";
-      getLogger9().error(this._error);
+      getLogger8().error(this._error);
       return;
     }
     const lastNode = nodes[nodes.length - 1];
@@ -8416,7 +8436,8 @@ function wrapSchemaInArray(schema) {
 import {
   InMemoryQueueStorage,
   JobQueueClient,
-  JobQueueServer
+  JobQueueServer,
+  wrapQueueStorage
 } from "@workglow/job-queue";
 import { createServiceToken as createServiceToken7, globalServiceRegistry as globalServiceRegistry4 } from "@workglow/util";
 var JOB_QUEUE_FACTORY = createServiceToken7("taskgraph.jobQueueFactory");
@@ -8427,8 +8448,10 @@ var defaultJobQueueFactory = async ({
 }) => {
   const storage = options?.storage ?? new InMemoryQueueStorage(queueName);
   await storage.migrate();
+  const { messageQueue, jobStore } = wrapQueueStorage(storage);
   const server = new JobQueueServer(jobClass, {
-    storage,
+    messageQueue,
+    jobStore,
     queueName,
     limiter: options?.limiter,
     workerCount: options?.workerCount,
@@ -8440,7 +8463,8 @@ var defaultJobQueueFactory = async ({
     stopTimeoutMs: options?.stopTimeoutMs
   });
   const client = new JobQueueClient({
-    storage,
+    messageQueue,
+    jobStore,
     queueName
   });
   client.attach(server);
@@ -8461,8 +8485,10 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
     };
     const storage = mergedOptions.storage ?? new InMemoryQueueStorage(queueName);
     await storage.migrate();
+    const { messageQueue, jobStore } = wrapQueueStorage(storage);
     const server = new JobQueueServer(jobClass, {
-      storage,
+      messageQueue,
+      jobStore,
       queueName,
       limiter: mergedOptions.limiter,
       workerCount: mergedOptions.workerCount,
@@ -8474,7 +8500,8 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
       stopTimeoutMs: mergedOptions.stopTimeoutMs
     });
     const client = new JobQueueClient({
-      storage,
+      messageQueue,
+      jobStore,
       queueName
     });
     client.attach(server);
@@ -8685,7 +8712,7 @@ queueMicrotask(() => {
 // src/task/TaskRegistry.ts
 import {
   createServiceToken as createServiceToken8,
-  getLogger as getLogger10,
+  getLogger as getLogger9,
   globalServiceRegistry as globalServiceRegistry5,
   registerInputCompactor,
   registerInputResolver
@@ -8708,7 +8735,7 @@ function registerTask(baseClass) {
     const result = validateSchema(schema);
     if (!result.valid) {
       const messages = result.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
-      getLogger10().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
+      getLogger9().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
         taskType: baseClass.type,
         schemaName: name,
         errors: result.errors
@@ -9200,6 +9227,7 @@ export {
   addBoundaryNodesToGraphJson,
   addBoundaryNodesToDependencyJson,
   _resetPortCodecsForTests,
+  __resetCacheableDeprecationWarnings,
   WorkflowRunContext,
   WorkflowEventBridge,
   WorkflowError,
@@ -9292,4 +9320,4 @@ export {
   BROWSER_GRANTS
 };
 
-//# debugId=E2522767BD1162D964756E2164756E21
+//# debugId=5FDD8EEAEE6A0F2A64756E2164756E21