@redocly/openapi-core 1.0.0-beta.63 → 1.0.0-beta.67

package/lib/types/redocly-yaml.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigTypes = void 0;
 const _1 = require(".");
+const utils_1 = require("../utils");
 const ConfigRoot = {
     properties: {
         apiDefinitions: {
             type: 'object',
             properties: {},
-            additionalProperties: { properties: { type: 'string' } }
+            additionalProperties: { properties: { type: 'string' } },
         },
         lint: 'ConfigLint',
         referenceDocs: 'ConfigReferenceDocs',
@@ -87,25 +88,297 @@ const ConfigSidebarLinks = {
         target: { type: 'string' },
     },
 };
+const CommonThemeColors = {
+    properties: {
+        main: { type: 'string' },
+        light: { type: 'string' },
+        dark: { type: 'string' },
+        contrastText: { type: 'string' },
+    },
+};
+const CommonColorProps = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        borderColor: { type: 'string' },
+        color: { type: 'string' },
+        tabTextColor: { type: 'string' },
+    },
+};
+const BorderThemeColors = {
+    properties: utils_1.pickObjectProps(CommonThemeColors.properties, ['light', 'dark']),
+};
+const HttpColors = {
+    properties: {
+        basic: { type: 'string' },
+        delete: { type: 'string' },
+        get: { type: 'string' },
+        head: { type: 'string' },
+        link: { type: 'string' },
+        options: { type: 'string' },
+        patch: { type: 'string' },
+        post: { type: 'string' },
+        put: { type: 'string' },
+    },
+};
+const ResponseColors = {
+    properties: {
+        errors: 'CommonColorProps',
+        info: 'CommonColorProps',
+        redirect: 'CommonColorProps',
+        success: 'CommonColorProps',
+    },
+};
+const SecondaryColors = {
+    properties: utils_1.omitObjectProps(CommonThemeColors.properties, ['dark']),
+};
+const TextThemeColors = {
+    properties: {
+        primary: { type: 'string' },
+        secondary: { type: 'string' },
+        light: { type: 'string' },
+    },
+};
+const ThemeColors = {
+    properties: {
+        accent: 'CommonThemeColors',
+        border: 'BorderThemeColors',
+        error: 'CommonThemeColors',
+        http: 'HttpColors',
+        primary: 'CommonThemeColors',
+        responses: 'ResponseColors',
+        secondary: 'SecondaryColors',
+        success: 'CommonThemeColors',
+        text: 'TextThemeColors',
+        tonalOffset: { type: 'number' },
+        warning: 'CommonThemeColors',
+    },
+};
+const SizeProps = {
+    properties: {
+        fontSize: { type: 'string' },
+        padding: { type: 'string' },
+        minWidth: { type: 'string' },
+    },
+};
+const Sizes = {
+    properties: {
+        small: 'SizeProps',
+        medium: 'SizeProps',
+        large: 'SizeProps',
+        xlarge: 'SizeProps',
+    },
+};
+const FontConfig = {
+    properties: {
+        fontFamily: { type: 'string' },
+        fontSize: { type: 'string' },
+        fontWeight: { type: 'string' },
+        lineHeight: { type: 'string' },
+    },
+};
+const ButtonsConfig = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, hoverStyle: { type: 'string' }, boxShadow: { type: 'string' }, hoverBoxShadow: { type: 'string' }, sizes: 'Sizes' }),
+};
+const BadgeFontConfig = {
+    properties: utils_1.pickObjectProps(FontConfig.properties, ['fontSize', 'lineHeight']),
+};
+const BadgeSizes = {
+    properties: {
+        medium: 'BadgeFontConfig',
+        small: 'BadgeFontConfig',
+    },
+};
+const HttpBadgesConfig = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, color: { type: 'string' }, sizes: 'BadgeSizes' }),
+};
+const LabelControls = {
+    properties: {
+        top: { type: 'string' },
+    },
+};
+const Panels = {
+    properties: {
+        borderRadius: { type: 'string' },
+    },
+};
+const TryItButton = {
+    properties: {
+        fullWidth: { type: 'boolean' },
+    },
+};
+const Components = {
+    properties: {
+        buttons: 'ButtonsConfig',
+        httpBadges: 'HttpBadgesConfig',
+        layoutControls: 'LabelControls',
+        panels: 'Panels',
+        tryItButton: 'TryItButton',
+        tryItSendButton: 'TryItButton',
+    },
+};
+const Breakpoints = {
+    properties: {
+        small: { type: 'string' },
+        medium: { type: 'string' },
+        large: { type: 'string' },
+    },
+};
+const StackedConfig = {
+    properties: {
+        maxWidth: 'Breakpoints',
+    },
+};
+const ThreePanelConfig = {
+    properties: {
+        maxWidth: 'Breakpoints',
+    },
+};
+const Layout = {
+    properties: {
+        showDarkRightPanel: { type: 'boolean' },
+        stacked: 'StackedConfig',
+        'three-panel': 'ThreePanelConfig',
+    },
+};
+const SchemaColorsConfig = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        border: { type: 'string' },
+    },
+};
+const Schema = {
+    properties: {
+        breakFieldNames: { type: 'boolean' },
+        caretColor: { type: 'string' },
+        caretSize: { type: 'string' },
+        constraints: 'SchemaColorsConfig',
+        defaultDetailsWidth: { type: 'string' },
+        examples: 'SchemaColorsConfig',
+        labelsTextSize: { type: 'string' },
+        linesColor: { type: 'string' },
+        nestedBackground: { type: 'string' },
+        nestingSpacing: { type: 'string' },
+        requireLabelColor: { type: 'string' },
+        typeNameColor: { type: 'string' },
+        typeTitleColor: { type: 'string' },
+    },
+};
+const GroupItemsConfig = {
+    properties: {
+        subItemsColor: { type: 'string' },
+        textTransform: { type: 'string' },
+        fontWeight: { type: 'string' },
+    },
+};
+const Level1Items = {
+    properties: utils_1.pickObjectProps(GroupItemsConfig.properties, ['textTransform']),
+};
+const SpacingConfig = {
+    properties: {
+        unit: { type: 'number' },
+        paddingHorizontal: { type: 'string' },
+        paddingVertical: { type: 'string' },
+        offsetTop: { type: 'string' },
+        offsetLeft: { type: 'string' },
+        offsetNesting: { type: 'string' },
+    },
+};
+const Sidebar = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontWeight', 'lineHeight'])), { activeBgColor: { type: 'string' }, activeTextColor: { type: 'string' }, backgroundColor: { type: 'string' }, borderRadius: { type: 'string' }, breakPath: { type: 'boolean' }, caretColor: { type: 'string' }, caretSize: { type: 'string' }, groupItems: 'GroupItemsConfig', level1items: 'Level1Items', rightLineColor: { type: 'string' }, separatorLabelColor: { type: 'string' }, showAtBreakpoint: { type: 'string' }, spacing: 'SpacingConfig', textColor: { type: 'string' }, width: { type: 'string' } }),
+};
+const Heading = {
+    properties: Object.assign(Object.assign({}, FontConfig.properties), { color: { type: 'string' }, transform: { type: 'string' } }),
+};
+const CodeConfig = {
+    properties: Object.assign(Object.assign({}, FontConfig.properties), { backgroundColor: { type: 'string' }, color: { type: 'string' }, wordBreak: { type: 'string' }, wrap: { type: 'boolean' } }),
+};
+const HeadingsConfig = {
+    properties: utils_1.omitObjectProps(FontConfig.properties, ['fontSize']),
+};
+const LinksConfig = {
+    properties: {
+        color: { type: 'string' },
+        hover: { type: 'string' },
+        textDecoration: { type: 'string' },
+        visited: { type: 'string' },
+    },
+};
+const Typography = {
+    properties: Object.assign(Object.assign({ code: 'CodeConfig', fieldName: 'FontConfig' }, utils_1.pickObjectProps(FontConfig.properties, ['fontSize', 'fontFamily'])), { fontWeightBold: { type: 'string' }, fontWeightLight: { type: 'string' }, fontWeightRegular: { type: 'string' }, heading1: 'Heading', heading2: 'Heading', heading3: 'Heading', headings: 'HeadingsConfig', lineHeight: { type: 'string' }, links: 'LinksConfig', optimizeSpeed: { type: 'boolean' }, rightPanelHeading: 'Heading', smoothing: { type: 'string' } }),
+};
+const TokenProps = {
+    properties: Object.assign({ color: { type: 'string' } }, utils_1.omitObjectProps(FontConfig.properties, ['fontWeight'])),
+};
+const CodeBlock = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        borderRadius: { type: 'string' },
+        tokens: 'TokenProps',
+    },
+};
+const Logo = {
+    properties: {
+        gutter: { type: 'string' },
+        maxHeight: { type: 'string' },
+        maxWidth: { type: 'string' },
+    },
+};
+const ButtonOverrides = {
+    properties: {
+        custom: { type: 'string' },
+    },
+};
+const Overrides = {
+    properties: {
+        DownloadButton: 'ButtonOverrides',
+        NextSectionButton: 'ButtonOverrides',
+    },
+};
+const RightPanel = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        panelBackgroundColor: { type: 'string' },
+        panelControlsBackgroundColor: { type: 'string' },
+        showAtBreakpoint: { type: 'string' },
+        textColor: { type: 'string' },
+        width: { type: 'string' },
+    },
+};
+const Shape = {
+    properties: { borderRadius: { type: 'string' } },
+};
+const ThemeSpacing = {
+    properties: {
+        sectionHorizontal: { type: 'number' },
+        sectionVertical: { type: 'number' },
+        unit: { type: 'number' },
+    },
+};
 const ConfigTheme = {
     properties: {
-        breakpoints: { type: 'object', additionalProperties: { type: 'string' } },
-        codeBlock: { type: 'object', additionalProperties: { type: 'string' } },
-        colors: { type: 'object', additionalProperties: { type: 'string' } },
-        components: { type: 'object', additionalProperties: { type: 'string' } },
-        layout: { type: 'object', additionalProperties: { type: 'string' } },
-        logo: { type: 'object', additionalProperties: { type: 'string' } },
-        overrides: { type: 'object', additionalProperties: { type: 'string' } },
-        rightPanel: { type: 'object', additionalProperties: { type: 'string' } },
-        schema: { type: 'object', additionalProperties: { type: 'string' } },
-        shape: { type: 'object', additionalProperties: { type: 'string' } },
-        sidebar: { type: 'object', additionalProperties: { type: 'string' } },
-        spacing: { type: 'object', additionalProperties: { type: 'string' } },
-        typography: { type: 'object', additionalProperties: { type: 'string' } },
+        breakpoints: 'Breakpoints',
+        codeBlock: 'CodeBlock',
+        colors: 'ThemeColors',
+        components: 'Components',
+        layout: 'Layout',
+        logo: 'Logo',
+        overrides: 'Overrides',
+        rightPanel: 'RightPanel',
+        schema: 'Schema',
+        shape: 'Shape',
+        sidebar: 'Sidebar',
+        spacing: 'ThemeSpacing',
+        typography: 'Typography',
         links: { properties: { color: { type: 'string' } } },
         codeSample: { properties: { backgroundColor: { type: 'string' } } },
     },
 };
+const GenerateCodeSamples = {
+    properties: {
+        skipOptionalParameters: { type: 'boolean' },
+        languages: _1.listOf('ConfigLanguage'),
+    },
+};
 const ConfigReferenceDocs = {
     properties: {
         theme: 'ConfigTheme',
@@ -119,12 +392,7 @@ const ConfigReferenceDocs = {
         expandDefaultServerVariables: { type: 'boolean' },
         expandResponses: { type: 'string' },
         expandSingleSchemaField: { type: 'boolean' },
-        generateCodeSamples: {
-            properties: {
-                skipOptionalParameters: { type: 'boolean' },
-                languages: _1.listOf('ConfigLanguage'),
-            },
-        },
+        generateCodeSamples: 'GenerateCodeSamples',
         generatedPayloadSamplesMaxDepth: { type: 'number' },
         hideDownloadButton: { type: 'boolean' },
         hideHostname: { type: 'boolean' },
@@ -138,7 +406,7 @@ const ConfigReferenceDocs = {
         htmlTemplate: { type: 'string' },
         jsonSampleExpandLevel: { type: 'string' },
         labels: 'ConfigLabels',
-        layout: { type: 'object' },
+        layout: { type: 'string' },
         maxDisplayedEnumValues: { type: 'number' },
         menuToggle: { type: 'boolean' },
         nativeScrollbars: { type: 'boolean' },
@@ -186,4 +454,47 @@ exports.ConfigTypes = {
     ConfigLabels,
     ConfigSidebarLinks,
     ConfigTheme,
+    ThemeColors,
+    CommonThemeColors,
+    BorderThemeColors,
+    HttpColors,
+    ResponseColors,
+    SecondaryColors,
+    TextThemeColors,
+    Sizes,
+    ButtonsConfig,
+    CommonColorProps,
+    BadgeFontConfig,
+    BadgeSizes,
+    HttpBadgesConfig,
+    LabelControls,
+    Panels,
+    TryItButton,
+    Breakpoints,
+    StackedConfig,
+    ThreePanelConfig,
+    SchemaColorsConfig,
+    SizeProps,
+    Level1Items,
+    SpacingConfig,
+    FontConfig,
+    CodeConfig,
+    HeadingsConfig,
+    LinksConfig,
+    TokenProps,
+    CodeBlock,
+    Logo,
+    ButtonOverrides,
+    Overrides,
+    RightPanel,
+    Shape,
+    ThemeSpacing,
+    GenerateCodeSamples,
+    GroupItemsConfig,
+    Components,
+    Layout,
+    Schema,
+    Sidebar,
+    Heading,
+    Typography,
 };

package/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import { HttpResolveConfig } from './config/config';
+import { UserContext } from './walk';
 export { parseYaml, stringifyYaml } from './js-yaml';
 export declare type StackFrame<T> = {
     prev: StackFrame<T> | null;
@@ -20,3 +21,15 @@ export declare function readFileFromUrl(url: string, config: HttpResolveConfig):
     mimeType: any;
 }>;
 export declare function match(url: string, pattern: string): boolean;
+export declare function pickObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function omitObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function splitCamelCaseIntoWords(str: string): Set<string>;
+export declare function validateMimeType({ type, value }: any, { report, location }: UserContext, allowedValues: string[]): void;
+export declare function validateMimeTypeOAS3({ type, value }: any, { report, location }: UserContext, allowedValues: string[]): void;
+export declare function isSingular(path: string): boolean;
+export declare function readFileAsStringSync(filePath: string): string;
+export declare function isPathParameter(pathSegment: string): boolean;
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+export declare function slash(path: string): string;

package/lib/utils.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
+const pluralize = require("pluralize");
 const js_yaml_1 = require("./js-yaml");
 var js_yaml_2 = require("./js-yaml");
 Object.defineProperty(exports, "parseYaml", { enumerable: true, get: function () { return js_yaml_2.parseYaml; } });
@@ -68,3 +69,78 @@ function match(url, pattern) {
     return minimatch(url, pattern);
 }
 exports.match = match;
+function pickObjectProps(object, keys) {
+    return Object.fromEntries(keys.filter((key) => key in object).map((key) => [key, object[key]]));
+}
+exports.pickObjectProps = pickObjectProps;
+function omitObjectProps(object, keys) {
+    return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+}
+exports.omitObjectProps = omitObjectProps;
+function splitCamelCaseIntoWords(str) {
+    const camel = str
+        .split(/(?:[-._])|([A-Z][a-z]+)/)
+        .filter(Boolean)
+        .map((item) => item.toLocaleLowerCase());
+    const caps = str
+        .split(/([A-Z]{2,})/)
+        .filter((e) => e && e === e.toUpperCase())
+        .map((item) => item.toLocaleLowerCase());
+    return new Set([...camel, ...caps]);
+}
+exports.splitCamelCaseIntoWords = splitCamelCaseIntoWords;
+function validateMimeType({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value[type])
+        return;
+    for (const mime of value[type]) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child(value[type].indexOf(mime)).key(),
+            });
+        }
+    }
+}
+exports.validateMimeType = validateMimeType;
+function validateMimeTypeOAS3({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value.content)
+        return;
+    for (const mime of Object.keys(value.content)) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child('content').child(mime).key(),
+            });
+        }
+    }
+}
+exports.validateMimeTypeOAS3 = validateMimeTypeOAS3;
+function isSingular(path) {
+    return pluralize.isSingular(path);
+}
+exports.isSingular = isSingular;
+function readFileAsStringSync(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+exports.readFileAsStringSync = readFileAsStringSync;
+function isPathParameter(pathSegment) {
+    return pathSegment.startsWith('{') && pathSegment.endsWith('{');
+}
+exports.isPathParameter = isPathParameter;
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, '/');
+}
+exports.slash = slash;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.63",
+  "version": "1.0.0-beta.67",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -30,7 +30,7 @@
     "Andriy Leliv <andriy@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/ajv": "^8.6.2",
+    "@redocly/ajv": "^8.6.4",
     "@types/node": "^14.11.8",
     "colorette": "^1.2.0",
     "js-levenshtein": "^1.1.6",
@@ -38,6 +38,7 @@
     "lodash.isequal": "^4.5.0",
     "minimatch": "^3.0.4",
     "node-fetch": "^2.6.1",
+    "pluralize": "^8.0.0",
     "yaml-ast-parser": "0.0.43"
   },
   "devDependencies": {
@@ -46,6 +47,7 @@
     "@types/lodash.isequal": "^4.5.5",
     "@types/minimatch": "^3.0.3",
     "@types/node-fetch": "^2.5.7",
+    "@types/pluralize": "^0.0.29",
     "typescript": "^4.0.5"
   }
 }

package/src/__tests__/lint.test.ts

@@ -87,6 +87,19 @@ describe('lint', () => {
           "severity": "error",
           "suggest": Array [],
         },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/referenceDocs/layout",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "Expected type \`string\` but got \`object\`.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
       ]
     `);
   });

package/src/__tests__/utils.test.ts

@@ -0,0 +1,74 @@
+import { pickObjectProps, omitObjectProps, slash } from '../utils';
+
+describe('utils', () => {
+  const testObject = {
+    a: 'value a',
+    b: 'value b',
+    c: 'value c',
+    d: 'value d',
+    e: 'value e',
+  };
+
+  describe('pickObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(pickObjectProps(testObject, ['a', 'b'])).toStrictEqual({ a: 'value a', b: 'value b' });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(pickObjectProps(testObject, ['a', 'b', 'nonExisting'])).toStrictEqual({
+        a: 'value a',
+        b: 'value b',
+      });
+    });
+
+    it('returns an empty object if no keys are passed', () => {
+      expect(pickObjectProps(testObject, [])).toStrictEqual({});
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(pickObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+
+  describe('omitObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c', 'nonExisting'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns full object if no keys are passed', () => {
+      expect(omitObjectProps(testObject, [])).toStrictEqual(testObject);
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(omitObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+
+  describe('slash path', () => {
+    it('can correctly slash path', () => {
+      [
+        ['foo\\bar', 'foo/bar'],
+        ['foo/bar', 'foo/bar'],
+        ['foo\\中文', 'foo/中文'],
+        ['foo/中文', 'foo/中文'],
+      ].forEach(([path, expectRes]) => {
+        expect(slash(path)).toBe(expectRes);
+      });
+    });
+
+    it('does not modify extended length paths', () => {
+      const extended = '\\\\?\\some\\path';
+      expect(slash(extended)).toBe(extended);
+    });
+  });
+});

package/src/config/all.ts

@@ -12,11 +12,13 @@ export default {
     'no-identical-paths': 'error',
     'no-ambiguous-paths': 'error',
     'no-path-trailing-slash': 'error',
+    'path-segment-plural': 'error',
     'path-declaration-must-exist': 'error',
     'path-not-include-query': 'error',
     'path-parameters-defined': 'error',
     'operation-description': 'error',
     'operation-2xx-response': 'error',
+    'operation-4xx-response': 'error',
     'operation-operationId': 'error',
     'operation-summary': 'error',
     'operation-operationId-unique': 'error',
@@ -29,6 +31,12 @@ export default {
     'no-enum-type-mismatch': 'error',
     'boolean-parameter-prefixes': 'error',
     'paths-kebab-case': 'error',
+    'no-http-verbs-in-paths': 'error',
+    'path-excludes-patterns': {
+      severity: 'error',
+      patterns: [],
+    },
+    'request-mime-type': 'error',
     spec: 'error',
   },
   oas3_0Rules: {
@@ -49,5 +57,5 @@ export default {
     'no-unused-components': 'error',
     'no-undefined-server-variable': 'error',
     'no-servers-empty-enum': 'error',
-  }
+  },
 } as LintRawConfig;

package/src/config/config.ts

@@ -4,7 +4,7 @@ import { dirname } from 'path';
 import { red, blue } from 'colorette';
 
 import { parseYaml, stringifyYaml } from '../js-yaml';
-import { notUndefined } from '../utils';
+import { notUndefined, slash } from '../utils';
 
 import {
   OasVersion,
@@ -211,7 +211,7 @@ export class LintConfig {
     const ignoreFile = path.join(dir, IGNORE_FILE);
     const mapped: Record<string, any> = {};
     for (const absFileName of Object.keys(this.ignore)) {
-      const ignoredRules = (mapped[path.relative(dir, absFileName)] = this.ignore[absFileName]);
+      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] = this.ignore[absFileName]);
       for (const ruleId of Object.keys(ignoredRules)) {
         ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
       }