@cadenza.io/service 1.12.9 → 1.13.1

package/dist/index.js

@@ -485,7 +485,7 @@ var ServiceRegistry = class _ServiceRegistry {
         "exposed",
         "created"
       ]
-    }).doOn("meta.service_registry_sync_requested").then(
+    }).doOn("meta.sync_requested").then(
       CadenzaService.createMetaTask(
         "Split service instances",
         function* (ctx) {
@@ -496,7 +496,6 @@ var ServiceRegistry = class _ServiceRegistry {
           }
         }
       ).then(this.handleInstanceUpdateTask)
-      // .emits("meta.process_signal_queue_requested"), // TODO Has to happen after the endpoints has been created...
     );
     this.updateInstanceId = CadenzaService.createMetaTask(
       "Update instance id",
@@ -1086,11 +1085,7 @@ var RestController = class _RestController {
                 let ctx2;
                 try {
                   ctx2 = req.body;
-                  console.log(
-                    "SIGNAL RECEIVED",
-                    ctx2,
-                    CadenzaService.broker.listObservedSignals()
-                  );
+                  console.log("SIGNAL RECEIVED", ctx2);
                   if (!CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
                     res.send(__spreadProps(__spreadValues({}, ctx2), {
                       __status: "error",
@@ -1099,7 +1094,10 @@ var RestController = class _RestController {
                     }));
                     return;
                   }
-                  res.send({ __status: "success" });
+                  res.send({
+                    __status: "success",
+                    __signalName: ctx2.__signalName
+                  });
                 } catch (e) {
                   console.error("Error in signal", e);
                   res.send({
@@ -1418,8 +1416,8 @@ var SocketController = class _SocketController {
             }
             const limiterOptions = {
               low: { points: Infinity, duration: 300 },
-              medium: { points: 100, duration: 300 },
-              high: { points: 50, duration: 60, blockDuration: 300 }
+              medium: { points: 1e3, duration: 300 },
+              high: { points: 100, duration: 60, blockDuration: 300 }
             };
             const limiter = new import_rate_limiter_flexible2.RateLimiterMemory(limiterOptions[profile]);
             socket.use((packet, next2) => {
@@ -1830,14 +1828,17 @@ var GraphMetadataController = class _GraphMetadataController {
     }).doOn("meta.task.relationship_added").emits("meta.graph_metadata.task_relationship_created");
     CadenzaService.createMetaTask("Handle task signal observation", (ctx) => {
       const firstChar = ctx.data.signalName.charAt(0);
+      let _signal = ctx.data.signalName;
       let signalServiceName;
       if (firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()) {
         signalServiceName = ctx.data.signalName.split(".")[0];
+        _signal = ctx.data.signalName.split(".").slice(1).join(".");
       }
       return {
         data: __spreadProps(__spreadValues({}, ctx.data), {
-          task_service_name: CadenzaService.serviceRegistry.serviceName,
-          signal_service_name: signalServiceName != null ? signalServiceName : CadenzaService.serviceRegistry.serviceName
+          signalName: _signal,
+          taskServiceName: CadenzaService.serviceRegistry.serviceName,
+          signalServiceName: signalServiceName != null ? signalServiceName : CadenzaService.serviceRegistry.serviceName
         })
       };
     }).doOn("meta.task.observed_signal").emits("meta.graph_metadata.task_signal_observed");
@@ -3013,6 +3014,158 @@ var DatabaseController = class _DatabaseController {
 
 // src/Cadenza.ts
 var import_uuid3 = require("uuid");
+
+// src/graph/controllers/GraphSyncController.ts
+var GraphSyncController = class _GraphSyncController {
+  static get instance() {
+    if (!this._instance) this._instance = new _GraphSyncController();
+    return this._instance;
+  }
+  constructor() {
+    var _a2;
+    (_a2 = CadenzaService.broker.getSignalsTask) == null ? void 0 : _a2.doOn("meta.sync_requested");
+    CadenzaService.registry.getAllTasks.doAfter(CadenzaService.broker.getSignalsTask);
+    CadenzaService.createMetaTask("Split routines for registration", (ctx, emit) => {
+      const { __routines } = ctx;
+      if (!__routines) return;
+      for (const routine of __routines) {
+        emit("meta.sync_controller.routine_added", {
+          data: {
+            name: routine.name,
+            version: routine.version,
+            description: routine.description,
+            serviceName: CadenzaService.serviceRegistry.serviceName,
+            isMeta: routine.isMeta
+          }
+        });
+        for (const task of routine.tasks) {
+          const tasks = task.getIterator();
+          while (tasks.hasNext()) {
+            const nextTask = tasks.next();
+            emit("meta.sync_controller.task_to_routine_map", {
+              data: {
+                taskName: nextTask.name,
+                taskVersion: nextTask.version,
+                routineName: routine.name,
+                routineVersion: routine.version,
+                serviceName: CadenzaService.serviceRegistry.serviceName
+              }
+            });
+          }
+        }
+      }
+    }).doAfter(CadenzaService.registry.getAllRoutines);
+    CadenzaService.createMetaTask("Split signals for registration", (ctx, emit) => {
+      const { __signals } = ctx;
+      if (!__signals) return;
+      for (const signal of __signals) {
+        const parts = signal.split(".");
+        const domain = parts[0] === "meta" ? parts[1] : parts[0];
+        const action = parts[parts.length - 1];
+        emit("meta.sync_controller.signal_added", {
+          data: {
+            name: signal,
+            domain,
+            action,
+            isMeta: parts[0] === "meta",
+            serviceName: CadenzaService.serviceRegistry.serviceName
+          }
+        });
+      }
+    }).doAfter(CadenzaService.broker.getSignalsTask);
+    CadenzaService.createMetaTask("Split tasks for registration", (ctx, emit) => {
+      const { __tasks } = ctx;
+      if (!__tasks) return;
+      for (const task of __tasks) {
+        if (task.hidden || !task.register) continue;
+        const { __functionString, __getTagCallback } = task.export();
+        emit("meta.sync_controller.task_added", {
+          data: {
+            name: task.name,
+            version: task.version,
+            description: task.description,
+            functionString: __functionString,
+            tagIdGetter: __getTagCallback,
+            layerIndex: task.layerIndex,
+            concurrency: task.concurrency,
+            timeout: task.timeout,
+            isUnique: task.isUnique,
+            isSignal: task.isSignal,
+            isThrottled: task.isThrottled,
+            isDebounce: task.isDebounce,
+            isEphemeral: task.isEphemeral,
+            isMeta: task.isMeta,
+            isSubMeta: task.isSubMeta,
+            isHidden: task.isHidden,
+            // inputSchema: task.inputSchema,
+            validateInputContext: task.validateInputContext,
+            // outputSchema: task.outputSchema,
+            validateOutputContext: task.validateOutputContext,
+            retryCount: task.retryCount,
+            retryDelay: task.retryDelay,
+            retryDelayMax: task.retryDelayMax,
+            retryDelayFactor: task.retryDelayFactor,
+            service_name: CadenzaService.serviceRegistry.serviceName
+          }
+        });
+        for (const signal of task.mapObservedSignals()) {
+          const firstChar = signal.charAt(0);
+          let _signal = signal;
+          let signalServiceName;
+          if (firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()) {
+            signalServiceName = signal.split(".")[0];
+            _signal = signal.split(".").slice(1).join(".");
+          }
+          emit("meta.sync_controller.signal_to_task_map", {
+            data: {
+              signalName: _signal,
+              taskName: task.name,
+              taskVersion: task.version,
+              taskServiceName: CadenzaService.serviceRegistry.serviceName,
+              signalServiceName: signalServiceName != null ? signalServiceName : CadenzaService.serviceRegistry.serviceName
+            }
+          });
+        }
+        for (const signal of task.mapSignals()) {
+          emit("meta.sync_controller.task_to_signal_map", {
+            data: {
+              signalName: signal,
+              taskName: task.name,
+              taskVersion: task.version,
+              serviceName: CadenzaService.serviceRegistry.serviceName
+            }
+          });
+        }
+        for (const signal of task.mapOnFailSignals()) {
+          emit("meta.sync_controller.task_to_signal_map", {
+            data: {
+              signalName: signal,
+              taskName: task.name,
+              taskVersion: task.version,
+              serviceName: CadenzaService.serviceRegistry.serviceName
+            }
+          });
+        }
+      }
+      for (const task of __tasks) {
+        if (task.hidden || !task.register) continue;
+        task.mapNext(
+          (t) => emit("meta.sync_controller.task_map", {
+            data: {
+              taskName: t.name,
+              taskVersion: t.version,
+              predecessorTaskName: task.name,
+              predecessorTaskVersion: task.version,
+              serviceName: CadenzaService.serviceRegistry.serviceName
+            }
+          })
+        );
+      }
+    }).doAfter(CadenzaService.registry.getAllTasks).then(CadenzaService.registry.getAllRoutines);
+  }
+};
+
+// src/Cadenza.ts
 var CadenzaService = class {
   static bootstrap() {
     if (this.isBootstrapped) return;
@@ -3368,13 +3521,10 @@ var CadenzaService = class {
     }
     this.createEphemeralMetaTask(
       "Handle service setup completion",
-      (ctx, emit) => {
+      (_, emit) => {
         GraphMetadataController.instance;
-        emit("meta.service_registry_sync_requested", {});
-        emit("meta.register_remote_signals_requested", { serviceName });
-        emit("meta.register_all_routines", {});
-        emit("meta.register_all_tasks", {});
-        emit("meta.register_all_signals", {});
+        GraphSyncController.instance;
+        emit("meta.sync_requested", {});
         return true;
       }
     ).doOn("meta.service_registry.instance_inserted");