@cadenza.io/service 1.21.16 → 1.22.0

package/dist/index.js

@@ -192,7 +192,6 @@ var DeputyTask = class extends import_core.Task {
       },
       ...ctx
     };
-    console.log("DEPUTY CONTEXT", deputyContext);
     return this.taskFunction(deputyContext, emit, progressCallback);
   }
 };
@@ -1181,7 +1180,7 @@ var RestController = class _RestController {
                 try {
                   ctx2 = req.body;
                   deputyExecId = ctx2.__metadata.__deputyExecId;
-                  console.log("delegation", deputyExecId, ctx2);
+                  console.log("Rest delegation", deputyExecId, ctx2);
                 } catch (e) {
                   console.error("Error in delegation", e);
                   res.send({
@@ -1195,7 +1194,7 @@ var RestController = class _RestController {
                 CadenzaService.createEphemeralMetaTask(
                   "Resolve delegation",
                   (endCtx) => {
-                    console.log("Resolve delegation", endCtx);
+                    console.log("Resolve Rest delegation", endCtx);
                     const metadata = endCtx.__metadata;
                     delete endCtx.__metadata;
                     res.json({
@@ -1216,7 +1215,7 @@ var RestController = class _RestController {
                 let ctx2;
                 try {
                   ctx2 = req.body;
-                  console.log("SIGNAL RECEIVED", ctx2);
+                  console.log("SIGNAL RECEIVED", ctx2.__signalName);
                   if (!CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
                     res.send({
                       ...ctx2,
@@ -1372,7 +1371,7 @@ var RestController = class _RestController {
         const handshakeTask = CadenzaService.createMetaTask(
           `Send Handshake to ${URL}`,
           async (ctx2, emit2) => {
-            console.log("Sending handshake", ctx2);
+            console.log("Sending Rest handshake", ctx2);
             try {
               const response = await this.fetchDataWithTimeout(
                 `${URL}/handshake`,
@@ -1385,7 +1384,7 @@ var RestController = class _RestController {
                 },
                 1e3
               );
-              console.log("Handshake result", response);
+              console.log("Rest Handshake result", response);
               if (response.__status !== "success") {
                 const error = response.__error ?? `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`;
                 console.error(error);
@@ -1421,7 +1420,7 @@ var RestController = class _RestController {
             if (ctx2.__remoteRoutineName === void 0) {
               return;
             }
-            console.log("Delegating", ctx2);
+            console.log("Delegating via REST", ctx2);
             let resultContext;
             try {
               const response = await (0, import_node_fetch.default)(`${URL}/delegation`, {
@@ -1583,12 +1582,19 @@ var SocketController = class _SocketController {
           }
           console.log("SocketServer: Setting up");
           const server = new import_socket.Server(ctx.__httpsServer ?? ctx.__httpServer, {
-            maxHttpBufferSize: 1e7
+            pingInterval: 3e4,
+            pingTimeout: 2e4,
+            maxHttpBufferSize: 1e7,
             // 10MB large payloads
+            connectionStateRecovery: {
+              maxDisconnectionDuration: 2 * 60 * 1e3,
+              // 2min
+              skipMiddlewares: true
+              // Optional: bypass rate limiter on recover
+            }
           });
           const profile = ctx.__securityProfile ?? "medium";
           server.use((socket, next) => {
-            console.log("Middleware running for socket:", socket.id);
             const origin = socket?.handshake?.headers?.origin;
             const allowedOrigins = ["*"];
             const networkType = ctx.__networkType ?? "internal";
@@ -1605,13 +1611,6 @@ var SocketController = class _SocketController {
             const limiter = new import_rate_limiter_flexible2.RateLimiterMemory(limiterOptions[profile]);
             const clientKey = socket?.handshake?.address || "unknown";
             socket.use((packet, packetNext) => {
-              console.log(
-                "Incoming packet:",
-                packet[0],
-                "from socket:",
-                socket.id,
-                clientKey
-              );
               limiter.consume(clientKey).then(() => packetNext()).catch((rej) => {
                 if (rej.msBeforeNext > 0) {
                   console.log(
@@ -1753,9 +1752,6 @@ var SocketController = class _SocketController {
                   __wsId: ws.id
                 });
               });
-              ws.onAny((event) => {
-                console.log("SocketServer: Any", event);
-              });
             } catch (e) {
               console.error("SocketServer: Error in socket event", e);
             }
@@ -1789,22 +1785,50 @@ var SocketController = class _SocketController {
         console.log("SocketClient: Connecting to", serviceName, URL);
         const socket = (0, import_socket2.io)(URL, {
           reconnection: true,
-          reconnectionAttempts: 20,
-          reconnectionDelay: 1e3,
+          reconnectionAttempts: 5,
+          reconnectionDelay: 2e3,
           reconnectionDelayMax: 1e4,
           randomizationFactor: 0.5,
-          retries: 5,
-          transports: ["websocket"]
+          transports: ["websocket"],
+          autoConnect: false
         });
-        const originalEmit = socket.emit;
-        let emitId = 0;
-        socket.emit = function(event, ...args) {
-          emitId++;
-          console.log(`[SOCKET EMIT #${emitId}] "${event}"`, {
-            args: args[0],
-            stack: new Error().stack?.split("\n").slice(1, 4).join("\n")
+        const emitWhenReady = (event, data, timeoutMs = 2e4, ack) => {
+          return new Promise((resolve, reject) => {
+            const tryEmit = () => {
+              if (!socket.connected) {
+                socket.once("connect", tryEmit);
+                return;
+              }
+              let timer;
+              if (timeoutMs !== 0) {
+                timer = setTimeout(() => {
+                  console.error(`${event} timed out`);
+                  reject(new Error(`${event} timed out`));
+                }, timeoutMs);
+              }
+              socket.timeout(timeoutMs).emit(event, data, (err, response) => {
+                if (err) {
+                  console.log("Timeout error:", err);
+                  response = {
+                    __error: `Timeout error: ${err}`,
+                    errored: true,
+                    ...ctx,
+                    ...ctx.__metadata
+                  };
+                  resolve(response);
+                  return;
+                }
+                if (timer) clearTimeout(timer);
+                if (ack) ack(response);
+                resolve(response);
+              });
+            };
+            if (socket.connected) {
+              tryEmit();
+            } else {
+              socket.once("connect", tryEmit);
+            }
           });
-          return originalEmit.apply(this, [event, ...args]);
         };
         socket.on("connect", () => {
           console.log("SocketClient: CONNECTED", socket.id);
@@ -1848,12 +1872,6 @@ var SocketController = class _SocketController {
           console.error("SocketClient: error", err);
           CadenzaService.broker.emit("meta.socket_client.error", err);
         });
-        socket.onAny((event) => {
-          console.log("SocketClient: Any", event);
-        });
-        socket.onAnyOutgoing((event) => {
-          console.log("Outgoing packet", event);
-        });
         socket.on("disconnect", () => {
           console.log("SocketClient: Disconnected", URL);
           CadenzaService.broker.emit(`meta.socket_client.disconnected:${fetchId}`, {
@@ -1861,13 +1879,15 @@ var SocketController = class _SocketController {
             serviceAddress,
             servicePort
           });
+          handshake = false;
         });
+        socket.connect();
         CadenzaService.createEphemeralMetaTask(
           `Handshake with ${URL}`,
-          (ctx2) => {
+          async () => {
             console.log("SocketClient: HANDSHAKING", URL);
             handshake = true;
-            socket.emit(
+            await emitWhenReady(
               "handshake",
               {
                 serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
@@ -1875,8 +1895,9 @@ var SocketController = class _SocketController {
                 isFrontend: isBrowser,
                 __status: "success"
               },
+              1e4,
               (result) => {
-                console.log("handshake result", result);
+                console.log("Socket handshake result", result);
               }
             );
           },
@@ -1891,8 +1912,11 @@ var SocketController = class _SocketController {
             return new Promise((resolve, reject) => {
               delete ctx2.__isSubMeta;
               console.log("Socket Delegate:", socket.connected, ctx2);
-              try {
-                socket.emit("delegation", ctx2, (resultContext) => {
+              emitWhenReady(
+                "delegation",
+                ctx2,
+                2e4,
+                (resultContext) => {
                   console.log("Resolved socket delegate", resultContext);
                   const metadata = resultContext.__metadata;
                   delete resultContext.__metadata;
@@ -1904,11 +1928,8 @@ var SocketController = class _SocketController {
                     }
                   );
                   resolve(resultContext);
-                });
-              } catch (e) {
-                console.log("Socket Delegate Error:", e);
-                reject(e);
-              }
+                }
+              );
             });
           },
           `Delegate flow to service ${serviceName} with address ${URL}`
@@ -1919,23 +1940,8 @@ var SocketController = class _SocketController {
             if (ctx2.__signalName === void 0) {
               return;
             }
-            return new Promise((resolve, reject) => {
-              socket.timeout(ctx2.__timeout ?? 1e4).emit("signal", ctx2, (err, response) => {
-                if (err) {
-                  console.log("socket error:", err);
-                  response = {
-                    __error: `Timeout error: ${err}`,
-                    errored: true,
-                    ...ctx2,
-                    ...ctx2.__metadata
-                  };
-                  emit(
-                    `meta.socket_client.signal_transmission_failed`,
-                    response
-                  );
-                  resolve(response);
-                  return;
-                }
+            return new Promise((resolve) => {
+              emitWhenReady("signal", ctx2, 1e4, (response) => {
                 if (ctx2.__routineExecId) {
                   emit(
                     `meta.socket_client.transmitted:${ctx2.__routineExecId}`,
@@ -2047,7 +2053,6 @@ var SignalController = class _SignalController {
             ctx.__emitterSignalName = __signalName;
             ctx.__signalName = "meta.signal_controller.foreign_signal_registered";
             ctx.__remoteServiceName = serviceName;
-            console.log("REMOTE SIGNAL DETECTED", ctx);
             if (serviceName === "*") {
               emit("meta.signal_controller.wildcard_signal_registered", ctx);
             } else {
@@ -2078,11 +2083,6 @@ var SignalController = class _SignalController {
     ).doAfter(CadenzaService.serviceRegistry.getRemoteSignalsTask);
     CadenzaService.createMetaTask("Handle foreign signal registration", (ctx) => {
       const { __emitterSignalName, __listenerServiceName } = ctx;
-      console.log(
-        "CREATING SIGNAL TRANSMISSION",
-        __emitterSignalName,
-        __listenerServiceName
-      );
       CadenzaService.createSignalTransmissionTask(
         __emitterSignalName,
         __listenerServiceName
@@ -2903,7 +2903,6 @@ var DatabaseController = class _DatabaseController {
                                         }
                                       }
                                     }
-                                    console.log("DDL applied");
                                     return true;
                                   },
                                   "Applies generated DDL to the database"
@@ -3573,7 +3572,6 @@ var GraphSyncController = class _GraphSyncController {
       for (const task of __tasks) {
         if (task.registered) continue;
         task.registered = true;
-        console.log("REGISTERING TASK", task.name);
         const { __functionString, __getTagCallback } = task.export();
         emit("meta.sync_controller.task_added", {
           data: {