fix: baseResolver cache issue

Author: DmitryAnansky

packages/respect-core/src/__tests__/run.test.ts

@@ -0,0 +1,73 @@
+import { BaseResolver, createConfig, logger } from '@redocly/openapi-core';
+
+import * as flowRunner from '../modules/flow-runner/index.js';
+import type * as loggerOutput from '../modules/logger-output/index.js';
+import { run } from '../run.js';
+
+vi.mock('../modules/flow-runner/index.js', () => ({
+  runTestFile: vi.fn(),
+}));
+
+vi.mock('../modules/logger-output/index.js', async () => {
+  const actual = await vi.importActual<typeof loggerOutput>('../modules/logger-output/index.js');
+  return {
+    ...actual,
+    displayErrors: vi.fn(),
+    displaySummary: vi.fn(),
+  };
+});
+
+describe('run', () => {
+  const defaultRunResult = {
+    executedWorkflows: [],
+    ctx: { noSecretsMasking: false, secretsSet: new Set() },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(flowRunner.runTestFile).mockResolvedValue(defaultRunResult as any);
+  });
+
+  it('clears the externalRefResolver cache between file runs so mutated parsed docs do not leak into the next file', async () => {
+    const config = await createConfig({});
+    const externalRefResolver = new BaseResolver(config.resolve);
+
+    externalRefResolver.cache.set('/seeded/before/run.yaml', Promise.resolve({} as any));
+
+    const seenCacheSizes: number[] = [];
+    vi.mocked(flowRunner.runTestFile).mockImplementation(async ({ options }) => {
+      seenCacheSizes.push(options.externalRefResolver?.cache.size ?? -1);
+      options.externalRefResolver?.cache.set(`/leaked/${options.file}`, Promise.resolve({} as any));
+      return defaultRunResult as any;
+    });
+
+    await run({
+      files: ['a.arazzo.yaml', 'b.arazzo.yaml', 'c.arazzo.yaml'],
+      config,
+      maxSteps: 2000,
+      maxFetchTimeout: 40_000,
+      requestFileLoader: { getFileBody: async () => new Blob() },
+      logger,
+      fetch,
+      externalRefResolver,
+    });
+
+    expect(seenCacheSizes).toEqual([0, 0, 0]);
+  });
+
+  it('does not throw when externalRefResolver is not provided', async () => {
+    const config = await createConfig({});
+
+    await expect(
+      run({
+        files: ['a.arazzo.yaml'],
+        config,
+        maxSteps: 2000,
+        maxFetchTimeout: 40_000,
+        requestFileLoader: { getFileBody: async () => new Blob() },
+        logger,
+        fetch,
+      })
+    ).resolves.toBeDefined();
+  });
+});

packages/respect-core/src/run.ts

@@ -47,6 +47,15 @@ export async function run(options: RespectOptions): Promise<RunFileResult[]> {
   const runAllFilesResult = [];
 
   for (const path of files) {
+    // The runner mutates the parsed Arazzo document in place (adds `workflow.time`
+    // and `step.checks`). When `externalRefResolver` is shared across files, its
+    // cache would return those mutated documents to the lint pass of subsequent
+    // files (e.g. ones previously executed via `$sourceDescriptions.*` workflow
+    // references), producing false "property is not expected here" struct errors.
+    // Clear the cache between files so each file starts from freshly parsed
+    // documents while preserving the resolver's transport config (proxy, mTLS, etc).
+    options.externalRefResolver?.cache.clear();
+
     const result = await runFile({
       options: { ...options, file: path },
       startedAt: performance.now(),