@cadenza.io/service 2.17.44 → 2.17.45

package/dist/index.js

@@ -8717,22 +8717,30 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   const executionRequestedSignal = `meta.sync_controller.insert_execution_requested:${tableName}`;
   const executionResolvedSignal = `meta.sync_controller.insert_execution_resolved:${tableName}`;
   const executionFailedSignal = `meta.sync_controller.insert_execution_failed:${tableName}`;
+  const pendingResolverContexts = /* @__PURE__ */ new Map();
   const prepareExecutionTask = CadenzaService.createMetaTask(
     `Prepare graph sync insert execution for ${tableName}`,
-    (ctx) => ({
-      ...ctx,
-      __resolverOriginalContext: {
+    (ctx) => {
+      const originalContext = {
         ...ctx
-      },
-      __resolverQueryData: buildSyncInsertQueryData(
-        ctx,
-        queryData
-      ),
-      queryData: buildSyncInsertQueryData(
+      };
+      const originalQueryData = buildSyncInsertQueryData(
         ctx,
         queryData
-      )
-    }),
+      );
+      if (typeof ctx.__resolverRequestId === "string") {
+        pendingResolverContexts.set(ctx.__resolverRequestId, {
+          originalContext,
+          originalQueryData
+        });
+      }
+      return {
+        ...ctx,
+        __resolverOriginalContext: originalContext,
+        __resolverQueryData: originalQueryData,
+        queryData: originalQueryData
+      };
+    },
     `Prepares ${tableName} graph-sync insert payloads for runner execution.`,
     {
       register: false,
@@ -8745,13 +8753,17 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       if (!ctx.__resolverRequestId) {
         return false;
       }
-      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? ctx.__resolverOriginalContext : {};
-      const originalQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : void 0;
+      const pendingResolverContext = pendingResolverContexts.get(
+        ctx.__resolverRequestId
+      );
+      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? ctx.__resolverOriginalContext : pendingResolverContext?.originalContext ? { ...pendingResolverContext.originalContext } : {};
+      const originalQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : pendingResolverContext?.originalQueryData;
       const normalizedContext = {
         ...originalContext,
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
+      pendingResolverContexts.delete(ctx.__resolverRequestId);
       emit(executionResolvedSignal, normalizedContext);
       return normalizedContext;
     },
@@ -8777,6 +8789,7 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
             ...resultCtx
           };
           delete normalizedResult.__resolverRequestId;
+          pendingResolverContexts.delete(resolverRequestId);
           resolve(normalizedResult);
           return normalizedResult;
         },
@@ -9039,17 +9052,16 @@ var GraphSyncController = class _GraphSyncController {
     ).doOn("meta.sync_controller.routine_registration_settled").emits("meta.sync_controller.synced_routines");
     this.splitTasksInRoutines = CadenzaService.createMetaTask(
       "Split tasks in routines",
-      (ctx, emit) => {
+      function* (ctx) {
         const { routines } = ctx;
-        if (!routines) return false;
+        if (!routines) return;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return false;
+          return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        let emittedCount = 0;
         for (const routine of routines) {
           if (!routine.registered) continue;
           for (const task of routine.tasks) {
@@ -9063,7 +9075,7 @@ var GraphSyncController = class _GraphSyncController {
               if (!nextTask?.registered) {
                 continue;
               }
-              emit("meta.sync_controller.routine_task_map_split", {
+              yield {
                 __syncing: ctx.__syncing,
                 data: {
                   taskName: nextTask.name,
@@ -9074,47 +9086,46 @@ var GraphSyncController = class _GraphSyncController {
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
-              });
-              emittedCount += 1;
+              };
             }
           }
         }
-        return emittedCount > 0;
       }
     );
-    CadenzaService.createMetaTask("Process split routine task map", (ctx) => ctx).doOn("meta.sync_controller.routine_task_map_split").then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "task_to_routine_map",
-        {
-          onConflict: {
-            target: [
-              "task_name",
-              "routine_name",
-              "task_version",
-              "routine_version",
-              "service_name"
-            ],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Register routine task", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    const registerTaskToRoutineMapTask = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "task_to_routine_map",
+      {
+        onConflict: {
+          target: [
+            "task_name",
+            "routine_name",
+            "task_version",
+            "routine_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 2e3
-          });
-          CadenzaService.getRoutine(ctx.__routineName).registeredTasks.add(
-            ctx.__taskName
-          );
-        })
-      )
+        }
+      },
+      { concurrency: 30 }
+    )?.then(
+      CadenzaService.createMetaTask("Register routine task", (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 2e3
+        });
+        CadenzaService.getRoutine(ctx.__routineName).registeredTasks.add(
+          ctx.__taskName
+        );
+      })
     );
+    if (registerTaskToRoutineMapTask) {
+      this.splitTasksInRoutines.then(registerTaskToRoutineMapTask);
+    }
     this.splitSignalsTask = CadenzaService.createMetaTask(
       "Split signals for registration",
       (ctx, emit) => {
@@ -9182,20 +9193,19 @@ var GraphSyncController = class _GraphSyncController {
     ).doOn("meta.sync_controller.signal_registration_settled").emits("meta.sync_controller.synced_signals");
     this.splitTasksForRegistration = CadenzaService.createMetaTask(
       "Split tasks for registration",
-      (ctx, emit) => {
+      function* (ctx) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const tasks = ctx.tasks;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return false;
+          return;
         }
-        let emittedCount = 0;
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
-          emit("meta.sync_controller.task_registration_split", {
+          yield {
             __syncing: ctx.__syncing,
             data: {
               name: task.name,
@@ -9229,47 +9239,46 @@ var GraphSyncController = class _GraphSyncController {
               }
             },
             __taskName: task.name
-          });
-          emittedCount += 1;
+          };
         }
-        return emittedCount > 0;
       }
     );
-    CadenzaService.createMetaTask("Process split task registration", (ctx) => ctx).doOn("meta.sync_controller.task_registration_split").then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "task",
-        {
-          onConflict: {
-            target: ["name", "service_name", "version"],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    const registerTaskTask = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "task",
+      {
+        onConflict: {
+          target: ["name", "service_name", "version"],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          CadenzaService.get(ctx.__taskName).registered = true;
-          emit("meta.sync_controller.task_registered", {
-            ...ctx,
-            task: CadenzaService.get(ctx.__taskName)
-          });
-          CadenzaService.debounce(
-            "meta.sync_controller.task_registration_settled",
-            { __syncing: true },
-            300
-          );
-          return true;
-        })
-      )
+        }
+      },
+      { concurrency: 30 }
+    )?.then(
+      CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        CadenzaService.get(ctx.__taskName).registered = true;
+        emit("meta.sync_controller.task_registered", {
+          ...ctx,
+          task: CadenzaService.get(ctx.__taskName)
+        });
+        CadenzaService.debounce(
+          "meta.sync_controller.task_registration_settled",
+          { __syncing: true },
+          300
+        );
+        return true;
+      })
     );
+    if (registerTaskTask) {
+      this.splitTasksForRegistration.then(registerTaskTask);
+    }
     CadenzaService.createUniqueMetaTask(
       "Gather task registration",
       () => {