@redocly/openapi-core 1.19.0 → 1.20.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @redocly/openapi-core
 
+## 1.20.1
+
+## 1.20.0
+
+### Minor Changes
+
+- Added support for ESM plugins and importing of plugins directly from npm package: `@vendor/package/plugin.js` instead of `./node_modules/@vendor/package/plugin.js`.
+- Added `info-license-strict` rule as a replacement of the `info-license-url` to support the OpenAPI 3.1 changes to allow identifier or URL license details.
+- Changed plugins format to export a function instead of an object for compatibility with other Redocly products. The backwards compatibility with an old format of plugins is maintained.
+
+### Patch Changes
+
+- Updated @redocly/config to v0.9.0.
+
 ## 1.19.0
 
 ### Minor Changes

package/__tests__/utils.ts

@@ -45,7 +45,7 @@ export const yamlSerializer = {
   },
 };
 
-export function makeConfigForRuleset(
+export async function makeConfigForRuleset(
   rules: Oas3RuleSet,
   plugin?: Partial<Plugin>,
   version: string = 'oas3'
@@ -55,7 +55,7 @@ export function makeConfigForRuleset(
   Object.keys(rules).forEach((name) => {
     rulesConf[`${ruleId}/${name}`] = 'error';
   });
-  const plugins = resolvePlugins([
+  const plugins = await resolvePlugins([
     {
       ...plugin,
       id: ruleId,
@@ -69,17 +69,24 @@ export function makeConfigForRuleset(
   });
 }
 
-export async function makeConfig(
-  rules: Record<string, RuleConfig>,
-  decorators?: Record<string, DecoratorConfig>,
-  configPath?: string
-) {
+export async function makeConfig({
+  rules,
+  decorators,
+  configPath,
+  arazzoRules,
+}: {
+  rules: Record<string, RuleConfig>;
+  decorators?: Record<string, DecoratorConfig>;
+  configPath?: string;
+  arazzoRules?: Record<string, RuleConfig>;
+}) {
   return new StyleguideConfig(
     await resolveStyleguideConfig({
       styleguideConfig: {
         plugins: [],
         extends: [],
         rules,
+        arazzoRules,
         decorators,
       },
     }),

package/lib/benchmark/benches/lint-with-many-rules.bench.d.ts

@@ -1,3 +1,4 @@
 export declare const name = "Validate with 50 top-level rules";
 export declare const count = 10;
+export declare function setupAsync(): Promise<void>;
 export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-many-rules.bench.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.count = exports.name = void 0;
+exports.setupAsync = setupAsync;
 exports.measureAsync = measureAsync;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -24,7 +25,10 @@ for (let i = 0; i < 50; i++) {
         };
     };
 }
-const config = (0, utils_1.makeConfigForRuleset)(ruleset);
+let config;
+async function setupAsync() {
+    config = await (0, utils_1.makeConfigForRuleset)(ruleset);
+}
 function measureAsync() {
     return (0, lint_1.lintDocument)({
         externalRefResolver: new resolve_1.BaseResolver(),

package/lib/benchmark/benches/lint-with-nested-rule.bench.d.ts

@@ -1,3 +1,4 @@
 export declare const name = "Validate with single nested rule";
 export declare const count = 10;
+export declare function setupAsync(): Promise<void>;
 export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-nested-rule.bench.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.count = exports.name = void 0;
+exports.setupAsync = setupAsync;
 exports.measureAsync = measureAsync;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -30,7 +31,10 @@ const visitor = {
         };
     },
 };
-const config = (0, utils_1.makeConfigForRuleset)(visitor);
+let config;
+async function setupAsync() {
+    config = await (0, utils_1.makeConfigForRuleset)(visitor);
+}
 function measureAsync() {
     return (0, lint_1.lintDocument)({
         externalRefResolver: new resolve_1.BaseResolver(),

package/lib/benchmark/benches/lint-with-no-rules.bench.d.ts

@@ -1,3 +1,4 @@
 export declare const name = "Validate with no rules";
 export declare const count = 10;
+export declare function setupAsync(): Promise<void>;
 export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-no-rules.bench.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.count = exports.name = void 0;
+exports.setupAsync = setupAsync;
 exports.measureAsync = measureAsync;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -11,7 +12,10 @@ exports.name = 'Validate with no rules';
 exports.count = 10;
 const rebillyDefinitionRef = (0, path_1.resolve)((0, path_1.join)(__dirname, 'rebilly.yaml'));
 const rebillyDocument = (0, utils_1.parseYamlToDocument)((0, fs_1.readFileSync)(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
-const config = (0, utils_1.makeConfigForRuleset)({});
+let config;
+async function setupAsync() {
+    config = await (0, utils_1.makeConfigForRuleset)({});
+}
 function measureAsync() {
     return (0, lint_1.lintDocument)({
         externalRefResolver: new resolve_1.BaseResolver(),

package/lib/benchmark/benches/lint-with-top-level-rule-report.bench.d.ts

@@ -1,3 +1,4 @@
 export declare const name = "Validate with single top-level rule and report";
 export declare const count = 10;
+export declare function setupAsync(): Promise<void>;
 export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-top-level-rule-report.bench.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.count = exports.name = void 0;
+exports.setupAsync = setupAsync;
 exports.measureAsync = measureAsync;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -11,19 +12,22 @@ exports.name = 'Validate with single top-level rule and report';
 exports.count = 10;
 const rebillyDefinitionRef = (0, path_1.resolve)((0, path_1.join)(__dirname, 'rebilly.yaml'));
 const rebillyDocument = (0, utils_1.parseYamlToDocument)((0, fs_1.readFileSync)(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
-const config = (0, utils_1.makeConfigForRuleset)({
-    test: () => {
-        return {
-            Schema(schema, ctx) {
-                if (schema.type === 'number') {
-                    ctx.report({
-                        message: 'type number is not allowed',
-                    });
-                }
-            },
-        };
-    },
-});
+let config;
+async function setupAsync() {
+    config = await (0, utils_1.makeConfigForRuleset)({
+        test: () => {
+            return {
+                Schema(schema, ctx) {
+                    if (schema.type === 'number') {
+                        ctx.report({
+                            message: 'type number is not allowed',
+                        });
+                    }
+                },
+            };
+        },
+    });
+}
 function measureAsync() {
     return (0, lint_1.lintDocument)({
         externalRefResolver: new resolve_1.BaseResolver(),

package/lib/benchmark/benches/lint-with-top-level-rule.bench.d.ts

@@ -1,3 +1,4 @@
 export declare const name = "Validate with single top-level rule";
 export declare const count = 10;
+export declare function setupAsync(): Promise<void>;
 export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-top-level-rule.bench.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.count = exports.name = void 0;
+exports.setupAsync = setupAsync;
 exports.measureAsync = measureAsync;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -11,18 +12,21 @@ exports.name = 'Validate with single top-level rule';
 exports.count = 10;
 const rebillyDefinitionRef = (0, path_1.resolve)((0, path_1.join)(__dirname, 'rebilly.yaml'));
 const rebillyDocument = (0, utils_1.parseYamlToDocument)((0, fs_1.readFileSync)(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
-const config = (0, utils_1.makeConfigForRuleset)({
-    test: () => {
-        let count = 0;
-        return {
-            Schema() {
-                count++;
-                if (count === -1)
-                    throw new Error('Disable optimization');
-            },
-        };
-    },
-});
+let config;
+async function setupAsync() {
+    config = await (0, utils_1.makeConfigForRuleset)({
+        test: () => {
+            let count = 0;
+            return {
+                Schema() {
+                    count++;
+                    if (count === -1)
+                        throw new Error('Disable optimization');
+                },
+            };
+        },
+    });
+}
 function measureAsync() {
     return (0, lint_1.lintDocument)({
         externalRefResolver: new resolve_1.BaseResolver(),

package/lib/benchmark/utils.d.ts

@@ -1,6 +1,6 @@
-import { Document } from '../resolve';
-import { Oas3RuleSet } from '../oas-types';
 import { StyleguideConfig } from '../config';
+import type { Document } from '../resolve';
+import type { Oas3RuleSet } from '../oas-types';
 import type { Plugin } from '../config/types';
 export declare function parseYamlToDocument(body: string, absoluteRef?: string): Document;
-export declare function makeConfigForRuleset(rules: Oas3RuleSet, plugin?: Partial<Plugin>): StyleguideConfig;
+export declare function makeConfigForRuleset(rules: Oas3RuleSet, plugin?: Partial<Plugin>): Promise<StyleguideConfig>;

package/lib/benchmark/utils.js

@@ -11,20 +11,20 @@ function parseYamlToDocument(body, absoluteRef = '') {
         parsed: (0, js_yaml_1.parseYaml)(body, { filename: absoluteRef }),
     };
 }
-function makeConfigForRuleset(rules, plugin) {
+async function makeConfigForRuleset(rules, plugin) {
     const rulesConf = {};
     const ruleId = 'test';
     Object.keys(rules).forEach((name) => {
         rulesConf[`${ruleId}/${name}`] = 'error';
     });
     const extendConfigs = [
-        (0, config_1.resolvePlugins)([
+        (await (0, config_1.resolvePlugins)([
             {
                 ...plugin,
                 id: ruleId,
                 rules: { oas3: rules },
             },
-        ]),
+        ])),
     ];
     if (rules) {
         extendConfigs.push({ rules });

package/lib/config/all.js

@@ -5,6 +5,7 @@ const all = {
         'info-contact': 'error',
         'info-license': 'error',
         'info-license-url': 'error',
+        'info-license-strict': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'error',
         'parameter-description': 'error',
@@ -108,6 +109,7 @@ const all = {
     async2Rules: {
         spec: 'error',
         'info-contact': 'error',
+        'info-license-strict': 'error',
         'operation-operationId': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'error',
@@ -117,12 +119,13 @@ const all = {
     async3Rules: {
         spec: 'error',
         'info-contact': 'error',
+        'info-license-strict': 'error',
         'operation-operationId': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'error',
         'channels-kebab-case': 'error',
         'no-channel-trailing-slash': 'error',
     },
-    arazzoRules: { spec: 'error' },
+    arazzoRules: { spec: 'error', 'parameters-no-body-inside-in': 'off' },
 };
 exports.default = all;

package/lib/config/builtIn.js

@@ -10,16 +10,11 @@ const oas2_1 = require("../rules/oas2");
 const async2_1 = require("../rules/async2");
 const async3_1 = require("../rules/async3");
 const arazzo_1 = require("../rules/arazzo");
-const oas3_2 = require("../rules/oas3");
-const oas2_2 = require("../rules/oas2");
-const async2_2 = require("../rules/async2");
-const async3_2 = require("../rules/async3");
-const arazzo_2 = require("../rules/arazzo");
-const oas3_3 = require("../decorators/oas3");
-const oas2_3 = require("../decorators/oas2");
-const async2_3 = require("../decorators/async2");
-const async3_3 = require("../decorators/async3");
-const arazzo_3 = require("../decorators/arazzo");
+const oas3_2 = require("../decorators/oas3");
+const oas2_2 = require("../decorators/oas2");
+const async2_2 = require("../decorators/async2");
+const async3_2 = require("../decorators/async3");
+const arazzo_2 = require("../decorators/arazzo");
 exports.builtInConfigs = {
     recommended: recommended_1.default,
     'recommended-strict': recommended_strict_1.default,
@@ -39,18 +34,18 @@ exports.defaultPlugin = {
         arazzo: arazzo_1.rules,
     },
     preprocessors: {
-        oas3: oas3_2.preprocessors,
-        oas2: oas2_2.preprocessors,
-        async2: async2_2.preprocessors,
-        async3: async3_2.preprocessors,
-        arazzo: arazzo_2.preprocessors,
+        oas3: oas3_1.preprocessors,
+        oas2: oas2_1.preprocessors,
+        async2: async2_1.preprocessors,
+        async3: async3_1.preprocessors,
+        arazzo: arazzo_1.preprocessors,
     },
     decorators: {
-        oas3: oas3_3.decorators,
-        oas2: oas2_3.decorators,
-        async2: async2_3.decorators,
-        async3: async3_3.decorators,
-        arazzo: arazzo_3.decorators,
+        oas3: oas3_2.decorators,
+        oas2: oas2_2.decorators,
+        async2: async2_2.decorators,
+        async3: async3_2.decorators,
+        arazzo: arazzo_2.decorators,
     },
     configs: exports.builtInConfigs,
 };

package/lib/config/config-resolvers.d.ts

@@ -14,7 +14,7 @@ export declare function resolveConfig({ rawConfig, configPath, externalRefResolv
     configPath?: string;
     externalRefResolver?: BaseResolver;
 }): Promise<Config>;
-export declare function resolvePlugins(plugins: (string | Plugin)[] | null, configPath?: string): Plugin[];
+export declare function resolvePlugins(plugins: (string | Plugin)[] | null, configPath?: string): Promise<Plugin[]>;
 export declare function resolveApis({ rawConfig, configPath, resolver, }: {
     rawConfig: RawConfig;
     configPath?: string;

package/lib/config/config-resolvers.js

@@ -7,18 +7,21 @@ exports.resolveApis = resolveApis;
 exports.resolveStyleguideConfig = resolveStyleguideConfig;
 exports.resolvePreset = resolvePreset;
 const path = require("path");
+const fs_1 = require("fs");
 const ref_utils_1 = require("../ref-utils");
 const utils_1 = require("../utils");
 const resolve_1 = require("../resolve");
 const builtIn_1 = require("./builtIn");
 const utils_2 = require("./utils");
 const env_1 = require("../env");
-const utils_3 = require("../utils");
 const config_1 = require("./config");
 const logger_1 = require("../logger");
 const asserts_1 = require("../rules/common/assertions/asserts");
 const types_1 = require("../types");
 const redocly_yaml_1 = require("../types/redocly-yaml");
+const DEFAULT_PROJECT_PLUGIN_PATHS = ['@theme/plugin.js', '@theme/plugin.cjs', '@theme/plugin.mjs'];
+// Workaround for dynamic imports being transpiled to require by Typescript: https://github.com/microsoft/TypeScript/issues/43329#issuecomment-811606238
+const _importDynamic = new Function('modulePath', 'return import(modulePath)');
 async function resolveConfigFileAndRefs({ configPath, externalRefResolver = new resolve_1.BaseResolver(), base = null, }) {
     if (!configPath) {
         throw new Error('Reference to a config is required.\n');
@@ -36,7 +39,7 @@ async function resolveConfigFileAndRefs({ configPath, externalRefResolver = new
     return { document, resolvedRefMap };
 }
 async function resolveConfig({ rawConfig, configPath, externalRefResolver, }) {
-    if (rawConfig.styleguide?.extends?.some(utils_3.isNotString)) {
+    if (rawConfig.styleguide?.extends?.some(utils_1.isNotString)) {
         throw new Error(`Error configuration format not detected in extends value must contain strings`);
     }
     const resolver = externalRefResolver ?? new resolve_1.BaseResolver((0, utils_2.getResolveConfig)(rawConfig.resolve));
@@ -56,46 +59,82 @@ async function resolveConfig({ rawConfig, configPath, externalRefResolver, }) {
         styleguide,
     }, configPath);
 }
-function resolvePlugins(plugins, configPath = '') {
+function getDefaultPluginPath(configPath) {
+    for (const pluginPath of DEFAULT_PROJECT_PLUGIN_PATHS) {
+        const absolutePluginPath = path.resolve(path.dirname(configPath), pluginPath);
+        if ((0, fs_1.existsSync)(absolutePluginPath)) {
+            return pluginPath;
+        }
+    }
+    return undefined;
+}
+async function resolvePlugins(plugins, configPath = '') {
     if (!plugins)
         return [];
     // TODO: implement or reuse Resolver approach so it will work in node and browser envs
-    const requireFunc = (plugin) => {
-        if (env_1.isBrowser && (0, utils_3.isString)(plugin)) {
+    const requireFunc = async (plugin) => {
+        if (env_1.isBrowser && (0, utils_1.isString)(plugin)) {
             logger_1.logger.error(`Cannot load ${plugin}. Plugins aren't supported in browser yet.`);
             return undefined;
         }
-        if ((0, utils_3.isString)(plugin)) {
+        if ((0, utils_1.isString)(plugin)) {
             try {
-                const absoltePluginPath = path.resolve(path.dirname(configPath), plugin);
+                const maybeAbsolutePluginPath = path.resolve(path.dirname(configPath), plugin);
+                const absolutePluginPath = (0, fs_1.existsSync)(maybeAbsolutePluginPath)
+                    ? maybeAbsolutePluginPath
+                    : // For plugins imported from packages specifically
+                        require.resolve(plugin);
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
-                return typeof __webpack_require__ === 'function'
-                    ? // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                        // @ts-ignore
-                        __non_webpack_require__(absoltePluginPath)
-                    : require(absoltePluginPath);
+                if (typeof __webpack_require__ === 'function') {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    return __non_webpack_require__(absolutePluginPath);
+                }
+                else {
+                    // you can import both cjs and mjs
+                    const mod = await _importDynamic(absolutePluginPath);
+                    return mod.default || mod;
+                }
             }
             catch (e) {
-                if (e instanceof SyntaxError) {
-                    throw e;
-                }
-                throw new Error(`Failed to load plugin "${plugin}". Please provide a valid path`);
+                throw new Error(`Failed to load plugin "${plugin}": ${e.message}\n\n${e.stack}`);
             }
         }
         return plugin;
     };
     const seenPluginIds = new Map();
-    return plugins
-        .map((p) => {
-        if ((0, utils_3.isString)(p) && (0, ref_utils_1.isAbsoluteUrl)(p)) {
-            throw new Error(logger_1.colorize.red(`We don't support remote plugins yet.`));
+    /**
+     * Include the default plugin automatically if it's not in configuration
+     */
+    const defaultPluginPath = getDefaultPluginPath(configPath);
+    if (defaultPluginPath) {
+        plugins.push(defaultPluginPath);
+    }
+    const resolvedPlugins = new Set();
+    const instances = await Promise.all(plugins.map(async (p) => {
+        if ((0, utils_1.isString)(p)) {
+            if ((0, ref_utils_1.isAbsoluteUrl)(p)) {
+                throw new Error(logger_1.colorize.red(`We don't support remote plugins yet.`));
+            }
+            if (resolvedPlugins.has(p)) {
+                return;
+            }
+            resolvedPlugins.add(p);
         }
-        // TODO: resolve npm packages similar to eslint
-        const pluginModule = requireFunc(p);
+        const requiredPlugin = await requireFunc(p);
+        const pluginCreatorOptions = { contentDir: path.dirname(configPath) };
+        const pluginModule = (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)
+            ? requiredPlugin
+            : (0, utils_2.isCommonJsPlugin)(requiredPlugin)
+                ? await requiredPlugin(pluginCreatorOptions)
+                : await requiredPlugin?.default?.(pluginCreatorOptions);
         if (!pluginModule) {
             return;
         }
+        if ((0, utils_1.isString)(p) && pluginModule.id && (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)) {
+            logger_1.logger.info(`Deprecated plugin format detected: ${pluginModule.id}\n`);
+        }
         const id = pluginModule.id;
         if (typeof id !== 'string') {
             throw new Error(logger_1.colorize.red(`Plugin must define \`id\` property in ${logger_1.colorize.blue(p.toString())}.`));
@@ -185,14 +224,14 @@ function resolvePlugins(plugins, configPath = '') {
             plugin.assertions = pluginModule.assertions;
         }
         return plugin;
-    })
-        .filter(utils_3.isDefined);
+    }));
+    return instances.filter(utils_1.isDefined);
 }
 async function resolveApis({ rawConfig, configPath = '', resolver, }) {
     const { apis = {}, styleguide: styleguideConfig = {} } = rawConfig;
     const resolvedApis = {};
     for (const [apiName, apiContent] of Object.entries(apis || {})) {
-        if (apiContent.styleguide?.extends?.some(utils_3.isNotString)) {
+        if (apiContent.styleguide?.extends?.some(utils_1.isNotString)) {
             throw new Error(`Error configuration format not detected in extends value must contain strings`);
         }
         const rawStyleguideConfig = getMergedRawStyleguideConfig(styleguideConfig, apiContent.styleguide);
@@ -209,9 +248,9 @@ async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configP
     if (parentConfigPaths.includes(configPath)) {
         throw new Error(`Circular dependency in config file: "${configPath}"`);
     }
-    const plugins = (0, utils_2.getUniquePlugins)(resolvePlugins([...(styleguideConfig?.plugins || []), builtIn_1.defaultPlugin], configPath));
+    const plugins = (0, utils_2.getUniquePlugins)(await resolvePlugins([...(styleguideConfig?.plugins || []), builtIn_1.defaultPlugin], configPath));
     const pluginPaths = styleguideConfig?.plugins
-        ?.filter(utils_3.isString)
+        ?.filter(utils_1.isString)
         .map((p) => path.resolve(path.dirname(configPath), p));
     const resolvedConfigPath = (0, ref_utils_1.isAbsoluteUrl)(configPath)
         ? configPath
@@ -367,7 +406,7 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
     return transformedRules;
 }
 function registerCustomAssertions(plugins, assertion) {
-    for (const field of (0, utils_3.keysOf)(assertion.assertions)) {
+    for (const field of (0, utils_1.keysOf)(assertion.assertions)) {
         const [pluginId, fn] = field.split('/');
         if (!pluginId || !fn)
             continue;

package/lib/config/config.d.ts

@@ -1,5 +1,6 @@
-import { NormalizedProblem } from '../walk';
-import { SpecVersion, SpecMajorVersion, Oas2RuleSet, Oas3RuleSet, Async3RuleSet, ArazzoRuleSet } from '../oas-types';
+import { SpecVersion, SpecMajorVersion } from '../oas-types';
+import type { NormalizedProblem } from '../walk';
+import type { Oas2RuleSet, Oas3RuleSet, Async3RuleSet, ArazzoRuleSet } from '../oas-types';
 import type { NodeType } from '../types';
 import type { DecoratorConfig, Plugin, PreprocessorConfig, Region, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedStyleguideConfig, RuleConfig, RuleSettings, Telemetry, ThemeRawConfig } from './types';
 export declare const IGNORE_FILE = ".redocly.lint-ignore.yaml";

package/lib/config/load.d.ts

@@ -1,5 +1,5 @@
-import { Config } from './config';
 import { BaseResolver } from '../resolve';
+import type { Config } from './config';
 import type { Document, ResolvedRefMap } from '../resolve';
 import type { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
 import type { RawConfig, RawUniversalConfig, Region } from './types';

package/lib/config/minimal.js

@@ -5,6 +5,7 @@ const minimal = {
         'info-contact': 'off',
         'info-license': 'off',
         'info-license-url': 'off',
+        'info-license-strict': 'off',
         'tag-description': 'warn',
         'tags-alphabetical': 'off',
         'parameter-description': 'off',
@@ -90,6 +91,7 @@ const minimal = {
     async2Rules: {
         spec: 'error',
         'info-contact': 'off',
+        'info-license-strict': 'off',
         'operation-operationId': 'warn',
         'tag-description': 'warn',
         'tags-alphabetical': 'off',
@@ -99,6 +101,7 @@ const minimal = {
     async3Rules: {
         spec: 'error',
         'info-contact': 'off',
+        'info-license-strict': 'off',
         'operation-operationId': 'warn',
         'tag-description': 'warn',
         'tags-alphabetical': 'off',
@@ -107,6 +110,7 @@ const minimal = {
     },
     arazzoRules: {
         spec: 'error',
+        'parameters-no-body-inside-in': 'off',
     },
 };
 exports.default = minimal;

package/lib/config/recommended-strict.js

@@ -4,7 +4,8 @@ const recommendedStrict = {
     rules: {
         'info-contact': 'off',
         'info-license': 'error',
-        'info-license-url': 'error',
+        'info-license-url': 'off',
+        'info-license-strict': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'off',
         'parameter-description': 'off',
@@ -90,6 +91,7 @@ const recommendedStrict = {
     async2Rules: {
         spec: 'error',
         'info-contact': 'off',
+        'info-license-strict': 'error',
         'operation-operationId': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'off',
@@ -99,6 +101,7 @@ const recommendedStrict = {
     async3Rules: {
         spec: 'error',
         'info-contact': 'off',
+        'info-license-strict': 'error',
         'operation-operationId': 'error',
         'tag-description': 'error',
         'tags-alphabetical': 'off',
@@ -107,6 +110,7 @@ const recommendedStrict = {
     },
     arazzoRules: {
         spec: 'error',
+        'parameters-no-body-inside-in': 'off',
     },
 };
 exports.default = recommendedStrict;