@redocly/openapi-core 1.16.0 → 1.17.0

package/src/config/load.ts

@@ -4,7 +4,7 @@ import { RedoclyClient } from '../redocly';
 import { isEmptyObject } from '../utils';
 import { parseYaml } from '../js-yaml';
 import { Config } from './config';
-import { ConfigValidationError, transformConfig } from './utils';
+import { ConfigValidationError, transformConfig, deepCloneMapWithJSON } from './utils';
 import { resolveConfig, resolveConfigFileAndRefs } from './config-resolvers';
 import { bundleConfig } from '../bundle';
 import { BaseResolver } from '../resolve';
@@ -80,10 +80,12 @@ async function addConfigMetadata({
   });
 }
 
-export type RawConfigProcessor = (
-  rawConfig: Document,
-  resolvedRefMap: ResolvedRefMap
-) => void | Promise<void>;
+export type RawConfigProcessor = (params: {
+  document: Document;
+  resolvedRefMap: ResolvedRefMap;
+  config: Config;
+  parsed: Document['parsed'];
+}) => void | Promise<void>;
 
 export async function loadConfig(
   options: {
@@ -103,12 +105,16 @@ export async function loadConfig(
     region,
     externalRefResolver,
   } = options;
-  const rawConfig = await getConfig({ configPath, processRawConfig, externalRefResolver });
+
+  const { rawConfig, document, parsed, resolvedRefMap } = await getConfig({
+    configPath,
+    externalRefResolver,
+  });
 
   const redoclyClient = isBrowser ? undefined : new RedoclyClient();
   const tokens = redoclyClient && redoclyClient.hasTokens() ? redoclyClient.getAllTokens() : [];
 
-  return addConfigMetadata({
+  const config = await addConfigMetadata({
     rawConfig,
     customExtends,
     configPath,
@@ -117,6 +123,24 @@ export async function loadConfig(
     region,
     externalRefResolver,
   });
+
+  if (document && parsed && resolvedRefMap && typeof processRawConfig === 'function') {
+    try {
+      await processRawConfig({
+        document,
+        resolvedRefMap,
+        config,
+        parsed,
+      });
+    } catch (e) {
+      if (e instanceof ConfigValidationError) {
+        throw e;
+      }
+      throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+    }
+  }
+
+  return config;
 }
 
 export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
@@ -139,31 +163,33 @@ export function findConfig(dir?: string): string | undefined {
 export async function getConfig(
   options: {
     configPath?: string;
-    processRawConfig?: RawConfigProcessor;
     externalRefResolver?: BaseResolver;
   } = {}
-): Promise<RawConfig> {
-  const {
-    configPath = findConfig(),
-    processRawConfig,
-    externalRefResolver = new BaseResolver(),
-  } = options;
-  if (!configPath) return {};
+): Promise<{
+  rawConfig: RawConfig;
+  document?: Document;
+  parsed?: Document['parsed'];
+  resolvedRefMap?: ResolvedRefMap;
+}> {
+  const { configPath = findConfig(), externalRefResolver = new BaseResolver() } = options;
+  if (!configPath) return { rawConfig: {} };
 
   try {
     const { document, resolvedRefMap } = await resolveConfigFileAndRefs({
       configPath,
       externalRefResolver,
     });
-    if (typeof processRawConfig === 'function') {
-      await processRawConfig(document, resolvedRefMap);
-    }
-    const bundledConfig = await bundleConfig(document, resolvedRefMap);
-    return transformConfig(bundledConfig);
+
+    const bundledRefMap = deepCloneMapWithJSON(resolvedRefMap);
+    const parsed = await bundleConfig(JSON.parse(JSON.stringify(document)), bundledRefMap);
+
+    return {
+      rawConfig: transformConfig(parsed),
+      document,
+      parsed,
+      resolvedRefMap,
+    };
   } catch (e) {
-    if (e instanceof ConfigValidationError) {
-      throw e;
-    }
     throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
   }
 }

package/src/config/utils.ts

@@ -364,3 +364,7 @@ export function getUniquePlugins(plugins: Plugin[]): Plugin[] {
 }
 
 export class ConfigValidationError extends Error {}
+
+export function deepCloneMapWithJSON<K, V>(originalMap: Map<K, V>): Map<K, V> {
+  return new Map(JSON.parse(JSON.stringify([...originalMap])));
+}

package/src/lint.ts

@@ -1,11 +1,11 @@
 import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve';
 import { normalizeVisitors } from './visitors';
 import { walkDocument } from './walk';
-import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
+import { StyleguideConfig, Config, initRules } from './config';
 import { normalizeTypes } from './types';
 import { releaseAjvInstance } from './rules/ajv';
 import { SpecVersion, getMajorSpecVersion, detectSpec, getTypes } from './oas-types';
-import { ConfigTypes } from './types/redocly-yaml';
+import { createConfigTypes } from './types/redocly-yaml';
 import { Spec } from './rules/common/spec';
 import { NoUnresolvedRefs } from './rules/no-unresolved-refs';
 
@@ -13,6 +13,7 @@ import type { Document, ResolvedRefMap } from './resolve';
 import type { ProblemSeverity, WalkContext } from './walk';
 import type { NodeType } from './types';
 import type { NestedVisitObject, Oas3Visitor, RuleInstanceConfig } from './visitors';
+import { rootRedoclyConfigSchema } from '@redocly/config';
 
 export async function lint(opts: {
   ref: string;
@@ -109,25 +110,25 @@ export async function lintDocument(opts: {
 
 export async function lintConfig(opts: {
   document: Document;
+  config: Config;
   resolvedRefMap?: ResolvedRefMap;
   severity?: ProblemSeverity;
   externalRefResolver?: BaseResolver;
   externalConfigTypes?: Record<string, NodeType>;
 }) {
-  const { document, severity, externalRefResolver = new BaseResolver() } = opts;
+  const { document, severity, externalRefResolver = new BaseResolver(), config } = opts;
 
   const ctx: WalkContext = {
     problems: [],
     oasVersion: SpecVersion.OAS3_0,
     visitorsData: {},
   };
-  const plugins = resolvePlugins([defaultPlugin]);
-  const config = new StyleguideConfig({
-    plugins,
-    rules: { spec: 'error' },
-  });
 
-  const types = normalizeTypes(opts.externalConfigTypes || ConfigTypes, config);
+  const types = normalizeTypes(
+    opts.externalConfigTypes || createConfigTypes(rootRedoclyConfigSchema, config),
+    { doNotResolveExamples: config.styleguide.doNotResolveExamples }
+  );
+
   const rules: (RuleInstanceConfig & {
     visitor: NestedVisitObject<unknown, Oas3Visitor | Oas3Visitor[]>;
   })[] = [

package/src/types/oas3_1.ts

@@ -170,6 +170,7 @@ const Schema: NodeType = {
     format: { type: 'string' },
     contentEncoding: { type: 'string' },
     contentMediaType: { type: 'string' },
+    contentSchema: 'Schema',
     default: null,
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },

package/src/types/redocly-yaml.ts

@@ -5,6 +5,8 @@ import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 
 import type { NodeType } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
+import { SpecVersion, getTypes } from '../oas-types';
+import { Config } from '../config';
 
 const builtInCommonRules = [
   'spec',
@@ -222,8 +224,6 @@ const oas3_1NodeTypesList = [
 
 export type Oas3_1NodeType = typeof oas3_1NodeTypesList[number];
 
-const asyncNodeTypesList = ['Message'] as const;
-
 const ConfigStyleguide: NodeType = {
   properties: {
     extends: {
@@ -350,35 +350,28 @@ const Schema: NodeType = {
   additionalProperties: {},
 };
 
-const AssertionDefinitionSubject: NodeType = {
-  properties: {
-    type: {
-      enum: [
-        ...new Set([
-          'any',
-          ...oas2NodeTypesList,
-          ...oas3NodeTypesList,
-          ...oas3_1NodeTypesList,
-          ...asyncNodeTypesList,
-          'SpecExtension',
-        ]),
-      ],
-    },
-    property: (value: unknown) => {
-      if (Array.isArray(value)) {
-        return { type: 'array', items: { type: 'string' } };
-      } else if (value === null) {
-        return null;
-      } else {
-        return { type: 'string' };
-      }
+function createAssertionDefinitionSubject(nodeNames: string[]): NodeType {
+  return {
+    properties: {
+      type: {
+        enum: [...new Set(['any', ...nodeNames, 'SpecExtension'])],
+      },
+      property: (value: unknown) => {
+        if (Array.isArray(value)) {
+          return { type: 'array', items: { type: 'string' } };
+        } else if (value === null) {
+          return null;
+        } else {
+          return { type: 'string' };
+        }
+      },
+      filterInParentKeys: { type: 'array', items: { type: 'string' } },
+      filterOutParentKeys: { type: 'array', items: { type: 'string' } },
+      matchParentKeys: { type: 'string' },
     },
-    filterInParentKeys: { type: 'array', items: { type: 'string' } },
-    filterOutParentKeys: { type: 'array', items: { type: 'string' } },
-    matchParentKeys: { type: 'string' },
-  },
-  required: ['type'],
-};
+    required: ['type'],
+  };
+}
 
 const AssertionDefinitionAssertions: NodeType = {
   properties: {
@@ -1057,7 +1050,13 @@ const ConfigMockServer: NodeType = {
   },
 };
 
-export const createConfigTypes = (extraSchemas: JSONSchema) => {
+export function createConfigTypes(extraSchemas: JSONSchema, config?: Config) {
+  const nodeNames = Object.values(SpecVersion).flatMap((version) => {
+    const types = config?.styleguide
+      ? config.styleguide.extendTypes(getTypes(version), version)
+      : getTypes(version);
+    return Object.keys(types);
+  });
   // Create types based on external schemas
   const nodeTypes = getNodeTypesFromJSONSchema('rootRedoclyConfigSchema', extraSchemas);
 
@@ -1065,9 +1064,10 @@ export const createConfigTypes = (extraSchemas: JSONSchema) => {
     ...CoreConfigTypes,
     ConfigRoot: createConfigRoot(nodeTypes), // This is the REAL config root type
     ConfigApisProperties: createConfigApisProperties(nodeTypes),
+    AssertionDefinitionSubject: createAssertionDefinitionSubject(nodeNames),
     ...nodeTypes,
   };
-};
+}
 
 const CoreConfigTypes: Record<string, NodeType> = {
   Assert,
@@ -1130,7 +1130,6 @@ const CoreConfigTypes: Record<string, NodeType> = {
   Heading,
   Typography,
   AssertionDefinitionAssertions,
-  AssertionDefinitionSubject,
 };
 
 export const ConfigTypes: Record<string, NodeType> = createConfigTypes(rootRedoclyConfigSchema);