@cadenza.io/service 1.9.54 → 1.9.55

package/dist/index.js

@@ -418,7 +418,7 @@ var ServiceRegistry = class _ServiceRegistry {
         let remoteSignals = (_a2 = this.remoteSignals.get(serviceName)) != null ? _a2 : [];
         remoteSignals = remoteSignals.concat((_b2 = this.remoteSignals.get("*")) != null ? _b2 : []);
         return __spreadValues({
-          __remoteSignals: remoteSignals
+          remoteSignals
         }, ctx);
       },
       "Gets remote signals"
@@ -749,11 +749,11 @@ var ServiceRegistry = class _ServiceRegistry {
         "Setup service",
         (ctx) => {
           var _a2, _b2;
-          const { serviceInstance, data, __useSocket, __retryCount } = ctx;
-          this.serviceInstanceId = (_a2 = data == null ? void 0 : data.uuid) != null ? _a2 : serviceInstance == null ? void 0 : serviceInstance.uuid;
+          const { service_instance, data, __useSocket, __retryCount } = ctx;
+          this.serviceInstanceId = (_a2 = service_instance == null ? void 0 : service_instance.uuid) != null ? _a2 : data == null ? void 0 : data.uuid;
           this.instances.set(
-            (_b2 = data == null ? void 0 : data.service_name) != null ? _b2 : serviceInstance == null ? void 0 : serviceInstance.service_name,
-            [__spreadValues({}, data != null ? data : serviceInstance)]
+            (_b2 = data == null ? void 0 : data.service_name) != null ? _b2 : service_instance == null ? void 0 : service_instance.service_name,
+            [__spreadValues({}, service_instance != null ? service_instance : data)]
           );
           this.useSocket = __useSocket;
           this.retryCount = __retryCount;
@@ -913,8 +913,14 @@ var RestController = class _RestController {
     return this._instance;
   }
   constructor() {
-    CadenzaService.registry.getTaskByName.doOn("meta.rest.delegation_requested");
-    CadenzaService.registry.getRoutineByName.doOn("meta.rest.delegation_requested");
+    CadenzaService.registry.getTaskByName.doOn(
+      "meta.rest.delegation_requested",
+      "meta.socket.delegation_requested"
+    );
+    CadenzaService.registry.getRoutineByName.doOn(
+      "meta.rest.delegation_requested",
+      "meta.socket.delegation_requested"
+    );
     CadenzaService.createMetaRoutine(
       "RestServer",
       [
@@ -1391,16 +1397,23 @@ var SocketController = class _SocketController {
             (ctx) => {
               const server = ctx.__socketServer;
               server.on("connection", (ws) => {
+                ws.on("handshake", (ctx2) => {
+                  console.log("Socket HANDSHAKE", ctx2.serviceInstanceId);
+                  ws.emit("handshake", {
+                    serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+                    __status: "success"
+                  });
+                  CadenzaService.broker.emit("meta.socket.handshake", ctx2);
+                });
                 ws.on(
                   "delegation",
                   (ctx2, callback) => {
+                    const deputyExecId = ctx2.__metadata.__deputyExecId;
                     CadenzaService.createEphemeralMetaTask(
                       "Resolve delegation",
                       callback,
                       "Resolves a delegation request using the provided callback from the client (.emitWithAck())"
-                    ).doOn(`meta.node.graph_completed:${ctx2.__routineExecId}`).emits(
-                      `meta.socket.delegation_resolved:${ctx2.__routineExecId}`
-                    );
+                    ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.socket.delegation_resolved:${deputyExecId}`);
                     CadenzaService.createEphemeralMetaTask(
                       "Delegation progress update",
                       (ctx3) => {
@@ -1416,10 +1429,10 @@ var SocketController = class _SocketController {
                         }
                       }
                     ).doOn(
-                      `meta.node.routine_execution_progress:${ctx2.__routineExecId}`,
-                      `meta.node.graph_completed:${ctx2.__routineExecId}`
+                      `meta.node.routine_execution_progress:${deputyExecId}`,
+                      `meta.node.graph_completed:${deputyExecId}`
                     ).emitsOnFail(
-                      `meta.socket.progress_failed:${ctx2.__routineExecId}`
+                      `meta.socket.progress_failed:${deputyExecId}`
                     );
                     CadenzaService.broker.emit(
                       "meta.socket.delegation_requested",
@@ -1488,15 +1501,15 @@ var SocketController = class _SocketController {
       "Connect to socket server",
       (ctx) => {
         const {
-          __serviceName,
-          __serviceInstanceId,
-          __serviceAddress,
-          __servicePort,
-          __protocol
+          serviceName,
+          serviceInstanceId,
+          serviceAddress,
+          servicePort,
+          protocol
         } = ctx;
-        const socketProtocol = __protocol === "https" ? "wss" : "ws";
-        const port = __protocol === "https" ? 443 : __servicePort;
-        const socket = (0, import_socket2.io)(`${socketProtocol}://${__serviceAddress}:${port}`, {
+        const socketProtocol = protocol === "https" ? "wss" : "ws";
+        const port = protocol === "https" ? 443 : servicePort;
+        const socket = (0, import_socket2.io)(`${socketProtocol}://${serviceAddress}:${port}`, {
           reconnection: true,
           reconnectionAttempts: 20,
           reconnectionDelay: 1e3,
@@ -1507,13 +1520,17 @@ var SocketController = class _SocketController {
         socket.on("connect", () => {
           CadenzaService.broker.emit("meta.socket_client.connected", ctx);
           socket.emit("handshake", {
-            __serviceInstanceId: ctx.__serviceInstanceId
+            serviceInstanceId
           });
         });
+        socket.on("handshake", (ctx2) => {
+          console.log("Socket client HANDSHAKE", ctx2);
+          CadenzaService.broker.emit("meta.socket_client.handshake", ctx2);
+        });
         socket.on("delegation_progress", (ctx2) => {
           CadenzaService.broker.emit(
-            `meta.socket_client.delegation_progress:${ctx2.__deputyExecId}`,
-            __spreadValues({ __serviceInstanceId }, ctx2)
+            `meta.socket_client.delegation_progress:${ctx2.__metadata.__deputyExecId}`,
+            __spreadValues({ serviceInstanceId }, ctx2)
           );
         });
         socket.on("status_update", (status) => {
@@ -1521,11 +1538,11 @@ var SocketController = class _SocketController {
         });
         socket.on("disconnect", () => {
           CadenzaService.broker.emit("meta.socket_client.disconnected", {
-            __serviceInstanceId
+            serviceInstanceId
           });
         });
         CadenzaService.createMetaTask(
-          `Delegate flow to ${__serviceInstanceId}`,
+          `Delegate flow to ${serviceInstanceId}`,
           (ctx2, emit) => __async(null, null, function* () {
             var _a2;
             if (ctx2.__remoteRoutineName === void 0) {
@@ -1548,14 +1565,14 @@ var SocketController = class _SocketController {
             }
             return resultContext;
           }),
-          `Delegate flow to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+          `Delegate flow to instance ${serviceInstanceId} of service ${serviceName} with address ${serviceAddress}:${servicePort}`
         ).doOn(
-          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+          `meta.service_registry.selected_instance_for_socket:${serviceInstanceId}`
         ).emitsOnFail(
-          `meta.socket_client.delegate_failed:${__serviceInstanceId}`
+          `meta.socket_client.delegate_failed:${serviceInstanceId}`
         );
         CadenzaService.createMetaTask(
-          `Transmit signal to ${__serviceInstanceId}`,
+          `Transmit signal to ${serviceInstanceId}`,
           (ctx2, emit) => __async(null, null, function* () {
             var _a2;
             if (ctx2.__signalName === void 0) {
@@ -1578,11 +1595,11 @@ var SocketController = class _SocketController {
             }
             return response;
           }),
-          `Transmits signal to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+          `Transmits signal to instance ${serviceInstanceId} of service ${serviceName} with address ${serviceAddress}:${servicePort}`
         ).doOn(
-          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+          `meta.service_registry.selected_instance_for_socket:${serviceInstanceId}`
         ).emitsOnFail(
-          `meta.socket_client.signal_transmission_failed:${__serviceInstanceId}`
+          `meta.socket_client.signal_transmission_failed:${serviceInstanceId}`
         );
         CadenzaService.createMetaTask(
           "Shutdown SocketClient",
@@ -1650,19 +1667,12 @@ var SignalController = class _SignalController {
     CadenzaService.createMetaTask(
       "Forward signal observations to remote service",
       (ctx, emit) => {
-        const { __remoteSignals } = ctx;
-        for (const remoteSignal of __remoteSignals) {
-          if (remoteSignal.__remoteServiceName === "*") {
-            emit(
-              "meta.signal_controller.wildcard_signal_registered",
-              remoteSignal
-            );
-          } else {
-            emit(
-              `meta.signal_controller.remote_signal_registered:${remoteSignal.__remoteServiceName}`,
-              remoteSignal
-            );
-          }
+        const { remoteSignals, serviceName } = ctx;
+        for (const remoteSignal of remoteSignals) {
+          emit(
+            `meta.signal_controller.remote_signal_registered:${serviceName}`,
+            remoteSignal
+          );
         }
         return true;
       },