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

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

@@ -5,6 +5,7 @@ const path = require("path");
 const colorette_1 = require("colorette");
 const coreVersion = require('../../package.json').version;
 const codeframes_1 = require("./codeframes");
+const config_1 = require("../config");
 const ERROR_MESSAGE = {
     INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
 };
@@ -20,6 +21,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 +95,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,
@@ -106,7 +132,7 @@ function formatProblems(problems, opts) {
                         ? Object.assign(Object.assign({}, p.from), { source: {
                                 ref: path.relative(cwd, ((_a = p.from) === null || _a === void 0 ? void 0 : _a.source.absoluteRef) || cwd),
                             } }) : undefined });
-                if (process.env.FORMAT_JSON_WITH_CODEFRAMES) {
+                if (config_1.env.FORMAT_JSON_WITH_CODEFRAMES) {
                     const location = p.location[0]; // TODO: support multiple locations
                     const loc = codeframes_1.getLineColLocation(location);
                     problem.codeframe = codeframes_1.getCodeframe(loc, color);
@@ -140,6 +166,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/index.js

@@ -18,27 +18,21 @@ const registry_api_1 = require("./registry-api");
 const config_1 = require("../config/config");
 const utils_1 = require("../utils");
 const TOKEN_FILENAME = '.redocly-config.json';
-let REDOCLY_DOMAIN; // workaround for the isRedoclyRegistryURL, see more below
 class RedoclyClient {
     constructor(region) {
         this.accessTokens = {};
         this.region = this.loadRegion(region);
         this.loadTokens();
-        this.domain = region ? config_1.DOMAINS[region] : process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
-        /*
-         * We can't use process.env here because it is replaced by a const in some client-side bundles,
-         * which breaks assignment.
-         */
-        REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+        this.domain = region ? config_1.DOMAINS[region] : config_1.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+        config_1.env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
         this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
     }
     loadRegion(region) {
         if (region && !config_1.DOMAINS[region]) {
-            process.stdout.write(colorette_1.red(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".\n`));
-            process.exit(1);
+            throw new Error(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".`);
         }
-        if (process.env.REDOCLY_DOMAIN) {
-            return (config_1.AVAILABLE_REGIONS.find((region) => config_1.DOMAINS[region] === process.env.REDOCLY_DOMAIN) || config_1.DEFAULT_REGION);
+        if (config_1.env.REDOCLY_DOMAIN) {
+            return (config_1.AVAILABLE_REGIONS.find((region) => config_1.DOMAINS[region] === config_1.env.REDOCLY_DOMAIN) || config_1.DEFAULT_REGION);
         }
         return region || config_1.DEFAULT_REGION;
     }
@@ -54,13 +48,7 @@ class RedoclyClient {
     }
     getAuthorizationHeader() {
         return __awaiter(this, void 0, void 0, function* () {
-            const token = this.accessTokens[this.region];
-            // print this only if there is token but invalid
-            if (token && !this.isAuthorizedWithRedoclyByRegion()) {
-                process.stderr.write(`${colorette_1.yellow('Warning:')} invalid Redocly API key. Use "npx @redocly/openapi-cli login" to provide your API key\n`);
-                return undefined;
-            }
-            return token;
+            return this.accessTokens[this.region];
         });
     }
     // </backward compatibility: portal>
@@ -76,8 +64,8 @@ class RedoclyClient {
                 [this.region]: credentials.token,
             })));
         }
-        if (process.env.REDOCLY_AUTHORIZATION) {
-            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: process.env.REDOCLY_AUTHORIZATION }));
+        if (config_1.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: config_1.env.REDOCLY_AUTHORIZATION }));
         }
     }
     getAllTokens() {
@@ -133,19 +121,16 @@ class RedoclyClient {
     login(accessToken, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
-            process.stdout.write(colorette_1.gray('\n  Logging in...\n'));
             try {
                 yield this.verifyToken(accessToken, this.region, verbose);
             }
             catch (err) {
-                process.stdout.write(colorette_1.red('Authorization failed. Please check if you entered a valid API key.\n'));
-                process.exit(1);
+                throw new Error('Authorization failed. Please check if you entered a valid API key.');
             }
             const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken, token: accessToken });
             this.accessTokens = credentials;
             this.registryApi.setAccessTokens(credentials);
             fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
-            process.stdout.write(colorette_1.green('  Authorization confirmed. ✅\n\n'));
         });
     }
     logout() {
@@ -153,12 +138,11 @@ class RedoclyClient {
         if (fs_1.existsSync(credentialsPath)) {
             fs_1.unlinkSync(credentialsPath);
         }
-        process.stdout.write('Logged out from the Redocly account. ✋\n');
     }
 }
 exports.RedoclyClient = RedoclyClient;
 function isRedoclyRegistryURL(link) {
-    const domain = REDOCLY_DOMAIN || process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+    const domain = config_1.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
     const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
     if (!link.startsWith(`https://api.${domain}/registry/`) &&
         !link.startsWith(`https://api.${legacyDomain}/registry/`)) {

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-types.d.ts

@@ -14,6 +14,7 @@ export declare namespace RegistryApiTypes {
         filePaths: string[];
         branch?: string;
         isUpsert?: boolean;
+        isPublic?: boolean;
     }
     export interface PrepareFileuploadOKResponse {
         filePath: 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;
@@ -13,5 +13,5 @@ export declare class RegistryApi {
         organizations: string[];
     }>;
     prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }: RegistryApiTypes.PushApiParams): Promise<void>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }: RegistryApiTypes.PushApiParams): Promise<void>;
 }

package/lib/redocly/registry-api.js

@@ -80,7 +80,7 @@ class RegistryApi {
             throw new Error('Could not prepare file upload');
         });
     }
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }) {
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.request(`/${organizationId}/${name}/${version}`, {
                 method: 'PUT',
@@ -93,6 +93,7 @@ class RegistryApi {
                     filePaths,
                     branch,
                     isUpsert,
+                    isPublic,
                 }),
             }, this.region);
             if (response.ok) {

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/index.js

@@ -7,7 +7,7 @@ const Assertions = (opts) => {
     let visitors = [];
     // As 'Assertions' has an array of asserts,
     // that array spreads into an 'opts' object on init rules phase here
-    // https://github.com/Redocly/openapi-cli/blob/master/packages/core/src/config/config.ts#L311
+    // https://github.com/Redocly/redocly-cli/blob/master/packages/core/src/config/config.ts#L311
     // that is why we need to iterate through 'opts' values;
     // before - filter only object 'opts' values
     const assertions = Object.values(opts).filter((opt) => typeof opt === 'object' && opt !== null);