@cadenza.io/service 1.25.8 → 1.26.0

package/dist/index.d.mts

@@ -13,6 +13,7 @@ declare class DeputyTask extends Task {
     readonly isDeputy: boolean;
     protected readonly remoteRoutineName: string;
     protected serviceName: string | undefined;
+    registeredDeputyMap: boolean;
     /**
      * Constructs a new instance of the class with the specified parameters.
      *
@@ -331,6 +332,7 @@ interface TableDefinition {
             [key in DbOperationType]?: (string | {
                 signal: string;
                 condition?: (ctx: AnyObject) => boolean;
+                queryData?: DbOperationPayload;
             })[];
         };
         emissions?: {
@@ -21974,6 +21976,8 @@ declare class CadenzaService {
      * ```
      */
     static run(task: Task | GraphRoutine, context: 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;
     /**
      * Logs a message with a specified log level and additional contextual data.
      * Records in the CadenzaDB when available.
@@ -21986,6 +21990,7 @@ declare class CadenzaService {
      * @return {void} No return value.
      */
     static log(message: string, data?: any, level?: "info" | "warning" | "error" | "critical", subjectServiceName?: string | null, subjectServiceInstanceId?: string | null): void;
+    static get(taskName: string): Task | undefined;
     /**
      * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
      * This method ensures proper task initialization, including setting a unique name,

package/dist/index.d.ts

@@ -13,6 +13,7 @@ declare class DeputyTask extends Task {
     readonly isDeputy: boolean;
     protected readonly remoteRoutineName: string;
     protected serviceName: string | undefined;
+    registeredDeputyMap: boolean;
     /**
      * Constructs a new instance of the class with the specified parameters.
      *
@@ -331,6 +332,7 @@ interface TableDefinition {
             [key in DbOperationType]?: (string | {
                 signal: string;
                 condition?: (ctx: AnyObject) => boolean;
+                queryData?: DbOperationPayload;
             })[];
         };
         emissions?: {
@@ -21974,6 +21976,8 @@ declare class CadenzaService {
      * ```
      */
     static run(task: Task | GraphRoutine, context: 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;
     /**
      * Logs a message with a specified log level and additional contextual data.
      * Records in the CadenzaDB when available.
@@ -21986,6 +21990,7 @@ declare class CadenzaService {
      * @return {void} No return value.
      */
     static log(message: string, data?: any, level?: "info" | "warning" | "error" | "critical", subjectServiceName?: string | null, subjectServiceInstanceId?: string | null): void;
+    static get(taskName: string): Task | undefined;
     /**
      * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
      * This method ensures proper task initialization, including setting a unique name,

package/dist/index.js

@@ -153,6 +153,7 @@ var DeputyTask = class extends import_core.Task {
       retryDelayFactor
     );
     this.isDeputy = true;
+    this.registeredDeputyMap = false;
     this.remoteRoutineName = remoteRoutineName;
     this.serviceName = serviceName;
     this.emit("meta.deputy.created", {
@@ -524,12 +525,21 @@ var ServiceRegistry = class _ServiceRegistry {
         "Split service instances",
         function* (ctx) {
           const { serviceInstances } = ctx;
-          if (!serviceInstances) return;
+          if (!serviceInstances) {
+            CadenzaService.log(
+              "SyncFailed: No service instances found",
+              ctx,
+              "error"
+            );
+          }
           for (const serviceInstance of serviceInstances) {
             yield { serviceInstance };
           }
         }
-      ).then(this.handleInstanceUpdateTask)
+      ).then(this.handleInstanceUpdateTask).doOn(
+        "meta.cadenza_db.gathered_sync_data",
+        "CadenzaDB.meta.cadenza_db.gathered_sync_data"
+      )
     );
     this.getInstanceById = CadenzaService.createMetaTask(
       "Get instance by id",
@@ -3693,15 +3703,39 @@ var DatabaseController = class _DatabaseController {
     CadenzaService.createThrottledTask(
       taskName,
       async (context, emit) => {
-        const triggerConditions = table.customSignals?.triggers?.query?.filter(
-          (trigger) => trigger.condition
-        );
-        for (const triggerCondition of triggerConditions ?? []) {
-          if (triggerCondition.condition && !triggerCondition.condition(context)) {
-            return {
-              failed: true,
-              error: `Condition for signal trigger failed: ${triggerCondition.signal}`
-            };
+        for (const action of Object.keys(table.customSignals?.triggers ?? {})) {
+          const triggerConditions = (
+            // @ts-ignore
+            table.customSignals?.triggers?.[action].filter(
+              (trigger) => trigger.condition
+            )
+          );
+          for (const triggerCondition of triggerConditions ?? []) {
+            if (triggerCondition.condition && !triggerCondition.condition(context)) {
+              return {
+                failed: true,
+                error: `Condition for signal trigger failed: ${triggerCondition.signal}`
+              };
+            }
+          }
+          const triggerQueryData = (
+            // @ts-ignore
+            table.customSignals?.triggers?.[action].filter(
+              (trigger) => trigger.queryData
+            )
+          );
+          for (const queryData of triggerQueryData ?? []) {
+            if (context.queryData) {
+              context.queryData = {
+                ...context.queryData,
+                ...queryData
+              };
+            } else {
+              context = {
+                ...context,
+                ...queryData
+              };
+            }
           }
         }
         try {
@@ -3785,175 +3819,284 @@ var GraphSyncController = class _GraphSyncController {
     return this._instance;
   }
   constructor() {
-    CadenzaService.createDebounceMetaTask(
-      "Debounce syncing of resources",
-      () => true,
-      "",
-      500
-    ).doAfter(CadenzaService.serviceRegistry.handleInstanceUpdateTask).then(
-      CadenzaService.broker.getSignalsTask.then(
-        CadenzaService.registry.getAllTasks.then(CadenzaService.registry.getAllRoutines)
-      )
-    );
-    CadenzaService.createMetaTask("Split routines for registration", (ctx, emit) => {
-      const { __routines } = ctx;
-      if (!__routines) return;
-      for (const routine of __routines) {
-        if (routine.registered) continue;
-        routine.registered = true;
-        emit("meta.sync_controller.routine_added", {
+    this.splitRoutinesTask = CadenzaService.createMetaTask(
+      "Split routines for registration",
+      (ctx, emit) => {
+        const { __routines } = ctx;
+        if (!__routines) return;
+        for (const routine of __routines) {
+          if (routine.registered) continue;
+          routine.registered = true;
+          emit("meta.sync_controller.routine_added", {
+            data: {
+              name: routine.name,
+              version: routine.version,
+              description: routine.description,
+              serviceName: CadenzaService.serviceRegistry.serviceName,
+              isMeta: routine.isMeta
+            }
+          });
+          for (const task of routine.tasks) {
+            const tasks = task.getIterator();
+            while (tasks.hasNext()) {
+              const nextTask = tasks.next();
+              emit("meta.sync_controller.task_to_routine_map", {
+                data: {
+                  taskName: nextTask.name,
+                  taskVersion: nextTask.version,
+                  routineName: routine.name,
+                  routineVersion: routine.version,
+                  serviceName: CadenzaService.serviceRegistry.serviceName
+                }
+              });
+            }
+          }
+        }
+        emit("meta.sync_controller.synced", {
           data: {
-            name: routine.name,
-            version: routine.version,
-            description: routine.description,
-            serviceName: CadenzaService.serviceRegistry.serviceName,
-            isMeta: routine.isMeta
+            is_active: true,
+            is_non_responsive: false,
+            is_blocked: false,
+            last_active: formatTimestamp(Date.now())
+          },
+          filter: {
+            uuid: CadenzaService.serviceRegistry.serviceInstanceId
           }
         });
-        for (const task of routine.tasks) {
-          const tasks = task.getIterator();
-          while (tasks.hasNext()) {
-            const nextTask = tasks.next();
-            emit("meta.sync_controller.task_to_routine_map", {
-              data: {
-                taskName: nextTask.name,
-                taskVersion: nextTask.version,
-                routineName: routine.name,
-                routineVersion: routine.version,
-                serviceName: CadenzaService.serviceRegistry.serviceName
-              }
-            });
-          }
-        }
+        CadenzaService.log("Synced data...");
       }
-      emit("meta.sync_controller.synced", {
-        data: {
-          is_active: true,
-          is_non_responsive: false,
-          is_blocked: false,
-          last_active: formatTimestamp(Date.now())
-        },
-        filter: {
-          uuid: CadenzaService.serviceRegistry.serviceInstanceId
+    );
+    this.splitSignalsTask = CadenzaService.createMetaTask(
+      "Split signals for registration",
+      function* (ctx, emit) {
+        const { __signals } = ctx;
+        if (!__signals) return;
+        const filteredSignals = __signals.filter(
+          (signal) => !signal.data.registered
+        ).map((signal) => signal.signal);
+        for (const signal of filteredSignals) {
+          const { isMeta, sourceServiceName, domain, action } = decomposeSignalName(signal);
+          yield {
+            data: {
+              name: signal,
+              sourceServiceName,
+              domain,
+              action,
+              isMeta,
+              serviceName: CadenzaService.serviceRegistry.serviceName
+            }
+          };
         }
-      });
-      CadenzaService.log("Service synced data.");
-    }).doAfter(CadenzaService.registry.getAllRoutines);
-    CadenzaService.createMetaTask("Split signals for registration", (ctx, emit) => {
-      const { __signals } = ctx;
-      if (!__signals) return;
-      const filteredSignals = __signals.filter(
-        (signal) => !signal.data.registered
-      ).map((signal) => signal.signal);
-      for (const signal of filteredSignals) {
-        const { isMeta, sourceServiceName, domain, action } = decomposeSignalName(signal);
-        emit("meta.sync_controller.signal_added", {
-          data: {
-            name: signal,
-            sourceServiceName,
-            domain,
-            action,
-            isMeta,
-            serviceName: CadenzaService.serviceRegistry.serviceName
+      }
+    ).doAfter(CadenzaService.broker.getSignalsTask).then(
+      CadenzaService.createCadenzaDBInsertTask("signal_registry", {
+        onConflict: {
+          target: ["name"],
+          action: {
+            do: "nothing"
           }
-        });
-        emit("meta.signal.registered", {
-          __signalName: signal
-        });
+        }
+      }).then(
+        CadenzaService.createMetaTask("Process signal registration", (ctx) => {
+          return { __signalName: ctx.signalRegistry?.name };
+        }).then(CadenzaService.broker.registerSignalTask)
+      )
+    );
+    this.splitTasksForRegistration = CadenzaService.createMetaTask(
+      "Split tasks for registration",
+      function* (ctx) {
+        const tasks = ctx.__tasks;
+        for (const task of tasks) {
+          if (task.registered) continue;
+          const { __functionString, __getTagCallback } = task.export();
+          yield {
+            data: {
+              name: task.name,
+              version: task.version,
+              description: task.description,
+              functionString: __functionString,
+              tagIdGetter: __getTagCallback,
+              layerIndex: task.layerIndex,
+              concurrency: task.concurrency,
+              timeout: task.timeout,
+              isUnique: task.isUnique,
+              isSignal: task.isSignal,
+              isThrottled: task.isThrottled,
+              isDebounce: task.isDebounce,
+              isEphemeral: task.isEphemeral,
+              isMeta: task.isMeta,
+              isSubMeta: task.isSubMeta,
+              isHidden: task.isHidden,
+              // inputSchema: task.inputSchema,
+              validateInputContext: task.validateInputContext,
+              // outputSchema: task.outputSchema,
+              validateOutputContext: task.validateOutputContext,
+              retryCount: task.retryCount,
+              retryDelay: task.retryDelay,
+              retryDelayMax: task.retryDelayMax,
+              retryDelayFactor: task.retryDelayFactor,
+              service_name: CadenzaService.serviceRegistry.serviceName
+            },
+            __name: task.name
+          };
+        }
       }
-    }).doAfter(CadenzaService.broker.getSignalsTask);
-    CadenzaService.createMetaTask("Split tasks for registration", (ctx, emit) => {
-      const { __tasks } = ctx;
-      if (!__tasks) return;
-      for (const task of __tasks) {
-        if (task.registered) continue;
-        task.registered = true;
-        const { __functionString, __getTagCallback } = task.export();
-        emit("meta.sync_controller.task_added", {
-          data: {
-            name: task.name,
-            version: task.version,
-            description: task.description,
-            functionString: __functionString,
-            tagIdGetter: __getTagCallback,
-            layerIndex: task.layerIndex,
-            concurrency: task.concurrency,
-            timeout: task.timeout,
-            isUnique: task.isUnique,
-            isSignal: task.isSignal,
-            isThrottled: task.isThrottled,
-            isDebounce: task.isDebounce,
-            isEphemeral: task.isEphemeral,
-            isMeta: task.isMeta,
-            isSubMeta: task.isSubMeta,
-            isHidden: task.isHidden,
-            // inputSchema: task.inputSchema,
-            validateInputContext: task.validateInputContext,
-            // outputSchema: task.outputSchema,
-            validateOutputContext: task.validateOutputContext,
-            retryCount: task.retryCount,
-            retryDelay: task.retryDelay,
-            retryDelayMax: task.retryDelayMax,
-            retryDelayFactor: task.retryDelayFactor,
-            service_name: CadenzaService.serviceRegistry.serviceName
+    ).then(
+      CadenzaService.createCadenzaDBInsertTask("task", {
+        onConflict: {
+          target: ["name", "service_name", "version"],
+          action: {
+            do: "nothing"
           }
-        });
-        task.mapObservedSignals((signal) => {
-          const firstChar = signal.charAt(0);
-          let _signal = signal;
+        }
+      }).then(
+        CadenzaService.createMetaTask("Record registration", (ctx) => {
+          CadenzaService.get(ctx.__name).registered = true;
+        })
+      )
+    );
+    const registerSignalTask = CadenzaService.createMetaTask(
+      "Record signal registration",
+      (ctx) => {
+        CadenzaService.get(ctx.__name)?.registeredSignals.add(ctx.__signalName);
+      }
+    );
+    this.registerSignalToTaskMapTask = CadenzaService.createMetaTask(
+      "Split observed signals of task",
+      function* (ctx) {
+        const task = ctx.__task;
+        if (task.hidden || !task.register) return;
+        for (const signal of task.observedSignals) {
+          let firstChar = signal.charAt(0);
           let signalServiceName;
+          let _signal = signal;
           if (firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()) {
             signalServiceName = signal.split(".")[0];
             _signal = signal.split(".").slice(1).join(".");
           }
-          emit("meta.sync_controller.signal_to_task_map", {
+          if (task.registeredSignals.has(_signal)) continue;
+          yield {
             data: {
               signalName: _signal,
               taskName: task.name,
               taskVersion: task.version,
               taskServiceName: CadenzaService.serviceRegistry.serviceName,
               signalServiceName: signalServiceName ?? CadenzaService.serviceRegistry.serviceName
-            }
-          });
-        });
-        task.mapSignals((signal) => {
-          emit("meta.sync_controller.task_to_signal_map", {
+            },
+            __name: task.name,
+            __signalName: _signal
+          };
+        }
+      }
+    ).then(
+      CadenzaService.createCadenzaDBInsertTask("signal_to_task_map", {
+        onConflict: {
+          target: [
+            "task_name",
+            "task_version",
+            "task_service_name",
+            "signal_name",
+            "signal_service_name"
+          ],
+          action: {
+            do: "nothing"
+          }
+        }
+      }).then(registerSignalTask)
+    );
+    this.registerTaskToSignalMapTask = CadenzaService.createMetaTask(
+      "Split emitted signals of task",
+      function* (ctx) {
+        const task = ctx.__task;
+        if (task.hidden || !task.register) return;
+        for (const signal of task.signalsToEmitAfter) {
+          if (task.registeredSignals.has(signal)) continue;
+          yield {
             data: {
               signalName: signal,
               taskName: task.name,
               taskVersion: task.version,
               serviceName: CadenzaService.serviceRegistry.serviceName
-            }
-          });
-        });
-        task.mapOnFailSignals((signal) => {
-          emit("meta.sync_controller.task_to_signal_map", {
-            // TODO: handle signals that are not observed.
+            },
+            __signalName: signal,
+            __name: task.name
+          };
+        }
+        for (const signal of task.signalsToEmitOnFail) {
+          if (task.registeredSignals.has(signal)) continue;
+          yield {
             data: {
               signalName: signal,
               taskName: task.name,
               taskVersion: task.version,
               serviceName: CadenzaService.serviceRegistry.serviceName,
               isOnFail: true
-            }
-          });
-        });
+            },
+            __signalName: signal,
+            __name: task.name
+          };
+        }
       }
-      for (const task of __tasks) {
-        if (task.hidden || !task.register) continue;
-        task.mapNext(
-          (t) => emit("meta.sync_controller.task_map", {
+    ).then(
+      CadenzaService.createCadenzaDBInsertTask("task_to_signal_map", {
+        onConflict: {
+          target: ["task_name", "task_version", "service_name", "signal_name"],
+          action: {
+            do: "nothing"
+          }
+        }
+      }).then(registerSignalTask)
+    );
+    this.registerTaskMapTask = CadenzaService.createMetaTask(
+      "Register task map to DB",
+      function* (ctx) {
+        const task = ctx.__task;
+        if (task.hidden || !task.register) return;
+        for (const t of task.nextTasks) {
+          if (task.taskMapRegistration.has(t.name)) {
+            continue;
+          }
+          yield {
             data: {
               taskName: t.name,
               taskVersion: t.version,
               predecessorTaskName: task.name,
               predecessorTaskVersion: task.version,
               serviceName: CadenzaService.serviceRegistry.serviceName
-            }
-          })
-        );
+            },
+            __name: task.name,
+            __nextTaskName: t.name
+          };
+        }
+      }
+    ).then(
+      CadenzaService.createCadenzaDBInsertTask("directional_task_graph_map", {
+        onConflict: {
+          target: [
+            "task_name",
+            "predecessor_task_name",
+            "task_version",
+            "predecessor_task_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
+          }
+        }
+      }).then(
+        CadenzaService.createMetaTask("Record task map registration", (ctx) => {
+          CadenzaService.get(ctx.__name)?.taskMapRegistration.add(ctx.__nextTaskName);
+        })
+      )
+    );
+    this.registerDeputyRelationshipTask = CadenzaService.createMetaTask(
+      "Register deputy relationship",
+      (ctx) => {
+        const task = ctx.__task;
+        if (task.hidden || !task.register) return;
         if (task.isDeputy && !task.signalName) {
-          emit("meta.sync_controller.deputy_relationship_created", {
+          if (task.registeredDeputyMap) return;
+          return {
             data: {
               triggered_task_name: task.remoteRoutineName,
               triggered_task_version: 1,
@@ -3961,12 +4104,56 @@ var GraphSyncController = class _GraphSyncController {
               deputy_task_name: task.name,
               deputy_task_version: task.version,
               deputy_service_name: CadenzaService.serviceRegistry.serviceName
-            }
-          });
+            },
+            __name: task.name
+          };
         }
       }
-      return true;
-    }).doAfter(CadenzaService.registry.getAllTasks);
+    ).then(
+      CadenzaService.createCadenzaDBInsertTask("directional_task_graph_map", {
+        onConflict: {
+          target: [
+            "task_name",
+            "predecessor_task_name",
+            "task_version",
+            "predecessor_task_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
+          }
+        }
+      }).then(
+        CadenzaService.createMetaTask(
+          "Record deputy relationship registration",
+          (ctx) => {
+            CadenzaService.get(ctx.__name).registeredDeputyMap = true;
+          }
+        )
+      )
+    );
+    CadenzaService.createDebounceMetaTask(
+      "Debounce syncing of resources",
+      () => true,
+      "",
+      500
+    ).doAfter(CadenzaService.serviceRegistry.handleInstanceUpdateTask).then(
+      CadenzaService.broker.getSignalsTask.clone().then(
+        this.splitSignalsTask,
+        CadenzaService.registry.getAllTasks.clone().then(
+          this.splitTasksForRegistration,
+          CadenzaService.registry.getAllRoutines.clone().then(
+            this.splitRoutinesTask,
+            CadenzaService.registry.doForEachTask.clone().then(
+              this.registerTaskMapTask,
+              this.registerSignalToTaskMapTask,
+              this.registerTaskToSignalMapTask,
+              this.registerDeputyRelationshipTask
+            )
+          )
+        )
+      )
+    );
   }
 };
 
@@ -4087,6 +4274,18 @@ var CadenzaService = class {
   static run(task, context) {
     this.runner?.run(task, context);
   }
+  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
+    );
+  }
   /**
    * Logs a message with a specified log level and additional contextual data.
    * Records in the CadenzaDB when available.
@@ -4121,6 +4320,9 @@ var CadenzaService = class {
       }
     });
   }
+  static get(taskName) {
+    return import_core3.default.get(taskName);
+  }
   /**
    * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
    * This method ensures proper task initialization, including setting a unique name,
@@ -4579,9 +4781,6 @@ var CadenzaService = class {
       GraphMetadataController.instance;
       GraphSyncController.instance;
       this.broker.schedule("meta.sync_requested", {}, 2e3);
-      if (options.cadenzaDB?.connect) {
-        this.broker.throttle("meta.sync_requested", {}, 3e5);
-      }
       this.log("Service created.");
       return true;
     }).doOn("meta.service_registry.instance_inserted");