fix(core): fix bug loading of .redocly.lint-ignore.yaml in browser environments

.changeset/sour-wings-follow.md

@@ -0,0 +1,5 @@
+---
+"@redocly/openapi-core": patch
+---
+
+Fixed an issue where `.redocly.lint-ignore.yaml` was not loaded in browser environments.

packages/core/src/__tests__/ref-utils.test.ts

@@ -5,6 +5,8 @@ import {
   parseRef,
   refBaseName,
   unescapePointerFragment,
+  isAbsoluteUrlOrFileUrl,
+  getDir,
 } from '../ref-utils.js';
 import { lintDocument } from '../lint.js';
 import { createConfig } from '../config/index.js';
@@ -183,4 +185,32 @@ describe('ref-utils', () => {
       expect(unescapePointerFragment('scope~1complex~0name')).toStrictEqual('scope/complex~name');
     });
   });
+
+  describe('isAbsoluteUrlOrFileUrl', () => {
+    it('should return true for http://, https://, and file:// URLs', () => {
+      expect(isAbsoluteUrlOrFileUrl('http://example.com/api.yaml')).toBe(true);
+      expect(isAbsoluteUrlOrFileUrl('https://example.com/api.yaml')).toBe(true);
+      expect(isAbsoluteUrlOrFileUrl('file:///Users/test/api.yaml')).toBe(true);
+    });
+
+    it('should return false for relative and absolute file paths', () => {
+      expect(isAbsoluteUrlOrFileUrl('./api.yaml')).toBe(false);
+      expect(isAbsoluteUrlOrFileUrl('../api.yaml')).toBe(false);
+      expect(isAbsoluteUrlOrFileUrl('/Users/test/api.yaml')).toBe(false);
+    });
+  });
+
+  describe('getDir', () => {
+    it('should return directory for file paths and URLs', () => {
+      expect(getDir('/Users/test/config/redocly.yaml')).toBe('/Users/test/config');
+      expect(getDir('http://example.com/config/redocly.yaml')).toBe('http://example.com/config');
+      expect(getDir('https://example.com/config/redocly.yaml')).toBe('https://example.com/config');
+      expect(getDir('file:///Users/test/config/redocly.yaml')).toBe('file:///Users/test/config');
+    });
+
+    it('should return path as-is if no extension (directory)', () => {
+      expect(getDir('/Users/test/config')).toBe('/Users/test/config');
+      expect(getDir('file:///Users/test/config')).toBe('file:///Users/test/config');
+    });
+  });
 });

packages/core/src/config/__tests__/config.test.ts

@@ -1,24 +1,6 @@
 import { type SpecVersion } from '../../oas-types.js';
 import { Config } from '../config.js';
-import * as jsYaml from '../../js-yaml/index.js';
-import * as fs from 'node:fs';
-import { ignoredFileStub } from './fixtures/ingore-file.js';
-import * as path from 'node:path';
 import { createConfig } from '../index.js';
-import * as doesYamlFileExistModule from '../../utils/does-yaml-file-exist.js';
-
-vi.mock('../../js-yaml/index.js', async () => {
-  const actual = await vi.importActual('../../js-yaml/index.js');
-  return { ...actual };
-});
-vi.mock('node:fs', async () => {
-  const actual = await vi.importActual('node:fs');
-  return { ...actual };
-});
-vi.mock('node:path', async () => {
-  const actual = await vi.importActual('node:path');
-  return { ...actual };
-});
 
 // Create the config and clean up not needed props for consistency
 const testConfig: Config = await createConfig(
@@ -237,12 +219,16 @@ describe('Config.extendTypes', () => {
 
 describe('generation ignore object', () => {
   it('should generate config with absoluteUri for ignore', () => {
-    vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => '');
-    vi.spyOn(jsYaml, 'parseYaml').mockImplementationOnce(() => ignoredFileStub);
-    vi.spyOn(doesYamlFileExistModule, 'doesYamlFileExist').mockImplementationOnce(() => true);
-    vi.spyOn(path, 'resolve').mockImplementationOnce((_, filename) => `some-path/${filename}`);
+    const ignore = {
+      'some-path/openapi.yaml': {
+        'no-unused-components': new Set(['#/components/schemas/Foo']),
+      },
+      'https://some-path.yaml': {
+        'no-unused-components': new Set(['#/components/schemas/Foo']),
+      },
+    };
 
-    const config = new Config(testConfig.resolvedConfig);
+    const config = new Config(testConfig.resolvedConfig, { ignore });
     config.resolvedConfig = 'resolvedConfig stub' as any;
 
     expect(config).toMatchSnapshot();

packages/core/src/config/__tests__/fixtures/ignore-file/.redocly.lint-ignore.yaml

@@ -0,0 +1,3 @@
+api.yaml:
+  operation-operationId:
+    - '#/paths/~1pets/get/operationId'

packages/core/src/config/__tests__/fixtures/ignore-file/api.yaml

@@ -0,0 +1,12 @@
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths:
+  /pets:
+    get:
+      operationId: ''
+      summary: Get pets
+      responses:
+        '200':
+          description: OK

packages/core/src/config/__tests__/fixtures/ignore-file/redocly.yaml

@@ -0,0 +1,3 @@
+rules:
+  operation-operationId: error
+  operation-summary: error

packages/core/src/config/__tests__/load.test.ts

@@ -1344,3 +1344,34 @@ function verifyOasRules(
     }
   });
 }
+
+describe('loadIgnoreFile', () => {
+  const ignoreFileDir = path.join(__dirname, './fixtures/ignore-file');
+  const ignoreFileConfig = path.join(ignoreFileDir, 'redocly.yaml');
+  const expectedIgnoreKey = path.join(ignoreFileDir, 'api.yaml');
+
+  it('should ignore only rules specified in ignore file', async () => {
+    const config = await loadConfig({ configPath: ignoreFileConfig });
+
+    expect(Object.keys(config.ignore)).toEqual([expectedIgnoreKey]);
+    expect(config.ignore[expectedIgnoreKey]['operation-operationId']).toBeInstanceOf(Set);
+    expect(config.ignore[expectedIgnoreKey]['operation-summary']).toBeUndefined();
+  });
+
+  it('should return empty object when ignore file does not exist', async () => {
+    const configPath = path.join(__dirname, './fixtures/load-redocly.yaml');
+    const config = await loadConfig({ configPath });
+
+    expect(config.ignore).toEqual({});
+  });
+
+  it('should load ignore file in browser environment (without fs.existsSync)', async () => {
+    const existsSyncSpy = vi.spyOn(fs, 'existsSync').mockImplementation(undefined as any);
+
+    const config = await loadConfig({ configPath: ignoreFileConfig });
+
+    expect(Object.keys(config.ignore)).toEqual([expectedIgnoreKey]);
+
+    existsSyncSpy.mockRestore();
+  });
+});

packages/core/src/config/config.ts

@@ -1,11 +1,9 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { parseYaml, stringifyYaml } from '../js-yaml/index.js';
+import { stringifyYaml } from '../js-yaml/index.js';
 import { slash } from '../utils/slash.js';
-import { doesYamlFileExist } from '../utils/does-yaml-file-exist.js';
 import { isPlainObject } from '../utils/is-plain-object.js';
 import { specVersions } from '../detect-spec.js';
-import { isBrowser } from '../env.js';
 import { getResolveConfig } from './get-resolve-config.js';
 import { isAbsoluteUrl } from '../ref-utils.js';
 import { groupAssertionRules } from './group-assertion-rules.js';
@@ -35,16 +33,6 @@ import type {
   RuleSettings,
 } from './types.js';
 
-function getIgnoreFilePath(configPath?: string): string | undefined {
-  if (configPath) {
-    return doesYamlFileExist(configPath)
-      ? path.join(path.dirname(configPath), IGNORE_FILE)
-      : path.join(configPath, IGNORE_FILE);
-  } else {
-    return isBrowser ? undefined : path.join(process.cwd(), IGNORE_FILE);
-  }
-}
-
 export class Config {
   resolvedConfig: ResolvedConfig;
   configPath?: string;
@@ -71,6 +59,7 @@ export class Config {
       resolvedRefMap?: ResolvedRefMap;
       alias?: string;
       plugins?: Plugin[];
+      ignore?: Record<string, Record<string, Set<string>>>;
     } = {}
   ) {
     this.resolvedConfig = resolvedConfig;
@@ -153,7 +142,7 @@ export class Config {
       },
     };
 
-    this.resolveIgnore(getIgnoreFilePath(opts.configPath));
+    this.ignore = opts.ignore || {};
   }
 
   forAlias(alias?: string) {
@@ -171,35 +160,11 @@ export class Config {
         resolvedRefMap: this.resolvedRefMap,
         alias,
         plugins: this.plugins,
+        ignore: this.ignore,
       }
     );
   }
 
-  resolveIgnore(ignoreFile?: string) {
-    if (!ignoreFile || !doesYamlFileExist(ignoreFile)) return;
-
-    this.ignore =
-      (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
-        string,
-        Record<string, Set<string>>
-      >) || {};
-
-    // resolve ignore paths
-    for (const fileName of Object.keys(this.ignore)) {
-      this.ignore[
-        isAbsoluteUrl(fileName) ? fileName : path.resolve(path.dirname(ignoreFile), fileName)
-      ] = this.ignore[fileName];
-
-      for (const ruleId of Object.keys(this.ignore[fileName])) {
-        this.ignore[fileName][ruleId] = new Set(this.ignore[fileName][ruleId]);
-      }
-
-      if (!isAbsoluteUrl(fileName)) {
-        delete this.ignore[fileName];
-      }
-    }
-  }
-
   saveIgnore() {
     const dir = this.configPath ? path.dirname(this.configPath) : process.cwd();
     const ignoreFile = path.join(dir, IGNORE_FILE);

packages/core/src/config/load.ts

@@ -8,10 +8,58 @@ import {
   type Document,
   type ResolvedRefMap,
 } from '../resolve.js';
-import { CONFIG_FILE_NAME } from './constants.js';
+import { CONFIG_FILE_NAME, IGNORE_FILE } from './constants.js';
+import { isAbsoluteUrlOrFileUrl, getDir } from '../ref-utils.js';
 
 import type { RawUniversalConfig } from './types.js';
 
+function resolvePath(base: string, relative: string): string {
+  if (isAbsoluteUrlOrFileUrl(base)) {
+    return new URL(relative, base.endsWith('/') ? base : `${base}/`).href;
+  }
+  return path.resolve(base, relative);
+}
+
+async function loadIgnoreFile(
+  configPath: string | undefined,
+  resolver: BaseResolver
+): Promise<Record<string, Record<string, Set<string>>> | undefined> {
+  if (!configPath) return undefined;
+
+  const configDir = getDir(configPath);
+  const ignorePath = resolvePath(configDir, IGNORE_FILE);
+
+  if (fs?.existsSync && !isAbsoluteUrlOrFileUrl(ignorePath) && !fs.existsSync(ignorePath)) {
+    return undefined;
+  }
+
+  const ignoreDocument = await resolver.resolveDocument(null, ignorePath, true);
+
+  if (ignoreDocument instanceof Error || !ignoreDocument.parsed) {
+    return undefined;
+  }
+
+  const ignore = (ignoreDocument.parsed || {}) as Record<string, Record<string, Set<string>>>;
+
+  for (const fileName of Object.keys(ignore)) {
+    const resolvedFileName = isAbsoluteUrlOrFileUrl(fileName)
+      ? fileName
+      : resolvePath(configDir, fileName);
+
+    ignore[resolvedFileName] = ignore[fileName];
+
+    for (const ruleId of Object.keys(ignore[fileName])) {
+      ignore[fileName][ruleId] = new Set(ignore[fileName][ruleId]);
+    }
+
+    if (resolvedFileName !== fileName) {
+      delete ignore[fileName];
+    }
+  }
+
+  return ignore;
+}
+
 export async function loadConfig(
   options: {
     configPath?: string;
@@ -38,11 +86,14 @@ export async function loadConfig(
     externalRefResolver,
   });
 
+  const ignore = await loadIgnoreFile(configPath, resolver);
+
   const config = new Config(resolvedConfig, {
     configPath,
     document: rawConfigDocument,
     resolvedRefMap: resolvedRefMap,
     plugins,
+    ignore,
   });
 
   return config;
@@ -79,11 +130,16 @@ export async function createConfig(
     configPath,
     externalRefResolver,
   });
+
+  const resolver = externalRefResolver ?? new BaseResolver();
+  const ignore = await loadIgnoreFile(configPath, resolver);
+
   return new Config(resolvedConfig, {
     configPath,
     document: rawConfigDocument,
     resolvedRefMap,
     plugins,
+    ignore,
   });
 }
 

packages/core/src/index.ts

@@ -55,6 +55,8 @@ export {
   unescapePointerFragment,
   isRef,
   isAbsoluteUrl,
+  isAbsoluteUrlOrFileUrl,
+  getDir,
   escapePointerFragment,
   type Location,
 } from './ref-utils.js';

packages/core/src/ref-utils.ts

@@ -1,3 +1,4 @@
+import * as path from 'node:path';
 import { isTruthy } from './utils/is-truthy.js';
 import { isPlainObject } from './utils/is-plain-object.js';
 
@@ -85,6 +86,20 @@ export function isAbsoluteUrl(ref: string) {
   return ref.startsWith('http://') || ref.startsWith('https://');
 }
 
+export function isAbsoluteUrlOrFileUrl(ref: string) {
+  return isAbsoluteUrl(ref) || ref.startsWith('file://');
+}
+
+export function getDir(filePath: string): string {
+  if (!path.extname(filePath)) {
+    return filePath;
+  }
+
+  return isAbsoluteUrlOrFileUrl(filePath)
+    ? filePath.substring(0, filePath.lastIndexOf('/'))
+    : path.dirname(filePath);
+}
+
 export function isMappingRef(mapping: string) {
   // TODO: proper detection of mapping refs
   return (