@slates/provider-handler 1.0.0-rc.29 → 1.0.0-rc.31

package/dist/index.module.js

@@ -162,17 +162,57 @@ var mapAction = (_slate, a) => {
     ...base,
     type: "action.trigger",
     capabilities: {},
-    invocation: a.source === "polling" ? {
-      type: "polling",
-      intervalSeconds: a.polling.intervalInSeconds ?? SlateDefaultPollingIntervalSeconds
-    } : {
-      type: "webhook",
-      autoRegistration: !!a.autoRegisterWebhook,
-      autoUnregistration: !!a.autoUnregisterWebhook,
-      http: a.http
-    }
+    triggerGroupId: a.triggerGroup.key
   };
 };
+var getTriggerGroup = (slate, triggerGroupId) => {
+  let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
+  if (!group) {
+    throw new ServiceError2(notFoundError(`trigger_group`, triggerGroupId));
+  }
+  return group;
+};
+var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
+  (action) => action.type === "trigger" && action.triggerGroup.key === triggerGroupId
+);
+var evaluateTriggerMatches = (slate, triggerGroupId, payload) => getTriggersForGroup(slate, triggerGroupId).filter((trigger) => trigger.matches(payload)).map((trigger) => trigger.key);
+var getWebhookAutoRegistration = (group) => {
+  if (group.source !== "webhook" || !group.webhook?.autoRegistration) {
+    throw new ServiceError2(
+      badRequestError({
+        message: `Trigger group does not support webhook auto-registration: ${group.key}`
+      })
+    );
+  }
+  return group.webhook.autoRegistration;
+};
+var getWebhookManualRegistration = (group) => {
+  if (group.source !== "webhook" || !group.webhook?.manualRegistration) {
+    throw new ServiceError2(
+      badRequestError({
+        message: `Trigger group does not support manual webhook registration: ${group.key}`
+      })
+    );
+  }
+  return group.webhook.manualRegistration;
+};
+var mapTriggerGroup = (group) => ({
+  id: group.key,
+  name: group.name,
+  description: group.description,
+  metadata: group.metadata,
+  invocation: group.source === "polling" ? {
+    type: "polling",
+    intervalSeconds: group.polling?.intervalSeconds ?? SlateDefaultPollingIntervalSeconds
+  } : {
+    type: "webhook",
+    registration: group.webhook?.manualRegistration ? {
+      mode: "manual",
+      userConfigSchema: toJsonSchema(group.webhook.manualRegistration.userConfigSchema),
+      fullConfigSchema: toJsonSchema(group.webhook.manualRegistration.fullConfigSchema)
+    } : { mode: "auto" }
+  }
+});
 
 // src/state.ts
 var State = class {
@@ -352,6 +392,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       maxAttachmentSizeBytes: directUpload.maxAttachmentSizeBytes ?? DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
     };
   };
+  let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
   let logger = new SlateLogger(listeners);
   let providerTrace = {
     providerId: slate.spec.key,
@@ -492,6 +533,9 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       hub: {
         capabilitiesNotification: true,
         liveInvocation: true
+      },
+      provider: {
+        triggerGroups: true
       }
     }
   }));
@@ -903,6 +947,9 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/actions.list", async ({ params }) => {
     getContextBasic();
     let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
+    if (!supportsTriggerGroups()) {
+      actions = actions.filter((action) => action.type !== "trigger");
+    }
     return {
       actions: actions.map((a) => mapAction(slate, a))
     };
@@ -927,6 +974,19 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       action: mapAction(slate, action)
     };
   });
+  manager.onRequest("slates/trigger_groups.list", async () => {
+    getContextBasic();
+    return {
+      triggerGroups: slate.triggerGroups.map(mapTriggerGroup)
+    };
+  });
+  manager.onRequest("slates/trigger_group.get", async ({ params }) => {
+    getContextBasic();
+    let triggerGroup = getTriggerGroup(slate, params.triggerGroupId);
+    return {
+      triggerGroup: mapTriggerGroup(triggerGroup)
+    };
+  });
   manager.onRequest("slates/action.tool.invoke", async ({ params }) => {
     let action = getActionWithType(slate, "tool", params.actionId);
     let input = validate(
@@ -1023,23 +1083,61 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
           outputKeyCount: getObjectKeyCount(result.output)
         })
       },
-      () => runWithContext(context, () => action.handleEvent(context))
+      () => runWithContext(context, () => action.map(context))
     );
     return withRequestTraces(context, { id: res.id, type: res.type, output: res.output });
   });
   manager.onRequest("slates/action.trigger.poll_events", async ({ params }) => {
-    let ctx = getContextFull();
-    let action = getActionWithType(slate, "trigger", params.actionId);
-    if (!action.pollEvents) {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new ServiceError4(
+        badRequestError3({
+          message: `Legacy trigger polling is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return { inputs: [], updatedState: params.state };
+  });
+  manager.onRequest("slates/action.trigger.webhook_handle", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new ServiceError4(
+        badRequestError3({
+          message: `Legacy trigger webhook handling is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return { inputs: [], updatedState: params.state, response: null };
+  });
+  manager.onRequest("slates/action.trigger.webhook_register", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
       throw new ServiceError4(
         badRequestError3({
-          message: `Trigger action does not support polling: ${params.actionId}`
+          message: `Legacy trigger webhook registration is disabled once trigger_group support is announced: ${params.actionId}`
         })
       );
     }
+    return { registrationDetails: null };
+  });
+  manager.onRequest("slates/action.trigger.webhook_unregister", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new ServiceError4(
+        badRequestError3({
+          message: `Legacy trigger webhook unregistration is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return {};
+  });
+  manager.onRequest("slates/trigger_group.webhook.targets_list", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
     let context = new SlateContext(
       ctx.config,
-      { state: params.state },
+      { pageToken: params.pageToken ?? null },
       ctx.auth?.output,
       slate.spec,
       logger
@@ -1047,35 +1145,168 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let res = await traceProviderCall(
       {
         component: "action",
-        functionName: "pollEvents",
-        message: `Polling events for trigger ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: (result) => `Polled ${result.inputs.length} event(s) for trigger ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while polling events`,
+        functionName: "webhookTargetList",
+        message: `Listing webhook targets for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Listed ${result.targets.length} webhook target(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while listing webhook targets`,
         metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type,
-          hasPreviousState: params.state !== null
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
         },
         onSuccess: (result) => ({
-          inputCount: result.inputs.length,
-          hasUpdatedState: result.updatedState !== void 0
+          targetCount: result.targets.length,
+          hasNextPageToken: result.nextPageToken !== null
         })
       },
-      () => runWithContext(context, () => action.pollEvents(context))
+      () => runWithContext(context, () => autoRegistration.webhookTargetList(context))
     );
     return withRequestTraces(context, {
-      inputs: res.inputs,
-      updatedState: res.updatedState
+      targets: res.targets,
+      nextPageToken: res.nextPageToken ?? null
     });
   });
-  manager.onRequest("slates/action.trigger.webhook_handle", async ({ params }) => {
+  manager.onRequest("slates/trigger_group.webhook.register", async ({ params }) => {
     let ctx = getContextFull();
-    let action = getActionWithType(slate, "trigger", params.actionId);
-    if (!action.handleRequest) {
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
+    let context = new SlateContext(
+      ctx.config,
+      {
+        webhookTargetIdentifier: params.webhookTargetIdentifier,
+        webhookTargetPayload: params.webhookTargetPayload,
+        webhookUrl: params.webhookUrl
+      },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookRegister",
+        message: `Registering webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Registered webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while registering a webhook`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          webhookTargetIdentifier: params.webhookTargetIdentifier
+        }
+      },
+      () => runWithContext(context, () => autoRegistration.webhookRegister(context))
+    );
+    return withRequestTraces(context, {
+      webhookRegistrationIdentifier: res.webhookRegistrationIdentifier,
+      webhookRegistrationPayload: res.webhookRegistrationPayload
+    });
+  });
+  manager.onRequest("slates/trigger_group.webhook.unregister", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
+    let context = new SlateContext(
+      ctx.config,
+      {
+        webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
+        webhookRegistrationPayload: params.webhookRegistrationPayload
+      },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookUnregister",
+        message: `Unregistering webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Unregistered webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while unregistering a webhook`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          webhookRegistrationIdentifier: params.webhookRegistrationIdentifier
+        }
+      },
+      () => runWithContext(context, () => autoRegistration.webhookUnregister(context))
+    );
+    return withRequestTraces(context, {});
+  });
+  manager.onRequest("slates/trigger_group.webhook.manual_setup", async ({ params }) => {
+    getContextBasic();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let manualRegistration = getWebhookManualRegistration(group);
+    let context = new SlateContext(
+      {},
+      { webhookUrl: params.webhookUrl },
+      {},
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookManualSetup",
+        message: `Building manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Built manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while building a manual webhook setup`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        }
+      },
+      () => runWithContext(context, () => manualRegistration.setup(context))
+    );
+    return {
+      webhookSetupDocument: res.webhookSetupDocument,
+      partialWebhookRegistrationPayload: res.partialWebhookRegistrationPayload
+    };
+  });
+  manager.onRequest("slates/trigger_group.webhook.manual_finish", async ({ params }) => {
+    getContextBasic();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let manualRegistration = getWebhookManualRegistration(group);
+    if (!manualRegistration.finish) {
       throw new ServiceError4(
         badRequestError3({
-          message: `Trigger action does not support webhook requests: ${params.actionId}`
+          message: `Trigger group does not support manual webhook finish: ${params.triggerGroupId}`
+        })
+      );
+    }
+    let context = new SlateContext(
+      {},
+      {
+        webhookUrl: params.webhookUrl,
+        partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
+        userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
+      },
+      {},
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookManualFinish",
+        message: `Finishing manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Finished manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while finishing a manual webhook setup`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        }
+      },
+      () => runWithContext(context, () => manualRegistration.finish(context))
+    );
+    return withRequestTraces(context, {
+      webhookRegistrationPayload: res.webhookRegistrationPayload
+    });
+  });
+  manager.onRequest("slates/trigger_group.webhook.process", async ({ params }) => {
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    if (group.source !== "webhook" || !group.webhook) {
+      throw new ServiceError4(
+        badRequestError3({
+          message: `Trigger group does not support webhook processing: ${params.triggerGroupId}`
         })
       );
     }
@@ -1085,126 +1316,122 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       body: params.body ? Uint8Array.from(atob(params.body.content), (c) => c.charCodeAt(0)) : null
     });
     let context = new SlateContext(
-      ctx.config,
+      {},
       {
         request: req,
-        state: params.state,
-        registrationDetails: params.registrationDetails ?? null
+        webhookRegistrationPayload: params.webhookRegistrationPayload
       },
-      ctx.auth?.output,
+      {},
       slate.spec,
       logger
     );
     let res = await traceProviderCall(
       {
         component: "action",
-        functionName: "handleRequest",
-        message: `Handling webhook request for trigger ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: (result) => `Received ${result.inputs.length} webhook event(s) for trigger ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while handling a webhook request`,
+        functionName: "webhookProcess",
+        message: `Processing webhook request for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Extracted ${result.events.length} event(s) from webhook request for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while processing a webhook request`,
         metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type,
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
           requestMethod: params.method,
-          hasRequestBody: !!params.body,
-          hasPreviousState: params.state !== null
+          hasRequestBody: !!params.body
         },
         onSuccess: (result) => ({
-          inputCount: result.inputs.length,
-          hasUpdatedState: result.updatedState !== void 0,
+          eventCount: result.events.length,
           hasResponse: result.response !== void 0
         })
       },
-      () => runWithContext(context, () => action.handleRequest(context))
+      () => runWithContext(context, () => group.webhook.process(context))
     );
+    for (let event of res.events) {
+      if (!event.matchers) {
+        throw new ServiceError4(
+          preconditionFailedError({
+            message: `Trigger group "${group.key}" process handler must return matchers for every event (return [] if there is nothing to assert)`
+          })
+        );
+      }
+    }
     let response = res.response === void 0 ? void 0 : await serializeWebhookHttpResponse(res.response);
     return withRequestTraces(context, {
-      inputs: res.inputs,
-      updatedState: res.updatedState,
+      events: res.events.map((event) => ({
+        matchers: event.matchers,
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      })),
       response
     });
   });
-  manager.onRequest("slates/action.trigger.webhook_register", async ({ params }) => {
+  manager.onRequest("slates/trigger_group.routing_matchers.get", async ({ params }) => {
     let ctx = getContextFull();
-    let action = getActionWithType(slate, "trigger", params.actionId);
-    if (!action.autoRegisterWebhook) {
-      throw new ServiceError4(
-        badRequestError3({
-          message: `Trigger action does not support webhook auto-registration: ${params.actionId}`
-        })
-      );
-    }
-    let context = new SlateContext(
-      ctx.config,
-      { webhookBaseUrl: params.webhookBaseUrl },
-      ctx.auth?.output,
-      slate.spec,
-      logger
-    );
-    let res = await traceProviderCall(
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let context = new SlateContext(ctx.config, {}, ctx.auth?.output, slate.spec, logger);
+    let matchers = await traceProviderCall(
       {
         component: "action",
-        functionName: "autoRegisterWebhook",
-        message: `Registering webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: `Registered webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while registering a webhook`,
+        functionName: "routingMatchers",
+        message: `Getting routing matchers for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Retrieved ${result.length} routing matcher(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while getting routing matchers`,
         metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
         },
         onSuccess: (result) => ({
-          hasRegistrationDetails: result.registrationDetails !== void 0,
-          hasState: result.state !== void 0
+          matcherCount: result.length
         })
       },
-      () => runWithContext(context, () => action.autoRegisterWebhook(context))
+      () => runWithContext(context, () => group.routingMatchers(context))
     );
-    return withRequestTraces(context, {
-      registrationDetails: res.registrationDetails,
-      state: res.state
-    });
+    return withRequestTraces(context, { matchers });
   });
-  manager.onRequest("slates/action.trigger.webhook_unregister", async ({ params }) => {
+  manager.onRequest("slates/trigger_group.polling.poll", async ({ params }) => {
     let ctx = getContextFull();
-    let action = getActionWithType(slate, "trigger", params.actionId);
-    if (!action.autoUnregisterWebhook) {
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    if (group.source !== "polling" || !group.polling) {
       throw new ServiceError4(
         badRequestError3({
-          message: `Trigger action does not support webhook auto-unregistration: ${params.actionId}`
+          message: `Trigger group does not support polling: ${params.triggerGroupId}`
         })
       );
     }
     let context = new SlateContext(
       ctx.config,
-      {
-        webhookBaseUrl: params.webhookBaseUrl,
-        registrationDetails: params.registrationDetails,
-        state: params.state
-      },
+      { state: params.state },
       ctx.auth?.output,
       slate.spec,
       logger
     );
-    await traceProviderCall(
+    let res = await traceProviderCall(
       {
         component: "action",
-        functionName: "autoUnregisterWebhook",
-        message: `Unregistering webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: `Unregistered webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while unregistering a webhook`,
+        functionName: "pollEvents",
+        message: `Polling events for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Polled ${result.events.length} event(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while polling events`,
         metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type,
-          hasRegistrationDetails: params.registrationDetails !== null,
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
           hasPreviousState: params.state !== null
-        }
+        },
+        onSuccess: (result) => ({
+          eventCount: result.events.length,
+          hasUpdatedState: result.updatedState !== void 0
+        })
       },
-      () => runWithContext(context, () => action.autoUnregisterWebhook(context))
+      () => runWithContext(context, () => group.polling.pollEvents(context))
     );
-    return withRequestTraces(context, {});
+    return withRequestTraces(context, {
+      updatedState: res.updatedState,
+      events: res.events.map((event) => ({
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      }))
+    });
   });
 });
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.29",
+  "version": "1.0.0-rc.31",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.18",
-    "@slates/provider": "1.0.0-rc.22",
+    "@slates/proto": "1.0.0-rc.19",
+    "@slates/provider": "1.0.0-rc.23",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },