@redocly/openapi-core 1.0.0-beta.92 → 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/types/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNamedType = exports.normalizeTypes = exports.mapOf = exports.listOf = void 0;
 function listOf(typeName) {
     return {
-        name: typeName + '_List',
+        name: `${typeName}List`,
         properties: {},
         items: typeName,
     };
@@ -11,7 +11,7 @@ function listOf(typeName) {
 exports.listOf = listOf;
 function mapOf(typeName) {
     return {
-        name: typeName + '_Map',
+        name: `${typeName}Map`,
         properties: {},
         additionalProperties: () => typeName,
     };

package/lib/types/oas3_1.js

@@ -17,7 +17,7 @@ const DefinitionRoot = {
         jsonSchemaDialect: { type: 'string' },
     },
     required: ['openapi', 'info'],
-    requiredOneOf: ['paths', 'components', 'webhooks']
+    requiredOneOf: ['paths', 'components', 'webhooks'],
 };
 const License = {
     properties: {
@@ -103,7 +103,10 @@ const Schema = {
         enum: { type: 'array' },
         type: (value) => {
             if (Array.isArray(value)) {
-                return { type: 'array', items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] } };
+                return {
+                    type: 'array',
+                    items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+                };
             }
             else {
                 return {
@@ -124,7 +127,14 @@ const Schema = {
         patternProperties: { type: 'object' },
         propertyNames: 'Schema',
         unevaluatedItems: 'Schema',
-        unevaluatedProperties: 'Schema',
+        unevaluatedProperties: (value) => {
+            if (typeof value === 'boolean') {
+                return { type: 'boolean' };
+            }
+            else {
+                return 'Schema';
+            }
+        },
         summary: { type: 'string' },
         properties: 'SchemaProperties',
         items: (value) => {
@@ -195,9 +205,25 @@ const SecurityScheme = {
                     case 'clientCredentials':
                         return ['type', 'flows', 'tokenUrl', 'refreshUrl', 'description', 'scopes'];
                     case 'authorizationCode':
-                        return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
                     default:
-                        return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
                 }
             case 'openIdConnect':
                 return ['type', 'openIdConnectUrl', 'description'];

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;