@cadenza.io/core 3.12.4 → 3.13.0

package/dist/index.mjs

@@ -424,7 +424,7 @@ var SignalBroker = class _SignalBroker {
 };
 
 // src/engine/GraphRunner.ts
-import { v4 as uuid5 } from "uuid";
+import { v4 as uuid6 } from "uuid";
 
 // src/engine/GraphRun.ts
 import { v4 as uuid2 } from "uuid";
@@ -1279,6 +1279,9 @@ var GraphNode = class _GraphNode extends SignalEmitter {
       };
     }
     this.emit(signal, data);
+    if (!this.task.emitsSignals.has(signal)) {
+      this.task.attachSignal(signal);
+    }
   }
   /**
    * Emits metrics with additional metadata describing the task execution and context.
@@ -1304,6 +1307,9 @@ var GraphNode = class _GraphNode extends SignalEmitter {
       };
     }
     this.emitMetrics(signal, data);
+    if (!this.task.emitsSignals.has(signal)) {
+      this.task.attachSignal(signal);
+    }
   }
   /**
    * Updates the progress of a task and emits metrics with associated metadata.
@@ -1923,6 +1929,9 @@ var GraphRoutine = class extends SignalEmitter {
   }
 };
 
+// src/graph/definition/Task.ts
+import { v4 as uuid5 } from "uuid";
+
 // src/graph/iterators/TaskIterator.ts
 var TaskIterator = class {
   constructor(task) {
@@ -1955,7 +1964,7 @@ var TaskIterator = class {
 };
 
 // src/graph/definition/Task.ts
-var Task = class extends SignalEmitter {
+var Task = class _Task extends SignalEmitter {
   /**
    * Constructs an instance of the task with the specified properties and configuration options.
    *
@@ -2007,12 +2016,14 @@ var Task = class extends SignalEmitter {
     this.destroyed = false;
     this.register = true;
     this.registered = false;
+    this.registeredSignals = /* @__PURE__ */ new Set();
+    this.taskMapRegistration = /* @__PURE__ */ new Set();
     this.emitsSignals = /* @__PURE__ */ new Set();
     this.signalsToEmitAfter = /* @__PURE__ */ new Set();
     this.signalsToEmitOnFail = /* @__PURE__ */ new Set();
     this.observedSignals = /* @__PURE__ */ new Set();
     this.name = name;
-    this.taskFunction = task.bind(this);
+    this.taskFunction = task;
     this.description = description;
     this.concurrency = concurrency;
     this.timeout = timeout;
@@ -2066,6 +2077,41 @@ var Task = class extends SignalEmitter {
       });
     }
   }
+  clone(traverse = false, includeSignals = false) {
+    const clonedTask = new _Task(
+      `${this.name} (clone ${uuid5().slice(0, 8)})`,
+      this.taskFunction,
+      this.description,
+      this.concurrency,
+      this.timeout,
+      this.register,
+      this.isUnique,
+      this.isMeta,
+      this.isSubMeta,
+      this.isHidden,
+      this.getTag,
+      this.inputContextSchema,
+      this.validateInputContext,
+      this.outputContextSchema,
+      this.validateOutputContext,
+      this.retryCount,
+      this.retryDelay,
+      this.retryDelayMax,
+      this.retryDelayFactor
+    );
+    if (includeSignals) {
+      clonedTask.doOn(...this.observedSignals);
+      clonedTask.emits(...this.signalsToEmitAfter);
+      clonedTask.emitsOnFail(...this.signalsToEmitOnFail);
+      clonedTask.emitsSignals = new Set(Array.from(this.emitsSignals));
+    }
+    if (traverse) {
+      this.mapNext((t) => {
+        clonedTask.then(t.clone(traverse, includeSignals));
+      });
+    }
+    return clonedTask;
+  }
   /**
    * Retrieves the tag associated with the instance.
    * Can be overridden by subclasses.
@@ -2527,6 +2573,10 @@ var Task = class extends SignalEmitter {
   doOn(...signals) {
     signals.forEach((signal) => {
       if (this.observedSignals.has(signal)) return;
+      if (this.emitsSignals.has(signal))
+        throw new Error(
+          `Detected signal loop for task ${this.name}. Signal name: ${signal}`
+        );
       Cadenza.broker.observe(signal, this);
       this.observedSignals.add(signal);
       if (this.register) {
@@ -2549,6 +2599,10 @@ var Task = class extends SignalEmitter {
    */
   emits(...signals) {
     signals.forEach((signal) => {
+      if (this.observedSignals.has(signal))
+        throw new Error(
+          `Detected signal loop for task ${this.name}. Signal name: ${signal}`
+        );
       this.signalsToEmitAfter.add(signal);
       this.attachSignal(signal);
     });
@@ -3027,9 +3081,9 @@ var GraphRunner = class extends SignalEmitter {
     const isSubMeta = allTasks.some((t) => t.isSubMeta) || !!context.__isSubMeta;
     context.__isSubMeta = isSubMeta;
     const isNewTrace = !context.__routineExecId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
-    const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? uuid5();
+    const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? uuid6();
     context.__executionTraceId = executionTraceId;
-    const routineExecId = context.__routineExecId ?? uuid5();
+    const routineExecId = context.__routineExecId ?? uuid6();
     context.__routineExecId = routineExecId;
     const ctx = new GraphContext(context || {});
     if (!isSubMeta) {
@@ -4220,6 +4274,21 @@ var Cadenza = class {
   static emit(event, data = {}) {
     this.broker?.emit(event, data);
   }
+  static schedule(taskName, context, timeoutMs, exactDateTime) {
+    this.broker?.schedule(taskName, context, timeoutMs, exactDateTime);
+  }
+  static throttle(taskName, context, intervalMs, leading = false, startDateTime) {
+    this.broker?.throttle(
+      taskName,
+      context,
+      intervalMs,
+      leading,
+      startDateTime
+    );
+  }
+  static get(taskName) {
+    return this.registry?.tasks.get(taskName);
+  }
   /**
    * Creates and registers a new task with the specified parameters and options.
    * Tasks are the basic building blocks of Cadenza graphs and are responsible for executing logic.