@cadenza.io/service 2.17.75 → 2.17.77

package/dist/browser/index.js

@@ -1212,39 +1212,12 @@ var ServiceRegistry = class _ServiceRegistry {
         if (trackedInstance?.isFrontend) {
           return true;
         }
-        const trackedTransport = this.getRouteableTransport(
-          trackedInstance,
-          this.useSocket ? "socket" : "rest"
-        );
         if (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName)) {
-          const communicationTypes = Array.from(
-            new Set(
-              this.deputies.get(serviceName)?.map((d) => d.communicationType) ?? []
-            )
+          const connected = this.ensureDependeeClientForInstance(
+            trackedInstance,
+            emit
           );
-          if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
-            communicationTypes.push("signal");
-          }
-          if (trackedTransport) {
-            const clientCreated = this.hasTransportClientCreated(
-              trackedInstance,
-              trackedTransport.uuid
-            );
-            if (!clientCreated) {
-              emit("meta.service_registry.dependee_registered", {
-                serviceName,
-                serviceInstanceId: uuid7,
-                serviceTransportId: trackedTransport.uuid,
-                serviceOrigin: trackedTransport.origin,
-                transportProtocols: trackedTransport.protocols,
-                communicationTypes
-              });
-              this.markTransportClientCreated(
-                trackedInstance,
-                trackedTransport.uuid
-              );
-            }
-          } else {
+          if (!connected) {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
               serviceInstanceId: uuid7,
@@ -1310,25 +1283,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!hasRemoteInterest) {
           return true;
         }
-        if (!this.hasTransportClientCreated(ownerInstance, transport.uuid)) {
-          const communicationTypes = Array.from(
-            new Set(
-              this.deputies.get(ownerInstance.serviceName)?.map((descriptor) => descriptor.communicationType) ?? []
-            )
-          );
-          if (!communicationTypes.includes("signal") && this.remoteSignals.has(ownerInstance.serviceName)) {
-            communicationTypes.push("signal");
-          }
-          emit("meta.service_registry.dependee_registered", {
-            serviceName: ownerInstance.serviceName,
-            serviceInstanceId: ownerInstance.uuid,
-            serviceTransportId: transport.uuid,
-            serviceOrigin: transport.origin,
-            transportProtocols: transport.protocols,
-            communicationTypes
-          });
-          this.markTransportClientCreated(ownerInstance, transport.uuid);
-        }
+        this.ensureDependeeClientForInstance(ownerInstance, emit);
         return true;
       },
       "Handles service transport updates independently from instance rows."
@@ -1357,11 +1312,13 @@ var ServiceRegistry = class _ServiceRegistry {
       },
       "Tracks remote dependency instances for runtime heartbeat monitoring."
     ).doOn("meta.service_registry.dependee_registered");
+    const normalizeServiceInstancesFromSync = (ctx) => this.normalizeServiceInstancesFromSync(ctx);
     CadenzaService.createMetaTask("Split service instances", function* (ctx) {
-      if (!ctx.serviceInstances) {
+      const serviceInstances = normalizeServiceInstancesFromSync(ctx);
+      if (serviceInstances.length === 0) {
         return;
       }
-      for (const serviceInstance of ctx.serviceInstances) {
+      for (const serviceInstance of serviceInstances) {
         yield { serviceInstance };
       }
     }).doOn(
@@ -1409,7 +1366,7 @@ var ServiceRegistry = class _ServiceRegistry {
     ).emits("meta.service_registry.registered_global_signals").doOn("global.meta.cadenza_db.gathered_sync_data");
     this.handleGlobalIntentRegistrationTask = CadenzaService.createMetaTask(
       "Handle global intent registration",
-      (ctx) => {
+      (ctx, emit) => {
         const intentToTaskMaps = this.normalizeIntentMaps(ctx);
         const sorted = intentToTaskMaps.sort((a, b) => {
           if (a.deleted && !b.deleted) return -1;
@@ -1425,6 +1382,7 @@ var ServiceRegistry = class _ServiceRegistry {
             name: map.intentName
           });
           this.registerRemoteIntentDeputy(map);
+          this.ensureDependeeClientsForService(map.serviceName, emit);
         }
         return true;
       },
@@ -2850,6 +2808,49 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return buildTransportClientKey(transport);
   }
+  resolveCommunicationTypesForService(serviceName) {
+    const communicationTypes = Array.from(
+      new Set(
+        this.deputies.get(serviceName)?.map((descriptor) => descriptor.communicationType) ?? []
+      )
+    );
+    if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
+      communicationTypes.push("signal");
+    }
+    return communicationTypes;
+  }
+  ensureDependeeClientForInstance(instance, emit) {
+    if (!instance || instance.uuid === this.serviceInstanceId || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+      return false;
+    }
+    if (!this.deputies.has(instance.serviceName) && !this.remoteIntents.has(instance.serviceName) && !this.remoteSignals.has(instance.serviceName)) {
+      return false;
+    }
+    const transport = this.getRouteableTransport(
+      instance,
+      this.useSocket ? "socket" : "rest"
+    );
+    if (!transport || this.hasTransportClientCreated(instance, transport.uuid)) {
+      return false;
+    }
+    emit("meta.service_registry.dependee_registered", {
+      serviceName: instance.serviceName,
+      serviceInstanceId: instance.uuid,
+      serviceTransportId: transport.uuid,
+      serviceOrigin: transport.origin,
+      transportProtocols: transport.protocols,
+      communicationTypes: this.resolveCommunicationTypesForService(
+        instance.serviceName
+      )
+    });
+    this.markTransportClientCreated(instance, transport.uuid);
+    return true;
+  }
+  ensureDependeeClientsForService(serviceName, emit) {
+    for (const instance of this.instances.get(serviceName) ?? []) {
+      this.ensureDependeeClientForInstance(instance, emit);
+    }
+  }
   hasTransportClientCreated(instance, transportId) {
     return (instance.clientCreatedTransportIds ?? []).includes(transportId);
   }