@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/config/config.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.StyleguideConfig = exports.IGNORE_FILE = void 0;
+const fs = require("fs");
+const path = require("path");
+const js_yaml_1 = require("../js-yaml");
+const utils_1 = require("../utils");
+const oas_types_1 = require("../oas-types");
+const env_1 = require("../env");
+const utils_2 = require("./utils");
+const ref_utils_1 = require("../ref-utils");
+exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
+const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
+    `# See https://redocly.com/docs/cli/ for more information.\n`;
+function getIgnoreFilePath(configFile) {
+    if (configFile) {
+        return (0, utils_1.doesYamlFileExist)(configFile)
+            ? path.join(path.dirname(configFile), exports.IGNORE_FILE)
+            : path.join(configFile, exports.IGNORE_FILE);
+    }
+    else {
+        return env_1.isBrowser ? undefined : path.join(process.cwd(), exports.IGNORE_FILE);
+    }
+}
+class StyleguideConfig {
+    constructor(rawConfig, configFile) {
+        this.rawConfig = rawConfig;
+        this.configFile = configFile;
+        this.ignore = {};
+        this._usedRules = new Set();
+        this._usedVersions = new Set();
+        this.plugins = rawConfig.plugins || [];
+        this.doNotResolveExamples = !!rawConfig.doNotResolveExamples;
+        this.recommendedFallback = rawConfig.recommendedFallback || false;
+        const ruleGroups = [
+            'rules',
+            'oas2Rules',
+            'oas3_0Rules',
+            'oas3_1Rules',
+            'async2Rules',
+            'async3Rules',
+            'arazzo1Rules',
+        ];
+        replaceSpecWithStruct(ruleGroups, rawConfig);
+        this.rules = {
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.rules, ...rawConfig.async2Rules },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.rules, ...rawConfig.async3Rules },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.rules, ...rawConfig.arazzo1Rules },
+        };
+        this.preprocessors = {
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.preprocessors, ...rawConfig.async2Preprocessors },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.preprocessors, ...rawConfig.async3Preprocessors },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Preprocessors },
+        };
+        this.decorators = {
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.decorators, ...rawConfig.async2Decorators },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.decorators, ...rawConfig.async3Decorators },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Decorators },
+        };
+        this.extendPaths = rawConfig.extendPaths || [];
+        this.pluginPaths = rawConfig.pluginPaths || [];
+        this.resolveIgnore(getIgnoreFilePath(configFile));
+    }
+    resolveIgnore(ignoreFile) {
+        if (!ignoreFile || !(0, utils_1.doesYamlFileExist)(ignoreFile))
+            return;
+        this.ignore =
+            (0, js_yaml_1.parseYaml)(fs.readFileSync(ignoreFile, 'utf-8')) || {};
+        replaceSpecWithStruct(Object.keys(this.ignore), this.ignore);
+        // resolve ignore paths
+        for (const fileName of Object.keys(this.ignore)) {
+            this.ignore[(0, ref_utils_1.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 (!(0, ref_utils_1.isAbsoluteUrl)(fileName)) {
+                delete this.ignore[fileName];
+            }
+        }
+    }
+    saveIgnore() {
+        const dir = this.configFile ? path.dirname(this.configFile) : process.cwd();
+        const ignoreFile = path.join(dir, exports.IGNORE_FILE);
+        const mapped = {};
+        for (const absFileName of Object.keys(this.ignore)) {
+            const mappedDefinitionName = (0, ref_utils_1.isAbsoluteUrl)(absFileName)
+                ? absFileName
+                : (0, utils_1.slash)(path.relative(dir, absFileName));
+            const ignoredRules = (mapped[mappedDefinitionName] = this.ignore[absFileName]);
+            for (const ruleId of Object.keys(ignoredRules)) {
+                ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]);
+            }
+        }
+        fs.writeFileSync(ignoreFile, IGNORE_BANNER + (0, js_yaml_1.stringifyYaml)(mapped));
+    }
+    addIgnore(problem) {
+        const ignore = this.ignore;
+        const loc = problem.location[0];
+        if (loc.pointer === undefined)
+            return;
+        const fileIgnore = (ignore[loc.source.absoluteRef] = ignore[loc.source.absoluteRef] || {});
+        const ruleIgnore = (fileIgnore[problem.ruleId] = fileIgnore[problem.ruleId] || new Set());
+        ruleIgnore.add(loc.pointer);
+    }
+    addProblemToIgnore(problem) {
+        const loc = problem.location[0];
+        if (loc.pointer === undefined)
+            return problem;
+        const fileIgnore = this.ignore[loc.source.absoluteRef] || {};
+        const ruleIgnore = fileIgnore[problem.ruleId];
+        const ignored = ruleIgnore && ruleIgnore.has(loc.pointer);
+        return ignored
+            ? {
+                ...problem,
+                ignored,
+            }
+            : problem;
+    }
+    extendTypes(types, version) {
+        let extendedTypes = types;
+        for (const plugin of this.plugins) {
+            if (plugin.typeExtension !== undefined) {
+                switch (version) {
+                    case oas_types_1.SpecVersion.OAS3_0:
+                    case oas_types_1.SpecVersion.OAS3_1:
+                        if (!plugin.typeExtension.oas3)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
+                        break;
+                    case oas_types_1.SpecVersion.OAS2:
+                        if (!plugin.typeExtension.oas2)
+                            continue;
+                        extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
+                        break;
+                    case oas_types_1.SpecVersion.Async2:
+                        if (!plugin.typeExtension.async2)
+                            continue;
+                        extendedTypes = plugin.typeExtension.async2(extendedTypes, version);
+                        break;
+                    case oas_types_1.SpecVersion.Async3:
+                        if (!plugin.typeExtension.async3)
+                            continue;
+                        extendedTypes = plugin.typeExtension.async3(extendedTypes, version);
+                        break;
+                    case oas_types_1.SpecVersion.Arazzo1:
+                        if (!plugin.typeExtension.arazzo1)
+                            continue;
+                        extendedTypes = plugin.typeExtension.arazzo1(extendedTypes, version);
+                        break;
+                    default:
+                        throw new Error('Not implemented');
+                }
+            }
+        }
+        return extendedTypes;
+    }
+    getRuleSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.rules[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings,
+            };
+        }
+        else {
+            return { severity: 'error', ...settings };
+        }
+    }
+    getPreprocessorSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.preprocessors[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings === 'on' ? 'error' : settings,
+            };
+        }
+        else {
+            return { severity: 'error', ...settings };
+        }
+    }
+    getDecoratorSettings(ruleId, oasVersion) {
+        this._usedRules.add(ruleId);
+        this._usedVersions.add(oasVersion);
+        const settings = this.decorators[oasVersion][ruleId] || 'off';
+        if (typeof settings === 'string') {
+            return {
+                severity: settings === 'on' ? 'error' : settings,
+            };
+        }
+        else {
+            return { severity: 'error', ...settings };
+        }
+    }
+    getUnusedRules() {
+        const rules = [];
+        const decorators = [];
+        const preprocessors = [];
+        for (const usedVersion of Array.from(this._usedVersions)) {
+            rules.push(...Object.keys(this.rules[usedVersion]).filter((name) => !this._usedRules.has(name)));
+            decorators.push(...Object.keys(this.decorators[usedVersion]).filter((name) => !this._usedRules.has(name)));
+            preprocessors.push(...Object.keys(this.preprocessors[usedVersion]).filter((name) => !this._usedRules.has(name)));
+        }
+        return {
+            rules,
+            preprocessors,
+            decorators,
+        };
+    }
+    getRulesForSpecVersion(version) {
+        switch (version) {
+            case oas_types_1.SpecMajorVersion.OAS3:
+                // eslint-disable-next-line no-case-declarations
+                const oas3Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
+                this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
+                this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
+                return oas3Rules;
+            case oas_types_1.SpecMajorVersion.OAS2:
+                // eslint-disable-next-line no-case-declarations
+                const oas2Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
+                this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));
+                this.plugins.forEach((p) => p.decorators?.oas2 && oas2Rules.push(p.decorators.oas2));
+                return oas2Rules;
+            case oas_types_1.SpecMajorVersion.Async2:
+                // eslint-disable-next-line no-case-declarations
+                const asyncApi2Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.async2 && asyncApi2Rules.push(p.preprocessors.async2));
+                this.plugins.forEach((p) => p.rules?.async2 && asyncApi2Rules.push(p.rules.async2));
+                this.plugins.forEach((p) => p.decorators?.async2 && asyncApi2Rules.push(p.decorators.async2));
+                return asyncApi2Rules;
+            case oas_types_1.SpecMajorVersion.Async3:
+                // eslint-disable-next-line no-case-declarations
+                const asyncApi3Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.async3 && asyncApi3Rules.push(p.preprocessors.async3));
+                this.plugins.forEach((p) => p.rules?.async3 && asyncApi3Rules.push(p.rules.async3));
+                this.plugins.forEach((p) => p.decorators?.async3 && asyncApi3Rules.push(p.decorators.async3));
+                return asyncApi3Rules;
+            case oas_types_1.SpecMajorVersion.Arazzo1:
+                // eslint-disable-next-line no-case-declarations
+                const arazzo1Rules = [];
+                this.plugins.forEach((p) => p.preprocessors?.arazzo1 && arazzo1Rules.push(p.preprocessors.arazzo1));
+                this.plugins.forEach((p) => p.rules?.arazzo1 && arazzo1Rules.push(p.rules.arazzo1));
+                this.plugins.forEach((p) => p.decorators?.arazzo1 && arazzo1Rules.push(p.decorators.arazzo1));
+                return arazzo1Rules;
+        }
+    }
+    skipRules(rules) {
+        for (const ruleId of rules || []) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
+                if (this.rules[version][ruleId]) {
+                    this.rules[version][ruleId] = 'off';
+                }
+                else if (Array.isArray(this.rules[version].assertions)) {
+                    // skip assertions
+                    for (const configurableRule of this.rules[version].assertions) {
+                        if (configurableRule.assertionId === ruleId) {
+                            configurableRule.severity = 'off';
+                        }
+                    }
+                }
+            }
+        }
+    }
+    skipPreprocessors(preprocessors) {
+        for (const preprocessorId of preprocessors || []) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
+                if (this.preprocessors[version][preprocessorId]) {
+                    this.preprocessors[version][preprocessorId] = 'off';
+                }
+            }
+        }
+    }
+    skipDecorators(decorators) {
+        for (const decoratorId of decorators || []) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
+                if (this.decorators[version][decoratorId]) {
+                    this.decorators[version][decoratorId] = 'off';
+                }
+            }
+        }
+    }
+}
+exports.StyleguideConfig = StyleguideConfig;
+// To support backwards compatibility with the old `spec` key we rename it to `struct`.
+function replaceSpecWithStruct(ruleGroups, config) {
+    for (const ruleGroup of ruleGroups) {
+        if (config[ruleGroup] && (0, utils_1.isPlainObject)(config[ruleGroup]) && 'spec' in config[ruleGroup]) {
+            (0, utils_1.showWarningForDeprecatedField)('spec', 'struct');
+            config[ruleGroup].struct = config[ruleGroup].spec;
+            delete config[ruleGroup].spec;
+        }
+    }
+}
+class Config {
+    constructor(rawConfig, configFile) {
+        this.rawConfig = rawConfig;
+        this.configFile = configFile;
+        this.apis = rawConfig.apis || {};
+        this.styleguide = new StyleguideConfig(rawConfig.styleguide || {}, configFile);
+        this.theme = rawConfig.theme || {};
+        this.resolve = (0, utils_2.getResolveConfig)(rawConfig?.resolve);
+        this.region = rawConfig.region;
+        this.organization = rawConfig.organization;
+        this.files = rawConfig.files || [];
+        this.telemetry = rawConfig.telemetry;
+    }
+}
+exports.Config = Config;

package/lib/config/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './types';
+export * from './rules';
+export * from './builtIn';
+export * from './load';
+export * from './utils';
+export * from './config-resolvers';

package/lib/config/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./builtIn"), exports);
+__exportStar(require("./load"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config-resolvers"), exports);

package/lib/config/load.d.ts

@@ -0,0 +1,38 @@
+import { BaseResolver } from '../resolve';
+import type { Config } from './config';
+import type { Document, ResolvedRefMap } from '../resolve';
+import type { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
+import type { RawConfig, RawUniversalConfig, Region } from './types';
+export type RawConfigProcessor = (params: {
+    document: Document;
+    resolvedRefMap: ResolvedRefMap;
+    config: Config;
+    parsed: Document['parsed'];
+}) => void | Promise<void>;
+export declare function loadConfig(options?: {
+    configPath?: string;
+    customExtends?: string[];
+    processRawConfig?: RawConfigProcessor;
+    externalRefResolver?: BaseResolver;
+    files?: string[];
+    region?: Region;
+}): Promise<Config>;
+export declare const CONFIG_FILE_NAMES: string[];
+export declare function findConfig(dir?: string): string | undefined;
+export declare function getConfig(options?: {
+    configPath?: string;
+    externalRefResolver?: BaseResolver;
+}): Promise<{
+    rawConfig: RawConfig;
+    document?: Document;
+    parsed?: Document['parsed'];
+    resolvedRefMap?: ResolvedRefMap;
+}>;
+type CreateConfigOptions = {
+    extends?: string[];
+    tokens?: RegionalTokenWithValidity[];
+    configPath?: string;
+    externalRefResolver?: BaseResolver;
+};
+export declare function createConfig(config: string | RawUniversalConfig, options?: CreateConfigOptions): Promise<Config>;
+export {};

package/lib/config/load.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILE_NAMES = void 0;
+exports.loadConfig = loadConfig;
+exports.findConfig = findConfig;
+exports.getConfig = getConfig;
+exports.createConfig = createConfig;
+const fs = require("fs");
+const path = require("path");
+const redocly_1 = require("../redocly");
+const utils_1 = require("../utils");
+const js_yaml_1 = require("../js-yaml");
+const utils_2 = require("./utils");
+const config_resolvers_1 = require("./config-resolvers");
+const bundle_1 = require("../bundle");
+const resolve_1 = require("../resolve");
+const env_1 = require("../env");
+const domains_1 = require("../redocly/domains");
+async function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, files, region, externalRefResolver, }) {
+    if (customExtends !== undefined) {
+        rawConfig.styleguide = rawConfig.styleguide || {};
+        rawConfig.styleguide.extends = customExtends;
+    }
+    else if ((0, utils_1.isEmptyObject)(rawConfig)) {
+        rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
+    }
+    if (tokens?.length) {
+        if (!rawConfig.resolve)
+            rawConfig.resolve = {};
+        if (!rawConfig.resolve.http)
+            rawConfig.resolve.http = {};
+        rawConfig.resolve.http.headers = [...(rawConfig.resolve.http.headers ?? [])];
+        for (const item of tokens) {
+            const domain = domains_1.DOMAINS[item.region];
+            rawConfig.resolve.http.headers.push({
+                matches: `https://api.${domain}/registry/**`,
+                name: 'Authorization',
+                envVariable: undefined,
+                value: item.token,
+            }, 
+            //support redocly.com domain for future compatibility
+            ...(item.region === 'us'
+                ? [
+                    {
+                        matches: `https://api.redoc.ly/registry/**`,
+                        name: 'Authorization',
+                        envVariable: undefined,
+                        value: item.token,
+                    },
+                ]
+                : []));
+        }
+    }
+    return (0, config_resolvers_1.resolveConfig)({
+        rawConfig: {
+            ...rawConfig,
+            files: files ?? rawConfig.files,
+            region: region ?? rawConfig.region,
+        },
+        configPath,
+        externalRefResolver,
+    });
+}
+async function loadConfig(options = {}) {
+    const { configPath = findConfig(), customExtends, processRawConfig, files, region, externalRefResolver, } = options;
+    const { rawConfig, document, parsed, resolvedRefMap } = await getConfig({
+        configPath,
+        externalRefResolver,
+    });
+    const redoclyClient = env_1.isBrowser ? undefined : new redocly_1.RedoclyClient();
+    const tokens = redoclyClient && redoclyClient.hasTokens() ? redoclyClient.getAllTokens() : [];
+    const config = await addConfigMetadata({
+        rawConfig,
+        customExtends,
+        configPath,
+        tokens,
+        files,
+        region,
+        externalRefResolver,
+    });
+    if (document && parsed && resolvedRefMap && typeof processRawConfig === 'function') {
+        try {
+            await processRawConfig({
+                document,
+                resolvedRefMap,
+                config,
+                parsed,
+            });
+        }
+        catch (e) {
+            if (e instanceof utils_2.ConfigValidationError) {
+                throw e;
+            }
+            throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+        }
+    }
+    return config;
+}
+exports.CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
+function findConfig(dir) {
+    if (!fs?.hasOwnProperty?.('existsSync'))
+        return;
+    const existingConfigFiles = exports.CONFIG_FILE_NAMES.map((name) => dir ? path.resolve(dir, name) : name).filter(fs.existsSync);
+    if (existingConfigFiles.length > 1) {
+        throw new Error(`
+      Multiple configuration files are not allowed.
+      Found the following files: ${existingConfigFiles.join(', ')}.
+      Please use 'redocly.yaml' instead.
+    `);
+    }
+    return existingConfigFiles[0];
+}
+async function getConfig(options = {}) {
+    const { configPath = findConfig(), externalRefResolver = new resolve_1.BaseResolver() } = options;
+    if (!configPath)
+        return { rawConfig: {} };
+    try {
+        const { document, resolvedRefMap } = await (0, config_resolvers_1.resolveConfigFileAndRefs)({
+            configPath,
+            externalRefResolver,
+        });
+        const bundledRefMap = (0, utils_2.deepCloneMapWithJSON)(resolvedRefMap);
+        const parsed = await (0, bundle_1.bundleConfig)(JSON.parse(JSON.stringify(document)), bundledRefMap);
+        return {
+            rawConfig: (0, utils_2.transformConfig)(parsed),
+            document,
+            parsed,
+            resolvedRefMap,
+        };
+    }
+    catch (e) {
+        throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+    }
+}
+async function createConfig(config, options) {
+    return addConfigMetadata({
+        rawConfig: (0, utils_2.transformConfig)(typeof config === 'string' ? (0, js_yaml_1.parseYaml)(config) : config),
+        ...options,
+    });
+}

package/lib/config/minimal.d.ts

@@ -0,0 +1,3 @@
+import type { PluginStyleguideConfig } from './types';
+declare const minimal: PluginStyleguideConfig<'built-in'>;
+export default minimal;