@slates/test 1.0.0-rc.17 → 1.0.0-rc.19

package/src/index.test.ts

@@ -6,7 +6,8 @@ import {
   SlateConfig,
   SlateSpecification,
   SlateTool,
-  SlateTrigger
+  SlateTrigger,
+  SlateTriggerGroup
 } from '@slates/provider';
 import { mkdtemp, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
@@ -18,12 +19,12 @@ import {
   expectSlateContract,
   expectSlateError,
   expectToolCall,
-  handleSlateTriggerWebhook,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,
-  pollSlateTriggerEvents,
-  registerSlateTriggerWebhook,
-  unregisterSlateTriggerWebhook
+  pollSlateTriggerGroupEvents,
+  processSlateTriggerGroupWebhook,
+  registerSlateTriggerGroupWebhook,
+  unregisterSlateTriggerGroupWebhook
 } from './index';
 
 (globalThis as typeof globalThis & { expect?: typeof expect }).expect = expect;
@@ -171,69 +172,52 @@ let createDemoSlate = () => {
     }))
     .build();
 
-  let webhookEcho = SlateTrigger.create(spec, {
-    key: 'webhook_echo',
-    name: 'Webhook Echo'
+  let webhookGroup = SlateTriggerGroup.create(spec, {
+    key: 'webhook_group',
+    name: 'Webhook Group'
   })
-    .input(
-      z.object({
-        value: z.string()
-      })
-    )
-    .output(
-      z.object({
-        echoed: z.string()
-      })
-    )
     .webhook({
-      http: {
-        methods: ['POST', 'OPTIONS'],
-        sync: {
-          mode: 'match',
-          match: [
-            {
-              method: 'POST',
-              hasHeader: 'x-demo-event'
-            },
+      autoRegistration: {
+        webhookTargetList: async () => ({
+          targets: [
             {
-              formBodyField: {
-                path: 'mode',
-                equals: 'subscribe'
-              }
+              webhookTargetIdentifier: 'default',
+              name: 'Default',
+              metadata: {},
+              webhookTargetPayload: {},
+              targetOwnership: 'single_user'
             }
           ],
-          timeoutMs: 4_000
-        }
-      },
-      autoRegisterWebhook: async ctx => ({
-        registrationDetails: {
-          webhookBaseUrl: ctx.input.webhookBaseUrl,
-          channelId: 'channel-1'
-        },
-        state: {
-          registered: true
-        }
-      }),
-      autoUnregisterWebhook: async ctx => {
-        if (ctx.input.registrationDetails?.channelId !== 'channel-1') {
-          throw new Error('Unexpected channel');
+          nextPageToken: null
+        }),
+        webhookRegister: async ctx => ({
+          webhookRegistrationIdentifier: 'reg-1',
+          webhookRegistrationPayload: {
+            webhookBaseUrl: ctx.input.webhookUrl,
+            channelId: 'channel-1'
+          }
+        }),
+        webhookUnregister: async ctx => {
+          if (ctx.input.webhookRegistrationPayload?.channelId !== 'channel-1') {
+            throw new Error('Unexpected channel');
+          }
         }
       },
-      handleRequest: async ctx => {
-        if (ctx.request.headers.get('x-demo-event') === 'ignore') {
-          return { inputs: [] };
+      process: async ctx => {
+        if (ctx.input.request.headers.get('x-demo-event') === 'ignore') {
+          return { events: [] };
         }
 
         return {
-          inputs: [
+          events: [
             {
-              value: (await ctx.request.text()) || 'empty'
+              matchers: [],
+              payload: {
+                value: (await ctx.input.request.text()) || 'empty'
+              }
             }
           ],
-          updatedState: {
-            lastEvent: ctx.request.headers.get('x-demo-event') ?? 'unknown'
-          },
-          response: new Response(ctx.registrationDetails?.channelId ?? 'missing', {
+          response: new Response(ctx.input.webhookRegistrationPayload?.channelId ?? 'missing', {
             status: 201,
             headers: {
               'content-type': 'text/plain',
@@ -241,20 +225,14 @@ let createDemoSlate = () => {
             }
           })
         };
-      },
-      handleEvent: async ctx => ({
-        type: 'demo.webhook',
-        id: `webhook-${ctx.input.value}`,
-        output: {
-          echoed: ctx.input.value
-        }
-      })
+      }
     })
+    .routingMatchers(async () => [])
     .build();
 
-  let pollEcho = SlateTrigger.create(spec, {
-    key: 'poll_echo',
-    name: 'Poll Echo'
+  let webhookEcho = SlateTrigger.create(spec, {
+    key: 'webhook_echo',
+    name: 'Webhook Echo'
   })
     .input(
       z.object({
@@ -266,27 +244,62 @@ let createDemoSlate = () => {
         echoed: z.string()
       })
     )
+    .triggerGroup(webhookGroup)
+    .matches(() => true)
+    .map(async ctx => ({
+      type: 'demo.webhook',
+      id: `webhook-${ctx.input.value}`,
+      output: {
+        echoed: ctx.input.value
+      }
+    }))
+    .build();
+
+  let pollGroup = SlateTriggerGroup.create(spec, {
+    key: 'poll_group',
+    name: 'Poll Group'
+  })
     .polling({
       pollEvents: async ctx => ({
-        inputs: ctx.input.state?.seen ? [] : [{ value: 'poll-value' }],
+        events: ctx.input.state?.seen ? [] : [{ payload: { value: 'poll-value' } }],
         updatedState: {
           seen: true
         }
-      }),
-      handleEvent: async ctx => ({
-        type: 'demo.poll',
-        id: `poll-${ctx.input.value}`,
-        output: {
-          echoed: ctx.input.value
-        }
       })
     })
+    .routingMatchers(async () => [])
+    .build();
+
+  let pollEcho = SlateTrigger.create(spec, {
+    key: 'poll_echo',
+    name: 'Poll Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .triggerGroup(pollGroup)
+    .matches(() => true)
+    .map(async ctx => ({
+      type: 'demo.poll',
+      id: `poll-${ctx.input.value}`,
+      output: {
+        echoed: ctx.input.value
+      }
+    }))
     .build();
 
   return Slate.create({
     spec,
     tools: [echo, fail, attachmentEcho, downloadLink],
-    triggers: [webhookEcho, pollEcho]
+    triggers: [webhookEcho, pollEcho],
+    triggerGroups: [webhookGroup, pollGroup]
   });
 };
 
@@ -416,6 +429,7 @@ describe('@slates/test', () => {
       },
       toolIds: ['echo', 'fail', 'attachment_echo', 'download_link'],
       triggerIds: ['webhook_echo', 'poll_echo'],
+      triggerGroupIds: ['webhook_group', 'poll_group'],
       authMethodIds: ['token_auth'],
       tools: [
         { id: 'echo', readOnly: false, destructive: false },
@@ -423,39 +437,14 @@ describe('@slates/test', () => {
         { id: 'attachment_echo', readOnly: true, destructive: false },
         { id: 'download_link', readOnly: true, destructive: false }
       ],
-      triggers: [
-        { id: 'webhook_echo', invocationType: 'webhook' },
-        { id: 'poll_echo', invocationType: 'polling' }
+      triggers: [{ id: 'webhook_echo' }, { id: 'poll_echo' }],
+      triggerGroups: [
+        { id: 'webhook_group', invocationType: 'webhook' },
+        { id: 'poll_group', invocationType: 'polling' }
       ]
     });
 
     expect(contract.configSchema.properties.prefix.type).toBe('string');
-    expect(contract.triggers.find(action => action.id === 'webhook_echo')?.invocation).toEqual(
-      {
-        type: 'webhook',
-        autoRegistration: true,
-        autoUnregistration: true,
-        http: {
-          methods: ['POST', 'OPTIONS'],
-          sync: {
-            mode: 'match',
-            match: [
-              {
-                method: 'POST',
-                hasHeader: 'x-demo-event'
-              },
-              {
-                formBodyField: {
-                  path: 'mode',
-                  equals: 'subscribe'
-                }
-              }
-            ],
-            timeoutMs: 4_000
-          }
-        }
-      }
-    );
 
     await expectToolCall({
       client,
@@ -510,46 +499,44 @@ describe('@slates/test', () => {
       }
     });
 
-    let registration = await registerSlateTriggerWebhook({
+    let registration = await registerSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
-      webhookBaseUrl: 'https://example.com/hooks/google-calendar'
+      triggerGroupId: 'webhook_group',
+      webhookTargetIdentifier: 'default',
+      webhookTargetPayload: {},
+      webhookUrl: 'https://example.com/hooks/google-calendar'
     });
     expect(registration).toMatchObject({
-      registrationDetails: {
+      webhookRegistrationIdentifier: 'reg-1',
+      webhookRegistrationPayload: {
         webhookBaseUrl: 'https://example.com/hooks/google-calendar',
         channelId: 'channel-1'
-      },
-      state: {
-        registered: true
       }
     });
 
-    let ignored = await handleSlateTriggerWebhook({
+    let ignored = await processSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
+      triggerGroupId: 'webhook_group',
       url: 'https://example.com/hooks/google-calendar',
       headers: {
         'x-demo-event': 'ignore'
-      }
+      },
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
-    expect(ignored.inputs).toEqual([]);
+    expect(ignored.events).toEqual([]);
 
-    let handled = await handleSlateTriggerWebhook({
+    let handled = await processSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
+      triggerGroupId: 'webhook_group',
       url: 'https://example.com/hooks/google-calendar',
       headers: {
         'x-demo-event': 'created'
       },
       body: 'payload-value',
-      registrationDetails: registration.registrationDetails
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
     expect(handled).toMatchObject({
-      inputs: [{ value: 'payload-value' }],
-      updatedState: {
-        lastEvent: 'created'
-      },
+      events: [{ matchers: [], payload: { value: 'payload-value' } }],
       response: {
         status: 201,
         headers: {
@@ -576,11 +563,11 @@ describe('@slates/test', () => {
     });
     expect(mapped.id).toBe('webhook-payload-value');
 
-    await unregisterSlateTriggerWebhook({
+    await unregisterSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
-      webhookBaseUrl: 'https://example.com/hooks/google-calendar',
-      registrationDetails: registration.registrationDetails
+      triggerGroupId: 'webhook_group',
+      webhookRegistrationIdentifier: registration.webhookRegistrationIdentifier,
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
 
     await expectSlateError(
@@ -608,12 +595,12 @@ describe('@slates/test', () => {
       }
     });
 
-    let initialPoll = await pollSlateTriggerEvents({
+    let initialPoll = await pollSlateTriggerGroupEvents({
       client,
-      triggerId: 'poll_echo'
+      triggerGroupId: 'poll_group'
     });
     expect(initialPoll).toMatchObject({
-      inputs: [{ value: 'poll-value' }],
+      events: [{ payload: { value: 'poll-value' } }],
       updatedState: {
         seen: true
       }
@@ -622,7 +609,7 @@ describe('@slates/test', () => {
     let mapped = await mapSlateTriggerEvent({
       client,
       triggerId: 'poll_echo',
-      input: initialPoll.inputs[0]!,
+      input: initialPoll.events[0]!.payload,
       type: 'demo.poll',
       output: {
         echoed: 'poll-value'
@@ -630,12 +617,12 @@ describe('@slates/test', () => {
     });
     expect(mapped.id).toBe('poll-poll-value');
 
-    let repeatedPoll = await pollSlateTriggerEvents({
+    let repeatedPoll = await pollSlateTriggerGroupEvents({
       client,
-      triggerId: 'poll_echo',
+      triggerGroupId: 'poll_group',
       state: initialPoll.updatedState
     });
-    expect(repeatedPoll.inputs).toEqual([]);
+    expect(repeatedPoll.events).toEqual([]);
     expect(repeatedPoll.updatedState).toEqual({
       seen: true
     });

package/src/runtime.ts

@@ -65,6 +65,12 @@ export interface ExpectedSlateAction {
   description?: string;
   readOnly?: boolean;
   destructive?: boolean;
+}
+
+export interface ExpectedSlateTriggerGroup {
+  id: string;
+  name?: string;
+  description?: string;
   invocationType?: 'polling' | 'webhook';
 }
 
@@ -195,16 +201,20 @@ export let createLocalSlateTestClient = (opts: {
 }) =>
   createSlatesClient({
     transport: createLocalSlateTransport({ slate: opts.slate as LocalSlate }),
-    state: opts.state,
+    state: {
+      capabilities: { triggers: true },
+      ...opts.state
+    },
     participants: opts.participants
   });
 
 export let getSlateContract = async (client: SlatesTestClient) => {
-  let [provider, actions, authMethods, configSchema] = await Promise.all([
+  let [provider, actions, authMethods, configSchema, triggerGroups] = await Promise.all([
     client.identify(),
     client.listActions(),
     client.listAuthMethods(),
-    client.getConfigSchema()
+    client.getConfigSchema(),
+    client.listTriggerGroups()
   ]);
 
   return {
@@ -216,6 +226,7 @@ export let getSlateContract = async (client: SlatesTestClient) => {
     triggers: actions.actions.filter(
       (action: SlatesAction): action is SlatesTriggerAction => action.type === 'action.trigger'
     ),
+    triggerGroups: triggerGroups.triggerGroups,
     authMethods: authMethods.authenticationMethods,
     configSchema: configSchema.schema
   };
@@ -244,6 +255,23 @@ let expectActionMatches = (
   if (expected.destructive !== undefined) {
     expect(actual?.tags?.destructive ?? false).toBe(expected.destructive);
   }
+};
+
+let expectTriggerGroupMatches = (
+  actual: Record<string, any> | undefined,
+  expected: ExpectedSlateTriggerGroup
+) => {
+  let expect = getVitestExpect();
+  expect(actual).toBeTruthy();
+  expect(actual?.id).toBe(expected.id);
+
+  if (expected.name !== undefined) {
+    expect(actual?.name).toBe(expected.name);
+  }
+
+  if (expected.description !== undefined) {
+    expect(actual?.description).toBe(expected.description);
+  }
 
   if (expected.invocationType !== undefined) {
     expect((actual as { invocation?: { type?: string } } | undefined)?.invocation?.type).toBe(
@@ -261,9 +289,11 @@ export let expectSlateContract = async (d: {
   };
   toolIds?: string[];
   triggerIds?: string[];
+  triggerGroupIds?: string[];
   authMethodIds?: string[];
   tools?: ExpectedSlateAction[];
   triggers?: ExpectedSlateAction[];
+  triggerGroups?: ExpectedSlateTriggerGroup[];
 }) => {
   let expect = getVitestExpect();
   let contract = await getSlateContract(d.client);
@@ -288,6 +318,10 @@ export let expectSlateContract = async (d: {
     );
   }
 
+  if (d.triggerGroupIds) {
+    expect(contract.triggerGroups.map(group => group.id)).toEqual(d.triggerGroupIds);
+  }
+
   if (d.authMethodIds) {
     expect(contract.authMethods.map((method: SlateAuthenticationMethod) => method.id)).toEqual(
       d.authMethodIds
@@ -308,59 +342,70 @@ export let expectSlateContract = async (d: {
     );
   }
 
+  for (let triggerGroup of d.triggerGroups ?? []) {
+    expectTriggerGroupMatches(
+      contract.triggerGroups.find(group => group.id === triggerGroup.id),
+      triggerGroup
+    );
+  }
+
   return contract;
 };
 
-export let registerSlateTriggerWebhook = async (d: {
+export let registerSlateTriggerGroupWebhook = async (d: {
   client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-}) => d.client.registerTriggerWebhook(d.triggerId, d.webhookBaseUrl);
+  triggerGroupId: string;
+  webhookTargetIdentifier: string;
+  webhookTargetPayload: any;
+  webhookUrl: string;
+}) =>
+  d.client.registerTriggerGroupWebhook({
+    triggerGroupId: d.triggerGroupId,
+    webhookTargetIdentifier: d.webhookTargetIdentifier,
+    webhookTargetPayload: d.webhookTargetPayload,
+    webhookUrl: d.webhookUrl
+  });
 
-export let pollSlateTriggerEvents = async (d: {
+export let pollSlateTriggerGroupEvents = async (d: {
   client: SlatesTestClient;
-  triggerId: string;
+  triggerGroupId: string;
   state?: any;
 }) => {
   d.client.ensureSession();
-  return d.client.request('slates/action.trigger.poll_events', {
-    actionId: d.triggerId,
+  return d.client.pollTriggerGroup({
+    triggerGroupId: d.triggerGroupId,
     state: d.state ?? null
   });
 };
 
-export let handleSlateTriggerWebhook = async (d: {
+export let processSlateTriggerGroupWebhook = async (d: {
   client: SlatesTestClient;
-  triggerId: string;
+  triggerGroupId: string;
   url: string;
   method?: string;
   headers?: Record<string, string>;
   body?: string | Uint8Array | null;
-  state?: any;
-  registrationDetails?: any;
+  webhookRegistrationPayload?: any;
 }) =>
-  d.client.handleTriggerWebhook({
-    actionId: d.triggerId,
+  d.client.processTriggerGroupWebhook({
+    triggerGroupId: d.triggerGroupId,
     url: d.url,
     method: d.method ?? 'POST',
     headers: d.headers,
     body: d.body,
-    state: d.state,
-    registrationDetails: d.registrationDetails
+    webhookRegistrationPayload: d.webhookRegistrationPayload ?? null
   });
 
-export let unregisterSlateTriggerWebhook = async (d: {
+export let unregisterSlateTriggerGroupWebhook = async (d: {
   client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-  registrationDetails: any;
-  state?: any;
+  triggerGroupId: string;
+  webhookRegistrationIdentifier: string;
+  webhookRegistrationPayload: any;
 }) =>
-  d.client.unregisterTriggerWebhook({
-    actionId: d.triggerId,
-    webhookBaseUrl: d.webhookBaseUrl,
-    registrationDetails: d.registrationDetails,
-    state: d.state
+  d.client.unregisterTriggerGroupWebhook({
+    triggerGroupId: d.triggerGroupId,
+    webhookRegistrationIdentifier: d.webhookRegistrationIdentifier,
+    webhookRegistrationPayload: d.webhookRegistrationPayload
   });
 
 export let mapSlateTriggerEvent = async (d: {