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

package/src/index.ts

@@ -18,13 +18,18 @@ import {
 } from '@slates/provider';
 import { PQueue } from './pQueue';
 import {
+  evaluateTriggerMatches,
   getAction,
   getActionWithType,
   getAdapter,
   getAuthMethod,
+  getTriggerGroup,
+  getWebhookAutoRegistration,
+  getWebhookManualRegistration,
   mapAction,
   mapAdapter,
-  mapAuthMethod
+  mapAuthMethod,
+  mapTriggerGroup
 } from './spec';
 import { State } from './state';
 import { toJsonSchema, validate } from './validation';
@@ -185,6 +190,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     let hubCapabilities = new State<{
       attachments?: { directUpload?: { enabled: boolean; maxAttachmentSizeBytes?: number } };
+      triggers?: boolean;
     } | null>(null);
     let liveInvocation = new State<Pick<SlateLiveInvocationInfo, 'token' | 'baseUrl'> | null>(
       null
@@ -203,6 +209,8 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       };
     };
 
+    let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
+
     let logger = new SlateLogger(listeners);
     let providerTrace = {
       providerId: slate.spec.key,
@@ -392,6 +400,9 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         hub: {
           capabilitiesNotification: true,
           liveInvocation: true
+        },
+        provider: {
+          triggerGroups: true
         }
       }
     }));
@@ -857,6 +868,10 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         ? 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))
       };
@@ -888,6 +903,23 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       };
     });
 
+    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);
 
@@ -995,27 +1027,76 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
             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);
+      getContextBasic();
+
+      if (supportsTriggerGroups()) {
+        throw new ServiceError(
+          badRequestError({
+            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 ServiceError(
+          badRequestError({
+            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 ServiceError(
+          badRequestError({
+            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 (!action.pollEvents) {
+      if (supportsTriggerGroups()) {
         throw new ServiceError(
           badRequestError({
-            message: `Trigger action does not support polling: ${params.actionId}`
+            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
@@ -1023,39 +1104,184 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let res = await traceProviderCall(
         {
           component: 'action',
-          functionName: 'pollEvents',
-          message: `Polling events for trigger ${formatEntityLabel(action.name, action.key)}`,
+          functionName: 'webhookTargetList',
+          message: `Listing webhook targets for trigger group ${formatEntityLabel(group.name, group.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`,
+            `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 !== undefined
+            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);
+      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 as any,
+        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))
+      );
 
-      if (!action.handleRequest) {
+      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 ServiceError(
           badRequestError({
-            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 as any,
+        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 ServiceError(
+          badRequestError({
+            message: `Trigger group does not support webhook processing: ${params.triggerGroupId}`
           })
         );
       }
@@ -1069,139 +1295,136 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       });
 
       let context = new SlateContext(
-        ctx.config,
+        {},
         {
           request: req,
-          state: params.state,
-          registrationDetails: params.registrationDetails ?? null
+          webhookRegistrationPayload: params.webhookRegistrationPayload
         },
-        ctx.auth?.output!,
-        slate.spec,
+        {},
+        slate.spec as any,
         logger
       );
       let res = await traceProviderCall(
         {
           component: 'action',
-          functionName: 'handleRequest',
-          message: `Handling webhook request for trigger ${formatEntityLabel(action.name, action.key)}`,
+          functionName: 'webhookProcess',
+          message: `Processing webhook request for trigger group ${formatEntityLabel(group.name, group.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`,
+            `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 !== undefined,
+            eventCount: result.events.length,
             hasResponse: result.response !== undefined
           })
         },
-        () => runWithContext(context, () => action.handleRequest!(context))
+        () => runWithContext(context, () => group.webhook!.process(context))
       );
 
+      for (let event of res.events) {
+        if (!event.matchers) {
+          throw new ServiceError(
+            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 === undefined
           ? undefined
           : 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 ServiceError(
-          badRequestError({
-            message: `Trigger action does not support webhook auto-registration: ${params.actionId}`
-          })
-        );
-      }
+      let group = getTriggerGroup(slate, params.triggerGroupId);
 
-      let context = new SlateContext(
-        ctx.config,
-        { webhookBaseUrl: params.webhookBaseUrl },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
-      );
-      let res = await traceProviderCall(
+      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 !== undefined,
-            hasState: result.state !== undefined
+            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 ServiceError(
           badRequestError({
-            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 !== undefined
+          })
         },
-        () => 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)
+        }))
+      });
     });
   });