@cadenza.io/service 2.17.70 → 2.17.72

package/dist/index.js

@@ -6111,6 +6111,14 @@ function decomposeSignalName(signalName) {
 }
 
 // src/signals/SignalController.ts
+function buildSignalDatabaseTriggerContext(data) {
+  return {
+    data: { ...data },
+    queryData: {
+      data: { ...data }
+    }
+  };
+}
 var SignalController = class _SignalController {
   static get instance() {
     if (!this._instance) this._instance = new _SignalController();
@@ -6136,15 +6144,16 @@ var SignalController = class _SignalController {
       (ctx, emit) => {
         const { signalName } = ctx;
         const { isMeta, isGlobal, domain, action } = decomposeSignalName(signalName);
-        emit("global.meta.signal_controller.signal_added", {
-          data: {
+        emit(
+          "global.meta.signal_controller.signal_added",
+          buildSignalDatabaseTriggerContext({
             name: signalName,
             isGlobal,
             domain,
             action,
             isMeta
-          }
-        });
+          })
+        );
         return ctx;
       },
       "Handles signal registration from a service instance"
@@ -6308,6 +6317,23 @@ function registerActorSessionPersistenceTasks() {
 }
 
 // src/graph/controllers/GraphMetadataController.ts
+function buildDatabaseTriggerContext(data, filter, extra = {}) {
+  const nextData = data && typeof data === "object" ? { ...data } : void 0;
+  const nextFilter = filter && typeof filter === "object" ? { ...filter } : void 0;
+  const queryData = {};
+  if (nextData !== void 0) {
+    queryData.data = nextData;
+  }
+  if (nextFilter !== void 0) {
+    queryData.filter = nextFilter;
+  }
+  return {
+    ...extra,
+    ...nextData !== void 0 ? { data: nextData } : {},
+    ...nextFilter !== void 0 ? { filter: nextFilter } : {},
+    ...Object.keys(queryData).length > 0 ? { queryData } : {}
+  };
+}
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
@@ -6315,21 +6341,19 @@ var GraphMetadataController = class _GraphMetadataController {
   }
   constructor() {
     CadenzaService.createMetaTask("Handle task creation", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          serviceName: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.task.created").emits("global.meta.graph_metadata.task_created");
     CadenzaService.createMetaTask("Handle task update", (ctx) => {
-      return {
-        ...ctx,
-        filter: {
+      return buildDatabaseTriggerContext(
+        ctx.data ?? void 0,
+        {
           ...ctx.filter,
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
-      };
+      );
     }).doOn("meta.task.layer_index_changed", "meta.task.destroyed").emits("global.meta.graph_metadata.task_updated");
     CadenzaService.createMetaTask("Handle task relationship creation", (ctx) => {
       const taskName = ctx.data?.taskName ?? ctx.data?.task_name;
@@ -6339,114 +6363,101 @@ var GraphMetadataController = class _GraphMetadataController {
       if (!task?.registered || !predecessorTask?.registered) {
         return false;
       }
-      return {
-        data: {
-          ...ctx.data,
-          serviceName: CadenzaService.serviceRegistry.serviceName,
-          predecessorServiceName: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName,
+        predecessorServiceName: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.task.relationship_added").emits("global.meta.graph_metadata.task_relationship_created");
     CadenzaService.createMetaTask("Handle task error", (ctx) => {
       CadenzaService.log(`Error in task ${ctx.data.taskName}`, ctx.data, "error");
     }).doOn("meta.node.errored");
     CadenzaService.createMetaTask("Handle task signal observation", (ctx) => {
       const isGlobal = ctx.signalName.startsWith("global.");
-      return {
-        data: {
-          ...ctx.data,
-          isGlobal,
-          serviceName: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        isGlobal,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.task.observed_signal").emits("global.meta.graph_metadata.task_signal_observed");
     CadenzaService.createMetaTask("Handle task signal attachment", (ctx) => {
-      return {
-        data: {
-          ...ctx.data
-        },
-        filter: {
+      return buildDatabaseTriggerContext(
+        ctx.data ?? void 0,
+        {
           ...ctx.filter,
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
-      };
+      );
     }).doOn("meta.task.attached_signal").emits("global.meta.graph_metadata.task_attached_signal");
     CadenzaService.createMetaTask("Handle task unsubscribing signal", (ctx) => {
-      return {
-        data: {
+      return buildDatabaseTriggerContext(
+        {
           deleted: true
         },
-        filter: {
+        {
           ...ctx.filter,
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
-      };
+      );
     }).doOn("meta.task.unsubscribed_signal").emits("meta.graph_metadata.task_unsubscribed_signal");
     CadenzaService.createMetaTask("Handle task detaching signal", (ctx) => {
-      return {
-        data: {
+      return buildDatabaseTriggerContext(
+        {
           deleted: true
         },
-        filter: {
+        {
           ...ctx.filter,
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
-      };
+      );
     }).doOn("meta.task.detached_signal").emits("global.meta.graph_metadata.task_detached_signal");
     CadenzaService.createMetaTask("Handle routine creation", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          serviceName: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
     }).doAfter(CadenzaService.registry.registerRoutine).emits("global.meta.graph_metadata.routine_created");
     CadenzaService.createMetaTask("Handle routine update", (ctx) => {
-      return {
-        ...ctx,
-        filter: {
+      return buildDatabaseTriggerContext(
+        ctx.data ?? void 0,
+        {
           ...ctx.filter,
           serviceName: CadenzaService.serviceRegistry.serviceName
         }
-      };
+      );
     }).doOn("meta.routine.destroyed").emits("global.meta.graph_metadata.routine_updated");
     CadenzaService.createMetaTask("Handle adding task to routine", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          serviceName: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.routine.task_added").emits("global.meta.graph_metadata.task_added_to_routine");
     CadenzaService.createMetaTask("Handle new trace", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          service_name: CadenzaService.serviceRegistry.serviceName,
-          service_instance_id: CadenzaService.serviceRegistry.serviceInstanceId
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        service_name: CadenzaService.serviceRegistry.serviceName,
+        service_instance_id: CadenzaService.serviceRegistry.serviceInstanceId
+      });
     }).doOn("meta.runner.new_trace", "sub_meta.signal_broker.new_trace").emits("global.meta.graph_metadata.execution_trace_created");
     CadenzaService.createMetaTask(
       "Handle routine execution creation",
       (ctx) => {
-        return {
-          queryData: {
-            data: {
-              ...ctx.data,
-              serviceName: CadenzaService.serviceRegistry.serviceName,
-              serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
-            }
-          }
-        };
+        return buildDatabaseTriggerContext({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
+        });
       },
       "Handles routine execution creation",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.runner.added_tasks").emits("global.meta.graph_metadata.routine_execution_created");
     CadenzaService.createMetaTask(
       "Handle routine execution started",
-      () => {
-        return true;
+      (ctx) => {
+        return buildDatabaseTriggerContext(
+          ctx.data ?? void 0,
+          ctx.filter ?? void 0
+        );
       },
       "Handles routine execution started",
       { concurrency: 100, isSubMeta: true }
@@ -6454,16 +6465,14 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle routine execution ended",
       (ctx) => {
-        return {
-          data: {
+        return buildDatabaseTriggerContext(
+          {
             ...ctx.data,
             serviceName: CadenzaService.serviceRegistry.serviceName,
             serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
           },
-          filter: {
-            ...ctx.filter
-          }
-        };
+          ctx.filter ?? void 0
+        );
       },
       "Handles routine execution ended",
       { concurrency: 100, isSubMeta: true }
@@ -6471,29 +6480,33 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution creation",
       (ctx) => {
-        return {
-          data: {
-            ...ctx.data,
-            serviceName: CadenzaService.serviceRegistry.serviceName,
-            serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
-          }
-        };
+        return buildDatabaseTriggerContext({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
+        });
       },
       "Handles task execution creation",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.scheduled").emits("global.meta.graph_metadata.task_execution_created");
     CadenzaService.createMetaTask(
       "Handle task execution mapped",
-      () => {
-        return true;
+      (ctx) => {
+        return buildDatabaseTriggerContext(
+          ctx.data ?? void 0,
+          ctx.filter ?? void 0
+        );
       },
       "Handles task execution mapping",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped", "meta.node.detected_previous_task_execution").emits("global.meta.graph_metadata.task_execution_mapped");
     CadenzaService.createMetaTask(
       "Handle task execution started",
-      () => {
-        return true;
+      (ctx) => {
+        return buildDatabaseTriggerContext(
+          ctx.data ?? void 0,
+          ctx.filter ?? void 0
+        );
       },
       "Handles task execution started",
       { concurrency: 100, isSubMeta: true }
@@ -6501,16 +6514,14 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution ended",
       (ctx) => {
-        return {
-          data: {
+        return buildDatabaseTriggerContext(
+          {
             ...ctx.data,
             serviceName: CadenzaService.serviceRegistry.serviceName,
             serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
           },
-          filter: {
-            ...ctx.filter
-          }
-        };
+          ctx.filter ?? void 0
+        );
       },
       "Handles task execution ended",
       { concurrency: 100, isSubMeta: true }
@@ -6518,45 +6529,39 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution relationship creation",
       (ctx) => {
-        return {
-          data: {
+        return buildDatabaseTriggerContext(
+          {
             executionCount: "increment",
             lastExecuted: formatTimestamp(Date.now())
           },
-          filter: {
+          {
             ...ctx.filter,
             serviceName: CadenzaService.serviceRegistry.serviceName
           }
-        };
+        );
       },
       "Handles task execution relationship creation",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped", "meta.node.detected_previous_task_execution").emits("global.meta.graph_metadata.relationship_executed");
     CadenzaService.createMetaTask("Handle actor creation", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          service_name: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        service_name: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.actor.created").emits("global.meta.graph_metadata.actor_created");
     CadenzaService.createMetaTask("Handle actor task association", (ctx) => {
-      return {
-        data: {
-          ...ctx.data,
-          service_name: CadenzaService.serviceRegistry.serviceName
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        service_name: CadenzaService.serviceRegistry.serviceName
+      });
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
     registerActorSessionPersistenceTasks();
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
       const intentName = ctx.data?.name;
-      return {
-        data: {
-          ...ctx.data,
-          isMeta: intentName ? isMetaIntentName(intentName) : false
-        }
-      };
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        isMeta: intentName ? isMetaIntentName(intentName) : false
+      });
     }).doOn("meta.inquiry_broker.added").emits("global.meta.graph_metadata.intent_created");
   }
 };
@@ -8812,24 +8817,63 @@ function buildMinimalSyncSignalContext(ctx, extra = {}) {
   return nextContext;
 }
 function buildSyncInsertQueryData(ctx, queryData = {}) {
+  const pickQueryData = (source, allowedKeys) => {
+    const next = {};
+    for (const key of allowedKeys) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        next[key] = source[key];
+      }
+    }
+    return next;
+  };
   const joinedQueryData = getJoinedContextValue(ctx, "queryData");
   const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : joinedQueryData && typeof joinedQueryData === "object" ? joinedQueryData : {};
   const nextQueryData = {
-    ...existingQueryData,
+    ...pickQueryData(existingQueryData, ["transaction"]),
     ...queryData
   };
   const resolvedData = Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedContextValue(ctx, "data");
   const resolvedBatch = Object.prototype.hasOwnProperty.call(ctx, "batch") || ctx.batch !== void 0 ? ctx.batch : getJoinedContextValue(ctx, "batch");
   if (resolvedData !== void 0) {
     nextQueryData.data = resolvedData && typeof resolvedData === "object" && !Array.isArray(resolvedData) ? { ...resolvedData } : resolvedData;
+  } else {
+    delete nextQueryData.data;
   }
   if (resolvedBatch !== void 0) {
     nextQueryData.batch = Array.isArray(resolvedBatch) ? resolvedBatch.map(
       (row) => row && typeof row === "object" ? { ...row } : row
     ) : resolvedBatch;
+  } else {
+    delete nextQueryData.batch;
   }
   return nextQueryData;
 }
+function buildSyncQueryQueryData(ctx, queryData = {}) {
+  const joinedQueryData = getJoinedContextValue(ctx, "queryData");
+  const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : joinedQueryData && typeof joinedQueryData === "object" ? joinedQueryData : {};
+  const nextQueryData = {};
+  const allowedKeys = [
+    "transaction",
+    "filter",
+    "fields",
+    "joins",
+    "sort",
+    "limit",
+    "offset",
+    "queryMode",
+    "aggregates",
+    "groupBy"
+  ];
+  for (const key of allowedKeys) {
+    if (Object.prototype.hasOwnProperty.call(existingQueryData, key)) {
+      nextQueryData[key] = existingQueryData[key];
+    }
+  }
+  return {
+    ...nextQueryData,
+    ...queryData
+  };
+}
 var REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY = 5;
 var REMOTE_AUTHORITY_SYNC_QUERY_CONCURRENCY = 3;
 function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
@@ -9147,10 +9191,10 @@ function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, optio
   });
   const prepareQueryTask = CadenzaService.createMetaTask(
     `Prepare graph sync query for ${tableName}`,
-    (ctx) => buildSyncExecutionEnvelope(ctx, {
-      ...ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {},
-      ...queryData
-    }),
+    (ctx) => buildSyncExecutionEnvelope(
+      ctx,
+      buildSyncQueryQueryData(ctx, queryData)
+    ),
     `Prepares ${tableName} graph-sync query payloads.`,
     {
       register: false,