@cadenza.io/service 2.17.74 → 2.17.76

package/dist/index.mjs

@@ -1161,39 +1161,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: uuid8,
-                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: uuid8,
@@ -1259,25 +1232,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."
@@ -1358,7 +1313,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;
@@ -1374,6 +1329,7 @@ var ServiceRegistry = class _ServiceRegistry {
             name: map.intentName
           });
           this.registerRemoteIntentDeputy(map);
+          this.ensureDependeeClientsForService(map.serviceName, emit);
         }
         return true;
       },
@@ -2799,6 +2755,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);
   }
@@ -3612,11 +3611,12 @@ var RestController = class _RestController {
      * @returns {Promise<any>} A promise that resolves to the parsed response data if the request is successful.
      * @throws {Error} Throws an error if the request fails due to issues such as timeout or other unexpected errors.
      */
-    this.fetchDataWithTimeout = async function(url, requestInit, timeoutMs) {
+    this.fetchDataWithTimeout = async (url, requestInit, timeoutMs) => {
       const signal = AbortSignal.timeout(timeoutMs);
       try {
         const response = await fetch(url, { ...requestInit, signal });
-        return await response.json();
+        const parsedResponse = await this.parseFetchResponse(response);
+        return parsedResponse.data;
       } catch (error) {
         if (error?.name === "AbortError") {
           CadenzaService.log(
@@ -3682,7 +3682,11 @@ var RestController = class _RestController {
             }
             console.log("Service inserted...");
             const app = express();
-            app.use(bodyParser.json());
+            app.use(
+              bodyParser.json({
+                limit: this.resolveJsonBodyLimit()
+              })
+            );
             switch (ctx.__securityProfile) {
               case "low":
                 app.use(helmet());
@@ -3855,6 +3859,32 @@ var RestController = class _RestController {
                   )
                 );
               });
+              app.use(
+                (error, _req, res, next) => {
+                  if (!error) {
+                    next();
+                    return;
+                  }
+                  const statusCode = typeof error.statusCode === "number" ? error.statusCode : typeof error.status === "number" ? error.status : error.type === "entity.too.large" ? 413 : 500;
+                  const message = error.type === "entity.too.large" ? `Request payload exceeded REST body limit ${this.resolveJsonBodyLimit()}.` : this.getErrorMessage(error);
+                  CadenzaService.log(
+                    "REST request failed before route completion.",
+                    {
+                      error: message,
+                      type: error.type,
+                      statusCode,
+                      path: _req?.path,
+                      method: _req?.method
+                    },
+                    statusCode >= 500 ? "error" : "warning"
+                  );
+                  res.status(statusCode).json({
+                    __status: "error",
+                    errored: true,
+                    __error: message
+                  });
+                }
+              );
               return true;
             },
             "Starts REST server and initiates meta-handling"
@@ -4393,6 +4423,42 @@ var RestController = class _RestController {
       return String(error);
     }
   }
+  resolveJsonBodyLimit() {
+    const configuredLimit = process.env.CADENZA_REST_BODY_LIMIT?.trim();
+    return configuredLimit && configuredLimit.length > 0 ? configuredLimit : "10mb";
+  }
+  async parseFetchResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const rawText = await response.text();
+    const headers = Object.fromEntries(response.headers.entries());
+    if (rawText.length === 0) {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        data: {}
+      };
+    }
+    if (!contentType.toLowerCase().includes("application/json")) {
+      throw new Error(
+        `Expected JSON response from ${response.url ?? "remote service"} but received ${contentType || "unknown content type"} (HTTP ${response.status}). Body preview: ${rawText.slice(0, 200)}`
+      );
+    }
+    try {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        data: JSON.parse(rawText)
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse JSON response from ${response.url ?? "remote service"} (HTTP ${response.status}). Body preview: ${rawText.slice(0, 200)}. Parse error: ${this.getErrorMessage(error)}`
+      );
+    }
+  }
   resolveDelegationTimeoutMs(ctx) {
     const syncing = ctx?.__syncing === true || ctx?.__metadata?.__syncing === true || Array.isArray(ctx?.joinedContexts) && ctx.joinedContexts.some(
       (joinedCtx) => joinedCtx?.__syncing === true || joinedCtx?.__metadata?.__syncing === true