@cadenza.io/service 1.20.8 → 1.21.0

package/dist/index.d.mts

@@ -37,12 +37,16 @@ declare class DeputyTask extends Task {
      * @param context - The GraphContext containing execution data.
      * @param emit
      * @param progressCallback - Callback to update progress (invoked by meta-layer).
+     * @param nodeData
      * @returns A Promise resolving with the task result or rejecting on error.
      * @emits {meta.deputy.executed} - Emitted with context to initiate delegation.
      * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
      * @note The resolution and progress are managed by ephemeral meta-tasks.
      */
-    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void): TaskResult;
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
 }
 
 type DbOperationType$1 = "query" | "insert" | "update" | "delete";
@@ -71,9 +75,10 @@ interface OnConflictAction {
 }
 type OpEffect = "increment" | "decrement" | "set";
 type ValueOrSubOp = any | SubOperation | OpEffect;
+type ValueOrList = any | any[];
 interface DbOperationPayload {
     data?: Record<string, ValueOrSubOp> | Record<string, ValueOrSubOp>[];
-    filter?: AnyObject;
+    filter?: Record<string, ValueOrList>;
     fields?: string[];
     joins?: Record<string, JoinDefinition>;
     sort?: Record<string, SortDirection>;
@@ -125,12 +130,16 @@ declare class DatabaseTask extends DeputyTask {
      * @param context - The GraphContext containing execution data.
      * @param emit
      * @param progressCallback - Callback to update progress (invoked by meta-layer).
+     * @param nodeData
      * @returns A Promise resolving with the task result or rejecting on error.
      * @emits {meta.deputy.executed} - Emitted with context including queryData to initiate delegation.
      * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
      * @note The resolution and progress are managed by ephemeral meta-tasks.
      */
-    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void): TaskResult;
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
 }
 
 interface ServiceInstanceDescriptor {
@@ -146,6 +155,7 @@ interface ServiceInstanceDescriptor {
     health: AnyObject;
     exposed: boolean;
     clientCreated?: boolean;
+    isFrontend: boolean;
 }
 interface DeputyDescriptor {
     serviceName: string;
@@ -341,6 +351,8 @@ type ServerOptions = {
         port?: number;
     };
     relatedServices?: string[][];
+    isDatabase?: boolean;
+    isFrontend?: boolean;
 };
 interface DatabaseOptions {
     databaseType?: "postgres";

package/dist/index.d.ts

@@ -37,12 +37,16 @@ declare class DeputyTask extends Task {
      * @param context - The GraphContext containing execution data.
      * @param emit
      * @param progressCallback - Callback to update progress (invoked by meta-layer).
+     * @param nodeData
      * @returns A Promise resolving with the task result or rejecting on error.
      * @emits {meta.deputy.executed} - Emitted with context to initiate delegation.
      * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
      * @note The resolution and progress are managed by ephemeral meta-tasks.
      */
-    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void): TaskResult;
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
 }
 
 type DbOperationType$1 = "query" | "insert" | "update" | "delete";
@@ -71,9 +75,10 @@ interface OnConflictAction {
 }
 type OpEffect = "increment" | "decrement" | "set";
 type ValueOrSubOp = any | SubOperation | OpEffect;
+type ValueOrList = any | any[];
 interface DbOperationPayload {
     data?: Record<string, ValueOrSubOp> | Record<string, ValueOrSubOp>[];
-    filter?: AnyObject;
+    filter?: Record<string, ValueOrList>;
     fields?: string[];
     joins?: Record<string, JoinDefinition>;
     sort?: Record<string, SortDirection>;
@@ -125,12 +130,16 @@ declare class DatabaseTask extends DeputyTask {
      * @param context - The GraphContext containing execution data.
      * @param emit
      * @param progressCallback - Callback to update progress (invoked by meta-layer).
+     * @param nodeData
      * @returns A Promise resolving with the task result or rejecting on error.
      * @emits {meta.deputy.executed} - Emitted with context including queryData to initiate delegation.
      * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
      * @note The resolution and progress are managed by ephemeral meta-tasks.
      */
-    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void): TaskResult;
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
 }
 
 interface ServiceInstanceDescriptor {
@@ -146,6 +155,7 @@ interface ServiceInstanceDescriptor {
     health: AnyObject;
     exposed: boolean;
     clientCreated?: boolean;
+    isFrontend: boolean;
 }
 interface DeputyDescriptor {
     serviceName: string;
@@ -341,6 +351,8 @@ type ServerOptions = {
         port?: number;
     };
     relatedServices?: string[][];
+    isDatabase?: boolean;
+    isFrontend?: boolean;
 };
 interface DatabaseOptions {
     databaseType?: "postgres";

package/dist/index.js

@@ -168,16 +168,20 @@ var DeputyTask = class extends import_core.Task {
    * @param context - The GraphContext containing execution data.
    * @param emit
    * @param progressCallback - Callback to update progress (invoked by meta-layer).
+   * @param nodeData
    * @returns A Promise resolving with the task result or rejecting on error.
    * @emits {meta.deputy.executed} - Emitted with context to initiate delegation.
    * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
    * @note The resolution and progress are managed by ephemeral meta-tasks.
    */
-  execute(context, emit, progressCallback) {
+  execute(context, emit, progressCallback, nodeData) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
     const deputyContext = {
       __localTaskName: this.name,
+      __localTaskVersion: this.version,
+      __localServiceName: CadenzaService.serviceRegistry.serviceName,
+      __previousTaskExecutionId: nodeData.nodeId,
       __remoteRoutineName: this.remoteRoutineName,
       __serviceName: this.serviceName,
       __localRoutineExecId: metadata.__routineExecId ?? metadata.__metadata?.__routineExecId,
@@ -251,18 +255,22 @@ var DatabaseTask = class extends DeputyTask {
    * @param context - The GraphContext containing execution data.
    * @param emit
    * @param progressCallback - Callback to update progress (invoked by meta-layer).
+   * @param nodeData
    * @returns A Promise resolving with the task result or rejecting on error.
    * @emits {meta.deputy.executed} - Emitted with context including queryData to initiate delegation.
    * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
    * @note The resolution and progress are managed by ephemeral meta-tasks.
    */
-  execute(context, emit, progressCallback) {
+  execute(context, emit, progressCallback, nodeData) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
     const dynamicQueryData = ctx.queryData ?? {};
     delete ctx.queryData;
     const deputyContext = {
       __localTaskName: this.name,
+      __localTaskVersion: this.version,
+      __localServiceName: CadenzaService.serviceRegistry.serviceName,
+      __previousTaskExecutionId: nodeData.nodeId,
       __remoteRoutineName: this.remoteRoutineName,
       __serviceName: this.serviceName,
       __executionTraceId: metadata.__executionTraceId ?? null,
@@ -283,6 +291,10 @@ var DatabaseTask = class extends DeputyTask {
   }
 };
 
+// src/utils/environment.ts
+var isNode = typeof process !== "undefined" && process.versions?.node != null;
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+
 // src/registry/ServiceRegistry.ts
 var ServiceRegistry = class _ServiceRegistry {
   constructor() {
@@ -298,7 +310,7 @@ var ServiceRegistry = class _ServiceRegistry {
       "Handle Instance Update",
       (ctx, emit) => {
         const { serviceInstance } = ctx;
-        const { uuid: uuid4, serviceName, address, port, exposed } = serviceInstance;
+        const { uuid: uuid4, serviceName, address, port, exposed, isFrontend } = serviceInstance;
         if (uuid4 === this.serviceInstanceId) return;
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
@@ -307,7 +319,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (existing) {
           Object.assign(existing, serviceInstance);
         } else {
-          if (this.deputies.has(serviceName) || this.remoteSignals.has(serviceName) || this.remoteSignals.has("*") && this.serviceName !== serviceName) {
+          if (!isFrontend && this.deputies.has(serviceName) || this.remoteSignals.has(serviceName) || this.remoteSignals.has("*") && this.serviceName !== serviceName) {
             const clientCreated = instances?.some(
               (i) => i.address === address && i.port === port && i.clientCreated && i.isActive
             );
@@ -498,7 +510,8 @@ var ServiceRegistry = class _ServiceRegistry {
         "is_blocked",
         "health",
         "exposed",
-        "created"
+        "created",
+        "is_frontend"
       ]
     }).doOn("meta.sync_requested").emits("meta.service_registry.synced_instances").then(
       CadenzaService.createMetaTask(
@@ -549,6 +562,7 @@ var ServiceRegistry = class _ServiceRegistry {
           localTaskName: ctx.localTaskName,
           communicationType: ctx.communicationType
         });
+        emit("meta.service_registry.deputy_registered", ctx);
       }
     ).doOn("meta.deputy.created");
     this.getAllInstances = CadenzaService.createMetaTask(
@@ -595,6 +609,15 @@ var ServiceRegistry = class _ServiceRegistry {
           );
           return context;
         }
+        if (instances[0].isFrontend) {
+          for (const instance of instances) {
+            emit(
+              `meta.service_registry.selected_instance_for_socket:${instance.address}`,
+              context
+            );
+          }
+          return context;
+        }
         let instancesToTry = instances.filter(
           (i) => !__triedInstances?.includes(i.uuid)
         );
@@ -791,7 +814,7 @@ var ServiceRegistry = class _ServiceRegistry {
         retryCount: 5,
         retryDelay: 1e3
       }
-    ).doOn("meta.rest.network_configured").then(
+    ).doOn("meta.rest.network_configured", "meta.rest.browser_detected").then(
       CadenzaService.createMetaTask(
         "Setup service",
         (ctx) => {
@@ -816,6 +839,68 @@ var ServiceRegistry = class _ServiceRegistry {
           ctx.__skipRemoteExecution = true;
         }
         console.log("service creation", ctx);
+        if (isBrowser) {
+          CadenzaService.createMetaTask("Prepare for signal sync", () => {
+            return {};
+          }).doAfter(this.fullSyncTask).then(
+            CadenzaService.createCadenzaDBQueryTask("signal_registry", {
+              fields: ["name", "service_name"],
+              filter: {
+                source_service_name: [ctx.__serviceName, "*"]
+              }
+            }).then(
+              CadenzaService.createMetaTask(
+                "Create signal transmission tasks",
+                (ctx2, emit) => {
+                  const signalRegistry = ctx2.signalRegistry;
+                  for (const signal of signalRegistry) {
+                    emit("meta.service_registry.foreign_signal_registered", {
+                      __emitterSignalName: signal.name,
+                      __listenerServiceName: signal.serviceName
+                    });
+                  }
+                  return true;
+                }
+              ).then(
+                CadenzaService.createMetaTask("Connect to services", (ctx2, emit) => {
+                  const services = Array.from(
+                    new Set(
+                      ctx2.signalRegistry.map((s) => s.serviceName)
+                    )
+                  );
+                  for (const service of services) {
+                    const instances = this.instances.get(service).filter((i) => i.isActive);
+                    for (const instance of instances) {
+                      if (instance.clientCreated) continue;
+                      const address = instance.address;
+                      const port = instance.port;
+                      const clientCreated = instances?.some(
+                        (i) => i.address === address && i.port === port && i.clientCreated && i.isActive
+                      );
+                      if (!clientCreated) {
+                        emit("meta.service_registry.dependee_registered", {
+                          serviceName: service,
+                          serviceInstanceId: instance.uuid,
+                          serviceAddress: address,
+                          servicePort: port,
+                          protocol: instance.exposed ? "https" : "http",
+                          communicationTypes: ["signal"]
+                        });
+                      }
+                      instance.clientCreated = true;
+                      instances.forEach((i) => {
+                        if (i.address === address && i.port === port) {
+                          i.clientCreated = true;
+                        }
+                      });
+                    }
+                  }
+                  return {};
+                })
+              )
+            )
+          );
+        }
         return ctx;
       },
       "Handles the request to create a service instance"
@@ -985,7 +1070,26 @@ var RestController = class _RestController {
       [
         CadenzaService.createMetaTask(
           "Setup Express app security",
-          (ctx) => {
+          (ctx, emit) => {
+            if (isBrowser) {
+              emit("meta.rest.browser_detected", {
+                data: {
+                  uuid: ctx.__serviceInstanceId,
+                  address: `browser:${ctx.__serviceInstanceId}`,
+                  port: 0,
+                  exposed: false,
+                  process_pid: 1,
+                  service_name: ctx.__serviceName,
+                  is_frontend: true,
+                  is_active: true,
+                  is_non_responsive: false,
+                  is_blocked: false,
+                  health: {}
+                },
+                ...ctx
+              });
+              return;
+            }
             const app = (0, import_express.default)();
             app.use(import_body_parser.default.json());
             switch (ctx.__securityProfile) {
@@ -1243,6 +1347,7 @@ var RestController = class _RestController {
                   process_pid: process.pid,
                   service_name: ctx.__serviceName,
                   is_active: true,
+                  is_database: ctx.__isDatabase,
                   is_non_responsive: false,
                   is_blocked: false,
                   health: {}
@@ -1522,12 +1627,33 @@ var SocketController = class _SocketController {
           server.on("connection", (ws) => {
             console.log("SocketServer: New connection");
             try {
+              ws.emit("handshake", {
+                serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+                serviceName: CadenzaService.serviceRegistry.serviceName,
+                __status: "success"
+              });
               ws.on("handshake", (ctx2) => {
                 console.log("Socket HANDSHAKE", ctx2.serviceInstanceId);
-                ws.emit("handshake", {
-                  serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
-                  __status: "success"
-                });
+                if (ctx2.isFrontend) {
+                  const fetchId = `browser:${ctx2.serviceInstanceId}`;
+                  CadenzaService.createMetaTask(
+                    `Transmit signal to ${fetchId}`,
+                    (ctx3, emit) => {
+                      if (ctx3.__signalName === void 0) {
+                        return;
+                      }
+                      ws.emit("signal", ctx3);
+                      if (ctx3.__routineExecId) {
+                        emit(
+                          `meta.socket_client.transmitted:${ctx3.__routineExecId}`,
+                          {}
+                        );
+                      }
+                    }
+                  ).doOn(
+                    `meta.service_registry.selected_instance_for_socket:${fetchId}`
+                  );
+                }
                 CadenzaService.broker.emit("meta.socket.handshake", ctx2);
               });
               ws.on(
@@ -1647,6 +1773,12 @@ var SocketController = class _SocketController {
         });
         socket.on("handshake", (ctx2) => {
           console.log("Socket client HANDSHAKE", ctx2);
+          socket.emit("handshake", {
+            serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+            serviceName: CadenzaService.serviceRegistry.serviceName,
+            isFrontend: isBrowser,
+            __status: "success"
+          });
           CadenzaService.broker.emit("meta.socket_client.handshake", ctx2);
         });
         socket.on("delegation_progress", (ctx2) => {
@@ -1655,6 +1787,11 @@ var SocketController = class _SocketController {
             ctx2
           );
         });
+        socket.on("signal", (ctx2) => {
+          if (CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
+            CadenzaService.broker.emit(ctx2.__signalName, ctx2);
+          }
+        });
         socket.on("status_update", (status) => {
           CadenzaService.broker.emit("meta.socket_client.status_received", status);
         });
@@ -1770,6 +1907,45 @@ var SocketController = class _SocketController {
   }
 };
 
+// src/utils/tools.ts
+function formatTimestamp(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+function decomposeSignalName(signalName) {
+  const parts = signalName.split(".");
+  const firstChar = signalName.charAt(0);
+  let isMeta = false;
+  let sourceServiceName = null;
+  let domain = parts.length === 2 ? parts[0] : "";
+  if (parts[0] === "meta") {
+    isMeta = true;
+    if (parts.length === 3) {
+      domain = parts[1];
+    } else {
+      domain = "";
+    }
+  } else if (firstChar === "*" || firstChar === firstChar.toUpperCase()) {
+    sourceServiceName = parts[0];
+    if (parts[1] === "meta") {
+      isMeta = true;
+      if (parts.length === 4) {
+        domain = parts[2];
+      } else {
+        domain = "";
+      }
+    } else {
+      domain = parts[1];
+    }
+  }
+  const action = parts[parts.length - 1];
+  return {
+    isMeta,
+    sourceServiceName,
+    domain,
+    action
+  };
+}
+
 // src/signals/SignalController.ts
 var SignalController = class _SignalController {
   static get instance() {
@@ -1781,15 +1957,14 @@ var SignalController = class _SignalController {
       "Handle Signal Registration",
       (ctx, emit) => {
         const { __signalName } = ctx;
-        const parts = __signalName.split(".");
-        const domain = parts[0] === "meta" ? parts[1] : parts[0];
-        const action = parts[parts.length - 1];
+        const { isMeta, sourceServiceName, domain, action } = decomposeSignalName(__signalName);
         emit("meta.signal_controller.signal_added", {
           data: {
             name: __signalName,
+            sourceServiceName,
             domain,
             action,
-            is_meta: parts[0] === "meta",
+            isMeta,
             service_name: CadenzaService.serviceRegistry.serviceName
           }
         });
@@ -1852,7 +2027,10 @@ var SignalController = class _SignalController {
         __listenerServiceName
       ).doOn(__emitterSignalName.split(".").slice(1).join("."));
       return true;
-    }).doOn("meta.signal_controller.foreign_signal_registered");
+    }).doOn(
+      "meta.signal_controller.foreign_signal_registered",
+      "meta.service_registry.foreign_signal_registered"
+    );
     CadenzaService.createMetaTask(
       "Add data to signal emission",
       (ctx) => {
@@ -1932,6 +2110,24 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       };
     }).doOn("meta.task.relationship_added").emits("meta.graph_metadata.task_relationship_created");
+    CadenzaService.createMetaTask(
+      "Handle task deputy relationship creation",
+      (ctx) => {
+        if (ctx.signalName) return;
+        return {
+          data: {
+            triggered_task_name: ctx.remoteRoutineName,
+            triggered_task_version: 1,
+            // TODO
+            triggered_service_name: ctx.serviceName,
+            deputy_task_name: ctx.localTaskName,
+            deputy_task_version: 1,
+            // TODO
+            deputy_service_name: CadenzaService.serviceRegistry.serviceName
+          }
+        };
+      }
+    ).doOn("meta.service_registry.deputy_registered").emits("meta.graph_metadata.deputy_relationship_created");
     CadenzaService.createMetaTask("Handle task signal observation", (ctx) => {
       const firstChar = ctx.data.signalName.charAt(0);
       let _signal = ctx.data.signalName;
@@ -2166,7 +2362,8 @@ var GraphMetadataController = class _GraphMetadataController {
       (ctx) => {
         return {
           data: {
-            executionCount: "increment"
+            execution_count: "increment",
+            last_executed: formatTimestamp(Date.now())
           },
           filter: {
             ...ctx.filter,
@@ -2177,6 +2374,37 @@ var GraphMetadataController = class _GraphMetadataController {
       "Handles task execution relationship creation",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped").emits("meta.graph_metadata.relationship_executed");
+    CadenzaService.createMetaTask(
+      "Handle explicit task execution relationship creation",
+      (ctx) => {
+        return {
+          data: {
+            deputy_task_execution_id: ctx.data.previousTaskExecutionId,
+            task_execution_id: ctx.data.taskExecutionId
+          }
+        };
+      }
+    ).doOn("meta.node.detected_previous_task_execution").emits("meta.graph_metadata.explicit_relationship_created");
+    CadenzaService.createMetaTask(
+      "Handle explicit task execution relationship execution",
+      (ctx) => {
+        if (!ctx.__localTaskName) return;
+        return {
+          data: {
+            execution_count: "increment",
+            last_executed: formatTimestamp(Date.now())
+          },
+          filter: {
+            deputy_task_name: ctx.__localTaskName,
+            deputy_task_version: ctx.__localTaskVersion,
+            deputy_service_name: ctx.__localServiceName,
+            triggered_task_name: ctx.filter.taskName,
+            triggered_task_version: ctx.filter.taskVersion,
+            triggered_service_name: CadenzaService.serviceRegistry.serviceName
+          }
+        };
+      }
+    ).doOn("meta.node.detected_previous_task_execution").emits("meta.graph_metadata.explicit_relationship_executed");
   }
 };
 
@@ -3043,8 +3271,18 @@ var DatabaseController = class _DatabaseController {
     const conditions = [];
     for (const [key, value] of Object.entries(filter)) {
       if (value !== void 0) {
-        conditions.push(`${(0, import_lodash_es.snakeCase)(key)} = $${params.length + 1}`);
-        params.push(value);
+        if (Array.isArray(value)) {
+          conditions.push(
+            `${(0, import_lodash_es.snakeCase)(key)} IN (${value.map((v) => {
+              const val = `$${params.length + 1}`;
+              params.push(v);
+              return val;
+            }).join(", ")})`
+          );
+        } else {
+          conditions.push(`${(0, import_lodash_es.snakeCase)(key)} = $${params.length + 1}`);
+          params.push(value);
+        }
       }
     }
     return conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -3244,15 +3482,14 @@ var GraphSyncController = class _GraphSyncController {
         (signal) => !signal.data.registered
       ).map((signal) => signal.signal);
       for (const signal of filteredSignals) {
-        const parts = signal.split(".");
-        const domain = parts[0] === "meta" ? parts[1] : parts[0];
-        const action = parts[parts.length - 1];
+        const { isMeta, sourceServiceName, domain, action } = decomposeSignalName(signal);
         emit("meta.sync_controller.signal_added", {
           data: {
             name: signal,
+            sourceServiceName,
             domain,
             action,
-            isMeta: parts[0] === "meta",
+            isMeta,
             serviceName: CadenzaService.serviceRegistry.serviceName
           }
         });
@@ -3341,7 +3578,6 @@ var GraphSyncController = class _GraphSyncController {
       }
       for (const task of __tasks) {
         if (task.hidden || !task.register) continue;
-        if (task.registered) continue;
         task.mapNext(
           (t) => emit("meta.sync_controller.task_map", {
             data: {
@@ -3353,6 +3589,18 @@ var GraphSyncController = class _GraphSyncController {
             }
           })
         );
+        if (task.isDeputy && !task.signalName) {
+          emit("meta.sync_controller.deputy_relationship_created", {
+            data: {
+              triggered_task_name: task.remoteRoutineName,
+              triggered_task_version: 1,
+              triggered_service_name: task.serviceName,
+              deputy_task_name: task.name,
+              deputy_task_version: task.version,
+              deputy_service_name: CadenzaService.serviceRegistry.serviceName
+            }
+          });
+        }
       }
       return true;
     }).doAfter(CadenzaService.registry.getAllTasks);
@@ -3653,6 +3901,7 @@ var CadenzaService = class {
       relatedServices: process.env.RELATED_SERVICES ? process.env.RELATED_SERVICES.split("|").map(
         (s) => s.trim().split(",")
       ) : [],
+      isFrontend: isBrowser,
       ...options
     };
     if (options.cadenzaDB?.connect) {
@@ -3706,7 +3955,8 @@ var CadenzaService = class {
       __securityProfile: options.securityProfile,
       __networkMode: options.networkMode,
       __retryCount: options.retryCount,
-      __cadenzaDBConnect: options.cadenzaDB?.connect
+      __cadenzaDBConnect: options.cadenzaDB?.connect,
+      __isDatabase: options.isDatabase
     };
     if (options.cadenzaDB?.connect) {
       import_core3.default.createEphemeralMetaTask("Create service", async (_, emit) => {
@@ -3735,6 +3985,12 @@ var CadenzaService = class {
     this.createCadenzaService(serviceName, description, options);
   }
   static createDatabaseService(name, schema, description = "", options = {}) {
+    if (isBrowser) {
+      console.warn(
+        "Database service creation is not supported in the browser. Use the CadenzaDB service instead."
+      );
+      return;
+    }
     if (this.serviceCreated) return;
     this.bootstrap();
     this.serviceRegistry.serviceName = name;
@@ -3756,6 +4012,7 @@ var CadenzaService = class {
       databaseType: "postgres",
       databaseName: (0, import_lodash_es2.snakeCase)(name),
       poolSize: parseInt(process.env.DATABASE_POOL_SIZE ?? "10"),
+      isDatabase: true,
       ...options
     };
     import_core3.default.broker.emit("meta.database_init_requested", {
@@ -3767,6 +4024,27 @@ var CadenzaService = class {
       console.log("Database service created");
       this.createCadenzaService(name, description, options);
     }).doOn("meta.database.setup_done");
+    if (options.cadenzaDB?.connect) {
+      import_core3.default.createEphemeralMetaTask("Insert database service", (_, emit) => {
+        emit("meta.created_database_service", {
+          data: {
+            service_name: name,
+            description,
+            schema,
+            is_meta: options.isMeta
+          }
+        });
+      }).doOn("meta.service_registry.service_inserted");
+    } else {
+      import_core3.default.broker.emit("meta.created_database_service", {
+        data: {
+          service_name: name,
+          description,
+          schema,
+          is_meta: options.isMeta
+        }
+      });
+    }
   }
   static createMetaDatabaseService(name, schema, description = "", options = {}) {
     this.bootstrap();