@slates/test 1.0.0-rc.2

package/dist/index.cjs

@@ -0,0 +1,240 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createLocalSlateTestClient: () => createLocalSlateTestClient,
+  createSlatesTestClient: () => createSlatesTestClient,
+  createSlatesVitestConfig: () => createSlatesVitestConfig,
+  expectSlateContract: () => expectSlateContract,
+  expectSlateError: () => expectSlateError,
+  expectToolCall: () => expectToolCall,
+  getSlateContract: () => getSlateContract,
+  handleSlateTriggerWebhook: () => handleSlateTriggerWebhook,
+  loadSlatesProfile: () => loadSlatesProfile,
+  loadSlatesRuntimeContext: () => loadSlatesRuntimeContext,
+  mapSlateTriggerEvent: () => mapSlateTriggerEvent,
+  registerSlateTriggerWebhook: () => registerSlateTriggerWebhook,
+  unregisterSlateTriggerWebhook: () => unregisterSlateTriggerWebhook,
+  withSlateProfile: () => withSlateProfile
+});
+module.exports = __toCommonJS(index_exports);
+var import_testing_tools = require("@lowerdeck/testing-tools");
+var import_client = require("@slates/client");
+var import_profiles = require("@slates/profiles");
+var import_promises = require("fs/promises");
+var getExpect = () => {
+  let maybeExpect = globalThis.expect;
+  if (!maybeExpect) {
+    throw new Error("Vitest expect is not available in the current runtime.");
+  }
+  return maybeExpect;
+};
+var loadSlatesRuntimeContext = async (opts = {}) => {
+  let runtimeContextPath = process.env.SLATES_TEST_CONTEXT_PATH;
+  if (runtimeContextPath) {
+    let raw = await (0, import_promises.readFile)(runtimeContextPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    let store2 = await (0, import_profiles.openSlatesCliStore)({ storePath: parsed.storePath });
+    let profile2 = store2.getProfile(opts.profile ?? parsed.profileId ?? null);
+    return {
+      integration: parsed.integration ?? store2.scope?.key ?? null,
+      profileId: profile2?.id ?? parsed.profileId ?? null,
+      profile: profile2,
+      storePath: parsed.storePath,
+      cliDir: parsed.cliDir
+    };
+  }
+  let store = process.env.SLATES_STORE_PATH ? await (0, import_profiles.openSlatesCliStore)({ storePath: process.env.SLATES_STORE_PATH }) : await (0, import_profiles.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
+  };
+};
+var loadSlatesProfile = async (opts = {}) => {
+  let context = await loadSlatesRuntimeContext(opts);
+  if (!context.profile) {
+    throw new Error("No Slates profile is available for the current test context.");
+  }
+  return context.profile;
+};
+var createSlatesTestClient = async (opts = {}) => {
+  let context = await loadSlatesRuntimeContext(opts);
+  if (!context.profile) {
+    throw new Error("No Slates profile is available for the current test context.");
+  }
+  let store = await (0, import_profiles.openSlatesCliStore)({ storePath: context.storePath });
+  return (0, import_profiles.createSlatesClientFromProfile)(context.profile, { cwd: opts.cwd, store });
+};
+var withSlateProfile = async (profileName, cb) => {
+  let profile = await loadSlatesProfile({ profile: profileName });
+  return cb({ profile });
+};
+var expectToolCall = async (d) => {
+  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;
+};
+var createLocalSlateTestClient = (opts) => (0, import_client.createSlatesClient)({
+  transport: (0, import_client.createLocalSlateTransport)({ slate: opts.slate }),
+  state: opts.state,
+  participants: opts.participants
+});
+var getSlateContract = async (client) => {
+  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
+  };
+};
+var expectActionMatches = (actual, expected) => {
+  let expect = getExpect();
+  expect(actual).toBeTruthy();
+  expect(actual?.id).toBe(expected.id);
+  if (expected.name !== void 0) {
+    expect(actual?.name).toBe(expected.name);
+  }
+  if (expected.description !== void 0) {
+    expect(actual?.description).toBe(expected.description);
+  }
+  if (expected.readOnly !== void 0) {
+    expect(actual?.tags?.readOnly ?? false).toBe(expected.readOnly);
+  }
+  if (expected.destructive !== void 0) {
+    expect(actual?.tags?.destructive ?? false).toBe(expected.destructive);
+  }
+  if (expected.invocationType !== void 0) {
+    expect(actual?.invocation?.type).toBe(
+      expected.invocationType
+    );
+  }
+};
+var expectSlateContract = async (d) => {
+  let expect = getExpect();
+  let contract = await getSlateContract(d.client);
+  if (d.provider) {
+    expect(contract.provider.id).toBe(d.provider.id);
+    if (d.provider.name !== void 0) {
+      expect(contract.provider.name).toBe(d.provider.name);
+    }
+    if (d.provider.description !== void 0) {
+      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;
+};
+var registerSlateTriggerWebhook = async (d) => d.client.registerTriggerWebhook(d.triggerId, d.webhookBaseUrl);
+var handleSlateTriggerWebhook = async (d) => d.client.handleTriggerWebhook({
+  actionId: d.triggerId,
+  url: d.url,
+  method: d.method ?? "POST",
+  headers: d.headers,
+  body: d.body,
+  state: d.state
+});
+var unregisterSlateTriggerWebhook = async (d) => d.client.unregisterTriggerWebhook({
+  actionId: d.triggerId,
+  webhookBaseUrl: d.webhookBaseUrl,
+  registrationDetails: d.registrationDetails,
+  state: d.state
+});
+var mapSlateTriggerEvent = async (d) => {
+  let expect = getExpect();
+  let result = await d.client.mapTriggerEvent(d.triggerId, d.input);
+  if (d.type !== void 0) {
+    expect(result.type).toBe(d.type);
+  }
+  if (d.output) {
+    expect(result.output).toMatchObject(d.output);
+  }
+  return result;
+};
+var expectSlateError = async (run, expected) => {
+  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 import_client.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.");
+};
+var createSlatesVitestConfig = (config = {}) => (0, import_testing_tools.createVitestConfig)(config);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLocalSlateTestClient,
+  createSlatesTestClient,
+  createSlatesVitestConfig,
+  expectSlateContract,
+  expectSlateError,
+  expectToolCall,
+  getSlateContract,
+  handleSlateTriggerWebhook,
+  loadSlatesProfile,
+  loadSlatesRuntimeContext,
+  mapSlateTriggerEvent,
+  registerSlateTriggerWebhook,
+  unregisterSlateTriggerWebhook,
+  withSlateProfile
+});