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

package/src/config/all.ts

@@ -26,7 +26,7 @@ export default {
     'operation-operationId-url-safe': 'error',
     'operation-parameters-unique': 'error',
     'operation-tag-defined': 'error',
-    'operation-security-defined': 'error',
+    'security-defined': 'error',
     'operation-singular-tag': 'error',
     'no-unresolved-refs': 'error',
     'no-enum-type-mismatch': 'error',
@@ -51,7 +51,8 @@ export default {
     'no-example-value-and-externalValue': 'error',
     'no-unused-components': 'error',
     'no-undefined-server-variable': 'error',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'operation-4xx-problem-details-rfc7807': 'error',
   },
   oas3_1Rules: {
     'no-server-example.com': 'error',
@@ -60,6 +61,7 @@ export default {
     'no-example-value-and-externalValue': 'error',
     'no-unused-components': 'error',
     'no-undefined-server-variable': 'error',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'operation-4xx-problem-details-rfc7807': 'error',
   },
 } as PluginStyleguideConfig;

package/src/config/config-resolvers.ts

@@ -1,5 +1,4 @@
 import * as path from 'path';
-import { blue, red } from 'colorette';
 import { isAbsoluteUrl } from '../ref-utils';
 import { BaseResolver } from '../resolve';
 import { defaultPlugin } from './builtIn';
@@ -21,8 +20,10 @@ import type {
   RuleConfig,
   DeprecatedInRawConfig,
 } from './types';
-import { isNotString, isString, notUndefined, parseYaml } from '../utils';
+import { isBrowser } from '../env';
+import { isNotString, isString, isDefined, parseYaml } from '../utils';
 import { Config } from './config';
+import { colorize, logger } from '../logger';
 
 export async function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config> {
   if (rawConfig.styleguide?.extends?.some(isNotString)) {
@@ -71,34 +72,57 @@ export function resolvePlugins(
 ): Plugin[] {
   if (!plugins) return [];
 
-  // @ts-ignore
-  const requireFunc = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
+  // TODO: implement or reuse Resolver approach so it will work in node and browser envs
+  const requireFunc = (plugin: string | Plugin): Plugin | undefined => {
+    if (isBrowser && isString(plugin)) {
+      logger.error(`Cannot load ${plugin}. Plugins aren't supported in browser yet.`);
+
+      return undefined;
+    }
+
+    if (isString(plugin)) {
+      const absoltePluginPath = path.resolve(path.dirname(configPath), 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);
+    }
+
+    return plugin;
+  };
 
   const seenPluginIds = new Map<string, string>();
 
   return plugins
     .map((p) => {
       if (isString(p) && isAbsoluteUrl(p)) {
-        throw new Error(red(`We don't support remote plugins yet.`));
+        throw new Error(colorize.red(`We don't support remote plugins yet.`));
       }
 
       // TODO: resolve npm packages similar to eslint
-      const pluginModule = isString(p)
-        ? (requireFunc(path.resolve(path.dirname(configPath), p)) as Plugin)
-        : p;
+      const pluginModule = requireFunc(p);
+
+      if (!pluginModule) {
+        return;
+      }
 
       const id = pluginModule.id;
       if (typeof id !== 'string') {
-        throw new Error(red(`Plugin must define \`id\` property in ${blue(p.toString())}.`));
+        throw new Error(
+          colorize.red(`Plugin must define \`id\` property in ${colorize.blue(p.toString())}.`)
+        );
       }
 
       if (seenPluginIds.has(id)) {
         const pluginPath = seenPluginIds.get(id)!;
         throw new Error(
-          red(
-            `Plugin "id" must be unique. Plugin ${blue(p.toString())} uses id "${blue(
-              id
-            )}" already seen in ${blue(pluginPath)}`
+          colorize.red(
+            `Plugin "id" must be unique. Plugin ${colorize.blue(
+              p.toString()
+            )} uses id "${colorize.blue(id)}" already seen in ${colorize.blue(pluginPath)}`
           )
         );
       }
@@ -153,7 +177,7 @@ export function resolvePlugins(
 
       return plugin;
     })
-    .filter(notUndefined);
+    .filter(isDefined);
 }
 
 export async function resolveApis({
@@ -166,7 +190,7 @@ export async function resolveApis({
   resolver?: BaseResolver;
 }): Promise<Record<string, ResolvedApi>> {
   const { apis = {}, styleguide: styleguideConfig = {} } = rawConfig;
-  let resolvedApis: Record<string, ResolvedApi> = {};
+  const resolvedApis: Record<string, ResolvedApi> = {};
   for (const [apiName, apiContent] of Object.entries(apis || {})) {
     if (apiContent.styleguide?.extends?.some(isNotString)) {
       throw new Error(
@@ -284,17 +308,19 @@ export function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedSt
   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.`);
+    throw new Error(
+      `Invalid config ${colorize.red(presetName)}: plugin ${pluginId} is not included.`
+    );
   }
 
-  const preset = plugin.configs?.[configName]! as ResolvedStyleguideConfig;
+  const preset = plugin.configs?.[configName];
   if (!preset) {
     throw new Error(
       pluginId
-        ? `Invalid config ${red(
+        ? `Invalid config ${colorize.red(
             presetName
           )}: plugin ${pluginId} doesn't export config with name ${configName}.`
-        : `Invalid config ${red(presetName)}: there is no such built-in config.`
+        : `Invalid config ${colorize.red(presetName)}: there is no such built-in config.`
     );
   }
   return preset;

package/src/config/config.ts

@@ -4,6 +4,7 @@ import { parseYaml, stringifyYaml } from '../js-yaml';
 import { slash, doesYamlFileExist } from '../utils';
 import { NormalizedProblem } from '../walk';
 import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+import { env } from '../env';
 
 import type { NodeType } from '../types';
 import type {
@@ -19,9 +20,6 @@ import type {
 } from './types';
 import { getResolveConfig } from './utils';
 
-// Alias environment here so this file can work in browser environments too.
-export const env = typeof process !== 'undefined' ? process.env || {} : {};
-
 export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER =
   `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
@@ -172,9 +170,11 @@ export class StyleguideConfig {
           case OasVersion.Version3_1:
             if (!plugin.typeExtension.oas3) continue;
             extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
+            break;
           case OasVersion.Version2:
             if (!plugin.typeExtension.oas2) continue;
             extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
+            break;
           default:
             throw new Error('Not implemented');
         }
@@ -192,7 +192,7 @@ export class StyleguideConfig {
         severity: settings,
       };
     } else {
-      return { severity: 'error' as 'error', ...settings };
+      return { severity: 'error', ...settings };
     }
   }
 
@@ -203,10 +203,10 @@ export class StyleguideConfig {
     const settings = this.preprocessors[oasVersion][ruleId] || 'off';
     if (typeof settings === 'string') {
       return {
-        severity: settings === 'on' ? ('error' as 'error') : settings,
+        severity: settings === 'on' ? 'error' : settings,
       };
     } else {
-      return { severity: 'error' as 'error', ...settings };
+      return { severity: 'error', ...settings };
     }
   }
 
@@ -216,10 +216,10 @@ export class StyleguideConfig {
     const settings = this.decorators[oasVersion][ruleId] || 'off';
     if (typeof settings === 'string') {
       return {
-        severity: settings === 'on' ? ('error' as 'error') : settings,
+        severity: settings === 'on' ? 'error' : settings,
       };
     } else {
-      return { severity: 'error' as 'error', ...settings };
+      return { severity: 'error', ...settings };
     }
   }
 
@@ -250,12 +250,14 @@ export class StyleguideConfig {
   getRulesForOasVersion(version: OasMajorVersion) {
     switch (version) {
       case OasMajorVersion.Version3:
+        // eslint-disable-next-line no-case-declarations
         const oas3Rules: Oas3RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
         this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
         this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
         return oas3Rules;
       case OasMajorVersion.Version2:
+        // eslint-disable-next-line no-case-declarations
         const oas2Rules: Oas2RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
         this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));

package/src/config/load.ts

@@ -2,20 +2,24 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { RedoclyClient } from '../redocly';
 import { isEmptyObject, loadYaml, doesYamlFileExist } from '../utils';
+import { parseYaml } from '../js-yaml';
 import { Config, DOMAINS } from './config';
 import { transformConfig } from './utils';
 import { resolveConfig } from './config-resolvers';
 
-import type { DeprecatedInRawConfig, RawConfig, Region } from './types';
+import type { DeprecatedInRawConfig, FlatRawConfig, RawConfig, Region } from './types';
+import { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
 
 async function addConfigMetadata({
   rawConfig,
   customExtends,
   configPath,
+  tokens,
 }: {
   rawConfig: RawConfig;
   customExtends?: string[];
   configPath?: string;
+  tokens?: RegionalTokenWithValidity[];
 }): Promise<Config> {
   if (customExtends !== undefined) {
     rawConfig.styleguide = rawConfig.styleguide || {};
@@ -25,10 +29,7 @@ async function addConfigMetadata({
     // rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
   }
 
-  const redoclyClient = new RedoclyClient();
-  const tokens = await redoclyClient.getTokens();
-
-  if (tokens.length) {
+  if (tokens?.length) {
     if (!rawConfig.resolve) rawConfig.resolve = {};
     if (!rawConfig.resolve.http) rawConfig.resolve.http = {};
     rawConfig.resolve.http.headers = [...(rawConfig.resolve.http.headers ?? [])];
@@ -69,10 +70,15 @@ export async function loadConfig(
   if (typeof processRawConfig === 'function') {
     await processRawConfig(rawConfig);
   }
-  return await addConfigMetadata({
+
+  const redoclyClient = new RedoclyClient();
+  const tokens = await redoclyClient.getTokens();
+
+  return addConfigMetadata({
     rawConfig,
     customExtends,
     configPath,
+    tokens,
   });
 }
 
@@ -96,9 +102,27 @@ export function findConfig(dir?: string): string | undefined {
 export async function getConfig(configPath: string | undefined = findConfig()): Promise<RawConfig> {
   if (!configPath || !doesYamlFileExist(configPath)) return {};
   try {
-    const rawConfig = (await loadYaml<RawConfig & DeprecatedInRawConfig>(configPath)) || {};
+    const rawConfig =
+      (await loadYaml<RawConfig & DeprecatedInRawConfig & FlatRawConfig>(configPath)) || {};
     return transformConfig(rawConfig);
   } catch (e) {
     throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
   }
 }
+
+type CreateConfigOptions = {
+  extends?: string[];
+  tokens?: RegionalTokenWithValidity[];
+};
+
+export async function createConfig(
+  config: string | RawConfig,
+  options?: CreateConfigOptions
+): Promise<Config> {
+  return addConfigMetadata({
+    rawConfig: transformConfig(
+      typeof config === 'string' ? (parseYaml(config) as RawConfig) : config
+    ),
+    ...options,
+  });
+}

package/src/config/minimal.ts

@@ -24,7 +24,7 @@ export default {
     'operation-operationId-unique': 'warn',
     'operation-parameters-unique': 'warn',
     'operation-tag-defined': 'off',
-    'operation-security-defined': 'warn',
+    'security-defined': 'warn',
     'operation-operationId-url-safe': 'warn',
     'operation-singular-tag': 'off',
     'no-unresolved-refs': 'error',
@@ -36,7 +36,7 @@ export default {
   oas3_0Rules: {
     'no-invalid-media-type-examples': {
       severity: 'warn',
-      disallowAdditionalProperties: true,
+      allowAdditionalProperties: false,
     },
     'no-server-example.com': 'warn',
     'no-server-trailing-slash': 'error',
@@ -44,15 +44,18 @@ export default {
     'no-example-value-and-externalValue': 'warn',
     'no-unused-components': 'warn',
     'no-undefined-server-variable': 'warn',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'spec-components-invalid-map-name': 'warn',
   },
   oas3_1Rules: {
+    'no-invalid-media-type-examples': 'warn',
     'no-server-example.com': 'warn',
     'no-server-trailing-slash': 'error',
     'no-empty-servers': 'warn',
     'no-example-value-and-externalValue': 'warn',
     'no-unused-components': 'warn',
     'no-undefined-server-variable': 'warn',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'spec-components-invalid-map-name': 'warn',
   },
 } as PluginStyleguideConfig;

package/src/config/recommended.ts

@@ -25,7 +25,7 @@ export default {
     'operation-operationId-url-safe': 'error',
     'operation-parameters-unique': 'error',
     'operation-tag-defined': 'off',
-    'operation-security-defined': 'error',
+    'security-defined': 'error',
     'operation-singular-tag': 'off',
     'no-unresolved-refs': 'error',
     'no-enum-type-mismatch': 'error',
@@ -36,7 +36,7 @@ export default {
   oas3_0Rules: {
     'no-invalid-media-type-examples': {
       severity: 'warn',
-      disallowAdditionalProperties: true,
+      allowAdditionalProperties: false,
     },
     'no-server-example.com': 'warn',
     'no-server-trailing-slash': 'error',
@@ -44,15 +44,18 @@ export default {
     'no-example-value-and-externalValue': 'error',
     'no-unused-components': 'warn',
     'no-undefined-server-variable': 'error',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'spec-components-invalid-map-name': 'error',
   },
   oas3_1Rules: {
+    'no-invalid-media-type-examples': 'warn',
     'no-server-example.com': 'warn',
     'no-server-trailing-slash': 'error',
     'no-empty-servers': 'error',
     'no-example-value-and-externalValue': 'error',
     'no-unused-components': 'warn',
     'no-undefined-server-variable': 'error',
-    'no-servers-empty-enum': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'spec-components-invalid-map-name': 'error',
   },
 } as PluginStyleguideConfig;

package/src/config/rules.ts

@@ -1,6 +1,6 @@
 import { RuleSet, OasVersion } from '../oas-types';
 import { StyleguideConfig } from './config';
-import { notUndefined } from '../utils';
+import { isDefined } from '../utils';
 
 export function initRules<T extends Function, P extends RuleSet<T>>(
   rules: P[],
@@ -42,5 +42,5 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
       })
     )
     .flatMap((visitor) => visitor)
-    .filter(notUndefined);
+    .filter(isDefined);
 }

package/src/config/types.ts

@@ -110,6 +110,7 @@ export type ResolveHeader =
 
 export type RawResolveConfig = {
   http?: Partial<HttpResolveConfig>;
+  doNotResolveExamples?: boolean;
 };
 
 export type HttpResolveConfig = {
@@ -128,6 +129,7 @@ export type AccessTokens = { [region in Region]?: string };
 export type DeprecatedInRawConfig = {
   apiDefinitions?: Record<string, string>;
   lint?: StyleguideRawConfig;
+  styleguide?: StyleguideRawConfig;
   referenceDocs?: Record<string, any>;
   apis?: Record<string, Api & DeprecatedInApi>;
 };
@@ -153,6 +155,15 @@ export type RawConfig = {
   organization?: string;
 } & FeaturesConfig;
 
+export type FlatApi = Omit<Api, 'styleguide'> &
+  Omit<ApiStyleguideRawConfig, 'doNotResolveExamples'>;
+
+export type FlatRawConfig = Omit<RawConfig, 'styleguide' | 'resolve' | 'apis'> &
+  Omit<StyleguideRawConfig, 'doNotResolveExamples'> & {
+    resolve?: RawResolveConfig;
+    apis?: Record<string, FlatApi>;
+  };
+
 export type ResolvedConfig = Omit<RawConfig, 'apis' | 'styleguide'> & {
   apis: Record<string, ResolvedApi>;
   styleguide: ResolvedStyleguideConfig;

package/src/config/utils.ts

@@ -1,18 +1,26 @@
-import { green, yellow } from 'colorette';
-import { assignExisting } from '../utils';
+import {
+  assignExisting,
+  isDefined,
+  isTruthy,
+  showErrorForDeprecatedField,
+  showWarningForDeprecatedField,
+} from '../utils';
 import { Config } from './config';
-
 import type {
   Api,
   DeprecatedInApi,
   DeprecatedInRawConfig,
+  FlatApi,
+  FlatRawConfig,
   Plugin,
   RawConfig,
   RawResolveConfig,
   ResolveConfig,
   ResolvedStyleguideConfig,
   RulesFields,
+  StyleguideRawConfig,
 } from './types';
+import { logger, colorize } from '../logger';
 
 export function parsePresetName(presetName: string): { pluginId: string; configName: string } {
   if (presetName.indexOf('/') > -1) {
@@ -34,13 +42,86 @@ export function transformApiDefinitionsToApis(
   return apis;
 }
 
+function extractFlatConfig<
+  T extends Partial<
+    (Api & DeprecatedInApi & FlatApi) & (DeprecatedInRawConfig & RawConfig & FlatRawConfig)
+  >
+>({
+  plugins,
+  extends: _extends,
+
+  rules,
+  oas2Rules,
+  oas3_0Rules,
+  oas3_1Rules,
+
+  preprocessors,
+  oas2Preprocessors,
+  oas3_0Preprocessors,
+  oas3_1Preprocessors,
+
+  decorators,
+  oas2Decorators,
+  oas3_0Decorators,
+  oas3_1Decorators,
+
+  ...rawConfigRest
+}: T): {
+  styleguideConfig?: StyleguideRawConfig;
+  rawConfigRest: Omit<T, 'plugins' | 'extends' | RulesFields>;
+} {
+  const styleguideConfig = {
+    plugins,
+    extends: _extends,
+
+    rules,
+    oas2Rules,
+    oas3_0Rules,
+    oas3_1Rules,
+
+    preprocessors,
+    oas2Preprocessors,
+    oas3_0Preprocessors,
+    oas3_1Preprocessors,
+
+    decorators,
+    oas2Decorators,
+    oas3_0Decorators,
+    oas3_1Decorators,
+
+    doNotResolveExamples: (rawConfigRest as FlatRawConfig).resolve?.doNotResolveExamples,
+  };
+
+  if (
+    (rawConfigRest.lint && rawConfigRest.styleguide) ||
+    (Object.values(styleguideConfig).some(isDefined) &&
+      (rawConfigRest.lint || rawConfigRest.styleguide))
+  ) {
+    throw new Error(
+      `Do not use 'lint', 'styleguide' and flat syntax together. \nSee more about the configuration in the docs: https://redocly.com/docs/cli/configuration/ \n`
+    );
+  }
+
+  return {
+    styleguideConfig: Object.values(styleguideConfig).some(isDefined)
+      ? styleguideConfig
+      : undefined,
+
+    rawConfigRest,
+  };
+}
+
 function transformApis(
-  legacyApis?: Record<string, Api & DeprecatedInApi>
+  legacyApis?: Record<string, Api & DeprecatedInApi & FlatApi>
 ): Record<string, Api> | undefined {
   if (!legacyApis) return undefined;
   const apis: Record<string, Api> = {};
   for (const [apiName, { lint, ...apiContent }] of Object.entries(legacyApis)) {
-    apis[apiName] = { styleguide: lint, ...apiContent };
+    const { styleguideConfig, rawConfigRest } = extractFlatConfig(apiContent);
+    apis[apiName] = {
+      styleguide: styleguideConfig || lint,
+      ...rawConfigRest,
+    };
   }
   return apis;
 }
@@ -79,7 +160,7 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
     extendPaths: [],
   };
 
-  for (let rulesConf of rulesConfList) {
+  for (const rulesConf of rulesConfList) {
     if (rulesConf.extends) {
       throw new Error(
         `'extends' is not supported in shared configs yet: ${JSON.stringify(rulesConf, null, 2)}.`
@@ -124,14 +205,14 @@ export function getMergedConfig(config: Config, apiName?: string): Config {
     config.rawConfig?.styleguide?.extendPaths,
   ]
     .flat()
-    .filter(Boolean) as string[];
+    .filter(isTruthy);
 
   const pluginPaths = [
     ...Object.values(config.apis).map((api) => api?.styleguide?.pluginPaths),
     config.rawConfig?.styleguide?.pluginPaths,
   ]
     .flat()
-    .filter(Boolean) as string[];
+    .filter(isTruthy);
 
   return apiName
     ? new Config(
@@ -160,34 +241,41 @@ export function getMergedConfig(config: Config, apiName?: string): Config {
 }
 
 function checkForDeprecatedFields(
-  deprecatedField: keyof DeprecatedInRawConfig,
-  updatedField: keyof RawConfig,
-  rawConfig: DeprecatedInRawConfig & RawConfig
+  deprecatedField: keyof (DeprecatedInRawConfig & RawConfig),
+  updatedField: keyof FlatRawConfig | undefined,
+  rawConfig: DeprecatedInRawConfig & RawConfig & FlatRawConfig
 ): void {
   const isDeprecatedFieldInApis =
     rawConfig.apis &&
     Object.values(rawConfig.apis).some(
-      (api: Api & DeprecatedInApi & DeprecatedInRawConfig) => api[deprecatedField]
+      (api: Api & FlatApi & DeprecatedInApi & DeprecatedInRawConfig & RawConfig & FlatRawConfig) =>
+        api[deprecatedField]
     );
 
-  if (rawConfig[deprecatedField] && rawConfig[updatedField]) {
-    throw new Error(`Do not use '${deprecatedField}' field. Use '${updatedField}' instead.\n`);
+  if (rawConfig[deprecatedField] && updatedField === null) {
+    showWarningForDeprecatedField(deprecatedField);
+  }
+
+  if (rawConfig[deprecatedField] && updatedField && rawConfig[updatedField]) {
+    showErrorForDeprecatedField(deprecatedField, updatedField);
   }
 
   if (rawConfig[deprecatedField] || isDeprecatedFieldInApis) {
-    process.stderr.write(
-      `The ${yellow(deprecatedField)} field is deprecated. Use ${green(
-        updatedField
-      )} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`
-    );
+    showWarningForDeprecatedField(deprecatedField, updatedField);
   }
 }
 
-export function transformConfig(rawConfig: DeprecatedInRawConfig & RawConfig): RawConfig {
-  const migratedFields: [keyof DeprecatedInRawConfig, keyof RawConfig][] = [
+export function transformConfig(
+  rawConfig: DeprecatedInRawConfig & RawConfig & FlatRawConfig
+): RawConfig {
+  const migratedFields: [
+    keyof (DeprecatedInRawConfig & RawConfig),
+    keyof FlatRawConfig | undefined
+  ][] = [
     ['apiDefinitions', 'apis'],
     ['referenceDocs', 'features.openapi'],
-    ['lint', 'styleguide'], // TODO: update docs
+    ['lint', undefined],
+    ['styleguide', undefined],
   ];
 
   for (const [deprecatedField, updatedField] of migratedFields) {
@@ -196,11 +284,13 @@ export function transformConfig(rawConfig: DeprecatedInRawConfig & RawConfig): R
 
   const { apis, apiDefinitions, referenceDocs, lint, ...rest } = rawConfig;
 
+  const { styleguideConfig, rawConfigRest } = extractFlatConfig(rest);
+
   return {
     'features.openapi': referenceDocs,
     apis: transformApis(apis) || transformApiDefinitionsToApis(apiDefinitions),
-    styleguide: lint,
-    ...rest,
+    styleguide: styleguideConfig || lint,
+    ...rawConfigRest,
   };
 }
 
@@ -221,7 +311,7 @@ export function getUniquePlugins(plugins: Plugin[]): Plugin[] {
       results.push(p);
       seen.add(p.id);
     } else if (p.id) {
-      process.stderr.write(`Duplicate plugin id "${yellow(p.id)}".\n`);
+      logger.warn(`Duplicate plugin id "${colorize.red(p.id)}".\n`);
     }
   }
   return results;

package/src/decorators/common/registry-dependencies.ts

@@ -4,10 +4,10 @@ import { isRedoclyRegistryURL } from '../../redocly';
 import { Oas3Decorator, Oas2Decorator } from '../../visitors';
 
 export const RegistryDependencies: Oas3Decorator | Oas2Decorator = () => {
-  let registryDependencies = new Set<string>();
+  const registryDependencies = new Set<string>();
 
   return {
-    DefinitionRoot: {
+    Root: {
       leave(_: any, ctx: UserContext) {
         const data = ctx.getVisitorData();
         data.links = Array.from(registryDependencies);