@redocly/openapi-core 1.0.0-beta.124 → 1.0.0-beta.126

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

@@ -36,7 +36,14 @@ exports.default = {
             severity: 'error',
             patterns: [],
         },
-        'request-mime-type': 'error',
+        'request-mime-type': {
+            severity: 'error',
+            allowedValues: ['application/json'],
+        },
+        'response-mime-type': {
+            severity: 'error',
+            allowedValues: ['application/json'],
+        },
         spec: 'error',
         'no-invalid-schema-examples': 'error',
         'no-invalid-parameter-examples': 'error',

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

@@ -110,12 +110,16 @@ class BaseResolver {
                     return new Source(absoluteRef, body, mimeType);
                 }
                 else {
+                    if (fs.lstatSync(absoluteRef).isDirectory()) {
+                        throw new Error(`Expected a file but received a folder at ${absoluteRef}`);
+                    }
                     const content = yield fs.promises.readFile(absoluteRef, 'utf-8');
                     // In some cases file have \r\n line delimeters like on windows, we should skip it.
                     return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
                 }
             }
             catch (error) {
+                error.message = error.message.replace(', lstat', '');
                 throw new ResolveError(error);
             }
         });
@@ -204,7 +208,7 @@ function resolveDocument(opts) {
                 if (Array.isArray(node)) {
                     const itemsType = type.items;
                     // we continue resolving unknown types, but stop early on known scalars
-                    if (type !== unknownType && itemsType === undefined) {
+                    if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                         return;
                     }
                     for (let i = 0; i < node.length; i++) {

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 RequiredStringPropertyMissingMinLength: 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.RequiredStringPropertyMissingMinLength = void 0;
+const RequiredStringPropertyMissingMinLength = () => {
+    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.RequiredStringPropertyMissingMinLength = RequiredStringPropertyMissingMinLength;

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.RequiredStringPropertyMissingMinLength,
 };
 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.RequiredStringPropertyMissingMinLength,
 };
 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.124",
+  "version": "1.0.0-beta.126",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/__tests__/resolve.test.ts

@@ -5,6 +5,7 @@ import { resolveDocument, BaseResolver, Document } from '../resolve';
 import { parseYamlToDocument } from '../../__tests__/utils';
 import { Oas3Types } from '../types/oas3';
 import { normalizeTypes } from '../types';
+import * as fs from 'fs';
 
 describe('collect refs', () => {
   it('should resolve local refs', async () => {
@@ -405,4 +406,25 @@ describe('collect refs', () => {
 
     expect(Array.from(resolvedRefs.values()).pop()!.node).toEqual({ type: 'string' });
   });
+
+  it('should throw error if ref is folder', async () => {
+    const cwd = path.join(__dirname, 'fixtures/resolve');
+    const rootDocument = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        components:
+          $ref: "./transitive/components.yaml#/components/schemas/a"
+      `,
+      path.join(cwd, 'foobar')
+    );
+    jest.spyOn(fs, 'lstatSync').mockImplementation((_) => ({ isDirectory: () => true } as any));
+
+    const resolvedRefs = await resolveDocument({
+      rootDocument,
+      externalRefResolver: new BaseResolver(),
+      rootType: normalizeTypes(Oas3Types).Root,
+    });
+
+    expect(Array.from(resolvedRefs.values()).pop()!.error).toBeInstanceOf(Error);
+  });
 });

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,

package/src/config/all.ts

@@ -36,7 +36,14 @@ export default {
       severity: 'error',
       patterns: [],
     },
-    'request-mime-type': 'error',
+    'request-mime-type': {
+      severity: 'error',
+      allowedValues: ['application/json'],
+    },
+    'response-mime-type': {
+      severity: 'error',
+      allowedValues: ['application/json'],
+    },
     spec: 'error',
     'no-invalid-schema-examples': 'error',
     'no-invalid-parameter-examples': 'error',

package/src/config/types.ts

@@ -1,4 +1,4 @@
-import type { ProblemSeverity } from '../walk';
+import type { ProblemSeverity, UserContext } from '../walk';
 import type {
   Oas3PreprocessorsSet,
   OasMajorVersion,
@@ -11,6 +11,7 @@ import type {
 } from '../oas-types';
 import type { NodeType } from '../types';
 import { Location } from '../ref-utils';
+import { SkipFunctionContext } from '../visitors';
 
 export type RuleSeverity = ProblemSeverity | 'off';
 
@@ -86,6 +87,8 @@ export type CustomRulesConfig = {
   oas2?: Oas2RuleSet;
 };
 
+export type AssertionContext = Partial<UserContext> & SkipFunctionContext & { node: any };
+
 export type AssertResult = { message?: string; location?: Location };
 export type CustomFunction = (
   value: any,