@devries-cameron20 / composio Mirror · read-only / commits / c942bc4d4
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 09:45 UTC

refactor(cli): extract the toolkit catalog family from the test layer (#4905)

This PR: - moves the toolkit, tool, and trigger-type catalog methods of the test `ComposioToolkitsRepository` out of `test/__utils__/services/test-layer.ts` into `test/__utils__/layers/toolkits.ts`, with their input type (`ToolkitsTestData`), defaults (`resolveToolkitsTestData`) and the `toClientTool` mapper; `notFoundError` moves to `test/__utils__/layers/not-found.ts` since the other families still use it - keeps `TestLive(input)` unchanged: `TestLiveInput['toolkitsData']` is now `ToolkitsTestData` (same fields), and the full repository spreads `toolkitCatalogMethods(toolkitsData)` before the auth-config, connected-account, and trigger-instance methods that stay in place for later extractions - adds `ToolkitsTest(data?)` (exported from `test/__utils__`): a repository that serves only the catalogs, built on the existing `makeToolkitsRepositoryStub`, so any other repository method dies; `ToolkitCatalogMethods` is an `Omit` of the repository shape, so a new repository method fails to compile until a family claims it - extends `test/src/services/test-layer.test.ts`: `ToolkitsTest` and `TestLive` give the same catalog answers (search and a 404), and `ToolkitsTest` dies on a method another family serves ## Context Unit U3 of the command-layout series (KTD5): `TestLive` becomes a composition of per-domain pieces one family per PR, toolkits and tools first because U1 and U2 touch them. No suite under `test/src/commands/` changes; the mock client's Tool Router and toolkit endpoints still read the same resolved `toolkitsData`. `test-layer.ts` goes from 1768 to 1466 lines. Next families: account and connected accounts (U5), then setup and the command runner (U7). Verified locally on the branch tip: `pnpm typecheck`; the CLI suite (152 files, 1676 passed, 1 skipped; the three new cases included, `validate:command-tests` at 18 exemptions, unchanged); `lint:effect` 0 diagnostics; `oxlint` and prettier clean on every touched file.

Alberto Schiabel committed Oct 16, 2026 at 00:05 UTC c942bc4d45f245be11eff9e98b68283122fc0543
5 files changed +403 -313
ts/packages/cli/test/__utils__/index.ts
+1
@@ -3,6 +3,7 @@ import pkg from '../../package.json' with { type: 'json' };
3 export * as MockConsole from './services/mock-console';
4 export * as MockTerminal from './services/mock-terminal';
5 export { TestLayer as TestLive } from './services/test-layer';
6 +export { ToolkitsTest } from './layers/toolkits';
7 export { cli } from './cli';
8 export { pkg };
9 export { withHttpServer } from './http-server';
ts/packages/cli/test/__utils__/layers/not-found.ts new
+19
@@ -0,0 +1,19 @@
1 +import { NotFoundError } from '@composio/client/effect';
2 +
3 +/**
4 + * A 404 as the Effect client reports one, with the API error envelope when the
5 + * scenario has one.
6 + */
7 +export const notFoundError = (
8 + message: string,
9 + envelope?: { readonly message: string; readonly suggested_fix: string }
10 +) =>
11 + new NotFoundError({
12 + message,
13 + method: 'GET',
14 + url: 'https://mock.invalid',
15 + status: 404,
16 + requestId: undefined,
17 + details: envelope ? { ...envelope, code: 404, slug: 'Not_Found', status: 404 } : undefined,
18 + body: envelope ? { error: envelope } : undefined,
19 + });
ts/packages/cli/test/__utils__/layers/toolkits.ts new
+341
@@ -0,0 +1,341 @@
1 +import type { ToolRetrieveResponse } from '@composio/client/resources/tools';
2 +import { Effect, Layer, String } from 'effect';
3 +import type {
4 + ToolkitVersionOverrides,
5 + ToolkitVersionSpec,
6 +} from 'src/effects/toolkit-version-overrides';
7 +import type { ToolkitDetailed, Toolkits } from 'src/models/toolkits';
8 +import type { Tool, Tools } from 'src/models/tools';
9 +import type { TriggerTypes, TriggerTypesAsEnums } from 'src/models/trigger-types';
10 +import {
11 + ComposioToolkitsRepository,
12 + type ComposioToolkitsRepositoryShape,
13 + type ToolkitProjectScope,
14 +} from 'src/services/composio-clients';
15 +import {
16 + InvalidToolkitsError,
17 + InvalidToolkitVersionsError,
18 + type InvalidVersionDetail,
19 +} from 'src/services/toolkit-version-validation';
20 +import { makeToolkitsRepositoryStub } from '../services/toolkits-repository-stub';
21 +import { notFoundError } from './not-found';
22 +
23 +/**
24 + * The toolkit, tool, and trigger-type catalogs a test repository serves.
25 + */
26 +export interface ToolkitsTestData {
27 + toolkits?: Toolkits;
28 + /**
29 + * Custom toolkits registered in the test project. Kept apart from
30 + * `toolkits`, the Composio-managed catalog, as the API keeps them apart.
31 + */
32 + projectToolkits?: Toolkits;
33 + /**
34 + * The project `projectToolkits` belong to. When set, a project-toolkit
35 + * lookup for any other scope, or for none, finds nothing, as the API
36 + * would answer for another project.
37 + */
38 + projectToolkitsScope?: ToolkitProjectScope;
39 + /**
40 + * Called with the scope of every project-toolkit lookup.
41 + */
42 + onGetProjectToolkits?: (scope: ToolkitProjectScope | undefined) => void;
43 + detailedToolkits?: ToolkitDetailed[];
44 + tools?: Tools;
45 + triggerTypesAsEnums?: TriggerTypesAsEnums;
46 + triggerTypes?: TriggerTypes;
47 +}
48 +
49 +/**
50 + * `ToolkitsTestData` with every catalog the test left out set to empty.
51 + */
52 +export const resolveToolkitsTestData = (data?: ToolkitsTestData) => {
53 + const defaults = {
54 + toolkits: [] as Toolkits,
55 + projectToolkits: [] as Toolkits,
56 + detailedToolkits: [] as ToolkitDetailed[],
57 + tools: [] as Tools,
58 + triggerTypesAsEnums: [] as TriggerTypesAsEnums,
59 + triggerTypes: [] as TriggerTypes,
60 + } satisfies ToolkitsTestData;
61 + return {
62 + ...defaults,
63 + ...(data ?? {}),
64 + detailedToolkits: data?.detailedToolkits ?? defaults.detailedToolkits,
65 + };
66 +};
67 +
68 +export type ResolvedToolkitsTestData = ReturnType<typeof resolveToolkitsTestData>;
69 +
70 +/**
71 + * The repository methods other families serve: auth configs, connected accounts, and trigger
72 + * instances.
73 + */
74 +type NonCatalogMethod =
75 + | 'listAuthConfigs'
76 + | 'getAuthConfig'
77 + | 'createAuthConfig'
78 + | 'getConnectedAccount'
79 + | 'listActiveTriggers'
80 + | 'createTrigger'
81 + | 'enableTrigger'
82 + | 'disableTrigger';
83 +
84 +export type ToolkitCatalogMethods = Omit<ComposioToolkitsRepositoryShape, NonCatalogMethod>;
85 +
86 +const toClientTool = (tool: Tool): ToolRetrieveResponse => {
87 + // Derive toolkit slug from tool slug prefix (e.g. GMAIL_SEND_EMAIL -> gmail)
88 + const parts = tool.slug.split('_');
89 + const toolkitSlug = parts.length > 1 ? parts[0]!.toLowerCase() : '';
90 + return {
91 + ...tool,
92 + available_versions: [...tool.available_versions],
93 + tags: [...tool.tags],
94 + no_auth: false,
95 + version: 'latest',
96 + scopes: [],
97 + scope_requirements: null,
98 + is_deprecated: false,
99 + deprecated: {
100 + displayName: tool.name,
101 + version: 'latest',
102 + available_versions: [...tool.available_versions],
103 + is_deprecated: false,
104 + toolkit: { logo: '' },
105 + },
106 + toolkit: { name: toolkitSlug, slug: toolkitSlug, logo: '' },
107 + };
108 +};
109 +
110 +/**
111 + * The repository's catalog methods, answering from `toolkitsData` the way the API would.
112 + */
113 +export const toolkitCatalogMethods = (
114 + toolkitsData: ResolvedToolkitsTestData
115 +): ToolkitCatalogMethods => ({
116 + getToolkits: () => Effect.succeed(toolkitsData.toolkits),
117 + getProjectToolkits: scope =>
118 + Effect.sync(() => {
119 + toolkitsData.onGetProjectToolkits?.(scope);
120 + const owner = toolkitsData.projectToolkitsScope;
121 + const inScope =
122 + owner === undefined ||
123 + (scope?.orgId === owner.orgId && scope.projectId === owner.projectId);
124 + return inScope ? toolkitsData.projectToolkits : [];
125 + }),
126 + getToolkitsBySlugs: (slugs: ReadonlyArray<string>) => {
127 + const normalizedSlugs = new Set(slugs.map(s => String.toLowerCase(s)));
128 + const found = toolkitsData.toolkits.filter(t =>
129 + normalizedSlugs.has(String.toLowerCase(t.slug))
130 + );
131 + if (found.length !== slugs.length) {
132 + const foundSlugs = new Set(found.map(t => String.toLowerCase(t.slug)));
133 + const notFound = slugs.filter(s => !foundSlugs.has(String.toLowerCase(s)));
134 + return Effect.fail(
135 + new InvalidToolkitsError({
136 + invalidToolkits: [...notFound],
137 + availableToolkits: toolkitsData.toolkits.map(t => t.slug),
138 + })
139 + );
140 + }
141 + return Effect.succeed(found);
142 + },
143 + getMetrics: () => Effect.succeed({ byteSize: 0, requests: 0 }),
144 + getToolsAsEnums: () => Effect.succeed(toolkitsData.tools.map(tool => tool.slug)),
145 + getTriggerTypesAsEnums: () => Effect.succeed(toolkitsData.triggerTypesAsEnums),
146 + getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
147 + let triggers = toolkitsData.triggerTypes;
148 + if (toolkitSlugs && toolkitSlugs.length > 0) {
149 + const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
150 + triggers = triggers.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
151 + }
152 + return Effect.succeed(triggers);
153 + },
154 + getTriggerTypeDetailed: (slug: string) => {
155 + const found = toolkitsData.triggerTypes.find(
156 + trigger => trigger.slug.toUpperCase() === slug.toUpperCase()
157 + );
158 + if (!found) {
159 + return Effect.fail(notFoundError(`Trigger type "${slug}" not found`));
160 + }
161 + return Effect.succeed(found);
162 + },
163 + getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
164 + let tools = toolkitsData.tools;
165 + if (toolkitSlugs && toolkitSlugs.length > 0) {
166 + const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
167 + tools = tools.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
168 + }
169 + return Effect.succeed(tools);
170 + },
171 + validateToolkits: (toolkitSlugs: ReadonlyArray<string>) => {
172 + const normalizedInputSlugs = toolkitSlugs.map(slug => String.toLowerCase(slug));
173 + const availableSlugs = toolkitsData.toolkits.map(toolkit => String.toLowerCase(toolkit.slug));
174 + const invalidSlugs = normalizedInputSlugs.filter(slug => !availableSlugs.includes(slug));
175 +
176 + if (invalidSlugs.length > 0) {
177 + return Effect.fail(
178 + new InvalidToolkitsError({
179 + invalidToolkits: invalidSlugs,
180 + availableToolkits: availableSlugs,
181 + })
182 + );
183 + }
184 +
185 + return Effect.succeed(normalizedInputSlugs);
186 + },
187 + filterToolkitsBySlugs: (toolkits, toolkitSlugs) => {
188 + const normalizedSlugs = new Set(toolkitSlugs.map(slug => String.toLowerCase(slug)));
189 + return toolkits.filter(toolkit => normalizedSlugs.has(String.toLowerCase(toolkit.slug)));
190 + },
191 + getToolsByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) => {
192 + // Filter tools based on toolkit slugs from specs
193 + const toolkitSlugs = specs.map(s => s.toolkitSlug.toUpperCase());
194 + const prefixes = toolkitSlugs.map(s => `${s}_`);
195 + const tools = toolkitsData.tools.filter(t =>
196 + prefixes.some(p => t.slug.toUpperCase().startsWith(p))
197 + );
198 + return Effect.succeed(tools);
199 + },
200 + validateToolkitVersions: (
201 + overrides: ToolkitVersionOverrides,
202 + relevantToolkits?: ReadonlyArray<string>
203 + ) => {
204 + // Mock implementation that validates against test fixture
205 + const invalidVersions: InvalidVersionDetail[] = [];
206 + const warnings: string[] = [];
207 +
208 + for (const [toolkit, version] of overrides) {
209 + // Check if toolkit should be validated
210 + if (relevantToolkits && !relevantToolkits.map(s => s.toLowerCase()).includes(toolkit)) {
211 + warnings.push(`Version override for "${toolkit}" will be ignored`);
212 + continue;
213 + }
214 +
215 + // Check if toolkit exists in the fixture
216 + const toolkitExists = toolkitsData.toolkits.some(t => String.toLowerCase(t.slug) === toolkit);
217 +
218 + if (!toolkitExists) {
219 + return Effect.fail(
220 + new InvalidToolkitsError({
221 + invalidToolkits: [toolkit],
222 + availableToolkits: toolkitsData.toolkits.map(t => t.slug),
223 + })
224 + );
225 + }
226 +
227 + // Mock: only accept 'latest' or versions matching pattern YYYYMMDD_NN
228 + const validPattern = /^\d{8}_\d{2}$/;
229 + if (version !== 'latest' && !validPattern.test(version)) {
230 + invalidVersions.push({
231 + toolkit,
232 + requestedVersion: version,
233 + availableVersions: ['20250901_00', '20250815_00', '20250710_00'],
234 + });
235 + }
236 + }
237 +
238 + if (invalidVersions.length > 0) {
239 + return Effect.fail(new InvalidToolkitVersionsError({ invalidVersions }));
240 + }
241 +
242 + return Effect.succeed({
243 + validatedOverrides: overrides,
244 + warnings: warnings as ReadonlyArray<string>,
245 + });
246 + },
247 + searchToolkits: (params: {
248 + search?: string;
249 + category?: string;
250 + limit?: number;
251 + cursor?: string;
252 + }) => {
253 + let results = [...toolkitsData.toolkits];
254 +
255 + if (params.search) {
256 + const q = params.search.toLowerCase();
257 + results = results.filter(
258 + t =>
259 + t.name.toLowerCase().includes(q) ||
260 + t.slug.toLowerCase().includes(q) ||
261 + t.meta.description.toLowerCase().includes(q)
262 + );
263 + }
264 +
265 + const limit = params.limit ?? 30;
266 + const items = results.slice(0, limit);
267 + return Effect.succeed({
268 + items,
269 + total_items: results.length,
270 + total_pages: Math.ceil(results.length / limit),
271 + next_cursor: null,
272 + });
273 + },
274 + searchTools: (params: {
275 + search?: string;
276 + toolkit_slug?: string;
277 + tags?: string;
278 + limit?: number;
279 + cursor?: string;
280 + }) => {
281 + let results = [...toolkitsData.tools];
282 +
283 + if (params.toolkit_slug) {
284 + const slugs = params.toolkit_slug.split(',').map(s => s.trim().toUpperCase() + '_');
285 + results = results.filter(t => slugs.some(p => t.slug.toUpperCase().startsWith(p)));
286 + }
287 +
288 + if (params.search) {
289 + const q = params.search.toLowerCase();
290 + results = results.filter(
291 + t =>
292 + t.name.toLowerCase().includes(q) ||
293 + t.slug.toLowerCase().includes(q) ||
294 + t.description.toLowerCase().includes(q)
295 + );
296 + }
297 +
298 + if (params.tags) {
299 + const tagList = params.tags.split(',').map(t => t.trim().toLowerCase());
300 + results = results.filter(t =>
301 + tagList.some(tag => t.tags.map(tt => tt.toLowerCase()).includes(tag))
302 + );
303 + }
304 +
305 + const limit = params.limit ?? 30;
306 + const items = results.slice(0, limit).map(toClientTool);
307 + return Effect.succeed({
308 + items,
309 + total_items: results.length,
310 + total_pages: Math.ceil(results.length / limit),
311 + current_page: 1,
312 + next_cursor: null,
313 + });
314 + },
315 + getToolDetailed: (slug: string) => {
316 + const found = toolkitsData.tools.find(t => t.slug.toUpperCase() === slug.toUpperCase());
317 + if (!found) {
318 + return Effect.fail(notFoundError(`Tool "${slug}" not found`));
319 + }
320 + return Effect.succeed(toClientTool(found));
321 + },
322 + getToolkitDetailed: (slug: string) => {
323 + const found = toolkitsData.detailedToolkits.find(
324 + t => t.slug.toLowerCase() === slug.toLowerCase()
325 + );
326 + if (!found) {
327 + return Effect.fail(notFoundError(`Toolkit "${slug}" not found`));
328 + }
329 + return Effect.succeed(found);
330 + },
331 +});
332 +
333 +/**
334 + * A `ComposioToolkitsRepository` that serves only the catalogs, for a test that needs nothing
335 + * else from the full `TestLive` layer. Any other repository method dies.
336 + */
337 +export const ToolkitsTest = (data?: ToolkitsTestData) =>
338 + Layer.succeed(
339 + ComposioToolkitsRepository,
340 + makeToolkitsRepositoryStub(toolkitCatalogMethods(resolveToolkitsTestData(data)))
341 + );
ts/packages/cli/test/__utils__/services/test-layer.ts
+9 -311
@@ -6,7 +6,6 @@ import type {
6 } from '@composio/client/resources/auth-configs';
7 import {
8 APIConnectionError,
9 - NotFoundError,
9 make as makeComposioClient,
10 type ComposioError,
11 type RequestOptions,
@@ -17,7 +16,6 @@ import type {
16 TriggerInstanceUpsertParams,
17 } from '@composio/client/resources/trigger-instances';
18 import type { SessionRetrieveInfoResponse } from '@composio/client/resources/auth';
20 -import type { ToolRetrieveResponse } from '@composio/client/resources/tools';
19 import { TIMESTAMP } from '../models/account';
20 import * as BunFileSystem from '@effect/platform-bun/BunFileSystem';
21 import * as BunPath from '@effect/platform-bun/BunPath';
@@ -33,7 +31,6 @@ import {
31 Path,
32 References,
33 Schedule,
36 - String,
34 } from 'effect';
35 import { CliConfig, type Command as CliCommand } from 'effect/cli';
36 import { ChildProcess, ChildProcessSpawner } from 'effect/process';
@@ -42,29 +39,18 @@ import { hostOnlyEnvConfigProvider } from 'test/__utils__/live-env-config-provid
39 import * as MockConsole from './mock-console';
40 import * as MockTerminal from './mock-terminal';
41 import { TerminalUITest } from './terminal-ui-test';
45 -import type { Toolkits, ToolkitDetailed } from 'src/models/toolkits';
42 import { NodeProcess } from 'src/services/node-process';
43 import { cliDebugFlagsLayer } from 'src/services/runtime-flags';
44 import {
45 ComposioClientSingleton,
46 ComposioSessionRepository,
47 ComposioToolkitsRepository,
52 - type ToolkitProjectScope,
48 } from 'src/services/composio-clients';
54 -import {
55 - InvalidToolkitsError,
56 - InvalidToolkitVersionsError,
57 - type InvalidVersionDetail,
58 -} from 'src/services/toolkit-version-validation';
49 import { type OrganizationSummary, type OrgProject } from 'src/services/composio-account';
60 -import type { ToolkitVersionOverrides } from 'src/effects/toolkit-version-overrides';
50 import { JsPackageManagerDetector } from 'src/services/js-package-manager-detector';
62 -import type { Tool, Tools } from 'src/models/tools';
63 -import type { TriggerTypes, TriggerTypesAsEnums } from 'src/models/trigger-types';
51 import type { AuthConfigItem } from 'src/models/auth-configs';
52 import type { ConnectedAccountItem } from 'src/models/connected-accounts';
53 import type { TriggerInstanceItem } from 'src/models/triggers';
67 -import type { ToolkitVersionSpec } from 'src/effects/toolkit-version-overrides';
54 import { ComposioUserContextLive } from 'src/services/user-context';
55 import { ComposioCliUserConfig } from 'src/services/cli-user-config';
56 import { CliUserConfig } from 'src/models/cli-user-config';
@@ -101,24 +87,12 @@ import {
87 } from 'src/services/setup-skill-installer';
88 import { FetchHttpClient, HttpClient } from 'effect/http';
89 import * as BunServices from '@effect/platform-bun/BunServices';
104 -
105 -/**
106 - * A 404 as the Effect client reports one, with the API error envelope when the
107 - * scenario has one.
108 - */
109 -const notFoundError = (
110 - message: string,
111 - envelope?: { readonly message: string; readonly suggested_fix: string }
112 -) =>
113 - new NotFoundError({
114 - message,
115 - method: 'GET',
116 - url: 'https://mock.invalid',
117 - status: 404,
118 - requestId: undefined,
119 - details: envelope ? { ...envelope, code: 404, slug: 'Not_Found', status: 404 } : undefined,
120 - body: envelope ? { error: envelope } : undefined,
121 - });
90 +import { notFoundError } from '../layers/not-found';
91 +import {
92 + resolveToolkitsTestData,
93 + toolkitCatalogMethods,
94 + type ToolkitsTestData,
95 +} from '../layers/toolkits';
96
97 /**
98 * The credentials and scope one mock-client request carries: the parameters
@@ -179,28 +153,7 @@ export interface TestLiveInput {
153 /**
154 * Mock toolkit-related data to use in test.
155 */
182 - toolkitsData?: {
183 - toolkits?: Toolkits;
184 - /**
185 - * Custom toolkits registered in the test project. Kept apart from
186 - * `toolkits`, the Composio-managed catalog, as the API keeps them apart.
187 - */
188 - projectToolkits?: Toolkits;
189 - /**
190 - * The project `projectToolkits` belong to. When set, a project-toolkit
191 - * lookup for any other scope, or for none, finds nothing, as the API
192 - * would answer for another project.
193 - */
194 - projectToolkitsScope?: ToolkitProjectScope;
195 - /**
196 - * Called with the scope of every project-toolkit lookup.
197 - */
198 - onGetProjectToolkits?: (scope: ToolkitProjectScope | undefined) => void;
199 - detailedToolkits?: ToolkitDetailed[];
200 - tools?: Tools;
201 - triggerTypesAsEnums?: TriggerTypesAsEnums;
202 - triggerTypes?: TriggerTypes;
203 - };
156 + toolkitsData?: ToolkitsTestData;
157
158 /**
159 * Account, session-info, and consumer data served by the mock client's
@@ -369,51 +322,14 @@ export interface TestLiveInput {
322
323 type RequiredLayer = Layer.Layer<CliCommand.Environment, unknown, never>;
324
372 -const toClientTool = (tool: Tool): ToolRetrieveResponse => {
373 - // Derive toolkit slug from tool slug prefix (e.g. GMAIL_SEND_EMAIL -> gmail)
374 - const parts = tool.slug.split('_');
375 - const toolkitSlug = parts.length > 1 ? parts[0]!.toLowerCase() : '';
376 - return {
377 - ...tool,
378 - available_versions: [...tool.available_versions],
379 - tags: [...tool.tags],
380 - no_auth: false,
381 - version: 'latest',
382 - scopes: [],
383 - scope_requirements: null,
384 - is_deprecated: false,
385 - deprecated: {
386 - displayName: tool.name,
387 - version: 'latest',
388 - available_versions: [...tool.available_versions],
389 - is_deprecated: false,
390 - toolkit: { logo: '' },
391 - },
392 - toolkit: { name: toolkitSlug, slug: toolkitSlug, logo: '' },
393 - };
394 -};
395 -
325 /**
326 * Effect layer that injects all the services needed for tests, using mocks to avoid
327 * side-effects like unwanted HTTP requests to remote services.
328 */
329 export const TestLayer = (input?: TestLiveInput) =>
330 Effect.gen(function* () {
402 - const defaultAppClientData = {
403 - toolkits: [] as Toolkits,
404 - projectToolkits: [] as Toolkits,
405 - detailedToolkits: [] as ToolkitDetailed[],
406 - tools: [] as Tools,
407 - triggerTypesAsEnums: [] as TriggerTypesAsEnums,
408 - triggerTypes: [] as TriggerTypes,
409 - } satisfies TestLiveInput['toolkitsData'];
331 const fixture = input?.fixture;
411 - const toolkitsData = {
412 - ...defaultAppClientData,
413 - ...(input?.toolkitsData ?? {}),
414 - detailedToolkits:
415 - input?.toolkitsData?.detailedToolkits ?? defaultAppClientData.detailedToolkits,
416 - };
332 + const toolkitsData = resolveToolkitsTestData(input?.toolkitsData);
333
334 const defaultAuthConfigsData = {
335 items: [] as AuthConfigItem[],
@@ -455,225 +371,7 @@ export const TestLayer = (input?: TestLiveInput) =>
371 const ComposioToolkitsRepositoryTest = Layer.succeed(
372 ComposioToolkitsRepository,
373 ComposioToolkitsRepository.of({
458 - getToolkits: () => Effect.succeed(toolkitsData.toolkits),
459 - getProjectToolkits: scope =>
460 - Effect.sync(() => {
461 - toolkitsData.onGetProjectToolkits?.(scope);
462 - const owner = toolkitsData.projectToolkitsScope;
463 - const inScope =
464 - owner === undefined ||
465 - (scope?.orgId === owner.orgId && scope.projectId === owner.projectId);
466 - return inScope ? toolkitsData.projectToolkits : [];
467 - }),
468 - getToolkitsBySlugs: (slugs: ReadonlyArray<string>) => {
469 - const normalizedSlugs = new Set(slugs.map(s => String.toLowerCase(s)));
470 - const found = toolkitsData.toolkits.filter(t =>
471 - normalizedSlugs.has(String.toLowerCase(t.slug))
472 - );
473 - if (found.length !== slugs.length) {
474 - const foundSlugs = new Set(found.map(t => String.toLowerCase(t.slug)));
475 - const notFound = slugs.filter(s => !foundSlugs.has(String.toLowerCase(s)));
476 - return Effect.fail(
477 - new InvalidToolkitsError({
478 - invalidToolkits: [...notFound],
479 - availableToolkits: toolkitsData.toolkits.map(t => t.slug),
480 - })
481 - );
482 - }
483 - return Effect.succeed(found);
484 - },
485 - getMetrics: () => Effect.succeed({ byteSize: 0, requests: 0 }),
486 - getToolsAsEnums: () => Effect.succeed(toolkitsData.tools.map(tool => tool.slug)),
487 - getTriggerTypesAsEnums: () => Effect.succeed(toolkitsData.triggerTypesAsEnums),
488 - getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
489 - let triggers = toolkitsData.triggerTypes;
490 - if (toolkitSlugs && toolkitSlugs.length > 0) {
491 - const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
492 - triggers = triggers.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
493 - }
494 - return Effect.succeed(triggers);
495 - },
496 - getTriggerTypeDetailed: (slug: string) => {
497 - const found = toolkitsData.triggerTypes.find(
498 - trigger => trigger.slug.toUpperCase() === slug.toUpperCase()
499 - );
500 - if (!found) {
501 - return Effect.fail(notFoundError(`Trigger type "${slug}" not found`));
502 - }
503 - return Effect.succeed(found);
504 - },
505 - getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
506 - let tools = toolkitsData.tools;
507 - if (toolkitSlugs && toolkitSlugs.length > 0) {
508 - const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
509 - tools = tools.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
510 - }
511 - return Effect.succeed(tools);
512 - },
513 - validateToolkits: (toolkitSlugs: ReadonlyArray<string>) => {
514 - const normalizedInputSlugs = toolkitSlugs.map(slug => String.toLowerCase(slug));
515 - const availableSlugs = toolkitsData.toolkits.map(toolkit =>
516 - String.toLowerCase(toolkit.slug)
517 - );
518 - const invalidSlugs = normalizedInputSlugs.filter(slug => !availableSlugs.includes(slug));
519 -
520 - if (invalidSlugs.length > 0) {
521 - return Effect.fail(
522 - new InvalidToolkitsError({
523 - invalidToolkits: invalidSlugs,
524 - availableToolkits: availableSlugs,
525 - })
526 - );
527 - }
528 -
529 - return Effect.succeed(normalizedInputSlugs);
530 - },
531 - filterToolkitsBySlugs: (toolkits, toolkitSlugs) => {
532 - const normalizedSlugs = new Set(toolkitSlugs.map(slug => String.toLowerCase(slug)));
533 - return toolkits.filter(toolkit => normalizedSlugs.has(String.toLowerCase(toolkit.slug)));
534 - },
535 - getToolsByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) => {
536 - // Filter tools based on toolkit slugs from specs
537 - const toolkitSlugs = specs.map(s => s.toolkitSlug.toUpperCase());
538 - const prefixes = toolkitSlugs.map(s => `${s}_`);
539 - const tools = toolkitsData.tools.filter(t =>
540 - prefixes.some(p => t.slug.toUpperCase().startsWith(p))
541 - );
542 - return Effect.succeed(tools);
543 - },
544 - validateToolkitVersions: (
545 - overrides: ToolkitVersionOverrides,
546 - relevantToolkits?: ReadonlyArray<string>
547 - ) => {
548 - // Mock implementation that validates against test fixture
549 - const invalidVersions: InvalidVersionDetail[] = [];
550 - const warnings: string[] = [];
551 -
552 - for (const [toolkit, version] of overrides) {
553 - // Check if toolkit should be validated
554 - if (relevantToolkits && !relevantToolkits.map(s => s.toLowerCase()).includes(toolkit)) {
555 - warnings.push(`Version override for "${toolkit}" will be ignored`);
556 - continue;
557 - }
558 -
559 - // Check if toolkit exists in the fixture
560 - const toolkitExists = toolkitsData.toolkits.some(
561 - t => String.toLowerCase(t.slug) === toolkit
562 - );
563 -
564 - if (!toolkitExists) {
565 - return Effect.fail(
566 - new InvalidToolkitsError({
567 - invalidToolkits: [toolkit],
568 - availableToolkits: toolkitsData.toolkits.map(t => t.slug),
569 - })
570 - );
571 - }
572 -
573 - // Mock: only accept 'latest' or versions matching pattern YYYYMMDD_NN
574 - const validPattern = /^\d{8}_\d{2}$/;
575 - if (version !== 'latest' && !validPattern.test(version)) {
576 - invalidVersions.push({
577 - toolkit,
578 - requestedVersion: version,
579 - availableVersions: ['20250901_00', '20250815_00', '20250710_00'],
580 - });
581 - }
582 - }
583 -
584 - if (invalidVersions.length > 0) {
585 - return Effect.fail(new InvalidToolkitVersionsError({ invalidVersions }));
586 - }
587 -
588 - return Effect.succeed({
589 - validatedOverrides: overrides,
590 - warnings: warnings as ReadonlyArray<string>,
591 - });
592 - },
593 - searchToolkits: (params: {
594 - search?: string;
595 - category?: string;
596 - limit?: number;
597 - cursor?: string;
598 - }) => {
599 - let results = [...toolkitsData.toolkits];
600 -
601 - if (params.search) {
602 - const q = params.search.toLowerCase();
603 - results = results.filter(
604 - t =>
605 - t.name.toLowerCase().includes(q) ||
606 - t.slug.toLowerCase().includes(q) ||
607 - t.meta.description.toLowerCase().includes(q)
608 - );
609 - }
610 -
611 - const limit = params.limit ?? 30;
612 - const items = results.slice(0, limit);
613 - return Effect.succeed({
614 - items,
615 - total_items: results.length,
616 - total_pages: Math.ceil(results.length / limit),
617 - next_cursor: null,
618 - });
619 - },
620 - searchTools: (params: {
621 - search?: string;
622 - toolkit_slug?: string;
623 - tags?: string;
624 - limit?: number;
625 - cursor?: string;
626 - }) => {
627 - let results = [...toolkitsData.tools];
628 -
629 - if (params.toolkit_slug) {
630 - const slugs = params.toolkit_slug.split(',').map(s => s.trim().toUpperCase() + '_');
631 - results = results.filter(t => slugs.some(p => t.slug.toUpperCase().startsWith(p)));
632 - }
633 -
634 - if (params.search) {
635 - const q = params.search.toLowerCase();
636 - results = results.filter(
637 - t =>
638 - t.name.toLowerCase().includes(q) ||
639 - t.slug.toLowerCase().includes(q) ||
640 - t.description.toLowerCase().includes(q)
641 - );
642 - }
643 -
644 - if (params.tags) {
645 - const tagList = params.tags.split(',').map(t => t.trim().toLowerCase());
646 - results = results.filter(t =>
647 - tagList.some(tag => t.tags.map(tt => tt.toLowerCase()).includes(tag))
648 - );
649 - }
650 -
651 - const limit = params.limit ?? 30;
652 - const items = results.slice(0, limit).map(toClientTool);
653 - return Effect.succeed({
654 - items,
655 - total_items: results.length,
656 - total_pages: Math.ceil(results.length / limit),
657 - current_page: 1,
658 - next_cursor: null,
659 - });
660 - },
661 - getToolDetailed: (slug: string) => {
662 - const found = toolkitsData.tools.find(t => t.slug.toUpperCase() === slug.toUpperCase());
663 - if (!found) {
664 - return Effect.fail(notFoundError(`Tool "${slug}" not found`));
665 - }
666 - return Effect.succeed(toClientTool(found));
667 - },
668 - getToolkitDetailed: (slug: string) => {
669 - const found = toolkitsData.detailedToolkits.find(
670 - t => t.slug.toLowerCase() === slug.toLowerCase()
671 - );
672 - if (!found) {
673 - return Effect.fail(notFoundError(`Toolkit "${slug}" not found`));
674 - }
675 - return Effect.succeed(found);
676 - },
374 + ...toolkitCatalogMethods(toolkitsData),
375 listAuthConfigs: (params: {
376 search?: string;
377 toolkit_slug?: string;
ts/packages/cli/test/src/services/test-layer.test.ts
+33 -2
@@ -1,12 +1,14 @@
1 import { describe, expect, it, vi } from '@effect/vitest';
2 -import { Effect } from 'effect';
2 +import { Effect, Exit } from 'effect';
3 +import { ComposioToolkitsRepository } from 'src/services/composio-clients';
4 import {
5 getSessionInfoByUserApiKey,
6 listOrganizations,
7 resolveConsumerProject,
8 } from 'src/services/composio-account';
8 -import { TestLive } from 'test/__utils__';
9 +import { TestLive, ToolkitsTest } from 'test/__utils__';
10 import { makeSessionInfo } from 'test/__utils__/models/account';
11 +import { makeToolkitFixture } from 'test/__utils__/models/toolkits';
12
13 describe('TestLayer', () => {
14 it.effect('leaves globalThis.fetch untouched', () =>
@@ -56,3 +58,32 @@ describe('TestLayer', () => {
58 })
59 );
60 });
61 +
62 +describe('ToolkitsTest', () => {
63 + const toolkitsData = {
64 + toolkits: [makeToolkitFixture('gmail', 'Gmail'), makeToolkitFixture('slack', 'Slack')],
65 + };
66 +
67 + it.effect.each([
68 + { name: 'ToolkitsTest', layer: ToolkitsTest(toolkitsData) },
69 + { name: 'TestLive', layer: TestLive({ toolkitsData }) },
70 + ])('serves the same catalog answers through $name', ({ layer }) =>
71 + Effect.gen(function* () {
72 + const repo = yield* ComposioToolkitsRepository;
73 + const search = yield* repo.searchToolkits({ search: 'gma' });
74 + const missing = yield* repo.getToolkitDetailed('nope').pipe(Effect.flip);
75 +
76 + expect(search.items.map(toolkit => toolkit.slug)).toEqual(['gmail']);
77 + expect(missing).toMatchObject({ _tag: '@composio/client/NotFoundError', status: 404 });
78 + }).pipe(Effect.provide(layer), Effect.scoped)
79 + );
80 +
81 + it.effect('dies on a repository method another family serves', () =>
82 + Effect.gen(function* () {
83 + const repo = yield* ComposioToolkitsRepository;
84 + const exit = yield* repo.listAuthConfigs({}).pipe(Effect.exit);
85 +
86 + expect(Exit.hasDies(exit)).toBe(true);
87 + }).pipe(Effect.provide(ToolkitsTest()))
88 + );
89 +});