@cadenza.io/service 2.0.0 → 2.0.2

package/dist/index.mjs

@@ -68,7 +68,7 @@ var DeputyTask = class extends Task {
           (responseCtx) => {
             console.log(
               "Resolving deputy",
-              remoteRoutineName,
+              context.__localTaskName,
               responseCtx.errored ? responseCtx.__error : ""
             );
             if (responseCtx?.errored) {
@@ -334,35 +334,38 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleGlobalSignalRegistrationTask = CadenzaService.createMetaTask(
       "Handle global Signal Registration",
       (ctx) => {
-        const { signalToTaskMap } = ctx;
-        const sortedSignalToTaskMap = signalToTaskMap.sort((a, b) => {
-          if (a.deleted && !b.deleted) return -1;
-          if (!a.deleted && b.deleted) return 1;
-          return 0;
-        });
+        const { signalToTaskMaps } = ctx;
+        const sortedSignalToTaskMap = signalToTaskMaps.sort(
+          (a, b) => {
+            if (a.deleted && !b.deleted) return -1;
+            if (!a.deleted && b.deleted) return 1;
+            return 0;
+          }
+        );
+        console.log("signalToTaskMap", sortedSignalToTaskMap);
         const locallyEmittedSignals = CadenzaService.broker.listEmittedSignals().filter((s) => s.startsWith("global."));
         for (const map of sortedSignalToTaskMap) {
           if (map.deleted) {
-            this.remoteSignals.get(map.taskServiceName)?.delete(map.signal);
-            if (!this.remoteSignals.get(map.taskServiceName)?.size) {
-              this.remoteSignals.delete(map.taskServiceName);
+            this.remoteSignals.get(map.serviceName)?.delete(map.signalName);
+            if (!this.remoteSignals.get(map.serviceName)?.size) {
+              this.remoteSignals.delete(map.serviceName);
             }
             CadenzaService.get(
-              `Transmit signal: ${map.signal} to ${map.taskServiceName}`
+              `Transmit signal: ${map.signalName} to ${map.serviceName}`
             )?.destroy();
             continue;
           }
-          if (locallyEmittedSignals.includes(map.signal)) {
-            if (!this.remoteSignals.get(map.taskServiceName)) {
-              this.remoteSignals.set(map.taskServiceName, /* @__PURE__ */ new Set());
+          if (locallyEmittedSignals.includes(map.signalName)) {
+            if (!this.remoteSignals.get(map.serviceName)) {
+              this.remoteSignals.set(map.serviceName, /* @__PURE__ */ new Set());
             }
-            if (!this.remoteSignals.get(map.taskServiceName)?.has(map.signal)) {
+            if (!this.remoteSignals.get(map.serviceName)?.has(map.signalName)) {
               CadenzaService.createSignalTransmissionTask(
-                map.signal,
-                map.taskServiceName
+                map.signalName,
+                map.serviceName
               );
             }
-            this.remoteSignals.get(map.taskServiceName)?.add(map.signal);
+            this.remoteSignals.get(map.serviceName)?.add(map.signalName);
           }
         }
         return true;
@@ -459,45 +462,43 @@ var ServiceRegistry = class _ServiceRegistry {
       },
       "Handles status update from socket broadcast"
     ).doOn("meta.socket_client.status_received");
-    this.fullSyncTask = CadenzaService.createCadenzaDBQueryTask("service_instance", {
-      filter: {
-        deleted: false,
-        is_active: true,
-        is_non_responsive: false,
-        is_blocked: false
-      },
-      fields: [
-        "uuid",
-        "address",
-        "port",
-        "service_name",
-        "is_active",
-        "is_non_responsive",
-        "is_blocked",
-        "health",
-        "exposed",
-        "created",
-        "is_frontend"
-      ]
-    }).doOn("meta.sync_requested").emits("meta.service_registry.synced_instances").then(
-      CadenzaService.createMetaTask(
-        "Split service instances",
-        function* (ctx) {
-          const { serviceInstances } = ctx;
-          if (!serviceInstances) {
-            CadenzaService.log(
-              "SyncFailed: No service instances found",
-              ctx,
-              "error"
-            );
-            return;
-          }
-          for (const serviceInstance of serviceInstances) {
-            yield { serviceInstance };
-          }
-        }
-      ).then(this.handleInstanceUpdateTask).doOn("meta.signal_controller.signal_map_added")
-    );
+    const mergeSyncDataTask = CadenzaService.createUniqueMetaTask(
+      "Merge sync data",
+      (ctx) => {
+        let joinedContext = {};
+        ctx.joinedContexts.forEach((ctx2) => {
+          joinedContext = { ...joinedContext, ...ctx2 };
+        });
+        console.log("Full sync joinedContext", joinedContext);
+        return joinedContext;
+      }
+    ).then(this.handleGlobalSignalRegistrationTask);
+    this.fullSyncTask = CadenzaService.createMetaRoutine("Full sync", [
+      CadenzaService.createCadenzaDBQueryTask("signal_to_task_map", {
+        fields: ["signal_name", "service_name", "deleted"]
+      }).then(mergeSyncDataTask),
+      CadenzaService.createCadenzaDBQueryTask("service_instance", {
+        filter: {
+          deleted: false,
+          is_active: true,
+          is_non_responsive: false,
+          is_blocked: false
+        },
+        fields: [
+          "uuid",
+          "address",
+          "port",
+          "service_name",
+          "is_active",
+          "is_non_responsive",
+          "is_blocked",
+          "health",
+          "exposed",
+          "created",
+          "is_frontend"
+        ]
+      }).then(mergeSyncDataTask)
+    ]).doOn("meta.sync_requested");
     this.getInstanceById = CadenzaService.createMetaTask(
       "Get instance by id",
       (context) => {
@@ -713,15 +714,6 @@ var ServiceRegistry = class _ServiceRegistry {
         retryDelayMax: 6e4,
         retryDelayFactor: 1.3
       }
-    ).then(
-      CadenzaService.createMetaTask(
-        "Set service name",
-        ({ __serviceName }) => {
-          this.serviceName = __serviceName;
-          return true;
-        },
-        "Sets service name after insertion"
-      )
     ).emits("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
     this.insertServiceInstanceTask = CadenzaService.createCadenzaDBInsertTask(
       "serviceInstance",
@@ -811,7 +803,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (isBrowser) {
           CadenzaService.createMetaTask("Prepare for signal sync", () => {
             return {};
-          }).doAfter(this.fullSyncTask).then(
+          }).then(
             CadenzaService.createCadenzaDBQueryTask("signal_registry", {
               fields: ["name"],
               filter: {
@@ -2758,7 +2750,7 @@ var DatabaseController = class _DatabaseController {
                       if (field.generated)
                         def += ` GENERATED ALWAYS AS ${field.generated.toUpperCase()} STORED`;
                       if (field.references)
-                        def += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "DO NOTHING"}`;
+                        def += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "CASCADE"}`;
                       if (field.encrypted) def += " ENCRYPTED";
                       if (field.constraints?.check) {
                         def += ` CHECK (${field.constraints.check})`;
@@ -3308,6 +3300,7 @@ var DatabaseController = class _DatabaseController {
     if (!data || Array.isArray(data) && data.length === 0) {
       return { errored: true, __error: "No data provided for insert" };
     }
+    let resultContext = {};
     const client = transaction ? await this.getClient() : this.dbClient;
     try {
       if (transaction) await client.query("BEGIN");
@@ -3360,24 +3353,32 @@ var DatabaseController = class _DatabaseController {
       );
       if (transaction) await client.query("COMMIT");
       const resultRows = this.toCamelCase(result.rows);
-      return {
+      resultContext = {
         [`${camelCase(tableName)}${isBatch ? "s" : ""}`]: isBatch ? resultRows : resultRows[0],
         rowCount: result.rowCount,
         __success: true
       };
     } catch (error) {
-      if (transaction) await client.query("ROLLBACK");
-      return {
-        ...context,
-        errored: true,
-        __error: `Insert failed: ${error.message}`,
-        __success: false
-      };
+      if (error.message.includes("violates unique constraint")) {
+        resultContext = {
+          [`${camelCase(tableName)}`]: null,
+          __success: false
+        };
+      } else {
+        if (transaction) await client.query("ROLLBACK");
+        resultContext = {
+          ...context,
+          errored: true,
+          __error: `Insert failed: ${error.message}`,
+          __success: false
+        };
+      }
     } finally {
       if (transaction && client) {
         client.release();
       }
     }
+    return resultContext;
   }
   /**
    * Updates a database table with the provided data and filter conditions.
@@ -3399,6 +3400,7 @@ var DatabaseController = class _DatabaseController {
     if (!data || Object.keys(data).length === 0) {
       return { errored: true, __error: "No data provided for update" };
     }
+    let resultContext = {};
     const client = transaction ? await this.getClient() : this.dbClient;
     try {
       if (transaction) await client.query("BEGIN");
@@ -3431,19 +3433,20 @@ var DatabaseController = class _DatabaseController {
       if (transaction) await client.query("COMMIT");
       const rows = this.toCamelCase(result.rows);
       if (rows.length === 0) {
-        return {
+        resultContext = {
           sql,
           params,
           __success: false
         };
+      } else {
+        resultContext = {
+          [`${camelCase(tableName)}`]: rows[0],
+          __success: true
+        };
       }
-      return {
-        [`${camelCase(tableName)}`]: rows[0],
-        __success: true
-      };
     } catch (error) {
       if (transaction) await client.query("ROLLBACK");
-      return {
+      resultContext = {
         ...context,
         errored: true,
         __error: `Update failed: ${error.message}`,
@@ -3454,6 +3457,7 @@ var DatabaseController = class _DatabaseController {
         client.release();
       }
     }
+    return resultContext;
   }
   /**
    * Deletes a record from the specified database table based on the given filter criteria.
@@ -3470,6 +3474,7 @@ var DatabaseController = class _DatabaseController {
     if (Object.keys(filter).length === 0) {
       return { errored: true, __error: "No filter provided for delete" };
     }
+    let resultContext = {};
     const client = transaction ? await this.getClient() : this.dbClient;
     try {
       if (transaction) await client.query("BEGIN");
@@ -3479,13 +3484,13 @@ var DatabaseController = class _DatabaseController {
       const result = await client.query(sql, params);
       if (transaction) await client.query("COMMIT");
       const rows = this.toCamelCase(result.rows);
-      return {
+      resultContext = {
         [`${camelCase(tableName)}`]: rows[0],
         __success: true
       };
     } catch (error) {
       if (transaction) await client.query("ROLLBACK");
-      return {
+      resultContext = {
         errored: true,
         __error: `Delete failed: ${error.message}`,
         __errors: { delete: error.message },
@@ -3496,6 +3501,7 @@ var DatabaseController = class _DatabaseController {
         client.release();
       }
     }
+    return resultContext;
   }
   /**
    * Constructs a SQL WHERE clause based on the provided filter object.
@@ -3588,9 +3594,7 @@ var DatabaseController = class _DatabaseController {
       let result;
       if (op.subOperation === "insert") {
         const resolvedData = await this.resolveNestedData(op.data, op.table);
-        const sql = `INSERT INTO ${op.table} (${Object.keys(resolvedData).join(", ")}) VALUES (${Object.values(
-          resolvedData
-        ).map((_, i) => `$${i + 1}`).join(", ")}) ON CONFLICT DO NOTHING RETURNING ${op.return ?? "*"}`;
+        const sql = `INSERT INTO ${op.table} (${Object.keys(resolvedData).map((k) => snakeCase(k)).join(", ")}) VALUES (${Object.values(resolvedData).map((_, i) => `$${i + 1}`).join(", ")}) ON CONFLICT DO NOTHING RETURNING ${op.return ?? "*"}`;
         result = await client.query(sql, Object.values(resolvedData));
         result = result.rows[0]?.[op.return ?? "uuid"];
         if (!result) {
@@ -3757,6 +3761,7 @@ var GraphSyncController = class _GraphSyncController {
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
       (ctx, emit) => {
+        console.log("SPLITTING ROUTINES FOR REGISTRATION");
         const { routines } = ctx;
         if (!routines) return;
         for (const routine of routines) {
@@ -3798,6 +3803,7 @@ var GraphSyncController = class _GraphSyncController {
             uuid: CadenzaService.serviceRegistry.serviceInstanceId
           }
         });
+        CadenzaService.log("Synced resources...");
       }
     ).attachSignal(
       "global.meta.sync_controller.routine_added",
@@ -3821,8 +3827,7 @@ var GraphSyncController = class _GraphSyncController {
               isGlobal,
               domain,
               action,
-              isMeta,
-              serviceName: CadenzaService.serviceRegistry.serviceName
+              isMeta
             }
           };
         }
@@ -3847,6 +3852,7 @@ var GraphSyncController = class _GraphSyncController {
     this.splitTasksForRegistration = CadenzaService.createMetaTask(
       "Split tasks for registration",
       function* (ctx) {
+        console.log("SPLITTING TASKS FOR REGISTRATION");
         const tasks = ctx.tasks;
         for (const task of tasks) {
           if (task.registered) continue;
@@ -4113,7 +4119,9 @@ var GraphSyncController = class _GraphSyncController {
       )
     );
     CadenzaService.throttle("sync_controller.sync_tick", { __syncing: true }, 12e4);
-    CadenzaService.schedule("meta.sync_requested", { __syncing: true }, 2e3);
+    if (this.isCadenzaDBReady) {
+      CadenzaService.schedule("meta.sync_requested", { __syncing: true }, 2e3);
+    }
   }
 };
 
@@ -4465,7 +4473,8 @@ var CadenzaService = class {
     options.isMeta = true;
     const name = `Transmit signal: ${signalName} to ${serviceName}`;
     if (this.get(name)) {
-      throw new Error(`Task '${name}' already exists`);
+      console.log("Signal transmission task already exists", name);
+      return;
     }
     return new SignalTransmissionTask(
       name,
@@ -4731,13 +4740,19 @@ var CadenzaService = class {
       __isDatabase: options.isDatabase
     };
     if (options.cadenzaDB?.connect) {
-      this.createEphemeralMetaTask("Create service", async (_, emit) => {
+      this.createEphemeralMetaTask("Create service", async (context, emit) => {
         emit("meta.create_service_requested", initContext);
       }).doOn("meta.fetch.handshake_complete");
     } else {
       this.emit("meta.create_service_requested", initContext);
+      this.createMetaTask("Create signal transmission for sync", (ctx) => {
+        this.createSignalTransmissionTask(
+          "global.meta.cadenza_db.gathered_sync_data",
+          ctx.serviceName
+        );
+      }).doOn("meta.rest.handshake");
     }
-    this.createEphemeralMetaTask("Handle service setup completion", () => {
+    this.createMetaTask("Handle service setup completion", () => {
       GraphMetadataController.instance;
       GraphSyncController.instance.isCadenzaDBReady = !!options.cadenzaDB?.connect;
       GraphSyncController.instance.init();
@@ -4804,24 +4819,9 @@ var CadenzaService = class {
       databaseName: options.databaseName,
       options
     });
-    this.createEphemeralMetaTask("Set database connection", () => {
-      if (options.cadenzaDB?.connect) {
-        this.createEphemeralMetaTask("Insert database service", (_, emit) => {
-          emit("global.meta.created_database_service", {
-            data: {
-              service_name: name,
-              description,
-              schema,
-              is_meta: options.isMeta
-            }
-          });
-          this.log("Database service created", {
-            name,
-            isMeta: options.isMeta
-          });
-        }).doOn("meta.service_registry.service_inserted");
-      } else {
-        this.emit("global.meta.created_database_service", {
+    this.createMetaTask("Set database connection", () => {
+      this.createMetaTask("Insert database service", (_, emit) => {
+        emit("global.meta.created_database_service", {
           data: {
             service_name: name,
             description,
@@ -4833,7 +4833,7 @@ var CadenzaService = class {
           name,
           isMeta: options.isMeta
         });
-      }
+      }).doOn("meta.service_registry.service_inserted");
       this.createCadenzaService(name, description, options);
     }).doOn("meta.database.setup_done");
   }