@cadenza.io/core 3.12.4 → 3.13.1

package/dist/index.d.mts

@@ -819,6 +819,8 @@ declare class Task extends SignalEmitter implements Graph {
     destroyed: boolean;
     register: boolean;
     registered: boolean;
+    registeredSignals: Set<string>;
+    taskMapRegistration: Set<string>;
     emitsSignals: Set<string>;
     signalsToEmitAfter: Set<string>;
     signalsToEmitOnFail: Set<string>;
@@ -848,6 +850,7 @@ declare class Task extends SignalEmitter implements Graph {
      * @param {number} [retryDelayFactor=1] - The factor by which the retry delay increases after each attempt.
      */
     constructor(name: string, task: TaskFunction, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: SchemaDefinition | undefined, validateInputContext?: boolean, outputSchema?: SchemaDefinition | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    clone(traverse?: boolean, includeSignals?: boolean): Task;
     /**
      * Retrieves the tag associated with the instance.
      * Can be overridden by subclasses.
@@ -1799,6 +1802,9 @@ declare class Cadenza {
      * ```
      */
     static emit(event: string, data?: AnyObject): void;
+    static schedule(taskName: string, context: AnyObject, timeoutMs: number, exactDateTime?: Date): void;
+    static throttle(taskName: string, context: AnyObject, intervalMs: number, leading?: boolean, startDateTime?: Date): void;
+    static get(taskName: string): Task | undefined;
     /**
      * 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.

package/dist/index.d.ts

@@ -819,6 +819,8 @@ declare class Task extends SignalEmitter implements Graph {
     destroyed: boolean;
     register: boolean;
     registered: boolean;
+    registeredSignals: Set<string>;
+    taskMapRegistration: Set<string>;
     emitsSignals: Set<string>;
     signalsToEmitAfter: Set<string>;
     signalsToEmitOnFail: Set<string>;
@@ -848,6 +850,7 @@ declare class Task extends SignalEmitter implements Graph {
      * @param {number} [retryDelayFactor=1] - The factor by which the retry delay increases after each attempt.
      */
     constructor(name: string, task: TaskFunction, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: SchemaDefinition | undefined, validateInputContext?: boolean, outputSchema?: SchemaDefinition | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    clone(traverse?: boolean, includeSignals?: boolean): Task;
     /**
      * Retrieves the tag associated with the instance.
      * Can be overridden by subclasses.
@@ -1799,6 +1802,9 @@ declare class Cadenza {
      * ```
      */
     static emit(event: string, data?: AnyObject): void;
+    static schedule(taskName: string, context: AnyObject, timeoutMs: number, exactDateTime?: Date): void;
+    static throttle(taskName: string, context: AnyObject, intervalMs: number, leading?: boolean, startDateTime?: Date): void;
+    static get(taskName: string): Task | undefined;
     /**
      * 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.

package/dist/index.js

@@ -461,7 +461,7 @@ var SignalBroker = class _SignalBroker {
 };
 
 // src/engine/GraphRunner.ts
-var import_uuid5 = require("uuid");
+var import_uuid6 = require("uuid");
 
 // src/engine/GraphRun.ts
 var import_uuid2 = require("uuid");
@@ -1316,6 +1316,9 @@ var GraphNode = class _GraphNode extends SignalEmitter {
       };
     }
     this.emit(signal, data);
+    if (!this.task.emitsSignals.has(signal)) {
+      this.task.emitsSignals.add(signal);
+    }
   }
   /**
    * Emits metrics with additional metadata describing the task execution and context.
@@ -1341,6 +1344,9 @@ var GraphNode = class _GraphNode extends SignalEmitter {
       };
     }
     this.emitMetrics(signal, data);
+    if (!this.task.emitsSignals.has(signal)) {
+      this.task.emitsSignals.add(signal);
+    }
   }
   /**
    * Updates the progress of a task and emits metrics with associated metadata.
@@ -1960,6 +1966,9 @@ var GraphRoutine = class extends SignalEmitter {
   }
 };
 
+// src/graph/definition/Task.ts
+var import_uuid5 = require("uuid");
+
 // src/graph/iterators/TaskIterator.ts
 var TaskIterator = class {
   constructor(task) {
@@ -1992,7 +2001,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.
    *
@@ -2044,12 +2053,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;
@@ -2103,6 +2114,41 @@ var Task = class extends SignalEmitter {
       });
     }
   }
+  clone(traverse = false, includeSignals = false) {
+    const clonedTask = new _Task(
+      `${this.name} (clone ${(0, import_uuid5.v4)().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.
@@ -2564,6 +2610,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) {
@@ -2586,6 +2636,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);
     });
@@ -3064,9 +3118,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 ?? (0, import_uuid5.v4)();
+    const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? (0, import_uuid6.v4)();
     context.__executionTraceId = executionTraceId;
-    const routineExecId = context.__routineExecId ?? (0, import_uuid5.v4)();
+    const routineExecId = context.__routineExecId ?? (0, import_uuid6.v4)();
     context.__routineExecId = routineExecId;
     const ctx = new GraphContext(context || {});
     if (!isSubMeta) {
@@ -4257,6 +4311,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.