@redocly/openapi-core 1.0.0-beta.94 → 1.0.0-beta.95

package/lib/config/types.d.ts

@@ -0,0 +1,113 @@
+import type { ProblemSeverity } from '../walk';
+import type { Oas3PreprocessorsSet, OasMajorVersion, Oas3DecoratorsSet, Oas2RuleSet, Oas2PreprocessorsSet, Oas2DecoratorsSet, Oas3RuleSet, OasVersion } from '../oas-types';
+import type { NodeType } from '../types';
+export declare type RuleConfig = ProblemSeverity | 'off' | ({
+    severity?: ProblemSeverity;
+} & Record<string, any>);
+export declare type PreprocessorConfig = ProblemSeverity | 'off' | 'on' | ({
+    severity?: ProblemSeverity;
+} & Record<string, any>);
+export declare type DecoratorConfig = PreprocessorConfig;
+export declare type LintRawConfig = {
+    plugins?: (string | Plugin)[];
+    extends?: string[];
+    doNotResolveExamples?: boolean;
+    recommendedFallback?: boolean;
+    rules?: Record<string, RuleConfig>;
+    oas2Rules?: Record<string, RuleConfig>;
+    oas3_0Rules?: Record<string, RuleConfig>;
+    oas3_1Rules?: Record<string, RuleConfig>;
+    preprocessors?: Record<string, PreprocessorConfig>;
+    oas2Preprocessors?: Record<string, PreprocessorConfig>;
+    oas3_0Preprocessors?: Record<string, PreprocessorConfig>;
+    oas3_1Preprocessors?: Record<string, PreprocessorConfig>;
+    decorators?: Record<string, DecoratorConfig>;
+    oas2Decorators?: Record<string, DecoratorConfig>;
+    oas3_0Decorators?: Record<string, DecoratorConfig>;
+    oas3_1Decorators?: Record<string, DecoratorConfig>;
+};
+export declare type ResolvedLintConfig = PluginLintConfig & {
+    plugins?: Plugin[];
+    recommendedFallback?: boolean;
+    extends?: void | never;
+    extendPaths?: string[];
+    pluginPaths?: string[];
+};
+export declare type PreprocessorsConfig = {
+    oas3?: Oas3PreprocessorsSet;
+    oas2?: Oas2PreprocessorsSet;
+};
+export declare type DecoratorsConfig = {
+    oas3?: Oas3DecoratorsSet;
+    oas2?: Oas2DecoratorsSet;
+};
+export declare type TypesExtensionFn = (types: Record<string, NodeType>, oasVersion: OasVersion) => Record<string, NodeType>;
+export declare type TypeExtensionsConfig = Partial<Record<OasMajorVersion, TypesExtensionFn>>;
+export declare type CustomRulesConfig = {
+    oas3?: Oas3RuleSet;
+    oas2?: Oas2RuleSet;
+};
+export declare type Plugin = {
+    id: string;
+    configs?: Record<string, PluginLintConfig>;
+    rules?: CustomRulesConfig;
+    preprocessors?: PreprocessorsConfig;
+    decorators?: DecoratorsConfig;
+    typeExtension?: TypeExtensionsConfig;
+};
+export declare type PluginLintConfig = Omit<LintRawConfig, 'plugins' | 'extends'>;
+export declare type ResolveHeader = {
+    name: string;
+    envVariable?: undefined;
+    value: string;
+    matches: string;
+} | {
+    name: string;
+    value?: undefined;
+    envVariable: string;
+    matches: string;
+};
+export declare type RawResolveConfig = {
+    http?: Partial<HttpResolveConfig>;
+};
+export declare type HttpResolveConfig = {
+    headers: ResolveHeader[];
+    customFetch?: Function;
+};
+export declare type ResolveConfig = {
+    http: HttpResolveConfig;
+};
+export declare type Region = 'us' | 'eu';
+export declare type AccessTokens = {
+    [region in Region]?: string;
+};
+export declare type DeprecatedRawConfig = {
+    apiDefinitions?: Record<string, string>;
+    lint?: LintRawConfig;
+    resolve?: RawResolveConfig;
+    region?: Region;
+    referenceDocs?: Record<string, any>;
+};
+export declare type Api = {
+    root: string;
+    lint?: Omit<LintRawConfig, 'plugins'>;
+    'features.openapi'?: Record<string, any>;
+    'features.mockServer'?: Record<string, any>;
+};
+export declare type ResolvedApi = Omit<Api, 'lint'> & {
+    lint: Omit<ResolvedLintConfig, 'plugins'>;
+};
+export declare type RawConfig = {
+    apis?: Record<string, Api>;
+    lint?: LintRawConfig;
+    resolve?: RawResolveConfig;
+    region?: Region;
+    'features.openapi'?: Record<string, any>;
+    'features.mockServer'?: Record<string, any>;
+    organization?: string;
+};
+export declare type ResolvedConfig = Omit<RawConfig, 'lint' | 'apis'> & {
+    lint: ResolvedLintConfig;
+    apis: Record<string, ResolvedApi>;
+};
+export declare type RulesFields = 'rules' | 'oas2Rules' | 'oas3_0Rules' | 'oas3_1Rules' | 'preprocessors' | 'oas2Preprocessors' | 'oas3_0Preprocessors' | 'oas3_1Preprocessors' | 'decorators' | 'oas2Decorators' | 'oas3_0Decorators' | 'oas3_1Decorators';

package/lib/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/utils.d.ts

@@ -0,0 +1,13 @@
+import { Config } from './config';
+import type { Api, DeprecatedRawConfig, Plugin, RawConfig, RawResolveConfig, ResolveConfig, ResolvedLintConfig, RulesFields } from './types';
+export declare function parsePresetName(presetName: string): {
+    pluginId: string;
+    configName: string;
+};
+export declare function transformApiDefinitionsToApis(apiDefinitions?: Record<string, string>): Record<string, Api>;
+export declare function prefixRules<T extends Record<string, any>>(rules: T, prefix: string): any;
+export declare function mergeExtends(rulesConfList: ResolvedLintConfig[]): Omit<ResolvedLintConfig, RulesFields> & Required<Pick<ResolvedLintConfig, RulesFields>>;
+export declare function getMergedConfig(config: Config, entrypointAlias?: string): Config;
+export declare function transformConfig(rawConfig: DeprecatedRawConfig | RawConfig): RawConfig;
+export declare function getResolveConfig(resolve?: RawResolveConfig): ResolveConfig;
+export declare function getUniquePlugins(plugins: Plugin[]): Plugin[];

package/lib/config/utils.js

@@ -0,0 +1,160 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniquePlugins = exports.getResolveConfig = exports.transformConfig = exports.getMergedConfig = exports.mergeExtends = exports.prefixRules = exports.transformApiDefinitionsToApis = exports.parsePresetName = void 0;
+const colorette_1 = require("colorette");
+const utils_1 = require("../utils");
+const config_1 = require("./config");
+function parsePresetName(presetName) {
+    if (presetName.indexOf('/') > -1) {
+        const [pluginId, configName] = presetName.split('/');
+        return { pluginId, configName };
+    }
+    else {
+        return { pluginId: '', configName: presetName };
+    }
+}
+exports.parsePresetName = parsePresetName;
+function transformApiDefinitionsToApis(apiDefinitions = {}) {
+    let apis = {};
+    for (const [apiName, apiPath] of Object.entries(apiDefinitions)) {
+        apis[apiName] = { root: apiPath };
+    }
+    return apis;
+}
+exports.transformApiDefinitionsToApis = transformApiDefinitionsToApis;
+function prefixRules(rules, prefix) {
+    if (!prefix)
+        return rules;
+    const res = {};
+    for (const name of Object.keys(rules)) {
+        res[`${prefix}/${name}`] = rules[name];
+    }
+    return res;
+}
+exports.prefixRules = prefixRules;
+function mergeExtends(rulesConfList) {
+    const result = {
+        rules: {},
+        oas2Rules: {},
+        oas3_0Rules: {},
+        oas3_1Rules: {},
+        preprocessors: {},
+        oas2Preprocessors: {},
+        oas3_0Preprocessors: {},
+        oas3_1Preprocessors: {},
+        decorators: {},
+        oas2Decorators: {},
+        oas3_0Decorators: {},
+        oas3_1Decorators: {},
+        plugins: [],
+        pluginPaths: [],
+        extendPaths: [],
+    };
+    for (let rulesConf of rulesConfList) {
+        if (rulesConf.extends) {
+            throw new Error(`\`extends\` is not supported in shared configs yet: ${JSON.stringify(rulesConf, null, 2)}.`);
+        }
+        Object.assign(result.rules, rulesConf.rules);
+        Object.assign(result.oas2Rules, rulesConf.oas2Rules);
+        utils_1.assignExisting(result.oas2Rules, rulesConf.rules || {});
+        Object.assign(result.oas3_0Rules, rulesConf.oas3_0Rules);
+        utils_1.assignExisting(result.oas3_0Rules, rulesConf.rules || {});
+        Object.assign(result.oas3_1Rules, rulesConf.oas3_1Rules);
+        utils_1.assignExisting(result.oas3_1Rules, rulesConf.rules || {});
+        Object.assign(result.preprocessors, rulesConf.preprocessors);
+        Object.assign(result.oas2Preprocessors, rulesConf.oas2Preprocessors);
+        utils_1.assignExisting(result.oas2Preprocessors, rulesConf.preprocessors || {});
+        Object.assign(result.oas3_0Preprocessors, rulesConf.oas3_0Preprocessors);
+        utils_1.assignExisting(result.oas3_0Preprocessors, rulesConf.preprocessors || {});
+        Object.assign(result.oas3_1Preprocessors, rulesConf.oas3_1Preprocessors);
+        utils_1.assignExisting(result.oas3_1Preprocessors, rulesConf.preprocessors || {});
+        Object.assign(result.decorators, rulesConf.decorators);
+        Object.assign(result.oas2Decorators, rulesConf.oas2Decorators);
+        utils_1.assignExisting(result.oas2Decorators, rulesConf.decorators || {});
+        Object.assign(result.oas3_0Decorators, rulesConf.oas3_0Decorators);
+        utils_1.assignExisting(result.oas3_0Decorators, rulesConf.decorators || {});
+        Object.assign(result.oas3_1Decorators, rulesConf.oas3_1Decorators);
+        utils_1.assignExisting(result.oas3_1Decorators, rulesConf.decorators || {});
+        result.plugins.push(...(rulesConf.plugins || []));
+        result.pluginPaths.push(...(rulesConf.pluginPaths || []));
+        result.extendPaths.push(...new Set(rulesConf.extendPaths));
+    }
+    return result;
+}
+exports.mergeExtends = mergeExtends;
+function getMergedConfig(config, entrypointAlias) {
+    var _a, _b, _c, _d, _e, _f;
+    const extendPaths = [
+        ...Object.values(config.apis).map((api) => { var _a; return (_a = api === null || api === void 0 ? void 0 : api.lint) === null || _a === void 0 ? void 0 : _a.extendPaths; }),
+        (_b = (_a = config.rawConfig) === null || _a === void 0 ? void 0 : _a.lint) === null || _b === void 0 ? void 0 : _b.extendPaths,
+    ]
+        .flat()
+        .filter(Boolean);
+    const pluginPaths = [
+        ...Object.values(config.apis).map((api) => { var _a; return (_a = api === null || api === void 0 ? void 0 : api.lint) === null || _a === void 0 ? void 0 : _a.pluginPaths; }),
+        (_d = (_c = config.rawConfig) === null || _c === void 0 ? void 0 : _c.lint) === null || _d === void 0 ? void 0 : _d.pluginPaths,
+    ]
+        .flat()
+        .filter(Boolean);
+    return entrypointAlias
+        ? new config_1.Config(Object.assign(Object.assign({}, config.rawConfig), { lint: Object.assign(Object.assign({}, (config.apis[entrypointAlias]
+                ? config.apis[entrypointAlias].lint
+                : config.rawConfig.lint)), { extendPaths,
+                pluginPaths }), 'features.openapi': Object.assign(Object.assign({}, config['features.openapi']), (_e = config.apis[entrypointAlias]) === null || _e === void 0 ? void 0 : _e['features.openapi']), 'features.mockServer': Object.assign(Object.assign({}, config['features.mockServer']), (_f = config.apis[entrypointAlias]) === null || _f === void 0 ? void 0 : _f['features.mockServer']) }), config.configFile)
+        : config;
+}
+exports.getMergedConfig = getMergedConfig;
+function transformConfig(rawConfig) {
+    if (rawConfig.apis && rawConfig.apiDefinitions) {
+        throw new Error("Do not use 'apiDefinitions' field. Use 'apis' instead.\n");
+    }
+    if (rawConfig['features.openapi'] &&
+        rawConfig.referenceDocs) {
+        throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
+    }
+    const _a = rawConfig, { apiDefinitions, referenceDocs } = _a, rest = __rest(_a, ["apiDefinitions", "referenceDocs"]);
+    if (apiDefinitions) {
+        process.stderr.write(`The ${colorette_1.yellow('apiDefinitions')} field is deprecated. Use ${colorette_1.green('apis')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
+    if (referenceDocs) {
+        process.stderr.write(`The ${colorette_1.yellow('referenceDocs')} field is deprecated. Use ${colorette_1.green('features.openapi')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
+    return Object.assign({ 'features.openapi': referenceDocs, apis: transformApiDefinitionsToApis(apiDefinitions) }, rest);
+}
+exports.transformConfig = transformConfig;
+function getResolveConfig(resolve) {
+    var _a, _b;
+    return {
+        http: {
+            headers: (_b = (_a = resolve === null || resolve === void 0 ? void 0 : resolve.http) === null || _a === void 0 ? void 0 : _a.headers) !== null && _b !== void 0 ? _b : [],
+            customFetch: undefined,
+        },
+    };
+}
+exports.getResolveConfig = getResolveConfig;
+function getUniquePlugins(plugins) {
+    const seen = new Set();
+    const results = [];
+    for (const p of plugins) {
+        if (!seen.has(p.id)) {
+            results.push(p);
+            seen.add(p.id);
+        }
+        else if (p.id) {
+            process.stderr.write(`Duplicate plugin id "${colorette_1.yellow(p.id)}".\n`);
+        }
+    }
+    return results;
+}
+exports.getUniquePlugins = getUniquePlugins;

package/lib/format/format.d.ts

@@ -4,7 +4,7 @@ export declare type Totals = {
     warnings: number;
     ignored: number;
 };
-export declare type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle';
+export declare type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate';
 export declare function getTotals(problems: (NormalizedProblem & {
     ignored?: boolean;
 })[]): Totals;

package/lib/format/format.js

@@ -20,6 +20,10 @@ const SEVERITY_NAMES = {
     warn: 'Warning',
     error: 'Error',
 };
+const CODECLIMATE_SEVERITY_MAPPING = {
+    error: 'critical',
+    warn: 'minor',
+};
 const MAX_SUGGEST = 5;
 function severityToNumber(severity) {
     return severity === 'error' ? 1 : 2;
@@ -90,10 +94,31 @@ function formatProblems(problems, opts) {
             process.stdout.write(`</checkstyle>\n`);
             break;
         }
+        case 'codeclimate':
+            outputForCodeClimate();
+            break;
     }
     if (totalProblems - ignoredProblems > maxProblems) {
         process.stderr.write(`< ... ${totalProblems - maxProblems} more problems hidden > ${colorette_1.gray('increase with `--max-problems N`')}\n`);
     }
+    function outputForCodeClimate() {
+        const issues = problems.map((p) => {
+            const location = p.location[0]; // TODO: support multiple location
+            const lineCol = codeframes_1.getLineColLocation(location);
+            return {
+                description: p.message,
+                location: {
+                    path: path.relative(cwd, location.source.absoluteRef),
+                    lines: {
+                        begin: lineCol.start.line,
+                    },
+                },
+                severity: CODECLIMATE_SEVERITY_MAPPING[p.severity],
+                fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
+            };
+        });
+        process.stdout.write(JSON.stringify(issues, null, 2));
+    }
     function outputJSON() {
         const resultObject = {
             totals,
@@ -140,6 +165,9 @@ function formatProblems(problems, opts) {
     }
     function formatStylish(problem, locationPad, ruleIdPad) {
         const color = COLORS[problem.severity];
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: \`warn,error,off\`';
+        }
         const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
         const { start } = problem.location[0];
         return `  ${`${start.line}:${start.col}`.padEnd(locationPad)}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;

package/lib/index.d.ts

@@ -8,8 +8,7 @@ export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
-export { Config, LintConfig, RawConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, } from './config/config';
-export { loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES, } from './config';
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
 export { parseYaml, stringifyYaml } from './js-yaml';

package/lib/index.js

@@ -16,17 +16,16 @@ var types_1 = require("./types");
 Object.defineProperty(exports, "normalizeTypes", { enumerable: true, get: function () { return types_1.normalizeTypes; } });
 var stats_1 = require("./rules/other/stats");
 Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return stats_1.Stats; } });
-var config_1 = require("./config/config");
+var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
 Object.defineProperty(exports, "LintConfig", { enumerable: true, get: function () { return config_1.LintConfig; } });
 Object.defineProperty(exports, "IGNORE_FILE", { enumerable: true, get: function () { return config_1.IGNORE_FILE; } });
 Object.defineProperty(exports, "getMergedConfig", { enumerable: true, get: function () { return config_1.getMergedConfig; } });
 Object.defineProperty(exports, "transformConfig", { enumerable: true, get: function () { return config_1.transformConfig; } });
-var load_1 = require("./config/load");
-Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_1.loadConfig; } });
-Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return load_1.getConfig; } });
-Object.defineProperty(exports, "findConfig", { enumerable: true, get: function () { return load_1.findConfig; } });
-Object.defineProperty(exports, "CONFIG_FILE_NAMES", { enumerable: true, get: function () { return load_1.CONFIG_FILE_NAMES; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+Object.defineProperty(exports, "findConfig", { enumerable: true, get: function () { return config_1.findConfig; } });
+Object.defineProperty(exports, "CONFIG_FILE_NAMES", { enumerable: true, get: function () { return config_1.CONFIG_FILE_NAMES; } });
 var redocly_1 = require("./redocly");
 Object.defineProperty(exports, "RedoclyClient", { enumerable: true, get: function () { return redocly_1.RedoclyClient; } });
 Object.defineProperty(exports, "isRedoclyRegistryURL", { enumerable: true, get: function () { return redocly_1.isRedoclyRegistryURL; } });

package/lib/lint.d.ts

@@ -1,6 +1,6 @@
 import { BaseResolver, Document } from './resolve';
 import { NodeType } from './types';
-import { LintConfig, Config } from './config/config';
+import { LintConfig, Config } from './config';
 export declare function lint(opts: {
     ref: string;
     config: Config;

package/lib/lint.js

@@ -16,14 +16,12 @@ const oas3_1_1 = require("./types/oas3_1");
 const oas3_1 = require("./types/oas3");
 const oas2_1 = require("./types/oas2");
 const walk_1 = require("./walk");
-const config_1 = require("./config/config");
+const config_1 = require("./config");
 const types_1 = require("./types");
-const rules_1 = require("./config/rules");
 const ajv_1 = require("./rules/ajv");
 const oas_types_1 = require("./oas-types");
 const redocly_yaml_1 = require("./types/redocly-yaml");
 const spec_1 = require("./rules/common/spec");
-const builtIn_1 = require("./config/builtIn");
 function lint(opts) {
     return __awaiter(this, void 0, void 0, function* () {
         const { ref, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
@@ -53,8 +51,8 @@ function lintDocument(opts) {
             oasVersion: oasVersion,
             visitorsData: {},
         };
-        const preprocessors = rules_1.initRules(rules, config, 'preprocessors', oasVersion);
-        const regularRules = rules_1.initRules(rules, config, 'rules', oasVersion);
+        const preprocessors = config_1.initRules(rules, config, 'preprocessors', oasVersion);
+        const regularRules = config_1.initRules(rules, config, 'rules', oasVersion);
         const normalizedVisitors = visitors_1.normalizeVisitors([...preprocessors, ...regularRules], types);
         const resolvedRefMap = yield resolve_1.resolveDocument({
             rootDocument: document,
@@ -80,9 +78,9 @@ function lintConfig(opts) {
             oasVersion: oas_types_1.OasVersion.Version3_0,
             visitorsData: {},
         };
+        const plugins = config_1.resolvePlugins([config_1.defaultPlugin]);
         const config = new config_1.LintConfig({
-            plugins: [builtIn_1.defaultPlugin],
-            extends: [],
+            plugins,
             rules: { spec: 'error' },
         });
         const types = types_1.normalizeTypes(redocly_yaml_1.ConfigTypes, config);

package/lib/redocly/index.d.ts

@@ -1,6 +1,6 @@
 import { RegistryApi } from './registry-api';
-import { AccessTokens, Region } from '../config/config';
 import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
+import type { AccessTokens, Region } from '../config/types';
 export declare class RedoclyClient {
     private accessTokens;
     private region;

package/lib/redocly/redocly-client-types.d.ts

@@ -1,4 +1,4 @@
-import { Region } from '../config/config';
+import type { Region } from '../config/types';
 export interface RegionalToken {
     region: Region;
     token: string;

package/lib/redocly/registry-api.d.ts

@@ -1,5 +1,5 @@
 import { RegistryApiTypes } from './registry-api-types';
-import { AccessTokens, Region } from '../config/config';
+import type { AccessTokens, Region } from '../config/types';
 export declare class RegistryApi {
     private accessTokens;
     private region;

package/lib/resolve.d.ts

@@ -1,6 +1,6 @@
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType } from './types';
-import { ResolveConfig } from './config/config';
+import { ResolveConfig } from './config/types';
 export declare type CollectedRefs = Map<string, Document>;
 export declare class Source {
     absoluteRef: string;

package/lib/resolve.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveDocument = exports.BaseResolver = exports.makeDocumentFromString = exports.makeRefId = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
 const fs = require("fs");
 const path = require("path");
-const url = require("url");
 const ref_utils_1 = require("./ref-utils");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
@@ -99,7 +98,7 @@ class BaseResolver {
             return ref;
         }
         if (base && ref_utils_1.isAbsoluteUrl(base)) {
-            return url.resolve(base, ref);
+            return new URL(ref, base).href;
         }
         return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
     }

package/lib/rules/common/assertions/utils.d.ts

@@ -15,6 +15,6 @@ export declare type AssertToApply = {
     runsOnValues: boolean;
 };
 export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
-export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type }: UserContext) => void;
+export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type, resolve }: UserContext) => void;
 export declare function getIntersectionLength(keys: string[], properties: string[]): number;
 export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;

package/lib/rules/common/assertions/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+const ref_utils_1 = require("../../../ref-utils");
 const asserts_1 = require("./asserts");
 function buildVisitorObject(subject, context, subjectVisitor) {
     if (!context) {
@@ -44,7 +45,8 @@ function buildVisitorObject(subject, context, subjectVisitor) {
 }
 exports.buildVisitorObject = buildVisitorObject;
 function buildSubjectVisitor(properties, asserts, context) {
-    return function (node, { report, location, key, type }) {
+    return function (node, { report, location, key, type, resolve }) {
+        var _a;
         // We need to check context's last node if it has the same type as subject node;
         // if yes - that means we didn't create context's last node visitor,
         // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
@@ -67,7 +69,9 @@ function buildSubjectVisitor(properties, asserts, context) {
         for (const assert of asserts) {
             if (properties) {
                 for (const property of properties) {
-                    runAssertion(node[property], assert, location.child(property), report);
+                    // we can have resolvable scalar so need to resolve value here.
+                    const value = ref_utils_1.isRef(node[property]) ? (_a = resolve(node[property])) === null || _a === void 0 ? void 0 : _a.node : node[property];
+                    runAssertion(value, assert, location.child(property), report);
                 }
             }
             else {

package/lib/utils.d.ts

@@ -1,5 +1,5 @@
-import { HttpResolveConfig } from './config/config';
 import { UserContext } from './walk';
+import type { HttpResolveConfig } from './config';
 export { parseYaml, stringifyYaml } from './js-yaml';
 export declare type StackFrame<T> = {
     prev: StackFrame<T> | null;
@@ -36,3 +36,6 @@ export declare function isPathParameter(pathSegment: string): boolean;
  */
 export declare function slash(path: string): string;
 export declare function isNotEmptyObject(obj: any): boolean;
+export declare function isString(value: unknown): value is string;
+export declare function isNotString<T>(value: string | T): value is T;
+export declare function assignExisting<T>(target: Record<string, T>, obj: Record<string, T>): void;

package/lib/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.assignExisting = exports.isNotString = exports.isString = exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
@@ -156,3 +156,20 @@ function isNotEmptyObject(obj) {
     return !!obj && Object.keys(obj).length > 0;
 }
 exports.isNotEmptyObject = isNotEmptyObject;
+// TODO: use it everywhere
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+function isNotString(value) {
+    return !isString(value);
+}
+exports.isNotString = isNotString;
+function assignExisting(target, obj) {
+    for (let k of Object.keys(obj)) {
+        if (target.hasOwnProperty(k)) {
+            target[k] = obj[k];
+        }
+    }
+}
+exports.assignExisting = assignExisting;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.94",
+  "version": "1.0.0-beta.95",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -13,7 +13,10 @@
     "url": "https://github.com/Redocly/openapi-cli.git"
   },
   "browser": {
-    "fs": false
+    "fs": false,
+    "path": "path-browserify",
+    "os": false,
+    "node-fetch": false
   },
   "homepage": "https://github.com/Redocly/openapi-cli",
   "keywords": [

package/src/__tests__/lint.test.ts

@@ -174,7 +174,7 @@ describe('lint', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({ spec: 'error' }),
+      config: await makeConfig({ spec: 'error' }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);

package/src/benchmark/benches/recommended-oas3.bench.ts

@@ -1,10 +1,9 @@
 import { readFileSync } from 'fs';
 import { join as pathJoin, resolve as pathResolve } from 'path';
 import { lintDocument } from '../../lint';
-import { LintConfig } from '../../config/config';
+import { LintConfig, defaultPlugin, resolvePreset } from '../../config';
 import { BaseResolver } from '../../resolve';
 import { parseYamlToDocument } from '../utils';
-import { defaultPlugin } from '../../config/builtIn';
 
 export const name = 'Validate with recommended rules';
 export const count = 10;
@@ -18,6 +17,6 @@ export function measureAsync() {
   return lintDocument({
     externalRefResolver: new BaseResolver(),
     document: rebillyDocument,
-    config: new LintConfig({ plugins: [defaultPlugin] }),
+    config: new LintConfig(resolvePreset('recommended', [defaultPlugin])),
   });
 }