@workglow/task-graph 0.0.109 → 0.0.111

package/dist/browser.js

@@ -848,8 +848,8 @@ async function resolveSchemaInputs(input, schema, config) {
         if (typeof value === "string") {
           value = await resolver(value, format, config.registry);
           resolved[key] = value;
-        } else if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
-          const results = await Promise.all(value.map((item) => resolver(item, format, config.registry)));
+        } else if (Array.isArray(value) && value.some((item) => typeof item === "string")) {
+          const results = await Promise.all(value.map((item) => typeof item === "string" ? resolver(item, format, config.registry) : item));
           value = results.filter((result) => result !== undefined);
           resolved[key] = value;
         }
@@ -2199,8 +2199,8 @@ class TaskGraphRunner {
     await this.handleComplete();
     return results;
   }
-  async runGraphReactive(input = {}) {
-    await this.handleStartReactive();
+  async runGraphReactive(input = {}, config) {
+    await this.handleStartReactive(config);
     const results = [];
     try {
       for await (const task of this.reactiveScheduler.tasks()) {
@@ -2583,7 +2583,7 @@ class TaskGraphRunner {
   async handleStart(config) {
     if (config?.registry !== undefined) {
       this.registry = config.registry;
-    } else {
+    } else if (this.registry === undefined) {
       this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
     }
     this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
@@ -2626,10 +2626,13 @@ class TaskGraphRunner {
     logger.time(this.timerLabel);
     this.graph.emit("start");
   }
-  async handleStartReactive() {
+  async handleStartReactive(config) {
     if (this.reactiveRunning) {
       throw new TaskConfigurationError("Graph is already running reactively");
     }
+    if (config?.registry !== undefined) {
+      this.registry = config.registry;
+    }
     this.reactiveScheduler.reset();
     this.reactiveRunning = true;
   }
@@ -3789,11 +3792,12 @@ class TaskGraph {
     return this.runner.runGraph(input, {
       outputCache: config?.outputCache || this.outputCache,
       parentSignal: config?.parentSignal || undefined,
-      accumulateLeafOutputs: config?.accumulateLeafOutputs
+      accumulateLeafOutputs: config?.accumulateLeafOutputs,
+      registry: config?.registry
     });
   }
-  runReactive(input = {}) {
-    return this.runner.runGraphReactive(input);
+  runReactive(input = {}, config = {}) {
+    return this.runner.runGraphReactive(input, config);
   }
   mergeExecuteOutputsToRunOutput(results, compoundMerge) {
     return this.runner.mergeExecuteOutputsToRunOutput(results, compoundMerge);
@@ -4345,7 +4349,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const clone = new TaskGraph;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newTask = new ctor(task.defaults, task.config);
+      const newTask = new ctor(task.defaults, task.config, task.runConfig);
       if (task.hasChildren()) {
         newTask.subGraph = this.cloneGraph(task.subGraph);
       }
@@ -5508,23 +5512,20 @@ class TaskQueueRegistry {
   getQueue(queueName) {
     return this.queues.get(queueName);
   }
-  startQueues() {
+  async startQueues() {
     for (const queue of this.queues.values()) {
-      queue.server.start();
+      await queue.server.start();
     }
-    return this;
   }
-  stopQueues() {
+  async stopQueues() {
     for (const queue of this.queues.values()) {
-      queue.server.stop();
+      await queue.server.stop();
     }
-    return this;
   }
-  clearQueues() {
+  async clearQueues() {
     for (const queue of this.queues.values()) {
-      queue.storage.deleteAll();
+      await queue.storage.deleteAll();
     }
-    return this;
   }
 }
 function getTaskQueueRegistry() {
@@ -5533,10 +5534,10 @@ function getTaskQueueRegistry() {
   }
   return taskQueueRegistry;
 }
-function setTaskQueueRegistry(registry) {
+async function setTaskQueueRegistry(registry) {
   if (taskQueueRegistry) {
-    taskQueueRegistry.stopQueues();
-    taskQueueRegistry.clearQueues();
+    await taskQueueRegistry.stopQueues();
+    await taskQueueRegistry.clearQueues();
   }
   taskQueueRegistry = registry;
 }
@@ -5865,6 +5866,11 @@ queueMicrotask(() => {
   Workflow.prototype.endReduce = CreateEndLoopWorkflow("endReduce");
 });
 // src/task/TaskRegistry.ts
+import {
+  createServiceToken as createServiceToken3,
+  globalServiceRegistry as globalServiceRegistry4,
+  registerInputResolver
+} from "@workglow/util";
 var taskConstructors = new Map;
 function registerTask(baseClass) {
   if (taskConstructors.has(baseClass.type)) {}
@@ -5874,56 +5880,85 @@ var TaskRegistry = {
   all: taskConstructors,
   registerTask
 };
+var TASK_CONSTRUCTORS = createServiceToken3("task.constructors");
+if (!globalServiceRegistry4.has(TASK_CONSTRUCTORS)) {
+  globalServiceRegistry4.register(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
+}
+function getGlobalTaskConstructors() {
+  return globalServiceRegistry4.get(TASK_CONSTRUCTORS);
+}
+function setGlobalTaskConstructors(map) {
+  globalServiceRegistry4.registerInstance(TASK_CONSTRUCTORS, map);
+}
+function getTaskConstructors(registry) {
+  if (!registry)
+    return TaskRegistry.all;
+  return registry.has(TASK_CONSTRUCTORS) ? registry.get(TASK_CONSTRUCTORS) : TaskRegistry.all;
+}
+function resolveTaskFromRegistry(id, _format, registry) {
+  const constructors = getTaskConstructors(registry);
+  const ctor = constructors.get(id);
+  if (!ctor)
+    return;
+  return {
+    name: ctor.type,
+    description: ctor.description ?? "",
+    inputSchema: ctor.inputSchema(),
+    outputSchema: ctor.outputSchema()
+  };
+}
+registerInputResolver("tasks", resolveTaskFromRegistry);
 
 // src/task/TaskJSON.ts
-var createSingleTaskFromJSON = (item, taskRegistry) => {
+var createSingleTaskFromJSON = (item, registry) => {
   if (!item.id)
     throw new TaskJSONError("Task id required");
   if (!item.type)
     throw new TaskJSONError("Task type required");
   if (item.defaults && Array.isArray(item.defaults))
     throw new TaskJSONError("Task defaults must be an object");
-  const taskClass = taskRegistry?.get(item.type) ?? TaskRegistry.all.get(item.type);
+  const constructors = getTaskConstructors(registry);
+  const taskClass = constructors.get(item.type);
   if (!taskClass)
     throw new TaskJSONError(`Task type ${item.type} not found, perhaps not registered?`);
   const taskConfig = {
     ...item.config,
     id: item.id
   };
-  const task = new taskClass(item.defaults ?? {}, taskConfig);
+  const task = new taskClass(item.defaults ?? {}, taskConfig, registry ? { registry } : {});
   return task;
 };
-var createTaskFromDependencyJSON = (item) => {
-  const task = createSingleTaskFromJSON(item);
+var createTaskFromDependencyJSON = (item, registry) => {
+  const task = createSingleTaskFromJSON(item, registry);
   if (item.subtasks && item.subtasks.length > 0) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for CompoundTasks");
     }
-    task.subGraph = createGraphFromDependencyJSON(item.subtasks);
+    task.subGraph = createGraphFromDependencyJSON(item.subtasks, registry);
   }
   return task;
 };
-var createGraphFromDependencyJSON = (jsonItems) => {
+var createGraphFromDependencyJSON = (jsonItems, registry) => {
   const subGraph = new TaskGraph;
   for (const subitem of jsonItems) {
-    subGraph.addTask(createTaskFromDependencyJSON(subitem));
+    subGraph.addTask(createTaskFromDependencyJSON(subitem, registry));
   }
   return subGraph;
 };
-var createTaskFromGraphJSON = (item, taskRegistry) => {
-  const task = createSingleTaskFromJSON(item, taskRegistry);
+var createTaskFromGraphJSON = (item, registry) => {
+  const task = createSingleTaskFromJSON(item, registry);
   if (item.subgraph) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for GraphAsTask");
     }
-    task.subGraph = createGraphFromGraphJSON(item.subgraph, taskRegistry);
+    task.subGraph = createGraphFromGraphJSON(item.subgraph, registry);
   }
   return task;
 };
-var createGraphFromGraphJSON = (graphJsonObj, taskRegistry) => {
+var createGraphFromGraphJSON = (graphJsonObj, registry) => {
   const subGraph = new TaskGraph;
   for (const subitem of graphJsonObj.tasks) {
-    subGraph.addTask(createTaskFromGraphJSON(subitem, taskRegistry));
+    subGraph.addTask(createTaskFromGraphJSON(subitem, registry));
   }
   for (const subitem of graphJsonObj.dataflows) {
     subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
@@ -5937,8 +5972,8 @@ var registerBaseTasks = () => {
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken3, EventEmitter as EventEmitter6 } from "@workglow/util";
-var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
+import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter6 } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken4("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
@@ -5979,9 +6014,11 @@ var TaskGraphPrimaryKeyNames = ["key"];
 class TaskGraphTabularRepository extends TaskGraphRepository {
   type = "TaskGraphTabularRepository";
   tabularRepository;
-  constructor({ tabularRepository }) {
+  registry;
+  constructor({ tabularRepository, registry }) {
     super();
     this.tabularRepository = tabularRepository;
+    this.registry = registry;
   }
   async setupDatabase() {
     await this.tabularRepository.setupDatabase?.();
@@ -5998,7 +6035,7 @@ class TaskGraphTabularRepository extends TaskGraphRepository {
       return;
     }
     const jsonObj = JSON.parse(value);
-    const graph = createGraphFromGraphJSON(jsonObj);
+    const graph = createGraphFromGraphJSON(jsonObj, this.registry);
     this.emit("graph_retrieved", key);
     return graph;
   }
@@ -6096,6 +6133,7 @@ export {
   wrapSchemaInArray,
   whileTaskConfigSchema,
   setTaskQueueRegistry,
+  setGlobalTaskConstructors,
   serialGraph,
   schemaAcceptsArray,
   resolveSchemaInputs,
@@ -6118,6 +6156,7 @@ export {
   hasStructuredOutput,
   graphAsTaskConfigSchema,
   getTaskQueueRegistry,
+  getTaskConstructors,
   getStructuredOutputSchemas,
   getStreamingPorts,
   getPortStreamMode,
@@ -6128,6 +6167,7 @@ export {
   getJobQueueFactory,
   getIterationContextSchemaForType,
   getInputModeFromSchema,
+  getGlobalTaskConstructors,
   getAppendPortId,
   findArrayPorts,
   filterIterationProperties,
@@ -6182,6 +6222,7 @@ export {
   Task,
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
+  TASK_CONSTRUCTORS,
   ReduceTask,
   PROPERTY_ARRAY,
   MapTask,
@@ -6209,4 +6250,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=00AC99F9F04A67EB64756E2164756E21
+//# debugId=5979668511C1CA3D64756E2164756E21