@redocly/openapi-core 1.0.0-beta.103 → 1.0.0-beta.106

package/src/config/config-resolvers.ts

@@ -12,28 +12,30 @@ import {
   transformConfig,
 } from './utils';
 import type {
-  LintRawConfig,
+  StyleguideRawConfig,
+  ApiStyleguideRawConfig,
   Plugin,
   RawConfig,
   ResolvedApi,
-  ResolvedLintConfig,
+  ResolvedStyleguideConfig,
   RuleConfig,
+  DeprecatedInRawConfig,
 } from './types';
 import { isNotString, isString, notUndefined, parseYaml } from '../utils';
 import { Config } from './config';
 
-export async function resolveConfig(rawConfig: RawConfig, configPath?: string) {
-  if (rawConfig.lint?.extends?.some(isNotString)) {
+export async function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config> {
+  if (rawConfig.styleguide?.extends?.some(isNotString)) {
     throw new Error(
-      `Error configuration format not detected in extends value must contain strings`,
+      `Error configuration format not detected in extends value must contain strings`
     );
   }
 
   const resolver = new BaseResolver(getResolveConfig(rawConfig.resolve));
-  const configExtends = rawConfig?.lint?.extends ?? ['recommended'];
-  const recommendedFallback = !rawConfig?.lint?.extends;
-  const lintConfig = {
-    ...rawConfig?.lint,
+  const configExtends = rawConfig?.styleguide?.extends ?? ['recommended'];
+  const recommendedFallback = !rawConfig?.styleguide?.extends;
+  const styleguideConfig = {
+    ...rawConfig?.styleguide,
     extends: configExtends,
     recommendedFallback,
   };
@@ -41,14 +43,14 @@ export async function resolveConfig(rawConfig: RawConfig, configPath?: string) {
   const apis = await resolveApis({
     rawConfig: {
       ...rawConfig,
-      lint: lintConfig,
+      styleguide: styleguideConfig,
     },
     configPath,
     resolver,
   });
 
-  const lint = await resolveLint({
-    lintConfig,
+  const styleguide = await resolveStyleguideConfig({
+    styleguideConfig,
     configPath,
     resolver,
   });
@@ -57,15 +59,15 @@ export async function resolveConfig(rawConfig: RawConfig, configPath?: string) {
     {
       ...rawConfig,
       apis,
-      lint,
+      styleguide,
     },
-    configPath,
+    configPath
   );
 }
 
 export function resolvePlugins(
   plugins: (string | Plugin)[] | null,
-  configPath: string = '',
+  configPath: string = ''
 ): Plugin[] {
   if (!plugins) return [];
 
@@ -95,9 +97,9 @@ export function resolvePlugins(
         throw new Error(
           red(
             `Plugin "id" must be unique. Plugin ${blue(p.toString())} uses id "${blue(
-              id,
-            )}" already seen in ${blue(pluginPath)}`,
-          ),
+              id
+            )}" already seen in ${blue(pluginPath)}`
+          )
         );
       }
 
@@ -124,7 +126,7 @@ export function resolvePlugins(
       if (pluginModule.preprocessors) {
         if (!pluginModule.preprocessors.oas3 && !pluginModule.preprocessors.oas2) {
           throw new Error(
-            `Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`,
+            `Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`
           );
         }
         plugin.preprocessors = {};
@@ -163,45 +165,48 @@ export async function resolveApis({
   configPath?: string;
   resolver?: BaseResolver;
 }): Promise<Record<string, ResolvedApi>> {
-  const { apis = {}, lint: lintConfig = {} } = rawConfig;
+  const { apis = {}, styleguide: styleguideConfig = {} } = rawConfig;
   let resolvedApis: Record<string, ResolvedApi> = {};
   for (const [apiName, apiContent] of Object.entries(apis || {})) {
-    if (apiContent.lint?.extends?.some(isNotString)) {
+    if (apiContent.styleguide?.extends?.some(isNotString)) {
       throw new Error(
-        `Error configuration format not detected in extends value must contain strings`,
+        `Error configuration format not detected in extends value must contain strings`
       );
     }
-    const rawLintConfig = getMergedLintRawConfig(lintConfig, apiContent.lint);
-    const apiLint = await resolveLint({
-      lintConfig: rawLintConfig,
+    const rawStyleguideConfig = getMergedRawStyleguideConfig(
+      styleguideConfig,
+      apiContent.styleguide
+    );
+    const resolvedApiConfig = await resolveStyleguideConfig({
+      styleguideConfig: rawStyleguideConfig,
       configPath,
       resolver,
     });
-    resolvedApis[apiName] = { ...apiContent, lint: apiLint };
+    resolvedApis[apiName] = { ...apiContent, styleguide: resolvedApiConfig };
   }
   return resolvedApis;
 }
 
-async function resolveAndMergeNestedLint(
+async function resolveAndMergeNestedStyleguideConfig(
   {
-    lintConfig,
+    styleguideConfig,
     configPath = '',
     resolver = new BaseResolver(),
   }: {
-    lintConfig?: LintRawConfig;
+    styleguideConfig?: StyleguideRawConfig;
     configPath?: string;
     resolver?: BaseResolver;
   },
   parentConfigPaths: string[] = [],
-  extendPaths: string[] = [],
-): Promise<ResolvedLintConfig> {
+  extendPaths: string[] = []
+): Promise<ResolvedStyleguideConfig> {
   if (parentConfigPaths.includes(configPath)) {
     throw new Error(`Circular dependency in config file: "${configPath}"`);
   }
   const plugins = getUniquePlugins(
-    resolvePlugins([...(lintConfig?.plugins || []), defaultPlugin], configPath),
+    resolvePlugins([...(styleguideConfig?.plugins || []), defaultPlugin], configPath)
   );
-  const pluginPaths = lintConfig?.plugins
+  const pluginPaths = styleguideConfig?.plugins
     ?.filter(isString)
     .map((p) => path.resolve(path.dirname(configPath), p));
 
@@ -209,8 +214,8 @@ async function resolveAndMergeNestedLint(
     ? configPath
     : configPath && path.resolve(configPath);
 
-  const extendConfigs: ResolvedLintConfig[] = await Promise.all(
-    lintConfig?.extends?.map(async (presetItem) => {
+  const extendConfigs: ResolvedStyleguideConfig[] = await Promise.all(
+    styleguideConfig?.extends?.map(async (presetItem) => {
       if (!isAbsoluteUrl(presetItem) && !path.extname(presetItem)) {
         return resolvePreset(presetItem, plugins);
       }
@@ -219,23 +224,23 @@ async function resolveAndMergeNestedLint(
         : isAbsoluteUrl(configPath)
         ? new URL(presetItem, configPath).href
         : path.resolve(path.dirname(configPath), presetItem);
-      const extendedLintConfig = await loadExtendLintConfig(pathItem, resolver);
-      return await resolveAndMergeNestedLint(
+      const extendedStyleguideConfig = await loadExtendStyleguideConfig(pathItem, resolver);
+      return await resolveAndMergeNestedStyleguideConfig(
         {
-          lintConfig: extendedLintConfig,
+          styleguideConfig: extendedStyleguideConfig,
           configPath: pathItem,
           resolver: resolver,
         },
         [...parentConfigPaths, resolvedConfigPath],
-        extendPaths,
+        extendPaths
       );
-    }) || [],
+    }) || []
   );
 
-  const { plugins: mergedPlugins = [], ...lint } = mergeExtends([
+  const { plugins: mergedPlugins = [], ...styleguide } = mergeExtends([
     ...extendConfigs,
     {
-      ...lintConfig,
+      ...styleguideConfig,
       plugins,
       extends: undefined,
       extendPaths: [...parentConfigPaths, resolvedConfigPath],
@@ -244,91 +249,125 @@ async function resolveAndMergeNestedLint(
   ]);
 
   return {
-    ...lint,
-    extendPaths: lint.extendPaths?.filter((path) => path && !isAbsoluteUrl(path)),
+    ...styleguide,
+    extendPaths: styleguide.extendPaths?.filter((path) => path && !isAbsoluteUrl(path)),
     plugins: getUniquePlugins(mergedPlugins),
-    recommendedFallback: lintConfig?.recommendedFallback,
-    doNotResolveExamples: lintConfig?.doNotResolveExamples,
+    recommendedFallback: styleguideConfig?.recommendedFallback,
+    doNotResolveExamples: styleguideConfig?.doNotResolveExamples,
   };
 }
 
-export async function resolveLint(
-  lintOpts: {
-    lintConfig?: LintRawConfig;
+export async function resolveStyleguideConfig(
+  opts: {
+    styleguideConfig?: StyleguideRawConfig;
     configPath?: string;
     resolver?: BaseResolver;
   },
   parentConfigPaths: string[] = [],
-  extendPaths: string[] = [],
-): Promise<ResolvedLintConfig> {
-  const resolvedLint = await resolveAndMergeNestedLint(lintOpts, parentConfigPaths, extendPaths);
+  extendPaths: string[] = []
+): Promise<ResolvedStyleguideConfig> {
+  const resolvedStyleguideConfig = await resolveAndMergeNestedStyleguideConfig(
+    opts,
+    parentConfigPaths,
+    extendPaths
+  );
 
   return {
-    ...resolvedLint,
-    rules: resolvedLint.rules && groupLintAssertionRules(resolvedLint.rules),
+    ...resolvedStyleguideConfig,
+    rules:
+      resolvedStyleguideConfig.rules &&
+      groupStyleguideAssertionRules(resolvedStyleguideConfig.rules),
   };
 }
 
-export function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedLintConfig {
+export function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedStyleguideConfig {
   const { pluginId, configName } = parsePresetName(presetName);
   const plugin = plugins.find((p) => p.id === pluginId);
   if (!plugin) {
     throw new Error(`Invalid config ${red(presetName)}: plugin ${pluginId} is not included.`);
   }
 
-  const preset = plugin.configs?.[configName]! as ResolvedLintConfig;
+  const preset = plugin.configs?.[configName]! as ResolvedStyleguideConfig;
   if (!preset) {
     throw new Error(
       pluginId
         ? `Invalid config ${red(
-            presetName,
+            presetName
           )}: plugin ${pluginId} doesn't export config with name ${configName}.`
-        : `Invalid config ${red(presetName)}: there is no such built-in config.`,
+        : `Invalid config ${red(presetName)}: there is no such built-in config.`
     );
   }
   return preset;
 }
 
-async function loadExtendLintConfig(
+async function loadExtendStyleguideConfig(
   filePath: string,
-  resolver: BaseResolver,
-): Promise<LintRawConfig> {
+  resolver: BaseResolver
+): Promise<StyleguideRawConfig> {
   try {
     const fileSource = await resolver.loadExternalRef(filePath);
-    const rawConfig = transformConfig(parseYaml(fileSource.body) as RawConfig);
-    if (!rawConfig.lint) {
-      throw new Error(`Lint configuration format not detected: "${filePath}"`);
+    const rawConfig = transformConfig(
+      parseYaml(fileSource.body) as RawConfig & DeprecatedInRawConfig
+    );
+    if (!rawConfig.styleguide) {
+      throw new Error(`Styleguide configuration format not detected: "${filePath}"`);
     }
 
-    return rawConfig.lint;
+    return rawConfig.styleguide;
   } catch (error) {
     throw new Error(`Failed to load "${filePath}": ${error.message}`);
   }
 }
 
-function getMergedLintRawConfig(configLint: LintRawConfig, apiLint?: LintRawConfig) {
+function getMergedRawStyleguideConfig(
+  rootStyleguideConfig: StyleguideRawConfig,
+  apiStyleguideConfig?: ApiStyleguideRawConfig
+) {
   const resultLint = {
-    ...configLint,
-    ...apiLint,
-    rules: { ...configLint?.rules, ...apiLint?.rules },
-    oas2Rules: { ...configLint?.oas2Rules, ...apiLint?.oas2Rules },
-    oas3_0Rules: { ...configLint?.oas3_0Rules, ...apiLint?.oas3_0Rules },
-    oas3_1Rules: { ...configLint?.oas3_1Rules, ...apiLint?.oas3_1Rules },
-    preprocessors: { ...configLint?.preprocessors, ...apiLint?.preprocessors },
-    oas2Preprocessors: { ...configLint?.oas2Preprocessors, ...apiLint?.oas2Preprocessors },
-    oas3_0Preprocessors: { ...configLint?.oas3_0Preprocessors, ...apiLint?.oas3_0Preprocessors },
-    oas3_1Preprocessors: { ...configLint?.oas3_1Preprocessors, ...apiLint?.oas3_1Preprocessors },
-    decorators: { ...configLint?.decorators, ...apiLint?.decorators },
-    oas2Decorators: { ...configLint?.oas2Decorators, ...apiLint?.oas2Decorators },
-    oas3_0Decorators: { ...configLint?.oas3_0Decorators, ...apiLint?.oas3_0Decorators },
-    oas3_1Decorators: { ...configLint?.oas3_1Decorators, ...apiLint?.oas3_1Decorators },
-    recommendedFallback: apiLint?.extends ? false : configLint.recommendedFallback,
+    ...rootStyleguideConfig,
+    ...apiStyleguideConfig,
+    rules: { ...rootStyleguideConfig?.rules, ...apiStyleguideConfig?.rules },
+    oas2Rules: { ...rootStyleguideConfig?.oas2Rules, ...apiStyleguideConfig?.oas2Rules },
+    oas3_0Rules: { ...rootStyleguideConfig?.oas3_0Rules, ...apiStyleguideConfig?.oas3_0Rules },
+    oas3_1Rules: { ...rootStyleguideConfig?.oas3_1Rules, ...apiStyleguideConfig?.oas3_1Rules },
+    preprocessors: {
+      ...rootStyleguideConfig?.preprocessors,
+      ...apiStyleguideConfig?.preprocessors,
+    },
+    oas2Preprocessors: {
+      ...rootStyleguideConfig?.oas2Preprocessors,
+      ...apiStyleguideConfig?.oas2Preprocessors,
+    },
+    oas3_0Preprocessors: {
+      ...rootStyleguideConfig?.oas3_0Preprocessors,
+      ...apiStyleguideConfig?.oas3_0Preprocessors,
+    },
+    oas3_1Preprocessors: {
+      ...rootStyleguideConfig?.oas3_1Preprocessors,
+      ...apiStyleguideConfig?.oas3_1Preprocessors,
+    },
+    decorators: { ...rootStyleguideConfig?.decorators, ...apiStyleguideConfig?.decorators },
+    oas2Decorators: {
+      ...rootStyleguideConfig?.oas2Decorators,
+      ...apiStyleguideConfig?.oas2Decorators,
+    },
+    oas3_0Decorators: {
+      ...rootStyleguideConfig?.oas3_0Decorators,
+      ...apiStyleguideConfig?.oas3_0Decorators,
+    },
+    oas3_1Decorators: {
+      ...rootStyleguideConfig?.oas3_1Decorators,
+      ...apiStyleguideConfig?.oas3_1Decorators,
+    },
+    recommendedFallback: apiStyleguideConfig?.extends
+      ? false
+      : rootStyleguideConfig.recommendedFallback,
   };
   return resultLint;
 }
 
-function groupLintAssertionRules(
-  rules: Record<string, RuleConfig> | undefined,
+function groupStyleguideAssertionRules(
+  rules: Record<string, RuleConfig> | undefined
 ): Record<string, RuleConfig> | undefined {
   if (!rules) {
     return rules;

package/src/config/config.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { parseYaml, stringifyYaml } from '../js-yaml';
-import { slash } from '../utils';
+import { slash, doesYamlFileExist } from '../utils';
 import { NormalizedProblem } from '../walk';
 import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
 
@@ -14,7 +14,7 @@ import type {
   ResolveConfig,
   ResolvedApi,
   ResolvedConfig,
-  ResolvedLintConfig,
+  ResolvedStyleguideConfig,
   RuleConfig,
 } from './types';
 import { getResolveConfig } from './utils';
@@ -46,10 +46,20 @@ function getDomains() {
   return domains;
 }
 
+function getIgnoreFilePath(configFile?: string): string | undefined {
+  if (configFile) {
+    return doesYamlFileExist(configFile)
+      ? path.join(path.dirname(configFile), IGNORE_FILE)
+      : path.join(configFile, IGNORE_FILE);
+  } else {
+    return typeof process === 'undefined' ? undefined : path.join(process.cwd(), IGNORE_FILE);
+  }
+}
+
 export const DOMAINS = getDomains();
 export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
-export class LintConfig {
+export class StyleguideConfig {
   plugins: Plugin[];
   ignore: Record<string, Record<string, Set<string>>> = {};
   doNotResolveExamples: boolean;
@@ -65,11 +75,11 @@ export class LintConfig {
   extendPaths: string[];
   pluginPaths: string[];
 
-  constructor(public rawConfig: ResolvedLintConfig, public configFile?: string) {
+  constructor(public rawConfig: ResolvedStyleguideConfig, public configFile?: string) {
     this.plugins = rawConfig.plugins || [];
     this.doNotResolveExamples = !!rawConfig.doNotResolveExamples;
 
-    this.recommendedFallback = rawConfig.recommendedFallback || false
+    this.recommendedFallback = rawConfig.recommendedFallback || false;
 
     this.rules = {
       [OasVersion.Version2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
@@ -91,29 +101,25 @@ export class LintConfig {
 
     this.extendPaths = rawConfig.extendPaths || [];
     this.pluginPaths = rawConfig.pluginPaths || [];
+    this.resolveIgnore(getIgnoreFilePath(configFile));
+  }
 
-    const dir = this.configFile
-      ? path.dirname(this.configFile)
-      : (typeof process !== 'undefined' && process.cwd()) || '';
-    const ignoreFile = path.join(dir, IGNORE_FILE);
+  resolveIgnore(ignoreFile?: string) {
+    if (!ignoreFile || !doesYamlFileExist(ignoreFile)) return;
 
-    /* no crash when using it on the client */
-    if (fs.hasOwnProperty('existsSync') && fs.existsSync(ignoreFile)) {
-      // TODO: parse errors
-      this.ignore =
-        (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
-          string,
-          Record<string, Set<string>>
-        >) || {};
-
-      // resolve ignore paths
-      for (const fileName of Object.keys(this.ignore)) {
-        this.ignore[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];
+    this.ignore =
+      (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
+        string,
+        Record<string, Set<string>>
+      >) || {};
+
+    // resolve ignore paths
+    for (const fileName of Object.keys(this.ignore)) {
+      this.ignore[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];
     }
   }
 
@@ -224,15 +230,13 @@ export class LintConfig {
 
     for (const usedVersion of Array.from(this._usedVersions)) {
       rules.push(
-        ...Object.keys(this.rules[usedVersion]).filter((name) => !this._usedRules.has(name)),
+        ...Object.keys(this.rules[usedVersion]).filter((name) => !this._usedRules.has(name))
       );
       decorators.push(
-        ...Object.keys(this.decorators[usedVersion]).filter((name) => !this._usedRules.has(name)),
+        ...Object.keys(this.decorators[usedVersion]).filter((name) => !this._usedRules.has(name))
       );
       preprocessors.push(
-        ...Object.keys(this.preprocessors[usedVersion]).filter(
-          (name) => !this._usedRules.has(name),
-        ),
+        ...Object.keys(this.preprocessors[usedVersion]).filter((name) => !this._usedRules.has(name))
       );
     }
 
@@ -293,7 +297,7 @@ export class LintConfig {
 
 export class Config {
   apis: Record<string, ResolvedApi>;
-  lint: LintConfig;
+  styleguide: StyleguideConfig;
   resolve: ResolveConfig;
   licenseKey?: string;
   region?: Region;
@@ -302,7 +306,7 @@ export class Config {
   organization?: string;
   constructor(public rawConfig: ResolvedConfig, public configFile?: string) {
     this.apis = rawConfig.apis || {};
-    this.lint = new LintConfig(rawConfig.lint || {}, configFile);
+    this.styleguide = new StyleguideConfig(rawConfig.styleguide || {}, configFile);
     this['features.openapi'] = rawConfig['features.openapi'] || {};
     this['features.mockServer'] = rawConfig['features.mockServer'] || {};
     this.resolve = getResolveConfig(rawConfig?.resolve);

package/src/config/load.ts

@@ -1,29 +1,28 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { RedoclyClient } from '../redocly';
-import { isEmptyObject, loadYaml } from '../utils';
+import { isEmptyObject, loadYaml, doesYamlFileExist } from '../utils';
 import { Config, DOMAINS } from './config';
 import { transformConfig } from './utils';
 import { resolveConfig } from './config-resolvers';
 
-import type { RawConfig, Region } from './types';
+import type { DeprecatedInRawConfig, RawConfig, Region } from './types';
 
 async function addConfigMetadata({
   rawConfig,
   customExtends,
-  configPath
+  configPath,
 }: {
   rawConfig: RawConfig;
   customExtends?: string[];
   configPath?: string;
-  
 }): Promise<Config> {
   if (customExtends !== undefined) {
-    rawConfig.lint = rawConfig.lint || {};
-    rawConfig.lint.extends = customExtends;
+    rawConfig.styleguide = rawConfig.styleguide || {};
+    rawConfig.styleguide.extends = customExtends;
   } else if (isEmptyObject(rawConfig)) {
     // TODO: check if we can add recommended here. add message here?
-    // rawConfig.lint = { extends: ['recommended'], recommendedFallback: true };
+    // rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
   }
 
   const redoclyClient = new RedoclyClient();
@@ -53,7 +52,7 @@ async function addConfigMetadata({
                 value: item.token,
               },
             ]
-          : []),
+          : [])
       );
     }
   }
@@ -64,27 +63,25 @@ async function addConfigMetadata({
 export async function loadConfig(
   configPath: string | undefined = findConfig(),
   customExtends?: string[],
-  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>,
+  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>
 ): Promise<Config> {
   const rawConfig = await getConfig(configPath);
-
   if (typeof processRawConfig === 'function') {
     await processRawConfig(rawConfig);
   }
-
   return await addConfigMetadata({
     rawConfig,
     customExtends,
     configPath,
   });
-};
+}
 
 export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
 
 export function findConfig(dir?: string): string | undefined {
   if (!fs.hasOwnProperty('existsSync')) return;
   const existingConfigFiles = CONFIG_FILE_NAMES.map((name) =>
-    dir ? path.resolve(dir, name) : name,
+    dir ? path.resolve(dir, name) : name
   ).filter(fs.existsSync);
   if (existingConfigFiles.length > 1) {
     throw new Error(`
@@ -96,10 +93,10 @@ export function findConfig(dir?: string): string | undefined {
   return existingConfigFiles[0];
 }
 
-export async function getConfig(configPath: string | undefined = findConfig()) {
-  if (!configPath) return {};
+export async function getConfig(configPath: string | undefined = findConfig()): Promise<RawConfig> {
+  if (!configPath || !doesYamlFileExist(configPath)) return {};
   try {
-    const rawConfig = ((await loadYaml(configPath)) || {}) as RawConfig;
+    const rawConfig = (await loadYaml<RawConfig & DeprecatedInRawConfig>(configPath)) || {};
     return transformConfig(rawConfig);
   } catch (e) {
     throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);

package/src/config/minimal.ts

@@ -1,4 +1,4 @@
-import type { PluginLintConfig } from './types';
+import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
@@ -18,7 +18,7 @@ export default {
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
     'operation-4xx-response': 'off',
-    'assertions': 'warn',
+    assertions: 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'warn',
     'operation-operationId-unique': 'warn',
@@ -55,4 +55,4 @@ export default {
     'no-undefined-server-variable': 'warn',
     'no-servers-empty-enum': 'error',
   },
-} as PluginLintConfig;
+} as PluginStyleguideConfig;

package/src/config/recommended.ts

@@ -1,4 +1,4 @@
-import type { PluginLintConfig } from './types';
+import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
@@ -17,7 +17,7 @@ export default {
     'path-parameters-defined': 'error',
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
-    'assertions': 'warn',
+    assertions: 'warn',
     'operation-4xx-response': 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'error',
@@ -55,4 +55,4 @@ export default {
     'no-undefined-server-variable': 'error',
     'no-servers-empty-enum': 'error',
   },
-} as PluginLintConfig;
+} as PluginStyleguideConfig;

package/src/config/rules.ts

@@ -1,12 +1,12 @@
 import { RuleSet, OasVersion } from '../oas-types';
-import { LintConfig } from './config';
+import { StyleguideConfig } from './config';
 import { notUndefined } from '../utils';
 
 export function initRules<T extends Function, P extends RuleSet<T>>(
   rules: P[],
-  config: LintConfig,
+  config: StyleguideConfig,
   type: 'rules' | 'preprocessors' | 'decorators',
-  oasVersion: OasVersion,
+  oasVersion: OasVersion
 ) {
   return rules
     .flatMap((ruleset) =>
@@ -31,7 +31,7 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
             severity: ruleSettings.severity,
             ruleId,
             visitor: visitor,
-          }))
+          }));
         }
 
         return {
@@ -39,8 +39,8 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
           ruleId,
           visitor: visitors, // note: actually it is only one visitor object
         };
-      }),
+      })
     )
-    .flatMap(visitor => visitor)
+    .flatMap((visitor) => visitor)
     .filter(notUndefined);
 }