@redocly/openapi-core 1.16.0 → 1.17.1

package/src/config/__tests__/load.test.ts

@@ -58,6 +58,88 @@ describe('loadConfig', () => {
     expect(mockFn).toHaveBeenCalled();
   });
 
+  it('should resolve config and call processRawConfig', async () => {
+    let problems: NormalizedProblem[];
+    let doc: any;
+
+    await loadConfig({
+      configPath: path.join(__dirname, './fixtures/resolve-refs-in-config/config-with-refs.yaml'),
+      processRawConfig: async ({ document, parsed, resolvedRefMap, config }) => {
+        doc = parsed;
+        problems = await lintConfig({
+          document,
+          severity: 'warn',
+          resolvedRefMap,
+          config,
+        });
+      },
+    });
+
+    expect(replaceSourceWithRef(problems!, __dirname)).toMatchInlineSnapshot(`
+      [
+        {
+          "from": {
+            "pointer": "#/seo",
+            "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
+          },
+          "location": [
+            {
+              "pointer": "#/title",
+              "reportOnKey": false,
+              "source": "fixtures/resolve-refs-in-config/seo.yaml",
+            },
+          ],
+          "message": "Expected type \`string\` but got \`integer\`.",
+          "ruleId": "configuration spec",
+          "severity": "warn",
+          "suggest": [],
+        },
+        {
+          "from": {
+            "pointer": "#/rules",
+            "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
+          },
+          "location": [
+            {
+              "pointer": "#/non-existing-rule",
+              "reportOnKey": true,
+              "source": "fixtures/resolve-refs-in-config/rules.yaml",
+            },
+          ],
+          "message": "Property \`non-existing-rule\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "warn",
+          "suggest": [],
+        },
+        {
+          "location": [
+            {
+              "pointer": "#/theme",
+              "reportOnKey": false,
+              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
+          "ruleId": "configuration no-unresolved-refs",
+          "severity": "warn",
+          "suggest": [],
+        },
+      ]
+    `);
+    expect(doc).toMatchInlineSnapshot(`
+      {
+        "rules": {
+          "info-license": "error",
+          "non-existing-rule": "warn",
+        },
+        "seo": {
+          "title": 1,
+        },
+        "theme": undefined,
+      }
+    `);
+  });
+
   it('should call externalRefResolver if such passed', async () => {
     const externalRefResolver = new BaseResolver();
     const resolverSpy = jest.spyOn(externalRefResolver, 'resolveDocument');
@@ -104,22 +186,16 @@ describe('findConfig', () => {
 describe('getConfig', () => {
   jest.spyOn(fs, 'hasOwnProperty').mockImplementation(() => false);
   it('should return empty object if there is no configPath and config file is not found', () => {
-    expect(getConfig()).toEqual(Promise.resolve({}));
+    expect(getConfig()).toEqual(Promise.resolve({ rawConfig: {} }));
   });
 
   it('should resolve refs in config', async () => {
     let problems: NormalizedProblem[];
-    const result = await getConfig({
+
+    const { rawConfig } = await getConfig({
       configPath: path.join(__dirname, './fixtures/resolve-refs-in-config/config-with-refs.yaml'),
-      processRawConfig: async (config, resolvedRefMap) => {
-        problems = await lintConfig({
-          document: config,
-          severity: 'warn',
-          resolvedRefMap,
-        });
-      },
     });
-    expect(result).toEqual({
+    expect(rawConfig).toEqual({
       seo: {
         title: 1,
       },
@@ -130,57 +206,6 @@ describe('getConfig', () => {
         },
       },
     });
-    expect(replaceSourceWithRef(problems!, __dirname)).toMatchInlineSnapshot(`
-      [
-        {
-          "from": {
-            "pointer": "#/seo",
-            "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
-          },
-          "location": [
-            {
-              "pointer": "#/title",
-              "reportOnKey": false,
-              "source": "fixtures/resolve-refs-in-config/seo.yaml",
-            },
-          ],
-          "message": "Expected type \`string\` but got \`integer\`.",
-          "ruleId": "configuration spec",
-          "severity": "warn",
-          "suggest": [],
-        },
-        {
-          "from": {
-            "pointer": "#/rules",
-            "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
-          },
-          "location": [
-            {
-              "pointer": "#/non-existing-rule",
-              "reportOnKey": true,
-              "source": "fixtures/resolve-refs-in-config/rules.yaml",
-            },
-          ],
-          "message": "Property \`non-existing-rule\` is not expected here.",
-          "ruleId": "configuration spec",
-          "severity": "warn",
-          "suggest": [],
-        },
-        {
-          "location": [
-            {
-              "pointer": "#/theme",
-              "reportOnKey": false,
-              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
-          "ruleId": "configuration no-unresolved-refs",
-          "severity": "warn",
-          "suggest": [],
-        },
-      ]
-    `);
   });
 });
 

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

@@ -134,6 +134,7 @@ const Schema: NodeType = {
     then: 'Schema',
     else: 'Schema',
     dependentSchemas: listOf('Schema'),
+    dependentRequired: 'DependentRequired',
     prefixItems: listOf('Schema'),
     contains: 'Schema',
     minContains: { type: 'integer', minimum: 0 },
@@ -170,6 +171,7 @@ const Schema: NodeType = {
     format: { type: 'string' },
     contentEncoding: { type: 'string' },
     contentMediaType: { type: 'string' },
+    contentSchema: 'Schema',
     default: null,
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },
@@ -265,6 +267,11 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
+const DependentRequired: NodeType = {
+  properties: {},
+  additionalProperties: { type: 'array', items: { type: 'string' } },
+};
+
 export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   ...Oas3Types,
   Info,
@@ -276,4 +283,5 @@ export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   NamedPathItems: mapOf('PathItem'),
   SecurityScheme,
   Operation,
+  DependentRequired,
 };

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',
@@ -218,12 +220,11 @@ const oas3_1NodeTypesList = [
   'NamedPathItems',
   'SecurityScheme',
   'Operation',
+  'DependentRequired',
 ] as const;
 
 export type Oas3_1NodeType = typeof oas3_1NodeTypesList[number];
 
-const asyncNodeTypesList = ['Message'] as const;
-
 const ConfigStyleguide: NodeType = {
   properties: {
     extends: {
@@ -350,35 +351,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 +1051,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 +1065,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 +1131,6 @@ const CoreConfigTypes: Record<string, NodeType> = {
   Heading,
   Typography,
   AssertionDefinitionAssertions,
-  AssertionDefinitionSubject,
 };
 
 export const ConfigTypes: Record<string, NodeType> = createConfigTypes(rootRedoclyConfigSchema);