@cadenza.io/service 2.17.18 → 2.17.20

package/dist/index.js

@@ -8232,18 +8232,89 @@ function buildIntentRegistryData(intent) {
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   return CadenzaService.getLocalCadenzaDBInsertTask(tableName) ?? (isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0);
 }
+var CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES = [
+  "intent_registry",
+  "routine",
+  "task_to_routine_map",
+  "signal_registry",
+  "task",
+  "actor",
+  "actor_task_map",
+  "signal_to_task_map",
+  "intent_to_task_map",
+  "directional_task_graph_map"
+];
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
     this.registeredActorTaskMaps = /* @__PURE__ */ new Set();
     this.registeredIntentDefinitions = /* @__PURE__ */ new Set();
+    this.loggedAuthorityTaskIntentDiagnostics = /* @__PURE__ */ new Set();
     this.isCadenzaDBReady = false;
+    this.initialized = false;
+    this.initRetryScheduled = false;
+    this.loggedCadenzaDBIntentSweep = false;
+    this.lastMissingLocalCadenzaDBInsertTablesKey = "";
   }
   static get instance() {
     if (!this._instance) this._instance = new _GraphSyncController();
     return this._instance;
   }
+  getMissingLocalCadenzaDBInsertTables() {
+    return CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES.filter(
+      (tableName) => !CadenzaService.getLocalCadenzaDBInsertTask(tableName)
+    );
+  }
+  ensureRetryInitTask() {
+    if (this.initRetryTask) {
+      return this.initRetryTask;
+    }
+    this.initRetryTask = CadenzaService.get("Retry graph sync init") ?? CadenzaService.createUniqueMetaTask(
+      "Retry graph sync init",
+      () => {
+        this.initRetryScheduled = false;
+        this.init();
+        return true;
+      },
+      "Retries graph sync controller initialization once local authority tasks exist."
+    ).doOn("meta.sync_controller.init_retry");
+    return this.initRetryTask;
+  }
   init() {
+    if (this.initialized) {
+      return;
+    }
+    const serviceName = resolveSyncServiceName();
+    if (serviceName === "CadenzaDB") {
+      const missingLocalInsertTables = this.getMissingLocalCadenzaDBInsertTables();
+      if (missingLocalInsertTables.length > 0) {
+        this.ensureRetryInitTask();
+        const missingKey = missingLocalInsertTables.join(",");
+        if (missingKey !== this.lastMissingLocalCadenzaDBInsertTablesKey) {
+          this.lastMissingLocalCadenzaDBInsertTablesKey = missingKey;
+          CadenzaService.log(
+            "Waiting for local CadenzaDB sync insert tasks before initializing graph sync controller.",
+            {
+              missingLocalInsertTables
+            },
+            "info"
+          );
+        }
+        if (!this.initRetryScheduled) {
+          this.initRetryScheduled = true;
+          CadenzaService.schedule(
+            "meta.sync_controller.init_retry",
+            {
+              __missingLocalInsertTables: missingLocalInsertTables
+            },
+            250
+          );
+        }
+        return;
+      }
+      this.lastMissingLocalCadenzaDBInsertTablesKey = "";
+    }
+    this.initialized = true;
     const insertIntentRegistryTask = resolveSyncInsertTask(
       this.isCadenzaDBReady,
       "intent_registry",
@@ -8262,8 +8333,8 @@ var GraphSyncController = class _GraphSyncController {
       async function* (ctx, emit) {
         const { routines } = ctx;
         if (!routines) return;
-        const serviceName = resolveSyncServiceName();
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8276,7 +8347,7 @@ var GraphSyncController = class _GraphSyncController {
               name: routine.name,
               version: routine.version,
               description: routine.description,
-              serviceName,
+              serviceName: serviceName2,
               isMeta: routine.isMeta
             },
             __routineName: routine.name
@@ -8319,8 +8390,8 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const { routines } = ctx;
         if (!routines) return;
-        const serviceName = resolveSyncServiceName();
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8342,7 +8413,7 @@ var GraphSyncController = class _GraphSyncController {
                   taskVersion: nextTask.version,
                   routineName: routine.name,
                   routineVersion: routine.version,
-                  serviceName
+                  serviceName: serviceName2
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
@@ -8447,8 +8518,8 @@ var GraphSyncController = class _GraphSyncController {
           delayMs: 3e3
         });
         const tasks = ctx.tasks;
-        const serviceName = resolveSyncServiceName();
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
           return;
         }
         for (const task of tasks) {
@@ -8480,7 +8551,7 @@ var GraphSyncController = class _GraphSyncController {
               retryDelay: task.retryDelay,
               retryDelayMax: task.retryDelayMax,
               retryDelayFactor: task.retryDelayFactor,
-              service_name: serviceName,
+              service_name: serviceName2,
               signals: {
                 emits: Array.from(task.emitsSignals),
                 signalsToEmitAfter: Array.from(task.signalsToEmitAfter),
@@ -8533,15 +8604,15 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        const serviceName = resolveSyncServiceName();
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
           return;
         }
         const actors = ctx.actors ?? [];
         for (const actor of actors) {
           const data = {
             ...buildActorRegistrationData(actor),
-            service_name: serviceName
+            service_name: serviceName2
           };
           if (!data.name) {
             continue;
@@ -8598,11 +8669,11 @@ var GraphSyncController = class _GraphSyncController {
         if (!metadata?.actorName) {
           return;
         }
-        const serviceName = resolveSyncServiceName(task);
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName(task);
+        if (!serviceName2) {
           return;
         }
-        const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${serviceName}`;
+        const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${serviceName2}`;
         if (this.registeredActorTaskMaps.has(registrationKey)) {
           return;
         }
@@ -8612,7 +8683,7 @@ var GraphSyncController = class _GraphSyncController {
             actor_version: 1,
             task_name: task.name,
             task_version: task.version,
-            service_name: serviceName,
+            service_name: serviceName2,
             mode: metadata.mode,
             description: task.description ?? metadata.actorDescription ?? "",
             is_meta: metadata.actorKind === "meta" || task.isMeta === true
@@ -8668,8 +8739,8 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const task = ctx.task;
         if (task.hidden || !task.register) return;
-        const serviceName = resolveSyncServiceName(task);
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName(task);
+        if (!serviceName2) {
           return;
         }
         for (const signal of task.observedSignals) {
@@ -8682,7 +8753,7 @@ var GraphSyncController = class _GraphSyncController {
               isGlobal,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName
+              serviceName: serviceName2
             },
             __taskName: task.name,
             __signal: signal
@@ -8716,6 +8787,24 @@ var GraphSyncController = class _GraphSyncController {
           delayMs: 3e3
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
+        if (resolveSyncServiceName() === "CadenzaDB" && !this.loggedCadenzaDBIntentSweep) {
+          const intentNames = intents.map((intent) => String(intent?.name ?? "").trim()).filter(Boolean);
+          const authorityIntentNames = intentNames.filter(
+            (intentName) => intentName === "meta-service-registry-full-sync" || intentName.includes("service_instance") || intentName.includes("service_instance_transport") || intentName.includes("intent_to_task_map") || intentName.includes("signal_to_task_map")
+          );
+          CadenzaService.log(
+            "CadenzaDB intent sweep diagnostics.",
+            {
+              totalIntents: intentNames.length,
+              hasMetaServiceRegistryFullSync: intentNames.includes(
+                "meta-service-registry-full-sync"
+              ),
+              authorityIntentNames
+            },
+            "info"
+          );
+          this.loggedCadenzaDBIntentSweep = true;
+        }
         for (const intent of intents) {
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
@@ -8768,12 +8857,34 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const task = ctx.task;
         if (task.hidden || !task.register) return;
-        const serviceName = resolveSyncServiceName(task);
-        if (!serviceName) {
+        const serviceName2 = resolveSyncServiceName(task);
+        if (!serviceName2) {
           return;
         }
         task.__registeredIntents = task.__registeredIntents ?? /* @__PURE__ */ new Set();
         task.__invalidMetaIntentWarnings = task.__invalidMetaIntentWarnings ?? /* @__PURE__ */ new Set();
+        if (serviceName2 === "CadenzaDB" && [
+          "Query service_instance",
+          "Query service_instance_transport",
+          "Query intent_to_task_map",
+          "Query signal_to_task_map"
+        ].includes(task.name)) {
+          const authorityTaskKey = `${task.name}:${task.version}`;
+          if (!this.loggedAuthorityTaskIntentDiagnostics.has(authorityTaskKey)) {
+            this.loggedAuthorityTaskIntentDiagnostics.add(authorityTaskKey);
+            CadenzaService.log(
+              "CadenzaDB authority task intent diagnostics.",
+              {
+                taskName: task.name,
+                taskVersion: task.version,
+                isMeta: task.isMeta,
+                handlesIntents: Array.from(task.handlesIntents ?? []),
+                registeredIntents: Array.from(task.__registeredIntents ?? [])
+              },
+              "info"
+            );
+          }
+        }
         for (const intent of task.handlesIntents) {
           if (task.__registeredIntents.has(intent)) continue;
           if (isMetaIntentName(intent) && !task.isMeta) {
@@ -8800,7 +8911,7 @@ var GraphSyncController = class _GraphSyncController {
               intentName: intent,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName
+              serviceName: serviceName2
             },
             __taskName: task.name,
             __intent: intent,
@@ -8809,11 +8920,11 @@ var GraphSyncController = class _GraphSyncController {
               intentName: intent,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName
+              serviceName: serviceName2
             }
           };
         }
-      }
+      }.bind(this)
     ).then(
       CadenzaService.createMetaTask(
         "Prepare intent definition for intent-to-task map",
@@ -8878,8 +8989,8 @@ var GraphSyncController = class _GraphSyncController {
           if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register) {
             continue;
           }
-          const serviceName = resolveSyncServiceName(t);
-          if (!serviceName) {
+          const serviceName2 = resolveSyncServiceName(t);
+          if (!serviceName2) {
             continue;
           }
           yield {
@@ -8888,7 +8999,7 @@ var GraphSyncController = class _GraphSyncController {
               taskVersion: t.version,
               predecessorTaskName: task.name,
               predecessorTaskVersion: task.version,
-              serviceName,
+              serviceName: serviceName2,
               predecessorServiceName
             },
             __taskName: task.name,
@@ -8937,16 +9048,16 @@ var GraphSyncController = class _GraphSyncController {
         if (task.hidden || !task.register) return;
         if (task.isDeputy && !task.signalName) {
           if (task.registeredDeputyMap) return;
-          const serviceName = resolveSyncServiceName(task);
+          const serviceName2 = resolveSyncServiceName(task);
           const predecessorServiceName = resolveSyncServiceName();
-          if (!serviceName || !predecessorServiceName) {
+          if (!serviceName2 || !predecessorServiceName) {
             return;
           }
           return {
             data: {
               task_name: task.remoteRoutineName,
               task_version: 1,
-              service_name: serviceName,
+              service_name: serviceName2,
               predecessor_task_name: task.name,
               predecessor_task_version: task.version,
               predecessor_service_name: predecessorServiceName