import path from 'node:path'; import { Effect, Option, ParseResult, Layer, Array as Arr } from 'effect'; import { FileSystem } from '@effect/platform'; import { BunFileSystem } from '@effect/platform-bun'; import { setupCacheDir } from 'src/effects/setup-cache-dir'; import { FORCE_CONFIG } from 'src/effects/force-config'; import { ComposioToolkitsRepository, InvalidToolkitsError } from './composio-clients'; import type { ToolkitVersionSpec } from 'src/effects/toolkit-version-overrides'; import { NodeOs } from './node-os'; import { toolkitsFromJSON, toolkitsToJSON, type Toolkits } from 'src/models/toolkits'; import { toolsAsEnumsFromJSON, toolsAsEnumsToJSON, ToolsFromJSON, ToolsToJSON, type Tools, } from 'src/models/tools'; import { TriggerTypesAsEnumsFromJSON, TriggerTypesAsEnumsToJSON, TriggerTypesFromJSON, TriggerTypesToJSON, type TriggerTypes, } from 'src/models/trigger-types'; import { ConfigLive } from './config'; /** * Cache file names for different data types */ export const CACHE_FILES = { toolkits: 'toolkits.json', tools: 'tools.json', toolsAsEnums: 'tools-as-enums.json', triggerTypesAsEnums: 'trigger-types-as-enums.json', triggerTypes: 'trigger-types.json', } as const; /** * Generic cache helper function that handles both cache read/write with graceful error handling. */ function createCachedEffect( cacheFileName: string, decoder: (input: string) => Effect.Effect, encoder: (input: T) => Effect.Effect, computation: Effect.Effect, cacheFilter?: (data: T) => Effect.Effect ): Effect.Effect { // First define the cache-handling function that will run with all required services const cacheEffect = Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const cacheDir = yield* setupCacheDir; const cacheFilePath = path.join(cacheDir, cacheFileName); const cacheFileExists = yield* fs .exists(cacheFilePath) .pipe(Effect.orElse(() => Effect.succeed(false))); const consumeFromCache = yield* FORCE_CONFIG['USE_CACHE']; if (consumeFromCache && cacheFileExists) { yield* Effect.logDebug(`Cache HIT for ${cacheFileName}`); // Try to read from cache const cachedResult = yield* fs.readFileString(cacheFilePath).pipe( Effect.flatMap(decoder), Effect.asSome, Effect.catchAll(error => { // Log cache read/parse errors but don't fail - fall through to computation return Effect.logWarning(`Failed to read/parse cache ${cacheFilePath}: ${error}`).pipe( Effect.as(Option.none()) ); }) ); if (Option.isSome(cachedResult)) { return yield* cacheFilter ? cacheFilter(cachedResult.value) : Effect.succeed(cachedResult.value); } } yield* Effect.logDebug(`Cache MISS for ${cacheFileName}`); // Fetch from the underlying service const result = yield* computation; // Write to cache only if we're fetching the full dataset (no cacheFilter). // Filtered API calls fetch partial data that would corrupt the shared cache file. if (!cacheFilter) { yield* encoder(result).pipe( Effect.flatMap(content => fs.writeFileString(cacheFilePath, content)), Effect.catchAll(error => Effect.logWarning(`Failed to write to cache ${cacheFilePath}: ${error}`) ) ); } return result; }); // Handle any cache errors by falling back to the original computation const handledCacheEffect = cacheEffect.pipe( Effect.catchAll(error => Effect.logWarning(`Cache operation failed: ${error}`).pipe(Effect.flatMap(() => computation)) ) ); // This ensures the returned effect has the same error type as the original computation // by providing all the required cache services return handledCacheEffect.pipe( Effect.provide(Layer.mergeAll(BunFileSystem.layer, NodeOs.Default)) ) as Effect.Effect; } /** * Cached implementation of ComposioToolkitsRepository using the wrapper layer pattern * * This layer adds file-based caching to the repository methods while preserving the * exact same interface and error types. */ export const ComposioToolkitsRepositoryCached = Layer.effect( ComposioToolkitsRepository, Effect.gen(function* () { const underlyingRepository = yield* ComposioToolkitsRepository; // Create the cached implementation that wraps the original implementation return ComposioToolkitsRepository.make({ getToolkits: () => { return createCachedEffect( CACHE_FILES.toolkits, toolkitsFromJSON, toolkitsToJSON, underlyingRepository.getToolkits() ); }, getToolkitsBySlugs: slugs => { const cacheFilter = (data: Toolkits) => { const slugSet = new Set(slugs.map(s => s.toUpperCase())); const filtered = data.filter(t => slugSet.has(t.slug.toUpperCase())); // Validate all requested slugs were found in the cache const foundSlugs = new Set(filtered.map(t => t.slug.toUpperCase())); const missingSlugs = slugs.filter(s => !foundSlugs.has(s.toUpperCase())); if (Arr.isNonEmptyReadonlyArray(missingSlugs)) { return Effect.fail( new InvalidToolkitsError({ invalidToolkits: missingSlugs, availableToolkits: data.map(t => t.slug), }) ); } return Effect.succeed(filtered); }; return createCachedEffect( CACHE_FILES.toolkits, toolkitsFromJSON, toolkitsToJSON, underlyingRepository.getToolkitsBySlugs(slugs), cacheFilter ); }, getToolsAsEnums: () => { return createCachedEffect( CACHE_FILES.toolsAsEnums, toolsAsEnumsFromJSON, toolsAsEnumsToJSON, underlyingRepository.getToolsAsEnums() ); }, getTriggerTypesAsEnums: () => { return createCachedEffect( CACHE_FILES.triggerTypesAsEnums, TriggerTypesAsEnumsFromJSON, TriggerTypesAsEnumsToJSON, underlyingRepository.getTriggerTypesAsEnums() ); }, // Trigger type detail should NOT be cached (single-item fetch, should be fresh) getTriggerTypeDetailed: slug => underlyingRepository.getTriggerTypeDetailed(slug), getTriggerTypes: (toolkitSlugs?: ReadonlyArray) => { const cacheFilter = toolkitSlugs && toolkitSlugs.length > 0 ? (data: TriggerTypes) => { const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`); return Effect.succeed( data.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p))) ); } : undefined; return createCachedEffect( CACHE_FILES.triggerTypes, TriggerTypesFromJSON, TriggerTypesToJSON, underlyingRepository.getTriggerTypes(toolkitSlugs), cacheFilter ); }, getTools: (toolkitSlugs?: ReadonlyArray) => { const cacheFilter = toolkitSlugs && toolkitSlugs.length > 0 ? (data: Tools) => { const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`); return Effect.succeed( data.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p))) ); } : undefined; return createCachedEffect( CACHE_FILES.tools, ToolsFromJSON, ToolsToJSON, underlyingRepository.getTools(toolkitSlugs), cacheFilter ); }, // Version-specific tools bypass cache because: // 1. Different versions = different cache keys needed // 2. Version-specific data shouldn't pollute the main cache // The cache is mainly useful for 'latest' during repeated dev iterations. getToolsByVersionSpecs: (specs: ReadonlyArray) => { return underlyingRepository.getToolsByVersionSpecs(specs); }, // These methods don't need caching as they operate on already fetched data // or perform validation that should always be fresh getMetrics: () => underlyingRepository.getMetrics(), validateToolkits: toolkitSlugs => underlyingRepository.validateToolkits(toolkitSlugs), filterToolkitsBySlugs: (toolkits, toolkitSlugs) => underlyingRepository.filterToolkitsBySlugs(toolkits, toolkitSlugs), // Version validation should NOT be cached because: // 1. available_versions can change frequently as new versions are released // 2. Validation should always reflect the current API state // 3. Caching validation results could cause false positives/negatives validateToolkitVersions: (overrides, relevantToolkits) => underlyingRepository.validateToolkitVersions(overrides, relevantToolkits), // These methods should NOT be cached: // - searchToolkits: results depend on query params, caching would be misleading // - getToolkitDetailed: detailed info should be fresh (auth config fields change) searchToolkits: params => underlyingRepository.searchToolkits(params), getToolkitDetailed: slug => underlyingRepository.getToolkitDetailed(slug), // Tool search/detail should NOT be cached (query-dependent, should be fresh) searchTools: params => underlyingRepository.searchTools(params), getToolDetailed: slug => underlyingRepository.getToolDetailed(slug), // Auth config operations should NOT be cached (CRUD operations, must be fresh) listAuthConfigs: params => underlyingRepository.listAuthConfigs(params), getAuthConfig: nanoid => underlyingRepository.getAuthConfig(nanoid), createAuthConfig: params => underlyingRepository.createAuthConfig(params), deleteAuthConfig: nanoid => underlyingRepository.deleteAuthConfig(nanoid), // Connected account operations should NOT be cached (CRUD operations, must be fresh) listConnectedAccounts: params => underlyingRepository.listConnectedAccounts(params), getConnectedAccount: nanoid => underlyingRepository.getConnectedAccount(nanoid), deleteConnectedAccount: nanoid => underlyingRepository.deleteConnectedAccount(nanoid), createConnectedAccountLink: params => underlyingRepository.createConnectedAccountLink(params), // Trigger instance listing should NOT be cached (status can change frequently) listActiveTriggers: params => underlyingRepository.listActiveTriggers(params), // Trigger instance mutations should NOT be cached createTrigger: (triggerSlug, params) => underlyingRepository.createTrigger(triggerSlug, params), enableTrigger: triggerId => underlyingRepository.enableTrigger(triggerId), disableTrigger: triggerId => underlyingRepository.disableTrigger(triggerId), deleteTrigger: triggerId => underlyingRepository.deleteTrigger(triggerId), }); }) ).pipe( // Provide the required dependencies for the layer Layer.provide(Layer.mergeAll(BunFileSystem.layer, NodeOs.Default, ConfigLive)) );