@slates/test 1.0.0-rc.3 → 1.0.0-rc.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/test",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.5",
   "publishConfig": {
     "access": "public"
   },
@@ -15,10 +15,18 @@
   "type": "module",
   "source": "src/index.ts",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "require": "./dist/index.cjs",
-    "import": "./dist/index.module.js",
-    "default": "./dist/index.module.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.module.js",
+      "default": "./dist/index.module.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "require": "./dist/config.cjs",
+      "import": "./dist/config.module.js",
+      "default": "./dist/config.module.js"
+    }
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.module.js",
@@ -27,16 +35,16 @@
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "lint": "prettier src/**/*.ts --check",
-    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
+    "build": "tsup --config tsup.config.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@lowerdeck/testing-tools": "latest",
-    "@slates/client": "1.0.0-rc.3",
-    "@slates/profiles": "1.0.0-rc.3"
+    "@slates/client": "1.0.0-rc.7",
+    "@slates/profiles": "1.0.0-rc.5"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.9",
+    "@slates/provider": "1.0.0-rc.11",
     "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2",

package/src/config.ts

@@ -0,0 +1,5 @@
+import { createVitestConfig } from '@lowerdeck/testing-tools';
+
+export let createSlatesVitestConfig = (
+  config: Parameters<typeof createVitestConfig>[0] = {}
+) => createVitestConfig(config);

package/src/index.test.ts

@@ -21,6 +21,7 @@ import {
   handleSlateTriggerWebhook,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,
+  pollSlateTriggerEvents,
   registerSlateTriggerWebhook,
   unregisterSlateTriggerWebhook
 } from './index';
@@ -39,6 +40,7 @@ afterEach(async () => {
   delete process.env.SLATES_INTEGRATION;
   delete process.env.SLATES_PROFILE_ID;
   delete process.env.SLATES_STORE_PATH;
+  delete process.env.SLATES_STORE_ROOT_DIR;
   delete process.env.SLATES_TEST_CONTEXT_PATH;
   await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
 });
@@ -224,10 +226,41 @@ let createDemoSlate = () => {
     })
     .build();
 
+  let pollEcho = SlateTrigger.create(spec, {
+    key: 'poll_echo',
+    name: 'Poll Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .polling({
+      pollEvents: async ctx => ({
+        inputs: ctx.input.state?.seen ? [] : [{ value: 'poll-value' }],
+        updatedState: {
+          seen: true
+        }
+      }),
+      handleEvent: 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]
+    triggers: [webhookEcho, pollEcho]
   });
 };
 
@@ -272,6 +305,66 @@ describe('@slates/test', () => {
     expect(context.storePath).toBe(store.storePath);
   });
 
+  it('loads only the selected auth method from the runtime context', async () => {
+    let cwd = await createTempDir();
+    let store = await openSlatesCliStore({
+      cwd,
+      scope: {
+        key: 'integrations/demo',
+        name: 'demo'
+      }
+    });
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: './demo-slate.mjs',
+        exportName: 'provider'
+      }
+    });
+    store.upsertAuth(profile.id, {
+      authMethodId: 'oauth',
+      authMethodName: 'Bot OAuth',
+      authType: 'auth.oauth',
+      input: {},
+      output: {
+        token: 'bot-token'
+      },
+      scopes: ['chat:write']
+    });
+    store.upsertAuth(profile.id, {
+      authMethodId: 'user_oauth',
+      authMethodName: 'User OAuth',
+      authType: 'auth.oauth',
+      input: {},
+      output: {
+        token: 'user-token'
+      },
+      scopes: ['search:read']
+    });
+    await store.save();
+
+    let runtimeContextPath = path.join(cwd, 'runtime.json');
+    await writeFile(
+      runtimeContextPath,
+      JSON.stringify({
+        integration: 'integrations/demo',
+        profileId: profile.id,
+        authMethodId: 'user_oauth',
+        storePath: store.storePath,
+        cliDir: store.dirPath
+      }),
+      'utf-8'
+    );
+
+    process.env.SLATES_TEST_CONTEXT_PATH = runtimeContextPath;
+
+    let context = await loadSlatesRuntimeContext({ cwd });
+    expect(context.authMethodId).toBe('user_oauth');
+    expect(Object.keys(context.profile?.auth ?? {})).toEqual(['user_oauth']);
+    expect(context.profile?.auth.user_oauth?.output.token).toBe('user-token');
+  });
+
   it('creates local slate clients and asserts provider contracts', async () => {
     let client = createLocalSlateTestClient({
       slate: createDemoSlate(),
@@ -296,7 +389,7 @@ describe('@slates/test', () => {
         description: 'A tiny test slate'
       },
       toolIds: ['echo', 'fail', 'attachment_echo', 'download_link'],
-      triggerIds: ['webhook_echo'],
+      triggerIds: ['webhook_echo', 'poll_echo'],
       authMethodIds: ['token_auth'],
       tools: [
         { id: 'echo', readOnly: false, destructive: false },
@@ -304,7 +397,10 @@ describe('@slates/test', () => {
         { id: 'attachment_echo', readOnly: true, destructive: false },
         { id: 'download_link', readOnly: true, destructive: false }
       ],
-      triggers: [{ id: 'webhook_echo', invocationType: 'webhook' }]
+      triggers: [
+        { id: 'webhook_echo', invocationType: 'webhook' },
+        { id: 'poll_echo', invocationType: 'polling' }
+      ]
     });
 
     expect(contract.configSchema.properties.prefix.type).toBe('string');
@@ -431,4 +527,53 @@ describe('@slates/test', () => {
       { code: 'internal.unexpected', kind: 'internal', status: 500 }
     );
   });
+
+  it('wraps trigger polling flows', async () => {
+    let client = createLocalSlateTestClient({
+      slate: createDemoSlate(),
+      state: {
+        config: {
+          prefix: 'Hi'
+        },
+        auth: {
+          authenticationMethodId: 'token_auth',
+          output: {
+            token: 'secret-token'
+          }
+        }
+      }
+    });
+
+    let initialPoll = await pollSlateTriggerEvents({
+      client,
+      triggerId: 'poll_echo'
+    });
+    expect(initialPoll).toMatchObject({
+      inputs: [{ value: 'poll-value' }],
+      updatedState: {
+        seen: true
+      }
+    });
+
+    let mapped = await mapSlateTriggerEvent({
+      client,
+      triggerId: 'poll_echo',
+      input: initialPoll.inputs[0]!,
+      type: 'demo.poll',
+      output: {
+        echoed: 'poll-value'
+      }
+    });
+    expect(mapped.id).toBe('poll-poll-value');
+
+    let repeatedPoll = await pollSlateTriggerEvents({
+      client,
+      triggerId: 'poll_echo',
+      state: initialPoll.updatedState
+    });
+    expect(repeatedPoll.inputs).toEqual([]);
+    expect(repeatedPoll.updatedState).toEqual({
+      seen: true
+    });
+  });
 });

package/src/index.ts

@@ -1,332 +1 @@
-import { createVitestConfig } from '@lowerdeck/testing-tools';
-import {
-  createLocalSlateTransport,
-  createSlatesClient,
-  SlateProtocolError
-} from '@slates/client';
-import type { SlatesProtocolClientOptions } from '@slates/client';
-import {
-  createSlatesClientFromProfile,
-  openSlatesCliStore,
-  SlatesProfileRecord
-} from '@slates/profiles';
-import { readFile } from 'fs/promises';
-
-export interface SlatesRuntimeContext {
-  integration: string | null;
-  profileId: string | null;
-  profile: SlatesProfileRecord | null;
-  storePath: string;
-  cliDir: string;
-}
-
-export type SlatesTestClient = ReturnType<typeof createSlatesClient>;
-
-type LocalSlate = Parameters<typeof createLocalSlateTransport>[0]['slate'];
-
-export interface ExpectedSlateAction {
-  id: string;
-  name?: string;
-  description?: string;
-  readOnly?: boolean;
-  destructive?: boolean;
-  invocationType?: 'polling' | 'webhook';
-}
-
-let getExpect = () => {
-  let maybeExpect = (globalThis as typeof globalThis & { expect?: typeof import('vitest').expect })
-    .expect;
-
-  if (!maybeExpect) {
-    throw new Error('Vitest expect is not available in the current runtime.');
-  }
-
-  return maybeExpect;
-};
-
-export let loadSlatesRuntimeContext = async (
-  opts: {
-    cwd?: string;
-    profile?: string | null;
-  } = {}
-): Promise<SlatesRuntimeContext> => {
-  let runtimeContextPath = process.env.SLATES_TEST_CONTEXT_PATH;
-  if (runtimeContextPath) {
-    let raw = await readFile(runtimeContextPath, 'utf-8');
-    let parsed = JSON.parse(raw) as {
-      integration?: string | null;
-      profileId: string | null;
-      storePath: string;
-      cliDir: string;
-    };
-    let store = await openSlatesCliStore({ storePath: parsed.storePath });
-    let profile = store.getProfile(opts.profile ?? parsed.profileId ?? null);
-
-    return {
-      integration: parsed.integration ?? store.scope?.key ?? null,
-      profileId: profile?.id ?? parsed.profileId ?? null,
-      profile,
-      storePath: parsed.storePath,
-      cliDir: parsed.cliDir
-    };
-  }
-
-  let store = process.env.SLATES_STORE_PATH
-    ? await openSlatesCliStore({ storePath: process.env.SLATES_STORE_PATH })
-    : await openSlatesCliStore({ cwd: opts.cwd });
-  let profileId = opts.profile ?? process.env.SLATES_PROFILE_ID ?? null;
-  let profile = store.getProfile(profileId);
-
-  return {
-    integration: process.env.SLATES_INTEGRATION ?? store.scope?.key ?? null,
-    profileId: profile?.id ?? null,
-    profile,
-    storePath: store.storePath,
-    cliDir: store.dirPath
-  };
-};
-
-export let loadSlatesProfile = async (
-  opts: { cwd?: string; profile?: string | null } = {}
-) => {
-  let context = await loadSlatesRuntimeContext(opts);
-  if (!context.profile) {
-    throw new Error('No Slates profile is available for the current test context.');
-  }
-
-  return context.profile;
-};
-
-export let createSlatesTestClient = async (
-  opts: { cwd?: string; profile?: string | null } = {}
-) => {
-  let context = await loadSlatesRuntimeContext(opts);
-  if (!context.profile) {
-    throw new Error('No Slates profile is available for the current test context.');
-  }
-
-  let store = await openSlatesCliStore({ storePath: context.storePath });
-  return createSlatesClientFromProfile(context.profile, { cwd: opts.cwd, store });
-};
-
-export let withSlateProfile = async <T>(
-  profileName: string | null | undefined,
-  cb: (ctx: { profile: SlatesProfileRecord }) => Promise<T>
-) => {
-  let profile = await loadSlatesProfile({ profile: profileName });
-  return cb({ profile });
-};
-
-export let expectToolCall = async (d: {
-  client?: Awaited<ReturnType<typeof createSlatesTestClient>>;
-  profile?: string | null;
-  toolId: string;
-  input: Record<string, any>;
-  output?: Record<string, any>;
-}) => {
-  let expect = getExpect();
-  let client = d.client ?? (await createSlatesTestClient({ profile: d.profile }));
-  let result = await client.invokeTool(d.toolId, d.input);
-
-  if (d.output) {
-    expect(result.output).toMatchObject(d.output);
-  }
-
-  return result;
-};
-
-export let createLocalSlateTestClient = (opts: {
-  slate: LocalSlate;
-  state?: SlatesProtocolClientOptions['state'];
-  participants?: SlatesProtocolClientOptions['participants'];
-}) =>
-  createSlatesClient({
-    transport: createLocalSlateTransport({ slate: opts.slate }),
-    state: opts.state,
-    participants: opts.participants
-  });
-
-export let getSlateContract = async (client: SlatesTestClient) => {
-  let [provider, actions, authMethods, configSchema] = await Promise.all([
-    client.identify(),
-    client.listActions(),
-    client.listAuthMethods(),
-    client.getConfigSchema()
-  ]);
-
-  return {
-    provider: provider.provider,
-    actions: actions.actions,
-    tools: actions.actions.filter(action => action.type === 'action.tool'),
-    triggers: actions.actions.filter(action => action.type === 'action.trigger'),
-    authMethods: authMethods.authenticationMethods,
-    configSchema: configSchema.schema
-  };
-};
-
-let expectActionMatches = (actual: Record<string, any> | undefined, expected: ExpectedSlateAction) => {
-  let expect = getExpect();
-  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.readOnly !== undefined) {
-    expect(actual?.tags?.readOnly ?? false).toBe(expected.readOnly);
-  }
-
-  if (expected.destructive !== undefined) {
-    expect(actual?.tags?.destructive ?? false).toBe(expected.destructive);
-  }
-
-  if (expected.invocationType !== undefined) {
-    expect((actual as { invocation?: { type?: string } } | undefined)?.invocation?.type).toBe(
-      expected.invocationType
-    );
-  }
-};
-
-export let expectSlateContract = async (d: {
-  client: SlatesTestClient;
-  provider?: {
-    id: string;
-    name?: string;
-    description?: string;
-  };
-  toolIds?: string[];
-  triggerIds?: string[];
-  authMethodIds?: string[];
-  tools?: ExpectedSlateAction[];
-  triggers?: ExpectedSlateAction[];
-}) => {
-  let expect = getExpect();
-  let contract = await getSlateContract(d.client);
-
-  if (d.provider) {
-    expect(contract.provider.id).toBe(d.provider.id);
-    if (d.provider.name !== undefined) {
-      expect(contract.provider.name).toBe(d.provider.name);
-    }
-    if (d.provider.description !== undefined) {
-      expect(contract.provider.description).toBe(d.provider.description);
-    }
-  }
-
-  if (d.toolIds) {
-    expect(contract.tools.map(action => action.id)).toEqual(d.toolIds);
-  }
-
-  if (d.triggerIds) {
-    expect(contract.triggers.map(action => action.id)).toEqual(d.triggerIds);
-  }
-
-  if (d.authMethodIds) {
-    expect(contract.authMethods.map(method => method.id)).toEqual(d.authMethodIds);
-  }
-
-  for (let tool of d.tools ?? []) {
-    expectActionMatches(contract.tools.find(action => action.id === tool.id), tool);
-  }
-
-  for (let trigger of d.triggers ?? []) {
-    expectActionMatches(contract.triggers.find(action => action.id === trigger.id), trigger);
-  }
-
-  return contract;
-};
-
-export let registerSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-}) => d.client.registerTriggerWebhook(d.triggerId, d.webhookBaseUrl);
-
-export let handleSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  url: string;
-  method?: string;
-  headers?: Record<string, string>;
-  body?: string | Uint8Array | null;
-  state?: any;
-}) =>
-  d.client.handleTriggerWebhook({
-    actionId: d.triggerId,
-    url: d.url,
-    method: d.method ?? 'POST',
-    headers: d.headers,
-    body: d.body,
-    state: d.state
-  });
-
-export let unregisterSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-  registrationDetails: any;
-  state?: any;
-}) =>
-  d.client.unregisterTriggerWebhook({
-    actionId: d.triggerId,
-    webhookBaseUrl: d.webhookBaseUrl,
-    registrationDetails: d.registrationDetails,
-    state: d.state
-  });
-
-export let mapSlateTriggerEvent = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  input: Record<string, any>;
-  output?: Record<string, any>;
-  type?: string;
-}) => {
-  let expect = getExpect();
-  let result = await d.client.mapTriggerEvent(d.triggerId, d.input);
-
-  if (d.type !== undefined) {
-    expect(result.type).toBe(d.type);
-  }
-
-  if (d.output) {
-    expect(result.output).toMatchObject(d.output);
-  }
-
-  return result;
-};
-
-export let expectSlateError = async (
-  run: Promise<unknown> | (() => Promise<unknown>),
-  expected: Record<string, any> | string | RegExp
-) => {
-  let expect = getExpect();
-  try {
-    await (typeof run === 'function' ? run() : run);
-  } catch (error) {
-    if (typeof expected === 'string' || expected instanceof RegExp) {
-      let message = error instanceof Error ? error.message : String(error);
-      if (expected instanceof RegExp) {
-        expect(message).toMatch(expected);
-      } else {
-        expect(message).toContain(expected);
-      }
-    } else if (error instanceof SlateProtocolError) {
-      expect(error.data).toMatchObject(expected);
-    } else {
-      expect(error).toMatchObject(expected);
-    }
-
-    return error;
-  }
-
-  throw new Error('Expected the operation to fail, but it completed successfully.');
-};
-
-export let createSlatesVitestConfig = (
-  config: Parameters<typeof createVitestConfig>[0] = {}
-) => createVitestConfig(config);
+export * from './runtime';