@redocly/openapi-core 1.0.0-beta.123 → 1.0.0-beta.125

package/lib/bundle.d.ts

@@ -1,6 +1,7 @@
 import { BaseResolver, Document } from './resolve';
 import { Oas3Rule } from './visitors';
 import { NormalizedNodeType, NodeType } from './types';
+import { NormalizedProblem } from './walk';
 import { OasMajorVersion } from './oas-types';
 import type { Config, StyleguideConfig } from './config';
 export declare type Oas3RuleSet = Record<string, Oas3Rule>;
@@ -19,14 +20,15 @@ export declare function bundle(opts: {
     skipRedoclyRegistryRefs?: boolean;
     removeUnusedComponents?: boolean;
     keepUrlRefs?: boolean;
-}): Promise<{
+}): Promise<BundleResult>;
+export declare type BundleResult = {
     bundle: Document;
-    problems: import("./walk").NormalizedProblem[];
+    problems: NormalizedProblem[];
     fileDependencies: Set<string>;
     rootType: NormalizedNodeType;
-    refTypes: Map<string, NormalizedNodeType> | undefined;
+    refTypes?: Map<string, NormalizedNodeType>;
     visitorsData: Record<string, Record<string, unknown>>;
-}>;
+};
 export declare function bundleDocument(opts: {
     document: Document;
     config: StyleguideConfig;
@@ -36,12 +38,5 @@ export declare function bundleDocument(opts: {
     skipRedoclyRegistryRefs?: boolean;
     removeUnusedComponents?: boolean;
     keepUrlRefs?: boolean;
-}): Promise<{
-    bundle: Document;
-    problems: import("./walk").NormalizedProblem[];
-    fileDependencies: Set<string>;
-    rootType: NormalizedNodeType;
-    refTypes: Map<string, NormalizedNodeType> | undefined;
-    visitorsData: Record<string, Record<string, unknown>>;
-}>;
+}): Promise<BundleResult>;
 export declare function mapTypeToComponent(typeName: string, version: OasMajorVersion): "headers" | "definitions" | "parameters" | "examples" | "schemas" | "responses" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | null;

package/lib/config/config.js

@@ -8,6 +8,7 @@ const utils_1 = require("../utils");
 const oas_types_1 = require("../oas-types");
 const env_1 = require("../env");
 const utils_2 = require("./utils");
+const ref_utils_1 = require("../ref-utils");
 exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
     `# See https://redoc.ly/docs/cli/ for more information.\n`;
@@ -75,11 +76,13 @@ class StyleguideConfig {
             js_yaml_1.parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) || {};
         // resolve ignore paths
         for (const fileName of Object.keys(this.ignore)) {
-            this.ignore[path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
+            this.ignore[ref_utils_1.isAbsoluteUrl(fileName) ? fileName : path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
             for (const ruleId of Object.keys(this.ignore[fileName])) {
                 this.ignore[fileName][ruleId] = new Set(this.ignore[fileName][ruleId]);
             }
-            delete this.ignore[fileName];
+            if (!ref_utils_1.isAbsoluteUrl(fileName)) {
+                delete this.ignore[fileName];
+            }
         }
     }
     saveIgnore() {
@@ -87,8 +90,10 @@ class StyleguideConfig {
         const ignoreFile = path.join(dir, exports.IGNORE_FILE);
         const mapped = {};
         for (const absFileName of Object.keys(this.ignore)) {
-            const ignoredRules = (mapped[utils_1.slash(path.relative(dir, absFileName))] =
-                this.ignore[absFileName]);
+            const mappedDefinitionName = ref_utils_1.isAbsoluteUrl(absFileName)
+                ? absFileName
+                : utils_1.slash(path.relative(dir, absFileName));
+            const ignoredRules = (mapped[mappedDefinitionName] = this.ignore[absFileName]);
             for (const ruleId of Object.keys(ignoredRules)) {
                 ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]);
             }

package/lib/config/types.d.ts

@@ -1,7 +1,8 @@
-import type { ProblemSeverity } from '../walk';
+import type { ProblemSeverity, UserContext } from '../walk';
 import type { Oas3PreprocessorsSet, OasMajorVersion, Oas3DecoratorsSet, Oas2RuleSet, Oas2PreprocessorsSet, Oas2DecoratorsSet, Oas3RuleSet, OasVersion } from '../oas-types';
 import type { NodeType } from '../types';
 import { Location } from '../ref-utils';
+import { SkipFunctionContext } from '../visitors';
 export declare type RuleSeverity = ProblemSeverity | 'off';
 export declare type RuleSettings = {
     severity: RuleSeverity;
@@ -54,6 +55,9 @@ export declare type CustomRulesConfig = {
     oas3?: Oas3RuleSet;
     oas2?: Oas2RuleSet;
 };
+export declare type AssertionContext = Partial<UserContext> & SkipFunctionContext & {
+    node: any;
+};
 export declare type AssertResult = {
     message?: string;
     location?: Location;

package/lib/format/format.js

@@ -7,6 +7,7 @@ const output_1 = require("../output");
 const coreVersion = require('../../package.json').version;
 const codeframes_1 = require("./codeframes");
 const env_1 = require("../env");
+const ref_utils_1 = require("../ref-utils");
 const ERROR_MESSAGE = {
     INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
 };
@@ -75,7 +76,7 @@ function formatProblems(problems, opts) {
         case 'stylish': {
             const groupedByFile = groupByFiles(problems);
             for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(groupedByFile)) {
-                logger_1.logger.info(`${logger_1.colorize.blue(path.relative(cwd, file))}:\n`);
+                logger_1.logger.info(`${logger_1.colorize.blue(ref_utils_1.isAbsoluteUrl(file) ? file : path.relative(cwd, file))}:\n`);
                 for (let i = 0; i < fileProblems.length; i++) {
                     const problem = fileProblems[i];
                     logger_1.logger.info(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
@@ -89,7 +90,7 @@ function formatProblems(problems, opts) {
             output_1.output.write('<?xml version="1.0" encoding="UTF-8"?>\n');
             output_1.output.write('<checkstyle version="4.3">\n');
             for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
-                output_1.output.write(`<file name="${xmlEscape(path.relative(cwd, file))}">\n`);
+                output_1.output.write(`<file name="${xmlEscape(ref_utils_1.isAbsoluteUrl(file) ? file : path.relative(cwd, file))}">\n`);
                 fileProblems.forEach(formatCheckstyle);
                 output_1.output.write(`</file>\n`);
             }
@@ -113,7 +114,9 @@ function formatProblems(problems, opts) {
             return {
                 description: p.message,
                 location: {
-                    path: path.relative(cwd, location.source.absoluteRef),
+                    path: ref_utils_1.isAbsoluteUrl(location.source.absoluteRef)
+                        ? location.source.absoluteRef
+                        : path.relative(cwd, location.source.absoluteRef),
                     lines: {
                         begin: lineCol.start.line,
                     },
@@ -129,12 +132,16 @@ function formatProblems(problems, opts) {
             totals,
             version,
             problems: problems.map((p) => {
-                var _a;
+                var _a, _b, _c;
                 const problem = Object.assign(Object.assign({}, p), { location: p.location.map((location) => (Object.assign(Object.assign({}, location), { source: {
-                            ref: path.relative(cwd, location.source.absoluteRef),
+                            ref: ref_utils_1.isAbsoluteUrl(location.source.absoluteRef)
+                                ? location.source.absoluteRef
+                                : path.relative(cwd, location.source.absoluteRef),
                         } }))), from: p.from
                         ? Object.assign(Object.assign({}, p.from), { source: {
-                                ref: path.relative(cwd, ((_a = p.from) === null || _a === void 0 ? void 0 : _a.source.absoluteRef) || cwd),
+                                ref: ref_utils_1.isAbsoluteUrl((_a = p.from) === null || _a === void 0 ? void 0 : _a.source.absoluteRef)
+                                    ? (_b = p.from) === null || _b === void 0 ? void 0 : _b.source.absoluteRef
+                                    : path.relative(cwd, ((_c = p.from) === null || _c === void 0 ? void 0 : _c.source.absoluteRef) || cwd),
                             } }) : undefined });
                 if (env_1.env.FORMAT_JSON_WITH_CODEFRAMES) {
                     const location = p.location[0]; // TODO: support multiple locations
@@ -156,7 +163,9 @@ function formatProblems(problems, opts) {
     function formatCodeframe(problem, idx) {
         const bgColor = getBgColor(problem);
         const location = problem.location[0]; // TODO: support multiple locations
-        const relativePath = path.relative(cwd, location.source.absoluteRef);
+        const relativePath = ref_utils_1.isAbsoluteUrl(location.source.absoluteRef)
+            ? location.source.absoluteRef
+            : path.relative(cwd, location.source.absoluteRef);
         const loc = codeframes_1.getLineColLocation(location);
         const atPointer = location.pointer ? logger_1.colorize.gray(`at ${location.pointer}`) : '';
         const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;

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

@@ -1,6 +1,10 @@
-import { AssertResult, CustomFunction } from 'core/src/config/types';
+import { AssertionContext, AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
-export declare type AssertionFn = (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[];
+export declare type AssertionFnContext = AssertionContext & {
+    baseLocation: Location;
+    rawValue?: any;
+};
+export declare type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
 export declare type Asserts = {
     pattern: AssertionFn;
     notPattern: AssertionFn;

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

@@ -35,7 +35,7 @@ exports.runOnValuesSet = new Set([
     'const',
 ]);
 exports.asserts = {
-    pattern: (value, condition, baseLocation) => {
+    pattern: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined' || 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];
@@ -47,7 +47,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    notPattern: (value, condition, baseLocation) => {
+    notPattern: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined' || 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];
@@ -59,7 +59,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    enum: (value, condition, baseLocation) => {
+    enum: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined' || 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];
@@ -70,7 +70,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    defined: (value, condition = true, baseLocation) => {
+    defined: (value, condition = true, { baseLocation }) => {
         const isDefined = typeof value !== 'undefined';
         const isValid = condition ? isDefined : !isDefined;
         return isValid
@@ -82,7 +82,7 @@ exports.asserts = {
                 },
             ];
     },
-    required: (value, keys, baseLocation) => {
+    required: (value, keys, { baseLocation }) => {
         return keys
             .map((requiredKey) => !value.includes(requiredKey) && {
             message: `${requiredKey} is required`,
@@ -90,7 +90,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    disallowed: (value, condition, baseLocation) => {
+    disallowed: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined' || 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];
@@ -101,7 +101,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    const: (value, condition, baseLocation) => {
+    const: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined')
             return [];
         if (Array.isArray(value)) {
@@ -123,7 +123,7 @@ exports.asserts = {
                 : [];
         }
     },
-    undefined: (value, condition = true, baseLocation) => {
+    undefined: (value, condition = true, { baseLocation }) => {
         const isUndefined = typeof value === 'undefined';
         const isValid = condition ? isUndefined : !isUndefined;
         return isValid
@@ -135,7 +135,7 @@ exports.asserts = {
                 },
             ];
     },
-    nonEmpty: (value, condition = true, baseLocation) => {
+    nonEmpty: (value, condition = true, { baseLocation }) => {
         const isEmpty = typeof value === 'undefined' || value === null || value === '';
         const isValid = condition ? !isEmpty : isEmpty;
         return isValid
@@ -147,17 +147,27 @@ exports.asserts = {
                 },
             ];
     },
-    minLength: (value, condition, 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 }];
+        return [
+            {
+                message: `Should have at least ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
     },
-    maxLength: (value, condition, 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 }];
+        return [
+            {
+                message: `Should have at most ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
     },
-    casing: (value, condition, baseLocation) => {
+    casing: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined' || 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];
@@ -177,7 +187,7 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
-    sortOrder: (value, condition, baseLocation) => {
+    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) {
@@ -197,7 +207,7 @@ exports.asserts = {
             },
         ];
     },
-    mutuallyExclusive: (value, condition, baseLocation) => {
+    mutuallyExclusive: (value, condition, { baseLocation }) => {
         if (utils_2.getIntersectionLength(value, condition) < 2)
             return [];
         return [
@@ -207,7 +217,7 @@ exports.asserts = {
             },
         ];
     },
-    mutuallyRequired: (value, condition, baseLocation) => {
+    mutuallyRequired: (value, condition, { baseLocation }) => {
         const isValid = utils_2.getIntersectionLength(value, condition) > 0
             ? utils_2.getIntersectionLength(value, condition) === condition.length
             : true;
@@ -220,7 +230,7 @@ exports.asserts = {
                 },
             ];
     },
-    requireAny: (value, condition, baseLocation) => {
+    requireAny: (value, condition, { baseLocation }) => {
         return utils_2.getIntersectionLength(value, condition) >= 1
             ? []
             : [
@@ -230,7 +240,7 @@ exports.asserts = {
                 },
             ];
     },
-    ref: (_value, condition, baseLocation, rawValue) => {
+    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');
@@ -258,6 +268,6 @@ exports.asserts = {
     },
 };
 function buildAssertCustomFunction(fn) {
-    return (value, options, baseLocation) => fn.call(null, value, options, baseLocation);
+    return (value, options, ctx) => fn.call(null, value, options, ctx);
 }
 exports.buildAssertCustomFunction = buildAssertCustomFunction;

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

@@ -1,4 +1,5 @@
 import { Asserts } from './asserts';
+import type { AssertionContext, AssertResult } from '../../../config';
 import type { Assertion, AssertionDefinition } from '.';
 import type { Oas2Visitor, Oas3Visitor, VisitFunction } from '../../../visitors';
 export declare type OrderDirection = 'asc' | 'desc';
@@ -12,9 +13,16 @@ export declare type AssertToApply = {
     runsOnKeys: boolean;
     runsOnValues: boolean;
 };
+declare 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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = exports.getAssertsToApply = void 0;
+exports.regexFromString = exports.runAssertion = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = exports.getAssertsToApply = void 0;
 const asserts_1 = require("./asserts");
 const logger_1 = require("../../../logger");
 const ref_utils_1 = require("../../../ref-utils");
@@ -43,31 +43,23 @@ exports.getAssertsToApply = getAssertsToApply;
 function getAssertionProperties({ subject }) {
     return (Array.isArray(subject.property) ? subject.property : [subject === null || subject === void 0 ? void 0 : subject.property]).filter(Boolean);
 }
-function applyAssertions(assertionDefinition, asserts, { rawLocation, rawNode, resolve, location, node }) {
-    var _a;
+function applyAssertions(assertionDefinition, asserts, ctx) {
     const properties = getAssertionProperties(assertionDefinition);
     const assertResults = [];
     for (const assert of asserts) {
-        const currentLocation = assert.name === 'ref' ? rawLocation : location;
         if (properties.length) {
             for (const property of properties) {
-                // 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];
                 assertResults.push(runAssertion({
-                    values: value,
-                    rawValues: rawNode[property],
                     assert,
-                    location: currentLocation.child(property),
+                    ctx,
+                    assertionProperty: property,
                 }));
             }
         }
         else {
-            const value = Array.isArray(node) ? node : Object.keys(node);
             assertResults.push(runAssertion({
-                values: value,
-                rawValues: rawNode,
                 assert,
-                location: currentLocation,
+                ctx,
             }));
         }
     }
@@ -77,7 +69,7 @@ function buildVisitorObject(assertion, subjectVisitor) {
     var _a, _b;
     const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
     const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
-        ? (node, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
+        ? (_, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
         : undefined;
     const targetVisitor = {
         [assertion.subject.type]: Object.assign({ enter: subjectVisitor }, (targetVisitorSkipFunction && { skip: targetVisitorSkipFunction })),
@@ -95,14 +87,8 @@ function buildVisitorObject(assertion, subjectVisitor) {
         }
         const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
         const assertsToApply = getAssertsToApply(assertionDefinitionNode);
-        const skipFunction = (node, key, { location, rawLocation, resolve, rawNode }) => !locatorPredicates.every((predicate) => predicate(key)) ||
-            !!applyAssertions(assertionDefinitionNode, assertsToApply, {
-                location,
-                node,
-                rawLocation,
-                rawNode,
-                resolve,
-            }).length;
+        const skipFunction = (node, key, ctx) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, Object.assign(Object.assign({}, ctx), { node })).length;
         const nodeVisitor = Object.assign({}, ((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }));
         if (assertionDefinitionNode.subject.type === assertion.subject.type &&
             index === context.length - 1) {
@@ -123,23 +109,17 @@ function buildVisitorObject(assertion, subjectVisitor) {
 }
 exports.buildVisitorObject = buildVisitorObject;
 function buildSubjectVisitor(assertId, assertion) {
-    return (node, { report, location, rawLocation, resolve, rawNode }) => {
+    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), {
-            rawLocation,
-            rawNode,
-            resolve,
-            location,
-            node,
-        });
+        const problems = applyAssertions(assertion, getAssertsToApply(assertion), Object.assign(Object.assign({}, ctx), { node }));
         if (problems.length) {
             for (const problemGroup of groupProblemsByPointer(problems)) {
                 const message = assertion.message || defaultMessage;
                 const problemMessage = getProblemsMessage(problemGroup);
-                report({
+                ctx.report({
                     message: message.replace(assertionMessageTemplates.problems, problemMessage),
-                    location: getProblemsLocation(problemGroup) || location,
+                    location: getProblemsLocation(problemGroup) || ctx.location,
                     forceSeverity: assertion.severity || 'error',
                     suggest: assertion.suggest || [],
                     ruleId: assertId,
@@ -207,9 +187,23 @@ function isOrdered(value, options) {
     return true;
 }
 exports.isOrdered = isOrdered;
-function runAssertion({ values, rawValues, assert, location }) {
-    return asserts_1.asserts[assert.name](values, assert.conditions, location, rawValues);
+function runAssertion({ assert, ctx, assertionProperty, }) {
+    var _a;
+    const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
+    if (assertionProperty) {
+        const values = ref_utils_1.isRef(ctx.node[assertionProperty])
+            ? (_a = ctx.resolve(ctx.node[assertionProperty])) === null || _a === void 0 ? void 0 : _a.node
+            : ctx.node[assertionProperty];
+        const rawValues = ctx.rawNode[assertionProperty];
+        const location = currentLocation.child(assertionProperty);
+        return asserts_1.asserts[assert.name](values, assert.conditions, Object.assign(Object.assign({}, 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, Object.assign(Object.assign({}, ctx), { rawValue: ctx.rawNode, baseLocation: currentLocation }));
+    }
 }
+exports.runAssertion = runAssertion;
 function regexFromString(input) {
     const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
     return matches && new RegExp(matches[1] || matches[3], matches[2]);

package/lib/rules/common/required-string-property-missing-min-length.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from 'core/src/visitors';
+export declare const RequiredStringPropertyMissingMunLength: Oas3Rule;

package/lib/rules/common/required-string-property-missing-min-length.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredStringPropertyMissingMunLength = void 0;
+const RequiredStringPropertyMissingMunLength = () => {
+    let skipSchemaProperties;
+    let requiredPropertiesSet;
+    return {
+        Schema: {
+            enter(schema) {
+                if (!(schema === null || schema === void 0 ? void 0 : schema.required)) {
+                    skipSchemaProperties = true;
+                    return;
+                }
+                requiredPropertiesSet = new Set(schema.required);
+                skipSchemaProperties = false;
+            },
+            SchemaProperties: {
+                skip() {
+                    return skipSchemaProperties;
+                },
+                Schema: {
+                    enter(schema, { key, location, report }) {
+                        if (requiredPropertiesSet.has(key) && schema.type === 'string') {
+                            if (!(schema === null || schema === void 0 ? void 0 : schema.minLength)) {
+                                report({
+                                    message: 'Property minLength is required.',
+                                    location: location.key(),
+                                });
+                            }
+                        }
+                    },
+                },
+            },
+        },
+    };
+};
+exports.RequiredStringPropertyMissingMunLength = RequiredStringPropertyMissingMunLength;

package/lib/rules/oas2/index.d.ts

@@ -41,5 +41,6 @@ export declare const rules: {
     'response-contains-header': Oas2Rule;
     'response-contains-property': Oas2Rule;
     'scalar-property-missing-example': import("../../visitors").Oas3Rule | Oas2Rule;
+    'required-string-property-missing-min-length': import("../../visitors").Oas3Rule;
 };
 export declare const preprocessors: {};

package/lib/rules/oas2/index.js

@@ -41,6 +41,7 @@ const path_segment_plural_1 = require("../common/path-segment-plural");
 const response_contains_header_1 = require("../common/response-contains-header");
 const response_contains_property_1 = require("./response-contains-property");
 const scalar_property_missing_example_1 = require("../common/scalar-property-missing-example");
+const required_string_property_missing_min_length_1 = require("../common/required-string-property-missing-min-length");
 exports.rules = {
     spec: spec_1.OasSpec,
     'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
@@ -83,5 +84,6 @@ exports.rules = {
     'response-contains-header': response_contains_header_1.ResponseContainsHeader,
     'response-contains-property': response_contains_property_1.ResponseContainsProperty,
     'scalar-property-missing-example': scalar_property_missing_example_1.ScalarPropertyMissingExample,
+    'required-string-property-missing-min-length': required_string_property_missing_min_length_1.RequiredStringPropertyMissingMunLength,
 };
 exports.preprocessors = {};

package/lib/rules/oas3/index.js

@@ -51,6 +51,7 @@ const response_contains_property_1 = require("./response-contains-property");
 const scalar_property_missing_example_1 = require("../common/scalar-property-missing-example");
 const spec_components_invalid_map_name_1 = require("./spec-components-invalid-map-name");
 const operation_4xx_problem_details_rfc7807_1 = require("./operation-4xx-problem-details-rfc7807");
+const required_string_property_missing_min_length_1 = require("../common/required-string-property-missing-min-length");
 exports.rules = {
     spec: spec_1.OasSpec,
     'info-contact': info_contact_1.InfoContact,
@@ -103,5 +104,6 @@ exports.rules = {
     'response-contains-property': response_contains_property_1.ResponseContainsProperty,
     'scalar-property-missing-example': scalar_property_missing_example_1.ScalarPropertyMissingExample,
     'spec-components-invalid-map-name': spec_components_invalid_map_name_1.SpecComponentsInvalidMapName,
+    'required-string-property-missing-min-length': required_string_property_missing_min_length_1.RequiredStringPropertyMissingMunLength,
 };
 exports.preprocessors = {};

package/lib/types/redocly-yaml.js

@@ -55,6 +55,7 @@ const builtInRulesList = [
     'response-contains-property',
     'scalar-property-missing-example',
     'spec-components-invalid-map-name',
+    'required-string-property-missing-min-length',
 ];
 const nodeTypesList = [
     'any',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.123",
+  "version": "1.0.0-beta.125",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/bundle.ts

@@ -5,7 +5,7 @@ import { Oas3Types } from './types/oas3';
 import { Oas2Types } from './types/oas2';
 import { Oas3_1Types } from './types/oas3_1';
 import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
-import { WalkContext, walkDocument, UserContext, ResolveResult } from './walk';
+import { WalkContext, walkDocument, UserContext, ResolveResult, NormalizedProblem } from './walk';
 import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
 import { isAbsoluteUrl, isRef, Location, refBaseName } from './ref-utils';
 import { initRules } from './config/rules';
@@ -64,6 +64,15 @@ export async function bundle(opts: {
 
 type BundleContext = WalkContext;
 
+export type BundleResult = {
+  bundle: Document;
+  problems: NormalizedProblem[];
+  fileDependencies: Set<string>;
+  rootType: NormalizedNodeType;
+  refTypes?: Map<string, NormalizedNodeType>;
+  visitorsData: Record<string, Record<string, unknown>>;
+};
+
 export async function bundleDocument(opts: {
   document: Document;
   config: StyleguideConfig;
@@ -73,7 +82,7 @@ export async function bundleDocument(opts: {
   skipRedoclyRegistryRefs?: boolean;
   removeUnusedComponents?: boolean;
   keepUrlRefs?: boolean;
-}) {
+}): Promise<BundleResult> {
   const {
     document,
     config,