@redocly/openapi-core 0.0.0-snapshot.1737554067

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
+exports.buildAssertCustomFunction = buildAssertCustomFunction;
+const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
+exports.runOnKeysSet = new Set([
+    'mutuallyExclusive',
+    'mutuallyRequired',
+    'enum',
+    'pattern',
+    'notPattern',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'disallowed',
+    'required',
+    'requireAny',
+    'ref',
+    'const',
+    'defined', // In case if `property` for assertions is not added
+]);
+exports.runOnValuesSet = new Set([
+    'pattern',
+    'notPattern',
+    'enum',
+    'defined',
+    'undefined',
+    'nonEmpty',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'ref',
+    'const',
+]);
+exports.asserts = {
+    pattern: (value, condition, { baseLocation, rawValue }) => {
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = (0, utils_2.regexFromString)(condition);
+        return values
+            .map((_val) => !regex?.test(_val) && {
+            message: `"${_val}" should match a regex ${condition}`,
+            location: (0, utils_1.isString)(value)
+                ? baseLocation
+                : (0, utils_1.isPlainObject)(rawValue)
+                    ? baseLocation.child(_val).key()
+                    : baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    notPattern: (value, condition, { baseLocation, rawValue }) => {
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = (0, utils_2.regexFromString)(condition);
+        return values
+            .map((_val) => regex?.test(_val) && {
+            message: `"${_val}" should not match a regex ${condition}`,
+            location: (0, utils_1.isString)(value)
+                ? baseLocation
+                : (0, utils_1.isPlainObject)(rawValue)
+                    ? baseLocation.child(_val).key()
+                    : baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    enum: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => !condition.includes(_val) && {
+            message: `"${_val}" should be one of the predefined values`,
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    defined: (value, condition = true, { baseLocation }) => {
+        const isDefined = typeof value !== 'undefined';
+        const isValid = condition ? isDefined : !isDefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should be defined` : 'Should be not defined',
+                    location: baseLocation,
+                },
+            ];
+    },
+    required: (value, keys, { baseLocation }) => {
+        return keys
+            .map((requiredKey) => !value.includes(requiredKey) && {
+            message: `${requiredKey} is required`,
+            location: baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    disallowed: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => condition.includes(_val) && {
+            message: `"${_val}" is disallowed`,
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .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: (0, 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;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be defined` : 'Should be defined',
+                    location: baseLocation,
+                },
+            ];
+    },
+    nonEmpty: (value, condition = true, { baseLocation }) => {
+        const isEmpty = typeof value === 'undefined' || value === null || value === '';
+        const isValid = condition ? !isEmpty : isEmpty;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be empty` : 'Should be empty',
+                    location: baseLocation,
+                },
+            ];
+    },
+    minLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length >= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at least ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
+    },
+    maxLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length <= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at most ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
+    },
+    casing: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const casingRegexes = {
+            camelCase: /^[a-z][a-zA-Z0-9]*$/g,
+            'kebab-case': /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g,
+            snake_case: /^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g,
+            PascalCase: /^[A-Z][a-zA-Z0-9]+$/g,
+            MACRO_CASE: /^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g,
+            'COBOL-CASE': /^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g,
+            flatcase: /^[a-z][a-z0-9]+$/g,
+        };
+        return values
+            .map((_val) => !_val.match(casingRegexes[condition]) && {
+            message: `"${_val}" should use ${condition}`,
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    sortOrder: (value, condition, { baseLocation }) => {
+        const direction = condition.direction || condition;
+        const property = condition.property;
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && !property) {
+            return [
+                {
+                    message: `Please define a property to sort objects by`,
+                    location: baseLocation,
+                },
+            ];
+        }
+        if (typeof value === 'undefined' || (0, utils_2.isOrdered)(value, condition))
+            return [];
+        return [
+            {
+                message: `Should be sorted in ${direction === 'asc' ? 'an ascending' : 'a descending'} order${property ? ` by property ${property}` : ''}`,
+                location: baseLocation,
+            },
+        ];
+    },
+    mutuallyExclusive: (value, condition, { baseLocation }) => {
+        if ((0, utils_2.getIntersectionLength)(value, condition) < 2)
+            return [];
+        return [
+            {
+                message: `${condition.join(', ')} keys should be mutually exclusive`,
+                location: baseLocation.key(),
+            },
+        ];
+    },
+    mutuallyRequired: (value, condition, { baseLocation }) => {
+        const isValid = (0, utils_2.getIntersectionLength)(value, condition) > 0
+            ? (0, utils_2.getIntersectionLength)(value, condition) === condition.length
+            : true;
+        return isValid
+            ? []
+            : [
+                {
+                    message: `Properties ${condition.join(', ')} are mutually required`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    requireAny: (value, condition, { baseLocation }) => {
+        return (0, utils_2.getIntersectionLength)(value, condition) >= 1
+            ? []
+            : [
+                {
+                    message: `Should have any of ${condition.join(', ')}`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    ref: (_value, condition, { baseLocation, rawValue }) => {
+        if (typeof rawValue === 'undefined')
+            return []; // property doesn't exist, no need to lint it with this assert
+        const hasRef = rawValue.hasOwnProperty('$ref');
+        if (typeof condition === 'boolean') {
+            const isValid = condition ? hasRef : !hasRef;
+            return isValid
+                ? []
+                : [
+                    {
+                        message: condition ? `should use $ref` : 'should not use $ref',
+                        location: hasRef ? baseLocation : baseLocation.key(),
+                    },
+                ];
+        }
+        const regex = (0, utils_2.regexFromString)(condition);
+        const isValid = hasRef && regex?.test(rawValue['$ref']);
+        return isValid
+            ? []
+            : [
+                {
+                    message: `$ref value should match ${condition}`,
+                    location: hasRef ? baseLocation : baseLocation.key(),
+                },
+            ];
+    },
+};
+function buildAssertCustomFunction(fn) {
+    return (value, options, ctx) => fn.call(null, value, options, ctx);
+}

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assertions = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("../../../utils");
+const Assertions = (opts) => {
+    const visitors = [];
+    // As 'Assertions' has an array of asserts,
+    // that array spreads into an 'opts' object on init rules phase here
+    // https://github.com/Redocly/redocly-cli/blob/main/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);
+    for (const [_, assertion] of assertions.entries()) {
+        if (!(0, utils_2.isString)(assertion.subject.type)) {
+            throw new Error(`${assertion.assertionId}: 'type' (String) is required`);
+        }
+        const subjectVisitor = (0, utils_1.buildSubjectVisitor)(assertion.assertionId, assertion);
+        const visitorObject = (0, utils_1.buildVisitorObject)(assertion, subjectVisitor);
+        visitors.push(visitorObject);
+    }
+    return visitors;
+};
+exports.Assertions = Assertions;

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

@@ -0,0 +1,28 @@
+import type { Asserts } from './asserts';
+import type { AssertionContext, AssertResult } from '../../../config';
+import type { Assertion, AssertionDefinition } from '.';
+import type { Oas2Visitor, Oas3Visitor, VisitFunction } from '../../../visitors';
+export type OrderDirection = 'asc' | 'desc';
+export type OrderOptions = {
+    direction: OrderDirection;
+    property: string;
+};
+export type AssertToApply = {
+    name: keyof Asserts;
+    conditions: any;
+    runsOnKeys: boolean;
+    runsOnValues: boolean;
+};
+type RunAssertionParams = {
+    ctx: AssertionContext;
+    assert: AssertToApply;
+    assertionProperty?: string;
+};
+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 runAssertion({ assert, ctx, assertionProperty, }: RunAssertionParams): AssertResult[];
+export declare function regexFromString(input: string): RegExp | null;
+export {};

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssertsToApply = getAssertsToApply;
+exports.buildVisitorObject = buildVisitorObject;
+exports.buildSubjectVisitor = buildSubjectVisitor;
+exports.getIntersectionLength = getIntersectionLength;
+exports.isOrdered = isOrdered;
+exports.runAssertion = runAssertion;
+exports.regexFromString = regexFromString;
+const asserts_1 = require("./asserts");
+const logger_1 = require("../../../logger");
+const ref_utils_1 = require("../../../ref-utils");
+const utils_1 = require("../../../utils");
+const assertionMessageTemplates = {
+    problems: '{{problems}}',
+};
+function getPredicatesFromLocators(locators) {
+    const { filterInParentKeys, filterOutParentKeys, matchParentKeys } = locators;
+    const keyMatcher = matchParentKeys && regexFromString(matchParentKeys);
+    const matchKeysPredicate = keyMatcher && ((key) => keyMatcher.test(key.toString()));
+    const filterInPredicate = Array.isArray(filterInParentKeys) &&
+        ((key) => filterInParentKeys.includes(key.toString()));
+    const filterOutPredicate = Array.isArray(filterOutParentKeys) &&
+        ((key) => !filterOutParentKeys.includes(key.toString()));
+    return [matchKeysPredicate, filterInPredicate, filterOutPredicate].filter(utils_1.isTruthy);
+}
+function getAssertsToApply(assertion) {
+    const assertsToApply = (0, utils_1.keysOf)(asserts_1.asserts)
+        .filter((assertName) => assertion.assertions[assertName] !== undefined)
+        .map((assertName) => {
+        return {
+            name: assertName,
+            conditions: assertion.assertions[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.subject.property) {
+        throw new Error(`The '${shouldRunOnValues.name}' assertion can't be used on all keys. Please provide a single property.`);
+    }
+    if (shouldRunOnKeys && assertion.subject.property) {
+        throw new Error(`The '${shouldRunOnKeys.name}' assertion can't be used on properties. Please remove the 'property' key.`);
+    }
+    return assertsToApply;
+}
+function getAssertionProperties({ subject }) {
+    return (Array.isArray(subject.property) ? subject.property : [subject?.property]).filter(Boolean);
+}
+function applyAssertions(assertionDefinition, asserts, ctx) {
+    const properties = getAssertionProperties(assertionDefinition);
+    const assertResults = [];
+    for (const assert of asserts) {
+        if (properties.length) {
+            for (const property of properties) {
+                assertResults.push(runAssertion({
+                    assert,
+                    ctx,
+                    assertionProperty: property,
+                }));
+            }
+        }
+        else {
+            assertResults.push(runAssertion({
+                assert,
+                ctx,
+            }));
+        }
+    }
+    return assertResults.flat();
+}
+function buildVisitorObject(assertion, subjectVisitor) {
+    const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
+    const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
+        ? (_, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
+        : undefined;
+    const targetVisitor = {
+        [assertion.subject.type]: {
+            enter: subjectVisitor,
+            ...(targetVisitorSkipFunction && { skip: targetVisitorSkipFunction }),
+        },
+    };
+    if (!Array.isArray(assertion.where)) {
+        return targetVisitor;
+    }
+    let currentVisitorLevel = {};
+    const visitor = currentVisitorLevel;
+    const context = assertion.where;
+    for (let index = 0; index < context.length; index++) {
+        const assertionDefinitionNode = context[index];
+        if (!(0, utils_1.isString)(assertionDefinitionNode.subject?.type)) {
+            throw new Error(`${assertion.assertionId} -> where -> [${index}]: 'type' (String) is required`);
+        }
+        const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
+        const assertsToApply = getAssertsToApply(assertionDefinitionNode);
+        const skipFunction = (node, key, ctx) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, { ...ctx, node }).length;
+        const nodeVisitor = {
+            ...((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }),
+        };
+        if (assertionDefinitionNode.subject.type === assertion.subject.type &&
+            index === context.length - 1) {
+            // We have to merge the visitors if the last node inside the `where` is the same as the subject.
+            targetVisitor[assertion.subject.type] = {
+                enter: subjectVisitor,
+                ...((nodeVisitor.skip && { skip: nodeVisitor.skip }) ||
+                    (targetVisitorSkipFunction && {
+                        skip: (node, key, ctx // We may have locators defined on assertion level and on where level for the same node type
+                        ) => !!(nodeVisitor.skip?.(node, key, ctx) || targetVisitorSkipFunction?.(node, key)),
+                    })),
+            };
+        }
+        else {
+            currentVisitorLevel = currentVisitorLevel[assertionDefinitionNode.subject?.type] =
+                nodeVisitor;
+        }
+    }
+    currentVisitorLevel[assertion.subject.type] = targetVisitor[assertion.subject.type];
+    return visitor;
+}
+function buildSubjectVisitor(assertId, assertion) {
+    return (node, ctx) => {
+        const properties = getAssertionProperties(assertion);
+        const defaultMessage = `${logger_1.colorize.blue(assertId)} failed because the ${logger_1.colorize.blue(assertion.subject.type)} ${logger_1.colorize.blue(properties.join(', '))} didn't meet the assertions: ${assertionMessageTemplates.problems}`.replace(/ +/g, ' ');
+        const problems = applyAssertions(assertion, getAssertsToApply(assertion), {
+            ...ctx,
+            node,
+        });
+        if (problems.length) {
+            for (const problemGroup of groupProblemsByPointer(problems)) {
+                const message = assertion.message || defaultMessage;
+                const problemMessage = getProblemsMessage(problemGroup);
+                ctx.report({
+                    message: message.replace(assertionMessageTemplates.problems, problemMessage),
+                    location: getProblemsLocation(problemGroup) || ctx.location,
+                    forceSeverity: assertion.severity || 'error',
+                    suggest: assertion.suggest || [],
+                    ruleId: assertId,
+                });
+            }
+        }
+    };
+}
+function groupProblemsByPointer(problems) {
+    const groups = {};
+    for (const problem of problems) {
+        if (!problem.location)
+            continue;
+        const pointer = problem.location.pointer;
+        groups[pointer] = groups[pointer] || [];
+        groups[pointer].push(problem);
+    }
+    return Object.values(groups);
+}
+function getProblemsLocation(problems) {
+    return problems.length ? problems[0].location : undefined;
+}
+function getProblemsMessage(problems) {
+    return problems.length === 1
+        ? problems[0].message ?? ''
+        : problems.map((problem) => `\n- ${problem.message ?? ''}`).join('');
+}
+function getIntersectionLength(keys, properties) {
+    const props = new Set(properties);
+    let count = 0;
+    for (const key of keys) {
+        if (props.has(key)) {
+            count++;
+        }
+    }
+    return count;
+}
+function isOrdered(value, options) {
+    const direction = options.direction || options;
+    const property = options.property;
+    for (let i = 1; i < value.length; i++) {
+        let currValue = value[i];
+        let prevVal = value[i - 1];
+        if (property) {
+            const currPropValue = value[i][property];
+            const prevPropValue = value[i - 1][property];
+            if (!currPropValue || !prevPropValue) {
+                return false; // property doesn't exist, so collection is not ordered
+            }
+            currValue = currPropValue;
+            prevVal = prevPropValue;
+        }
+        if (typeof currValue === 'string' && typeof prevVal === 'string') {
+            currValue = currValue.toLowerCase();
+            prevVal = prevVal.toLowerCase();
+        }
+        const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}
+function runAssertion({ assert, ctx, assertionProperty, }) {
+    const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
+    if (assertionProperty) {
+        const values = (0, ref_utils_1.isRef)(ctx.node[assertionProperty])
+            ? ctx.resolve(ctx.node[assertionProperty])?.node
+            : ctx.node[assertionProperty];
+        const rawValues = ctx.rawNode[assertionProperty];
+        const location = currentLocation.child(assertionProperty);
+        return asserts_1.asserts[assert.name](values, assert.conditions, {
+            ...ctx,
+            baseLocation: location,
+            rawValue: rawValues,
+        });
+    }
+    else {
+        const value = Array.isArray(ctx.node) ? ctx.node : Object.keys(ctx.node);
+        return asserts_1.asserts[assert.name](value, assert.conditions, {
+            ...ctx,
+            rawValue: ctx.rawNode,
+            baseLocation: currentLocation,
+        });
+    }
+}
+function regexFromString(input) {
+    const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
+    return matches && new RegExp(matches[1] || matches[3], matches[2]);
+}

package/lib/rules/common/info-contact.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const InfoContact: Oas3Rule | Oas2Rule;

package/lib/rules/common/info-contact.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoContact = void 0;
+const utils_1 = require("../utils");
+const InfoContact = () => {
+    return {
+        Info(info, { report, location }) {
+            if (!info.contact) {
+                report({
+                    message: (0, utils_1.missingRequiredField)('Info', 'contact'),
+                    location: location.child('contact').key(),
+                });
+            }
+        },
+    };
+};
+exports.InfoContact = InfoContact;

package/lib/rules/common/info-license-strict.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule, Async2Rule, Async3Rule } from '../../visitors';
+export declare const InfoLicenseStrict: Oas2Rule | Oas3Rule | Async2Rule | Async3Rule;

package/lib/rules/common/info-license-strict.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoLicenseStrict = void 0;
+const oas_types_1 = require("../../oas-types");
+const utils_1 = require("../utils");
+const InfoLicenseStrict = () => {
+    let specVersion;
+    return {
+        Root: {
+            enter(root) {
+                specVersion = (0, oas_types_1.detectSpec)(root);
+            },
+            License: {
+                leave(license, ctx) {
+                    if (specVersion === 'oas3_1') {
+                        (0, utils_1.validateOneOfDefinedAndNonEmpty)(['url', 'identifier'], license, ctx);
+                    }
+                    else {
+                        (0, utils_1.validateDefinedAndNonEmpty)('url', license, ctx);
+                    }
+                },
+            },
+        },
+    };
+};
+exports.InfoLicenseStrict = InfoLicenseStrict;

package/lib/rules/common/info-license-url.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const InfoLicenseUrl: Oas3Rule | Oas2Rule;

package/lib/rules/common/info-license-url.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoLicenseUrl = void 0;
+const utils_1 = require("../utils");
+const InfoLicenseUrl = () => {
+    return {
+        License(license, ctx) {
+            (0, utils_1.validateDefinedAndNonEmpty)('url', license, ctx);
+        },
+    };
+};
+exports.InfoLicenseUrl = InfoLicenseUrl;

package/lib/rules/common/info-license.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const InfoLicense: Oas3Rule | Oas2Rule;

package/lib/rules/common/info-license.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoLicense = void 0;
+const utils_1 = require("../utils");
+const InfoLicense = () => {
+    return {
+        Info(info, { report }) {
+            if (!info.license) {
+                report({
+                    message: (0, utils_1.missingRequiredField)('Info', 'license'),
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.InfoLicense = InfoLicense;