@cadenza.io/service 1.4.1 → 1.5.1

package/dist/index.d.mts

@@ -140,11 +140,14 @@ interface ServiceInstanceDescriptor {
     isBlocked: boolean;
     health: AnyObject;
     exposed: boolean;
+    clientCreated?: boolean;
 }
 interface DeputyDescriptor {
-    __serviceName: string;
-    __remoteRoutineName: string;
-    __localTaskName: string;
+    serviceName: string;
+    remoteRoutineName?: string;
+    signalName?: string;
+    localTaskName: string;
+    communicationType: string;
 }
 declare class ServiceRegistry {
     private static _instance;

package/dist/index.d.ts

@@ -140,11 +140,14 @@ interface ServiceInstanceDescriptor {
     isBlocked: boolean;
     health: AnyObject;
     exposed: boolean;
+    clientCreated?: boolean;
 }
 interface DeputyDescriptor {
-    __serviceName: string;
-    __remoteRoutineName: string;
-    __localTaskName: string;
+    serviceName: string;
+    remoteRoutineName?: string;
+    signalName?: string;
+    localTaskName: string;
+    communicationType: string;
 }
 declare class ServiceRegistry {
     private static _instance;

package/dist/index.js

@@ -203,10 +203,11 @@ var DeputyTask = class extends import_core.Task {
     this.remoteRoutineName = remoteRoutineName;
     this.serviceName = serviceName;
     this.emit("meta.deputy.created", {
-      __localTaskName: this.name,
-      __localTaskVersion: this.version,
-      __remoteRoutineName: this.remoteRoutineName,
-      __serviceName: this.serviceName
+      localTaskName: this.name,
+      localTaskVersion: this.version,
+      remoteRoutineName: this.remoteRoutineName,
+      serviceName: this.serviceName,
+      communicationType: "delegation"
     });
   }
   /**
@@ -333,6 +334,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleInstanceUpdateTask = CadenzaService.createMetaTask(
       "Handle Instance Update",
       (ctx, emit) => {
+        var _a2;
         const { serviceInstance } = ctx;
         const { id, serviceName, address, port, exposed } = serviceInstance;
         if (!this.instances.has(serviceName))
@@ -343,13 +345,32 @@ var ServiceRegistry = class _ServiceRegistry {
           Object.assign(existing, serviceInstance);
         } else {
           if (this.deputies.has(serviceName)) {
+            const communicationTypes = Array.from(
+              new Set(
+                (_a2 = this.deputies.get(serviceName).map((d) => d.communicationType)) != null ? _a2 : []
+              )
+            );
             emit("meta.service_registry.dependee_registered", {
-              __serviceName: serviceName,
-              __serviceInstanceId: id,
-              __serviceAddress: address,
-              __servicePort: port,
-              __protocol: exposed ? "https" : "http"
+              serviceName,
+              serviceInstanceId: id,
+              serviceAddress: address,
+              servicePort: port,
+              protocol: exposed ? "https" : "http",
+              communicationTypes
             });
+            serviceInstance.clientCreated = true;
+            for (const instance of this.instances.get(serviceName)) {
+              if (instance.clientCreated) continue;
+              instance.clientCreated = true;
+              emit("meta.service_registry.dependee_registered", {
+                serviceName,
+                serviceInstanceId: id,
+                serviceAddress: address,
+                servicePort: port,
+                protocol: exposed ? "https" : "http",
+                communicationTypes
+              });
+            }
           }
           instances.push(serviceInstance);
         }
@@ -402,7 +423,7 @@ var ServiceRegistry = class _ServiceRegistry {
         const { serviceInstances } = ctx;
         if (!serviceInstances) return;
         for (const serviceInstance of serviceInstances) {
-          yield serviceInstance;
+          yield { serviceInstance };
         }
       }).then(this.handleInstanceUpdateTask)
     );
@@ -446,21 +467,15 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleDeputyRegistrationTask = CadenzaService.createMetaTask(
       "Handle Deputy Registration",
       (ctx, emit) => {
-        const { __serviceName } = ctx;
-        this.deputies.set(__serviceName, {
-          __serviceName,
-          __remoteRoutineName: ctx.__remoteRoutineName,
-          __localTaskName: ctx.__localTaskName
+        const { serviceName } = ctx;
+        if (!this.deputies.has(serviceName)) this.deputies.set(serviceName, []);
+        this.deputies.get(serviceName).push({
+          serviceName,
+          remoteRoutineName: ctx.remoteRoutineName,
+          signalName: ctx.signalName,
+          localTaskName: ctx.localTaskName,
+          communicationType: ctx.communicationType
         });
-        for (const instance of this.instances.get(__serviceName)) {
-          emit(`meta.service_registry.dependee_registered:${instance.id}`, {
-            __serviceName,
-            __serviceInstanceId: instance.id,
-            __serviceAddress: instance.address,
-            __servicePort: instance.port,
-            __protocol: instance.exposed ? "https" : "http"
-          });
-        }
       }
     ).doOn("meta.deputy.created");
     this.getAllInstances = CadenzaService.createMetaTask(
@@ -802,6 +817,13 @@ var SignalTransmissionTask = class extends import_core2.Task {
     this.isDeputy = true;
     this.serviceName = serviceName;
     this.signalName = signalName;
+    this.emit("meta.deputy.created", {
+      localTaskName: this.name,
+      localTaskVersion: this.version,
+      serviceName: this.serviceName,
+      communicationType: "signal",
+      signalName: this.signalName
+    });
   }
   /**
    * Triggers the database operation delegation flow via a signal to the meta-layer.
@@ -1072,33 +1094,54 @@ var RestController = class _RestController {
       "Bootstraps the REST server as socket fallback"
     ).doOn("meta.service_registry.service_inserted");
     CadenzaService.createMetaTask(
-      "FetchClient",
-      (ctx) => {
+      "Setup fetch client",
+      (ctx, emit) => {
         const {
-          __serviceName,
-          __serviceInstanceId,
-          __serviceAddress,
-          __servicePort,
-          __protocol
+          serviceName,
+          serviceInstanceId,
+          serviceAddress,
+          servicePort,
+          protocol
         } = ctx;
-        const port = __protocol === "https" ? 443 : __servicePort;
-        const URL = `${__protocol}://${__serviceAddress}:${port}`;
+        const port = protocol === "https" ? 443 : servicePort;
+        const URL = `${protocol}://${serviceAddress}:${port}`;
         CadenzaService.createMetaTask(
           "Send Handshake",
-          (ctx2) => __async(null, null, function* () {
+          (ctx2, emit2) => __async(null, null, function* () {
+            var _a2;
             const response = yield (0, import_node_fetch.default)(`${URL}/handshake`, {
               method: "POST",
               body: JSON.stringify(ctx2)
             });
             const result = yield response.json();
-            result.__serviceInstanceId = __serviceInstanceId;
-            return result;
+            if (result.__status === "error" || result.status !== 200) {
+              throw new Error(
+                (_a2 = result.__error) != null ? _a2 : `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`
+              );
+            }
+            console.log(
+              `Connected to service ${serviceName} ${ctx2.serviceInstanceId}`,
+              result
+            );
+            for (const communicationType of ctx2.communicationTypes) {
+              emit2("meta.fetch.service_communication_established", {
+                serviceInstanceId: ctx2.serviceInstanceId,
+                serviceInstanceClientId: CadenzaService.serviceRegistry.serviceInstanceId,
+                communicationType
+              });
+            }
           }),
-          "Sends handshake request"
-        ).doOn("meta.fetch.handshake_requested").emits("meta.fetch.handshake_complete");
+          "Sends handshake request",
+          {
+            retryCount: 20,
+            retryDelay: 200,
+            retryDelayMax: 5e3,
+            retryDelayFactor: 1.5
+          }
+        ).doOn(`meta.fetch.handshake_requested:${serviceInstanceId}`).emits("meta.fetch.handshake_complete");
         CadenzaService.createMetaTask(
           "Delegate flow to REST server",
-          (ctx2, emit) => __async(null, null, function* () {
+          (ctx2, emit2) => __async(null, null, function* () {
             if (ctx2.__remoteRoutineName === void 0) {
               return;
             }
@@ -1115,18 +1158,18 @@ var RestController = class _RestController {
                 errored: true
               }, ctx2), ctx2.__metadata);
             } finally {
-              emit(`meta.fetch.delegated:${ctx2.__deputyExecId}`, resultContext);
+              emit2(`meta.fetch.delegated:${ctx2.__deputyExecId}`, resultContext);
             }
             return resultContext;
           }),
           "Sends delegation request"
         ).doOn(
-          `meta.service_registry.selected_instance_for_fetch:${__serviceInstanceId}`,
-          `meta.service_registry.socket_failed:${__serviceInstanceId}`
+          `meta.service_registry.selected_instance_for_fetch:${serviceInstanceId}`,
+          `meta.service_registry.socket_failed:${serviceInstanceId}`
         ).emitsOnFail("meta.fetch.delegate_failed");
         CadenzaService.createMetaTask(
           "Transmit signal to server",
-          (ctx2, emit) => __async(null, null, function* () {
+          (ctx2, emit2) => __async(null, null, function* () {
             if (ctx2.__signalName === void 0) {
               return;
             }
@@ -1138,7 +1181,7 @@ var RestController = class _RestController {
               });
               response = yield response.json();
               if (ctx2.__routineExecId) {
-                emit(`meta.fetch.transmitted:${ctx2.__routineExecId}`, response);
+                emit2(`meta.fetch.transmitted:${ctx2.__routineExecId}`, response);
               }
             } catch (e) {
               response = __spreadValues({
@@ -1150,8 +1193,8 @@ var RestController = class _RestController {
           }),
           "Sends signal request"
         ).doOn(
-          `meta.service_registry.selected_instance_for_fetch:${__serviceInstanceId}`,
-          `meta.signal_controller.remote_signal_registered:${__serviceName}`,
+          `meta.service_registry.selected_instance_for_fetch:${serviceInstanceId}`,
+          `meta.signal_controller.remote_signal_registered:${serviceName}`,
           "meta.signal_controller.wildcard_signal_registered"
         ).emitsOnFail("meta.fetch.signal_transmission_failed");
         CadenzaService.createMetaTask(
@@ -1171,6 +1214,7 @@ var RestController = class _RestController {
           }),
           "Requests status"
         ).doOn("meta.fetch.status_check_requested").emits("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
+        emit(`meta.fetch.handshake_requested:${serviceInstanceId}`, __spreadValues({}, ctx));
         return true;
       },
       "Manages REST client requests as fallback"
@@ -2191,7 +2235,7 @@ var DatabaseController = class _DatabaseController {
       "DatabaseServiceInit",
       [
         // Database health check
-        // Create database roll
+        // Create database role
         // Create schema version table
         CadenzaService.createMetaTask(
           "Create database",
@@ -2233,20 +2277,34 @@ var DatabaseController = class _DatabaseController {
               }
               for (const [tableName, table] of Object.entries(schema.tables)) {
                 if (!table.fields || typeof table.fields !== "object") {
+                  console.log(tableName, "missing fields");
                   throw new Error(`Invalid table ${tableName}: missing fields`);
                 }
                 for (const [fieldName, field] of Object.entries(table.fields)) {
                   if (!fieldName.split("").every((c) => /[a-z_]/.test(c))) {
+                    console.log(tableName, "field not lowercase", fieldName);
                     throw new Error(
                       `Invalid field name ${fieldName} for ${tableName}. Field names must only contain lowercase alphanumeric characters and underscores`
                     );
                   }
                   if (!Object.values(SCHEMA_TYPES).includes(field.type)) {
+                    console.log(
+                      tableName,
+                      "field invalid type",
+                      fieldName,
+                      field.type
+                    );
                     throw new Error(
                       `Invalid type ${field.type} for ${tableName}.${fieldName}`
                     );
                   }
-                  if (field.references && !field.references.match(/^[\w]+\.[\w]+$/)) {
+                  if (field.references && !field.references.match(/^[\w]+[(\w)]+$/)) {
+                    console.log(
+                      tableName,
+                      "invalid reference",
+                      fieldName,
+                      field.references
+                    );
                     throw new Error(
                       `Invalid reference ${field.references} for ${tableName}.${fieldName}`
                     );
@@ -2256,11 +2314,23 @@ var DatabaseController = class _DatabaseController {
                       const triggers = (_a2 = table.customSignals.triggers) == null ? void 0 : _a2[op];
                       const emissions = (_b2 = table.customSignals.emissions) == null ? void 0 : _b2[op];
                       if (triggers && !Array.isArray(triggers) && typeof triggers !== "object") {
+                        console.log(
+                          tableName,
+                          "invalid triggers",
+                          op,
+                          triggers
+                        );
                         throw new Error(
                           `Invalid triggers for ${tableName}.${op}`
                         );
                       }
                       if (emissions && !Array.isArray(emissions) && typeof emissions !== "object") {
+                        console.log(
+                          tableName,
+                          "invalid emissions",
+                          op,
+                          emissions
+                        );
                         throw new Error(
                           `Invalid emissions for ${tableName}.${op}`
                         );
@@ -2814,6 +2884,7 @@ CREATE TRIGGER prevent_modification BEFORE UPDATE OR DELETE ON ${tableName} FOR
         return typeof signal === "string" ? signal : signal.signal;
       })) != null ? _d2 : []
     ).emits(defaultSignal);
+    console.log("Created database task", op, tableName);
   }
 };
 
@@ -3161,7 +3232,6 @@ var CadenzaService = class {
     });
     import_core3.default.createEphemeralMetaTask("Initiate controllers", () => {
       GraphMetadataController.instance;
-      console.log("META CONTROLLERS INITIATED");
     }).doOn("meta.service_registry.instance_inserted").emits("meta.process_signal_queue_requested");
     this.serviceCreated = true;
   }