@cadenza.io/service 2.0.7 → 2.0.9

package/dist/index.js

@@ -1017,6 +1017,7 @@ var SignalTransmissionTask = class extends import_core2.Task {
     const metadata = context.getMetadata();
     const deputyContext = {
       __localTaskName: this.name,
+      __localServiceName: CadenzaService.serviceRegistry.serviceName,
       __serviceName: this.serviceName,
       __executionTraceId: metadata.__executionTraceId ?? null,
       __localRoutineExecId: metadata.__routineExecId ?? metadata.__metadata?.__routineExecId,
@@ -1844,7 +1845,7 @@ var SocketController = class _SocketController {
                     console.log(
                       "Received signal",
                       ctx2.__signalName,
-                      ctx2.__serviceName
+                      ctx2.__localServiceName
                     );
                     CadenzaService.emit(ctx2.__signalName, ctx2);
                   } else {
@@ -2300,6 +2301,9 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       };
     }).doOn("meta.task.relationship_added").emits("global.meta.graph_metadata.task_relationship_created");
+    CadenzaService.createMetaTask("Handle task error", (ctx) => {
+      CadenzaService.log(`Error in task ${ctx.data.taskName}`, ctx.data, "error");
+    }).doOn("meta.node.errored");
     CadenzaService.createMetaTask(
       "Handle task deputy relationship creation",
       (ctx) => {
@@ -2327,9 +2331,24 @@ var GraphMetadataController = class _GraphMetadataController {
       };
     }).doOn("meta.task.observed_signal").emits("global.meta.graph_metadata.task_signal_observed");
     CadenzaService.createMetaTask("Handle task signal attachment", (ctx) => {
+      const { isGlobal, domain, action, isMeta } = decomposeSignalName(
+        ctx.data.signalName
+      );
       return {
         data: {
           ...ctx.data,
+          signalName: {
+            subOperation: "insert",
+            table: "signal_registry",
+            data: {
+              name: ctx.data.signalName,
+              isGlobal,
+              domain,
+              action,
+              isMeta
+            },
+            return: "name"
+          },
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
       };
@@ -3399,13 +3418,13 @@ var DatabaseController = class _DatabaseController {
         __success: true
       };
     } catch (error) {
+      if (transaction) await client.query("ROLLBACK");
       if (error.message.includes("violates unique constraint")) {
         resultContext = {
           [`${(0, import_lodash_es.camelCase)(tableName)}`]: null,
           __success: false
         };
       } else {
-        if (transaction) await client.query("ROLLBACK");
         resultContext = {
           ...context,
           errored: true,
@@ -3873,14 +3892,18 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("signal_registry", {
-        onConflict: {
-          target: ["name"],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "signal_registry",
+        {
+          onConflict: {
+            target: ["name"],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertSignalRegistry"))?.then(
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertSignalRegistry"))?.then(
         CadenzaService.createMetaTask("Process signal registration", (ctx) => {
           if (!ctx.__syncing) {
             return;
@@ -3930,14 +3953,18 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("task", {
-        onConflict: {
-          target: ["name", "service_name", "version"],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "task",
+        {
+          onConflict: {
+            target: ["name", "service_name", "version"],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertTask"))?.then(
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertTask"))?.then(
         CadenzaService.createMetaTask("Record registration", (ctx) => {
           if (!ctx.__syncing) {
             return;
@@ -3963,21 +3990,10 @@ var GraphSyncController = class _GraphSyncController {
         for (const signal of task.observedSignals) {
           const _signal = signal.split(":")[0];
           if (task.registeredSignals.has(signal)) continue;
-          const { isMeta, isGlobal, domain, action } = decomposeSignalName(_signal);
+          const { isGlobal } = decomposeSignalName(_signal);
           yield {
             data: {
-              signalName: {
-                subOperation: "insert",
-                table: "signal_registry",
-                data: {
-                  name: _signal,
-                  isMeta,
-                  isGlobal,
-                  domain,
-                  action
-                },
-                return: "name"
-              },
+              signalName: _signal,
               isGlobal,
               taskName: task.name,
               taskVersion: task.version,
@@ -3989,19 +4005,23 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("signal_to_task_map", {
-        onConflict: {
-          target: [
-            "task_name",
-            "task_version",
-            "service_name",
-            "signal_name"
-          ],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "signal_to_task_map",
+        {
+          onConflict: {
+            target: [
+              "task_name",
+              "task_version",
+              "service_name",
+              "signal_name"
+            ],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertSignalToTaskMap"))?.then(registerSignalTask)
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertSignalToTaskMap"))?.then(registerSignalTask)
     );
     this.registerTaskToSignalMapTask = CadenzaService.createMetaTask(
       "Split emitted signals of task",
@@ -4011,22 +4031,10 @@ var GraphSyncController = class _GraphSyncController {
         for (const signal of task.emitsSignals) {
           const _signal = signal.split(":")[0];
           if (task.registeredSignals.has(_signal)) continue;
-          const { isMeta, isGlobal, domain, action } = decomposeSignalName(_signal);
           const isOnFail = task.signalsToEmitOnFail.has(signal);
           yield {
             data: {
-              signalName: {
-                subOperation: "insert",
-                table: "signal_registry",
-                data: {
-                  name: _signal,
-                  isMeta,
-                  isGlobal,
-                  domain,
-                  action
-                },
-                return: "name"
-              },
+              signalName: _signal,
               taskName: task.name,
               taskVersion: task.version,
               serviceName: CadenzaService.serviceRegistry.serviceName,
@@ -4038,19 +4046,23 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("task_to_signal_map", {
-        onConflict: {
-          target: [
-            "task_name",
-            "task_version",
-            "service_name",
-            "signal_name"
-          ],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "task_to_signal_map",
+        {
+          onConflict: {
+            target: [
+              "task_name",
+              "task_version",
+              "service_name",
+              "signal_name"
+            ],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertTaskToSignalMap"))?.then(registerSignalTask)
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertTaskToSignalMap"))?.then(registerSignalTask)
     );
     this.registerTaskMapTask = CadenzaService.createMetaTask(
       "Register task map to DB",
@@ -4075,20 +4087,24 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("directional_task_graph_map", {
-        onConflict: {
-          target: [
-            "task_name",
-            "predecessor_task_name",
-            "task_version",
-            "predecessor_task_version",
-            "service_name"
-          ],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "directional_task_graph_map",
+        {
+          onConflict: {
+            target: [
+              "task_name",
+              "predecessor_task_name",
+              "task_version",
+              "predecessor_task_version",
+              "service_name"
+            ],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertDirectionalTaskGraphMap"))?.then(
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertDirectionalTaskGraphMap"))?.then(
         CadenzaService.createMetaTask("Record task map registration", (ctx) => {
           if (!ctx.__syncing) {
             return;
@@ -4118,21 +4134,25 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask("deputy_task_map", {
-        onConflict: {
-          target: [
-            "deputy_task_name",
-            "triggered_task_name",
-            "deputy_task_version",
-            "triggered_task_version",
-            "deputy_service_name",
-            "triggered_service_name"
-          ],
-          action: {
-            do: "nothing"
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "deputy_task_map",
+        {
+          onConflict: {
+            target: [
+              "deputy_task_name",
+              "triggered_task_name",
+              "deputy_task_version",
+              "triggered_task_version",
+              "deputy_service_name",
+              "triggered_service_name"
+            ],
+            action: {
+              do: "nothing"
+            }
           }
-        }
-      }) : CadenzaService.get("dbInsertDeputyTaskMap"))?.then(
+        },
+        { concurrency: 50 }
+      ) : CadenzaService.get("dbInsertDeputyTaskMap"))?.then(
         CadenzaService.createMetaTask(
           "Record deputy relationship registration",
           (ctx) => {