@workglow/task-graph 0.0.57 → 0.0.58

package/dist/bun.js

@@ -780,6 +780,7 @@ class Task {
     let json = this.stripSymbols({
       id: this.config.id,
       type: this.type,
+      ...this.config.name ? { name: this.config.name } : {},
       defaults: this.defaults,
       ...Object.keys(provenance).length ? { provenance } : {},
       ...extras && Object.keys(extras).length ? { extras } : {}
@@ -2401,27 +2402,70 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   }
 }
 // src/task/JobQueueFactory.ts
-import { JobQueue } from "@workglow/job-queue";
+import {
+  JobQueueClient,
+  JobQueueServer
+} from "@workglow/job-queue";
 import { InMemoryQueueStorage } from "@workglow/storage";
 import { createServiceToken as createServiceToken2, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
 var JOB_QUEUE_FACTORY = createServiceToken2("taskgraph.jobQueueFactory");
-var defaultJobQueueFactory = async ({ queueName, jobClass, options }) => {
-  const queueOptions = {
-    ...options ?? {}
-  };
-  queueOptions.storage ??= new InMemoryQueueStorage(queueName);
-  return new JobQueue(queueName, jobClass, queueOptions);
+var defaultJobQueueFactory = async ({
+  queueName,
+  jobClass,
+  options
+}) => {
+  const storage = options?.storage ?? new InMemoryQueueStorage(queueName);
+  await storage.setupDatabase();
+  const server = new JobQueueServer(jobClass, {
+    storage,
+    queueName,
+    limiter: options?.limiter,
+    workerCount: options?.workerCount,
+    pollIntervalMs: options?.pollIntervalMs,
+    deleteAfterCompletionMs: options?.deleteAfterCompletionMs,
+    deleteAfterFailureMs: options?.deleteAfterFailureMs,
+    deleteAfterDisabledMs: options?.deleteAfterDisabledMs,
+    cleanupIntervalMs: options?.cleanupIntervalMs
+  });
+  const client = new JobQueueClient({
+    storage,
+    queueName
+  });
+  client.attach(server);
+  return { server, client, storage };
 };
 function registerJobQueueFactory(factory) {
   globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
 }
-function createJobQueueFactoryFromClass(QueueCtor, defaultOptions = {}) {
-  return ({ queueName, jobClass, options }) => {
+function createJobQueueFactoryWithOptions(defaultOptions = {}) {
+  return async ({
+    queueName,
+    jobClass,
+    options
+  }) => {
     const mergedOptions = {
       ...defaultOptions,
       ...options ?? {}
     };
-    return new QueueCtor(queueName, jobClass, mergedOptions);
+    const storage = mergedOptions.storage ?? new InMemoryQueueStorage(queueName);
+    await storage.setupDatabase();
+    const server = new JobQueueServer(jobClass, {
+      storage,
+      queueName,
+      limiter: mergedOptions.limiter,
+      workerCount: mergedOptions.workerCount,
+      pollIntervalMs: mergedOptions.pollIntervalMs,
+      deleteAfterCompletionMs: mergedOptions.deleteAfterCompletionMs,
+      deleteAfterFailureMs: mergedOptions.deleteAfterFailureMs,
+      deleteAfterDisabledMs: mergedOptions.deleteAfterDisabledMs,
+      cleanupIntervalMs: mergedOptions.cleanupIntervalMs
+    });
+    const client = new JobQueueClient({
+      storage,
+      queueName
+    });
+    client.attach(server);
+    return { server, client, storage };
   };
 }
 function getJobQueueFactory() {
@@ -2441,30 +2485,31 @@ var taskQueueRegistry = null;
 
 class TaskQueueRegistry {
   queues = new Map;
-  registerQueue(jobQueue) {
-    if (this.queues.has(jobQueue.queueName)) {
-      throw new Error(`Queue with name ${jobQueue.queueName} already exists`);
+  registerQueue(queue) {
+    const queueName = queue.server.queueName;
+    if (this.queues.has(queueName)) {
+      throw new Error(`Queue with name ${queueName} already exists`);
     }
-    this.queues.set(jobQueue.queueName, jobQueue);
+    this.queues.set(queueName, queue);
   }
-  getQueue(queue) {
-    return this.queues.get(queue);
+  getQueue(queueName) {
+    return this.queues.get(queueName);
   }
   startQueues() {
     for (const queue of this.queues.values()) {
-      queue.start();
+      queue.server.start();
     }
     return this;
   }
   stopQueues() {
     for (const queue of this.queues.values()) {
-      queue.stop();
+      queue.server.stop();
     }
     return this;
   }
   clearQueues() {
     for (const queue of this.queues.values()) {
-      queue.clear();
+      queue.storage.deleteAll();
     }
     return this;
   }
@@ -2502,14 +2547,14 @@ class JobQueueTask extends ArrayTask {
       if (this.config.queue === false && !this.constructor.canRunDirectly) {
         throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
       }
-      const queue = await this.resolveQueue(input);
-      const job = await this.createJob(input, queue);
-      if (!queue) {
+      const registeredQueue = await this.resolveQueue(input);
+      if (!registeredQueue) {
         if (!this.constructor.canRunDirectly) {
           const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
           throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
         }
         this.currentJobId = undefined;
+        const job = await this.createJob(input, this.currentQueueName);
         cleanup = job.onJobProgress((progress, message, details) => {
           executeContext.updateProgress(progress, message, details);
         });
@@ -2519,14 +2564,18 @@ class JobQueueTask extends ArrayTask {
         });
         return output2;
       }
-      const jobId = await queue.add(job);
-      this.currentJobId = jobId;
-      this.currentQueueName = queue?.queueName;
-      this.currentRunnerId = job.jobRunId;
-      cleanup = queue.onJobProgress(jobId, (progress, message, details) => {
+      const { client } = registeredQueue;
+      const jobInput = await this.getJobInput(input);
+      const handle = await client.submit(jobInput, {
+        jobRunId: this.currentRunnerId,
+        maxRetries: 10
+      });
+      this.currentJobId = handle.id;
+      this.currentQueueName = client.queueName;
+      cleanup = handle.onProgress((progress, message, details) => {
         executeContext.updateProgress(progress, message, details);
       });
-      const output = await queue.waitFor(jobId);
+      const output = await handle.waitFor();
       if (output === undefined) {
         throw new TaskConfigurationError("Job disabled, should not happen");
       }
@@ -2537,10 +2586,12 @@ class JobQueueTask extends ArrayTask {
       cleanup();
     }
   }
-  async createJob(input, queue) {
-    const jobCtor = queue?.jobClass ?? this.jobClass;
-    return new jobCtor({
-      queueName: queue?.queueName ?? this.currentQueueName,
+  async getJobInput(input) {
+    return input;
+  }
+  async createJob(input, queueName) {
+    return new this.jobClass({
+      queueName: queueName ?? this.currentQueueName,
       jobRunId: this.currentRunnerId,
       input
     });
@@ -2552,10 +2603,10 @@ class JobQueueTask extends ArrayTask {
       return;
     }
     if (typeof preference === "string") {
-      const queue2 = getTaskQueueRegistry().getQueue(preference);
-      if (queue2) {
-        this.currentQueueName = queue2.queueName;
-        return queue2;
+      const registeredQueue2 = getTaskQueueRegistry().getQueue(preference);
+      if (registeredQueue2) {
+        this.currentQueueName = registeredQueue2.server.queueName;
+        return registeredQueue2;
       }
       this.currentQueueName = preference;
       return;
@@ -2566,19 +2617,19 @@ class JobQueueTask extends ArrayTask {
       return;
     }
     this.currentQueueName = queueName;
-    let queue = getTaskQueueRegistry().getQueue(queueName);
-    if (!queue) {
-      queue = await this.createAndRegisterQueue(queueName, input);
-      await queue.start();
+    let registeredQueue = getTaskQueueRegistry().getQueue(queueName);
+    if (!registeredQueue) {
+      registeredQueue = await this.createAndRegisterQueue(queueName, input);
+      await registeredQueue.server.start();
     }
-    return queue;
+    return registeredQueue;
   }
   async getDefaultQueueName(_input) {
     return this.type;
   }
   async createAndRegisterQueue(queueName, input) {
     const factory = getJobQueueFactory();
-    let queue = await factory({
+    let registeredQueue = await factory({
       queueName,
       jobClass: this.jobClass,
       input,
@@ -2587,24 +2638,24 @@ class JobQueueTask extends ArrayTask {
     });
     const registry = getTaskQueueRegistry();
     try {
-      registry.registerQueue(queue);
+      registry.registerQueue(registeredQueue);
     } catch (err) {
       if (err instanceof Error && err.message.includes("already exists")) {
         const existing = registry.getQueue(queueName);
         if (existing) {
-          queue = existing;
+          registeredQueue = existing;
         }
       } else {
         throw err;
       }
     }
-    return queue;
+    return registeredQueue;
   }
   async abort() {
-    if (this.currentQueueName) {
-      const queue = getTaskQueueRegistry().getQueue(this.currentQueueName);
-      if (queue) {
-        await queue.abort(this.currentJobId);
+    if (this.currentQueueName && this.currentJobId) {
+      const registeredQueue = getTaskQueueRegistry().getQueue(this.currentQueueName);
+      if (registeredQueue) {
+        await registeredQueue.client.abort(this.currentJobId);
       }
     }
     super.abort();
@@ -2842,7 +2893,7 @@ export {
   ensureTask,
   createTaskFromGraphJSON,
   createTaskFromDependencyJSON,
-  createJobQueueFactoryFromClass,
+  createJobQueueFactoryWithOptions,
   createGraphFromGraphJSON,
   createGraphFromDependencyJSON,
   connect,
@@ -2888,4 +2939,4 @@ export {
   ArrayTask
 };
 
-//# debugId=D3EC2E99FF734C2C64756E2164756E21
+//# debugId=54877F3DCD961A9A64756E2164756E21