mcp-event-intelligence 0.4.0 → 0.6.0

package/scripts/lib/trigger-control-plane.mjs

@@ -67,6 +67,47 @@ function scalarSchemaForConstant(value) {
   return {};
 }
 
+function walkPatternValue(value, visitor) {
+  if (!value || typeof value !== 'object') return;
+  if (value.kind === 'field') {
+    visitor(value.ref, value.path, 'pattern value');
+    return;
+  }
+  if (value.kind === 'arithmetic') {
+    for (const arg of value.args ?? []) walkPatternValue(arg, visitor);
+  }
+}
+
+function walkPatternNode(node, visitor) {
+  if (!node || typeof node !== 'object') return;
+
+  if (node.kind === 'compare') {
+    walkPatternValue(node.left, visitor);
+    if (node.right) walkPatternValue(node.right, visitor);
+  }
+  if (
+    node.kind === 'aggregate' ||
+    node.kind === 'state' ||
+    node.kind === 'distinct'
+  ) {
+    if (node.path) visitor(node.ref, node.path, `pattern ${node.kind}`);
+  }
+  if (node.kind === 'semantic') {
+    for (const input of node.input ?? []) {
+      const [ref, ...parts] = String(input).split('.');
+      if (ref && parts.length) {
+        visitor(ref, parts.join('.'), 'pattern semantic input');
+      }
+    }
+  }
+
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkPatternNode(child, visitor);
+  }
+  if (node.child) walkPatternNode(node.child, visitor);
+  if (node.forbidden) walkPatternNode(node.forbidden, visitor);
+}
+
 function assertSubscriptionArguments(source, args, purpose) {
   const inputSchema = source?.inputSchema;
   if (
@@ -122,23 +163,24 @@ export class TriggerControlPlane {
     });
   }
 
-  listEventSources({ connectionIds } = {}) {
+  async listEventSources({ connectionIds } = {}) {
     return this.store.listEventSources({
       connectionIds,
       enabledOnly: true,
     });
   }
 
-  listTriggers({ owner: ownerInput } = {}) {
+  async listTriggers({ owner: ownerInput } = {}) {
     const owner = ownerInput ? actorIdentity(ownerInput) : null;
-    return this.store.listTriggers()
-      .map((definition) => ({
-        definition,
-        state: this.store.getTriggerState(
-          definition.triggerId,
-          definition.version,
-        ),
-      }))
+    const definitions = await this.store.listTriggers();
+    const entries = await Promise.all(definitions.map(async (definition) => ({
+      definition,
+      state: await this.store.getTriggerState(
+        definition.triggerId,
+        definition.version,
+      ),
+    })));
+    return entries
       .filter((entry) => !owner || samePrincipal(entry.state.owner, owner));
   }
 
@@ -195,9 +237,9 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    this.assertSourcesAvailable(definition, allowedConnectionIds);
+    await this.assertSourcesAvailable(definition, allowedConnectionIds);
 
-    if (this.store.listTriggers().some((candidate) =>
+    if ((await this.store.listTriggers()).some((candidate) =>
       candidate.triggerId === definition.triggerId &&
       candidate.version === definition.version
     )) {
@@ -280,7 +322,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const current = this.store.listTriggers().find(
+    const current = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === expectedVersion,
@@ -293,7 +335,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(
+    const currentState = await this.store.getTriggerState(
       triggerId,
       expectedVersion,
     );
@@ -310,16 +352,19 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const competing = this.store.listTriggers()
-      .filter((candidate) => candidate.triggerId === triggerId)
-      .find((candidate) => {
-        if (candidate.version === expectedVersion) return false;
-        const state = this.store.getTriggerState(
-          candidate.triggerId,
-          candidate.version,
-        );
-        return state.status === 'active' || state.status === 'paused';
-      });
+    let competing = null;
+    for (const candidate of (await this.store.listTriggers())
+      .filter((item) => item.triggerId === triggerId)) {
+      if (candidate.version === expectedVersion) continue;
+      const state = await this.store.getTriggerState(
+        candidate.triggerId,
+        candidate.version,
+      );
+      if (state.status === 'active' || state.status === 'paused') {
+        competing = candidate;
+        break;
+      }
+    }
     if (competing) {
       const error = new Error(
         `Another trigger version is current: ${triggerId}@${competing.version}`,
@@ -339,7 +384,7 @@ export class TriggerControlPlane {
       error.code = 'TRIGGER_NEW_VERSION_REQUIRED';
       throw error;
     }
-    if (this.store.listTriggers().some((candidate) =>
+    if ((await this.store.listTriggers()).some((candidate) =>
       candidate.triggerId === triggerId &&
       candidate.version === definition.version
     )) {
@@ -354,7 +399,7 @@ export class TriggerControlPlane {
       ? [...new Set(connectionIds.map(String).filter(Boolean))]
       : currentState.connectionIds;
 
-    this.assertSourcesAvailable(definition, allowedConnectionIds);
+    await this.assertSourcesAvailable(definition, allowedConnectionIds);
 
     await this.retireMatches(
       triggerId,
@@ -445,7 +490,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const definition = this.store.listTriggers().find(
+    const definition = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === version,
@@ -456,7 +501,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(triggerId, version);
+    const currentState = await this.store.getTriggerState(triggerId, version);
     if (!samePrincipal(currentState.owner, owner)) {
       const error = new Error('Trigger owner mismatch');
       error.code = 'TRIGGER_OWNER_MISMATCH';
@@ -565,7 +610,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const definition = this.store.listTriggers().find(
+    const definition = (await this.store.listTriggers()).find(
       (candidate) =>
         candidate.triggerId === triggerId &&
         candidate.version === version,
@@ -576,7 +621,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const currentState = this.store.getTriggerState(triggerId, version);
+    const currentState = await this.store.getTriggerState(triggerId, version);
     if (!samePrincipal(currentState.owner, owner)) {
       const error = new Error('Trigger owner mismatch');
       error.code = 'TRIGGER_OWNER_MISMATCH';
@@ -632,7 +677,7 @@ export class TriggerControlPlane {
     };
   }
 
-  assertSourcesAvailable(definition, connectionIds) {
+  async assertSourcesAvailable(definition, connectionIds) {
     const allowedConnectionIds = Array.isArray(connectionIds)
       ? [...new Set(connectionIds.map(String).filter(Boolean))]
       : [];
@@ -644,7 +689,7 @@ export class TriggerControlPlane {
       throw error;
     }
 
-    const sources = this.listEventSources({
+    const sources = await this.listEventSources({
       connectionIds: allowedConnectionIds,
     });
 
@@ -730,16 +775,58 @@ export class TriggerControlPlane {
       }
     }
 
-    for (const field of definition.correlation?.deterministic?.fields ?? []) {
-      const clause = definition.clauses.find(
-        (candidate) => candidate.id === field.ref,
-      );
-      const source = clause ? resolveSource(clause) : null;
-      assertAdvertisedPath(
-        source,
-        field.path,
-        `Correlation ${field.ref}`,
-      );
+
+    {
+      const clauseForRef = (ref) =>
+        definition.clauses.find((candidate) => candidate.id === ref);
+      const sourceForRef = (ref) => {
+        const clause = clauseForRef(ref);
+        return clause ? resolveSource(clause) : null;
+      };
+
+      for (const dimension of definition.pattern.partitionBy ?? []) {
+        for (const field of dimension.fields ?? []) {
+          assertAdvertisedPath(
+            sourceForRef(field.ref),
+            field.path,
+            `Pattern partition ${dimension.key}`,
+          );
+        }
+      }
+
+      walkPatternNode(definition.pattern.root, (ref, fieldPath, purpose) => {
+        assertAdvertisedPath(
+          sourceForRef(ref),
+          fieldPath,
+          purpose,
+        );
+      });
+    }
+
+    for (const measure of definition.derivedEvent?.measures ?? []) {
+      const expression = measure.expression;
+      const clauseForRef = (ref) =>
+        definition.clauses.find((candidate) => candidate.id === ref);
+      const sourceForRef = (ref) => {
+        const clause = clauseForRef(ref);
+        return clause ? resolveSource(clause) : null;
+      };
+
+      if (expression.kind === 'aggregate' && expression.path) {
+        assertAdvertisedPath(
+          sourceForRef(expression.ref),
+          expression.path,
+          `Derived measure ${measure.key}`,
+        );
+      } else {
+        walkPatternValue(expression, (ref, fieldPath) => {
+          assertAdvertisedPath(
+            sourceForRef(ref),
+            fieldPath,
+            `Derived measure ${measure.key}`,
+          );
+        });
+      }
     }
 
     for (const projection of definition.derivedEvent?.projections ?? []) {
@@ -775,7 +862,7 @@ export class TriggerControlPlane {
     return allowedConnectionIds;
   }
 
-  buildDerivedOutputPayloadSchema(definition) {
+  async buildDerivedOutputPayloadSchema(definition) {
     if (!definition.derivedEvent) return null;
 
     const properties = {
@@ -785,7 +872,7 @@ export class TriggerControlPlane {
           triggerId: { type: 'string' },
           triggerVersion: { type: 'string' },
           matchId: { type: 'string' },
-          correlationKey: { type: ['string', 'null'] },
+          partitionKey: { type: ['string', 'null'] },
           contractVersion: { type: 'string' },
           schemaFingerprint: { type: 'string' },
         },
@@ -805,7 +892,66 @@ export class TriggerControlPlane {
       properties[key] = scalarSchemaForConstant(value);
     }
 
-    const allSources = this.store.listEventSources();
+    const allSources = await this.store.listEventSources();
+    const sourceSchemaForRefPath = (ref, fieldPath) => {
+      const clause = definition.clauses.find(
+        (candidate) => candidate.id === ref,
+      );
+      const source = clause
+        ? allSources.find(
+            (candidate) =>
+              candidate.eventName === clause.event &&
+              candidate.serverId === clause.serverId &&
+              (
+                !clause.contractVersion ||
+                String(candidate.metadata?.contractVersion || '') ===
+                  String(clause.contractVersion)
+              ),
+          )
+        : null;
+      return getSchemaNode(source?.payloadSchema, fieldPath) ?? {};
+    };
+
+    const schemaForMeasureExpression = (expression) => {
+      if (!expression || typeof expression !== 'object') return {};
+      if (expression.kind === 'literal') {
+        if (expression.value === null) return { type: 'null' };
+        return scalarSchemaForConstant(expression.value);
+      }
+      if (expression.kind === 'field') {
+        return sourceSchemaForRefPath(expression.ref, expression.path);
+      }
+      if (
+        expression.kind === 'occurredAt' ||
+        expression.kind === 'arithmetic'
+      ) {
+        return { type: 'number' };
+      }
+      if (expression.kind === 'aggregate') {
+        if (
+          ['count', 'countDistinct'].includes(expression.function)
+        ) {
+          return { type: 'integer' };
+        }
+        if (
+          ['sum', 'avg', 'min', 'max', 'stddev', 'percentile']
+            .includes(expression.function)
+        ) {
+          return { type: 'number' };
+        }
+        return sourceSchemaForRefPath(
+          expression.ref,
+          expression.path,
+        );
+      }
+      return {};
+    };
+
+    for (const measure of definition.derivedEvent.measures ?? []) {
+      properties[measure.key] =
+        schemaForMeasureExpression(measure.expression);
+    }
+
     for (const projection of definition.derivedEvent.projections ?? []) {
       const clause = definition.clauses.find(
         (candidate) => candidate.id === projection.ref,
@@ -832,13 +978,14 @@ export class TriggerControlPlane {
       required: [
         '_derived',
         ...Object.keys(definition.derivedEvent.constants ?? {}),
+        ...(definition.derivedEvent.measures ?? []).map((measure) => measure.key),
       ],
     };
   }
 
   async assertDerivedOutputContract(definition) {
     if (!definition.derivedEvent) return null;
-    const payloadSchema = this.buildDerivedOutputPayloadSchema(definition);
+    const payloadSchema = await this.buildDerivedOutputPayloadSchema(definition);
     try {
       return await this.contractRegistry.assertCompatible({
         eventName: definition.derivedEvent.name,
@@ -869,7 +1016,7 @@ export class TriggerControlPlane {
     if (!definition.derivedEvent) return null;
 
     const contractVersion = String(definition.derivedEvent.contractVersion);
-    const payloadSchema = this.buildDerivedOutputPayloadSchema(definition);
+    const payloadSchema = await this.buildDerivedOutputPayloadSchema(definition);
 
     const contract = await this.contractRegistry.registerProducer({
       eventName: definition.derivedEvent.name,
@@ -912,7 +1059,7 @@ export class TriggerControlPlane {
 
   async retireMatches(triggerId, version, reason) {
     const now = this.now().toISOString();
-    const matches = this.store.listTriggerMatches(triggerId)
+    const matches = (await this.store.listTriggerMatches(triggerId))
       .filter((record) =>
         record.triggerVersion === version &&
         (record.status === 'partial' || record.status === 'matched')
@@ -924,10 +1071,12 @@ export class TriggerControlPlane {
         status: 'expired',
         updatedAt: now,
       });
-      for (const deadline of this.store.listTemporalDeadlines?.({
-        matchId: record.matchId,
-        status: 'pending',
-      }) ?? []) {
+      for (const deadline of this.store.listTemporalDeadlines
+        ? await this.store.listTemporalDeadlines({
+          matchId: record.matchId,
+          status: 'pending',
+        })
+        : []) {
         await this.store.setTemporalDeadlineStatus?.(
           deadline.deadlineId,
           'cancelled',
@@ -952,7 +1101,7 @@ export class TriggerControlPlane {
     await this.store.appendAudit({
       auditId: await stableId(
         'audit',
-        `${kind}:${entityType}:${entityId}:${timestamp}:${this.store.auditLength()}`,
+        `${kind}:${entityType}:${entityId}:${timestamp}:${await this.store.auditLength()}`,
       ),
       traceId,
       timestamp,