@cadenza.io/service 2.17.73 → 2.17.75

package/dist/index.d.mts

@@ -22926,6 +22926,8 @@ declare class RestController {
     private resolveTransportDiagnosticsOptions;
     private ensureFetchClientDiagnostics;
     private getErrorMessage;
+    private resolveJsonBodyLimit;
+    private parseFetchResponse;
     private resolveDelegationTimeoutMs;
     private recordFetchClientError;
     private collectFetchTransportDiagnostics;

package/dist/index.d.ts

@@ -22926,6 +22926,8 @@ declare class RestController {
     private resolveTransportDiagnosticsOptions;
     private ensureFetchClientDiagnostics;
     private getErrorMessage;
+    private resolveJsonBodyLimit;
+    private parseFetchResponse;
     private resolveDelegationTimeoutMs;
     private recordFetchClientError;
     private collectFetchTransportDiagnostics;

package/dist/index.js

@@ -3663,11 +3663,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 (0, import_node_fetch.default)(url, { ...requestInit, signal });
-        return await response.json();
+        const parsedResponse = await this.parseFetchResponse(response);
+        return parsedResponse.data;
       } catch (error) {
         if (error?.name === "AbortError") {
           CadenzaService.log(
@@ -3733,7 +3734,11 @@ var RestController = class _RestController {
             }
             console.log("Service inserted...");
             const app = (0, import_express.default)();
-            app.use(import_body_parser.default.json());
+            app.use(
+              import_body_parser.default.json({
+                limit: this.resolveJsonBodyLimit()
+              })
+            );
             switch (ctx.__securityProfile) {
               case "low":
                 app.use((0, import_helmet.default)());
@@ -3906,6 +3911,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"
@@ -4444,6 +4475,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
@@ -9749,7 +9816,7 @@ var GraphSyncController = class _GraphSyncController {
         });
         const signalName = resolveSignalNameFromSyncContext(ctx);
         if (!signalName) {
-          return true;
+          return false;
         }
         const signalObservers = CadenzaService.signalBroker.signalObservers;
         if (!signalObservers?.has(signalName)) {