@redocly/openapi-core 1.0.0-beta.111 → 1.0.0-beta.113

package/lib/config/all.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'error',
         'info-contact': 'error',
         'info-license': 'error',
         'info-license-url': 'error',

package/lib/config/config-resolvers.js

@@ -33,22 +33,19 @@ const config_1 = require("./config");
 const logger_1 = require("../logger");
 const asserts_1 = require("../rules/common/assertions/asserts");
 function resolveConfig(rawConfig, configPath) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         if ((_b = (_a = rawConfig.styleguide) === null || _a === void 0 ? void 0 : _a.extends) === null || _b === void 0 ? void 0 : _b.some(utils_3.isNotString)) {
             throw new Error(`Error configuration format not detected in extends value must contain strings`);
         }
         const resolver = new resolve_1.BaseResolver(utils_2.getResolveConfig(rawConfig.resolve));
-        const configExtends = (_d = (_c = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.styleguide) === null || _c === void 0 ? void 0 : _c.extends) !== null && _d !== void 0 ? _d : ['recommended'];
-        const recommendedFallback = !((_e = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.styleguide) === null || _e === void 0 ? void 0 : _e.extends);
-        const styleguideConfig = Object.assign(Object.assign({}, rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.styleguide), { extends: configExtends, recommendedFallback });
         const apis = yield resolveApis({
-            rawConfig: Object.assign(Object.assign({}, rawConfig), { styleguide: styleguideConfig }),
+            rawConfig,
             configPath,
             resolver,
         });
         const styleguide = yield resolveStyleguideConfig({
-            styleguideConfig,
+            styleguideConfig: rawConfig.styleguide,
             configPath,
             resolver,
         });
@@ -254,18 +251,10 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
         if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
             const assertion = rule;
             if (plugins) {
-                for (const field of Object.keys(assertion)) {
-                    const [pluginId, fn] = field.split('/');
-                    if (!pluginId || !fn)
-                        continue;
-                    const plugin = plugins.find((plugin) => plugin.id === pluginId);
-                    if (!plugin) {
-                        throw Error(logger_1.colorize.red(`Plugin ${logger_1.colorize.blue(pluginId)} isn't found.`));
-                    }
-                    if (!plugin.assertions || !plugin.assertions[fn]) {
-                        throw Error(`Plugin ${logger_1.colorize.red(pluginId)} doesn't export assertions function with name ${logger_1.colorize.red(fn)}.`);
-                    }
-                    asserts_1.asserts[field] = asserts_1.buildAssertCustomFunction(plugin.assertions[fn]);
+                registerCustomAssertions(plugins, assertion);
+                // We may have custom assertion inside where block
+                for (const context of assertion.where || []) {
+                    registerCustomAssertions(plugins, context);
                 }
             }
             assertions.push(Object.assign(Object.assign({}, assertion), { assertionId: ruleKey.replace('assert/', '') }));
@@ -280,3 +269,18 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
     }
     return transformedRules;
 }
+function registerCustomAssertions(plugins, assertion) {
+    for (const field of utils_3.keysOf(assertion.assertions)) {
+        const [pluginId, fn] = field.split('/');
+        if (!pluginId || !fn)
+            continue;
+        const plugin = plugins.find((plugin) => plugin.id === pluginId);
+        if (!plugin) {
+            throw Error(logger_1.colorize.red(`Plugin ${logger_1.colorize.blue(pluginId)} isn't found.`));
+        }
+        if (!plugin.assertions || !plugin.assertions[fn]) {
+            throw Error(`Plugin ${logger_1.colorize.red(pluginId)} doesn't export assertions function with name ${logger_1.colorize.red(fn)}.`);
+        }
+        asserts_1.asserts[field] = asserts_1.buildAssertCustomFunction(plugin.assertions[fn]);
+    }
+}

package/lib/config/config.d.ts

@@ -1,7 +1,7 @@
 import { NormalizedProblem } from '../walk';
 import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
 import type { NodeType } from '../types';
-import type { DecoratorConfig, Plugin, PreprocessorConfig, Region, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedStyleguideConfig, RuleConfig } from './types';
+import type { DecoratorConfig, Plugin, PreprocessorConfig, Region, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedStyleguideConfig, RuleConfig, RuleSettings } from './types';
 export declare const IGNORE_FILE = ".redocly.lint-ignore.yaml";
 export declare const DEFAULT_REGION = "us";
 export declare const DOMAINS: {
@@ -29,15 +29,9 @@ export declare class StyleguideConfig {
     addIgnore(problem: NormalizedProblem): void;
     addProblemToIgnore(problem: NormalizedProblem): NormalizedProblem;
     extendTypes(types: Record<string, NodeType>, version: OasVersion): Record<string, NodeType>;
-    getRuleSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: string;
-    };
-    getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: string;
-    };
-    getDecoratorSettings(ruleId: string, oasVersion: OasVersion): {
-        severity: string;
-    };
+    getRuleSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
+    getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
+    getDecoratorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
     getUnusedRules(): {
         rules: string[];
         preprocessors: string[];

package/lib/config/config.js

@@ -34,7 +34,7 @@ function getIgnoreFilePath(configFile) {
             : path.join(configFile, exports.IGNORE_FILE);
     }
     else {
-        return typeof process === 'undefined' ? undefined : path.join(process.cwd(), exports.IGNORE_FILE);
+        return env_1.isBrowser ? undefined : path.join(process.cwd(), exports.IGNORE_FILE);
     }
 }
 exports.DOMAINS = getDomains();

package/lib/config/load.d.ts

@@ -10,7 +10,7 @@ export declare function loadConfig(options?: {
 }): Promise<Config>;
 export declare const CONFIG_FILE_NAMES: string[];
 export declare function findConfig(dir?: string): string | undefined;
-export declare function getConfig(configPath?: string | undefined): Promise<RawConfig>;
+export declare function getConfig(configPath?: string | undefined, processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>): Promise<RawConfig>;
 declare type CreateConfigOptions = {
     extends?: string[];
     tokens?: RegionalTokenWithValidity[];

package/lib/config/load.js

@@ -18,7 +18,7 @@ const js_yaml_1 = require("../js-yaml");
 const config_1 = require("./config");
 const utils_2 = require("./utils");
 const config_resolvers_1 = require("./config-resolvers");
-function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, }) {
+function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, files, region, }) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         if (customExtends !== undefined) {
@@ -26,8 +26,7 @@ function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, }) {
             rawConfig.styleguide.extends = customExtends;
         }
         else if (utils_1.isEmptyObject(rawConfig)) {
-            // TODO: check if we can add recommended here. add message here?
-            // rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
+            rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
         }
         if (tokens === null || tokens === void 0 ? void 0 : tokens.length) {
             if (!rawConfig.resolve)
@@ -56,17 +55,13 @@ function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, }) {
                     : []));
             }
         }
-        return config_resolvers_1.resolveConfig(rawConfig, configPath);
+        return config_resolvers_1.resolveConfig(Object.assign(Object.assign({}, rawConfig), { files: files !== null && files !== void 0 ? files : rawConfig.files, region: region !== null && region !== void 0 ? region : rawConfig.region }), configPath);
     });
 }
 function loadConfig(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-        const config = yield getConfig(configPath);
-        const rawConfig = Object.assign(Object.assign({}, config), { files: files !== null && files !== void 0 ? files : config.files, region: region !== null && region !== void 0 ? region : config.region });
-        if (typeof processRawConfig === 'function') {
-            yield processRawConfig(rawConfig);
-        }
+        const rawConfig = yield getConfig(configPath, processRawConfig);
         const redoclyClient = new redocly_1.RedoclyClient();
         const tokens = yield redoclyClient.getTokens();
         return addConfigMetadata({
@@ -74,6 +69,8 @@ function loadConfig(options = {}) {
             customExtends,
             configPath,
             tokens,
+            files,
+            region,
         });
     });
 }
@@ -93,12 +90,15 @@ function findConfig(dir) {
     return existingConfigFiles[0];
 }
 exports.findConfig = findConfig;
-function getConfig(configPath = findConfig()) {
+function getConfig(configPath = findConfig(), processRawConfig) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!configPath || !utils_1.doesYamlFileExist(configPath))
             return {};
         try {
             const rawConfig = (yield utils_1.loadYaml(configPath)) || {};
+            if (typeof processRawConfig === 'function') {
+                yield processRawConfig(rawConfig);
+            }
             return utils_2.transformConfig(rawConfig);
         }
         catch (e) {

package/lib/config/minimal.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'warn',
         'info-contact': 'off',
         'info-license': 'off',
         'info-license-url': 'off',

package/lib/config/recommended.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'warn',
         'info-contact': 'off',
         'info-license': 'warn',
         'info-license-url': 'warn',

package/lib/config/rules.d.ts

@@ -1,7 +1,10 @@
 import { RuleSet, OasVersion } from '../oas-types';
 import { StyleguideConfig } from './config';
-export declare function initRules<T extends Function, P extends RuleSet<T>>(rules: P[], config: StyleguideConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: OasVersion): {
-    severity: string;
+import type { ProblemSeverity } from '../walk';
+declare type InitializedRule = {
+    severity: ProblemSeverity;
     ruleId: string;
     visitor: any;
-}[];
+};
+export declare function initRules<T extends Function, P extends RuleSet<T>>(rules: P[], config: StyleguideConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: OasVersion): InitializedRule[];
+export {};

package/lib/config/rules.js

@@ -14,16 +14,17 @@ function initRules(rules, config, type, oasVersion) {
         if (ruleSettings.severity === 'off') {
             return undefined;
         }
+        const severity = ruleSettings.severity;
         const visitors = rule(ruleSettings);
         if (Array.isArray(visitors)) {
             return visitors.map((visitor) => ({
-                severity: ruleSettings.severity,
+                severity,
                 ruleId,
                 visitor: visitor,
             }));
         }
         return {
-            severity: ruleSettings.severity,
+            severity,
             ruleId,
             visitor: visitors, // note: actually it is only one visitor object
         };

package/lib/config/types.d.ts

@@ -3,6 +3,9 @@ import type { Oas3PreprocessorsSet, OasMajorVersion, Oas3DecoratorsSet, Oas2Rule
 import type { NodeType } from '../types';
 import { Location } from '../ref-utils';
 export declare type RuleSeverity = ProblemSeverity | 'off';
+export declare type RuleSettings = {
+    severity: RuleSeverity;
+};
 export declare type PreprocessorSeverity = RuleSeverity | 'on';
 export declare type RuleConfig = RuleSeverity | ({
     severity?: ProblemSeverity;

package/lib/ref-utils.d.ts

@@ -23,3 +23,4 @@ export declare function pointerBaseName(pointer: string): string;
 export declare function refBaseName(ref: string): string;
 export declare function isAbsoluteUrl(ref: string): boolean;
 export declare function isMappingRef(mapping: string): boolean;
+export declare function isAnchor(ref: string): boolean;

package/lib/ref-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
+exports.isAnchor = exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
 const utils_1 = require("./utils");
 function joinPointer(base, key) {
     if (base === '')
@@ -74,3 +74,7 @@ function isMappingRef(mapping) {
         mapping.indexOf('/') > -1);
 }
 exports.isMappingRef = isMappingRef;
+function isAnchor(ref) {
+    return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
+}
+exports.isAnchor = isAnchor;

package/lib/resolve.js

@@ -186,6 +186,7 @@ function resolveDocument(opts) {
         return resolvedRefMap;
         function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
             const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+            const anchorRefsMap = new Map();
             walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
             function walk(node, type, nodeAbsoluteRef) {
                 if (typeof node !== 'object' || node === null) {
@@ -196,6 +197,10 @@ function resolveDocument(opts) {
                     return;
                 }
                 seedNodes.add(nodeId);
+                const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+                if (anchor) {
+                    anchorRefsMap.set(`#${anchor}`, node);
+                }
                 if (Array.isArray(node)) {
                     const itemsType = type.items;
                     // we continue resolving unknown types, but stop early on known scalars
@@ -245,6 +250,20 @@ function resolveDocument(opts) {
                     if (hasRef(refStack.prev, ref)) {
                         throw new Error('Self-referencing circular pointer');
                     }
+                    if (ref_utils_1.isAnchor(ref.$ref)) {
+                        // Wait for all anchors in the document to be collected firstly.
+                        yield utils_1.nextTick();
+                        const resolvedRef = {
+                            resolved: true,
+                            isRemote: false,
+                            node: anchorRefsMap.get(ref.$ref),
+                            document,
+                            nodePointer: ref.$ref,
+                        };
+                        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                        resolvedRefMap.set(refId, resolvedRef);
+                        return resolvedRef;
+                    }
                     const { uri, pointer } = ref_utils_1.parseRef(ref.$ref);
                     const isRemote = uri !== null;
                     let targetDoc;

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

@@ -1,8 +1,25 @@
 import { AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
-declare type Asserts = Record<string, (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[]>;
-export declare const runOnKeysSet: Set<string>;
-export declare const runOnValuesSet: Set<string>;
+export declare type AssertionFn = (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[];
+export declare type Asserts = {
+    pattern: AssertionFn;
+    enum: AssertionFn;
+    defined: AssertionFn;
+    required: AssertionFn;
+    disallowed: AssertionFn;
+    undefined: AssertionFn;
+    nonEmpty: AssertionFn;
+    minLength: AssertionFn;
+    maxLength: AssertionFn;
+    casing: AssertionFn;
+    sortOrder: AssertionFn;
+    mutuallyExclusive: AssertionFn;
+    mutuallyRequired: AssertionFn;
+    requireAny: AssertionFn;
+    ref: AssertionFn;
+    const: AssertionFn;
+};
+export declare const runOnKeysSet: Set<keyof Asserts>;
+export declare const runOnValuesSet: Set<keyof Asserts>;
 export declare const asserts: Asserts;
-export declare function buildAssertCustomFunction(fn: CustomFunction): (value: string[], options: any, baseLocation: Location) => any;
-export {};
+export declare function buildAssertCustomFunction(fn: CustomFunction): AssertionFn;

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

@@ -16,6 +16,8 @@ exports.runOnKeysSet = new Set([
     'required',
     'requireAny',
     'ref',
+    'const',
+    'defined', // In case if `property` for assertions is not added
 ]);
 exports.runOnValuesSet = new Set([
     'pattern',
@@ -28,6 +30,7 @@ exports.runOnValuesSet = new Set([
     'casing',
     'sortOrder',
     'ref',
+    'const',
 ]);
 exports.asserts = {
     pattern: (value, condition, baseLocation) => {
@@ -84,6 +87,28 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
+    const: (value, condition, baseLocation) => {
+        if (typeof value === 'undefined')
+            return [];
+        if (Array.isArray(value)) {
+            return value
+                .map((_val) => condition !== _val && {
+                message: `"${_val}" should be equal ${condition} `,
+                location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            })
+                .filter(utils_1.isTruthy);
+        }
+        else {
+            return value !== condition
+                ? [
+                    {
+                        message: `${value} should be equal ${condition}`,
+                        location: baseLocation,
+                    },
+                ]
+                : [];
+        }
+    },
     undefined: (value, condition = true, baseLocation) => {
         const isUndefined = typeof value === 'undefined';
         const isValid = condition ? isUndefined : !isUndefined;

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

@@ -1,2 +1,27 @@
-import { Oas2Rule, Oas3Rule } from '../../../visitors';
-export declare const Assertions: Oas3Rule | Oas2Rule;
+import { asserts, AssertionFn } from './asserts';
+import { Oas2Visitor, Oas3Visitor } from '../../../visitors';
+import { RuleSeverity } from '../../../config';
+export declare type AssertionLocators = {
+    filterInParentKeys?: (string | number)[];
+    filterOutParentKeys?: (string | number)[];
+    matchParentKeys?: string;
+};
+export declare type AssertionDefinition = {
+    subject: {
+        type: string;
+        property?: string | string[];
+    } & AssertionLocators;
+    assertions: {
+        [name in keyof typeof asserts]?: AssertionFn;
+    };
+};
+export declare type RawAssertion = AssertionDefinition & {
+    where?: AssertionDefinition[];
+    message?: string;
+    suggest?: string[];
+    severity?: RuleSeverity;
+};
+export declare type Assertion = RawAssertion & {
+    assertionId: string;
+};
+export declare const Assertions: (opts: Record<string, Assertion>) => (Oas3Visitor | Oas2Visitor)[];

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Assertions = void 0;
-const asserts_1 = require("./asserts");
 const utils_1 = require("./utils");
+const utils_2 = require("../../../utils");
 const Assertions = (opts) => {
     const visitors = [];
     // As 'Assertions' has an array of asserts,
@@ -13,35 +13,12 @@ const Assertions = (opts) => {
     const assertions = Object.values(opts).filter((opt) => typeof opt === 'object' && opt !== null);
     for (const [index, assertion] of assertions.entries()) {
         const assertId = (assertion.assertionId && `${assertion.assertionId} assertion`) || `assertion #${index + 1}`;
-        if (!assertion.subject) {
-            throw new Error(`${assertId}: 'subject' is required`);
-        }
-        const subjects = Array.isArray(assertion.subject)
-            ? assertion.subject
-            : [assertion.subject];
-        const assertsToApply = Object.keys(asserts_1.asserts)
-            .filter((assertName) => assertion[assertName] !== undefined)
-            .map((assertName) => {
-            return {
-                name: assertName,
-                conditions: assertion[assertName],
-                runsOnKeys: asserts_1.runOnKeysSet.has(assertName),
-                runsOnValues: asserts_1.runOnValuesSet.has(assertName),
-            };
-        });
-        const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
-        const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
-        if (shouldRunOnValues && !assertion.property) {
-            throw new Error(`${shouldRunOnValues.name} can't be used on all keys. Please provide a single property.`);
-        }
-        if (shouldRunOnKeys && assertion.property) {
-            throw new Error(`${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`);
-        }
-        for (const subject of subjects) {
-            const subjectVisitor = utils_1.buildSubjectVisitor(assertId, assertion, assertsToApply);
-            const visitorObject = utils_1.buildVisitorObject(subject, assertion.context, subjectVisitor);
-            visitors.push(visitorObject);
+        if (!utils_2.isString(assertion.subject.type)) {
+            throw new Error(`${assertId}: 'type' (String) is required`);
         }
+        const subjectVisitor = utils_1.buildSubjectVisitor(assertId, assertion);
+        const visitorObject = utils_1.buildVisitorObject(assertion, subjectVisitor);
+        visitors.push(visitorObject);
     }
     return visitors;
 };

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

@@ -1,27 +1,20 @@
-import type { RuleSeverity } from '../../../config';
-import { UserContext } from '../../../walk';
+import { Asserts } from './asserts';
+import type { Assertion, AssertionDefinition } from '.';
+import type { Oas2Visitor, Oas3Visitor, VisitFunction } from '../../../visitors';
 export declare type OrderDirection = 'asc' | 'desc';
 export declare type OrderOptions = {
     direction: OrderDirection;
     property: string;
 };
-declare type Assertion = {
-    property: string | string[];
-    context?: Record<string, any>[];
-    severity?: RuleSeverity;
-    suggest?: any[];
-    message?: string;
-    subject: string;
-};
 export declare type AssertToApply = {
-    name: string;
+    name: keyof Asserts;
     conditions: any;
     runsOnKeys: boolean;
     runsOnValues: boolean;
 };
-export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
-export declare function buildSubjectVisitor(assertId: string, assertion: Assertion, asserts: AssertToApply[]): (node: any, { report, location, rawLocation, key, type, resolve, rawNode }: UserContext) => void;
+export declare function getAssertsToApply(assertion: AssertionDefinition): AssertToApply[];
+export declare function buildVisitorObject(assertion: Assertion, subjectVisitor: VisitFunction<any>): Oas2Visitor | Oas3Visitor;
+export declare function buildSubjectVisitor(assertId: string, assertion: Assertion): VisitFunction<any>;
 export declare function getIntersectionLength(keys: string[], properties: string[]): number;
 export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;
 export declare function regexFromString(input: string): RegExp | null;
-export {};