@redocly/openapi-core 1.5.0 → 1.6.0

package/src/config/load.ts

@@ -1,20 +1,17 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { RedoclyClient } from '../redocly';
-import { isEmptyObject, loadYaml, doesYamlFileExist } from '../utils';
+import { isEmptyObject, doesYamlFileExist } from '../utils';
 import { parseYaml } from '../js-yaml';
 import { Config, DOMAINS } from './config';
 import { ConfigValidationError, transformConfig } from './utils';
-import { resolveConfig } from './config-resolvers';
+import { resolveConfig, resolveConfigFileAndRefs } from './config-resolvers';
+import { bundleConfig } from '../bundle';
 
-import type {
-  DeprecatedInRawConfig,
-  FlatRawConfig,
-  RawConfig,
-  RawUniversalConfig,
-  Region,
-} from './types';
-import { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
+import type { Document } from '../resolve';
+import type { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
+import type { RawConfig, RawUniversalConfig, Region } from './types';
+import type { BaseResolver, ResolvedRefMap } from '../resolve';
 
 async function addConfigMetadata({
   rawConfig,
@@ -73,17 +70,30 @@ async function addConfigMetadata({
   );
 }
 
+export type RawConfigProcessor = (
+  rawConfig: Document,
+  resolvedRefMap: ResolvedRefMap
+) => void | Promise<void>;
+
 export async function loadConfig(
   options: {
     configPath?: string;
     customExtends?: string[];
-    processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>;
+    processRawConfig?: RawConfigProcessor;
+    externalRefResolver?: BaseResolver;
     files?: string[];
     region?: Region;
   } = {}
 ): Promise<Config> {
-  const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-  const rawConfig = await getConfig(configPath, processRawConfig);
+  const {
+    configPath = findConfig(),
+    customExtends,
+    processRawConfig,
+    files,
+    region,
+    externalRefResolver,
+  } = options;
+  const rawConfig = await getConfig({ configPath, processRawConfig, externalRefResolver });
 
   const redoclyClient = new RedoclyClient();
   const tokens = await redoclyClient.getTokens();
@@ -116,17 +126,24 @@ export function findConfig(dir?: string): string | undefined {
 }
 
 export async function getConfig(
-  configPath: string | undefined = findConfig(),
-  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>
+  options: {
+    configPath?: string;
+    processRawConfig?: RawConfigProcessor;
+    externalRefResolver?: BaseResolver;
+  } = {}
 ): Promise<RawConfig> {
+  const { configPath = findConfig(), processRawConfig, externalRefResolver } = options;
   if (!configPath || !doesYamlFileExist(configPath)) return {};
   try {
-    const rawConfig =
-      (await loadYaml<RawConfig & DeprecatedInRawConfig & FlatRawConfig>(configPath)) || {};
+    const { document, resolvedRefMap } = await resolveConfigFileAndRefs({
+      configPath,
+      externalRefResolver,
+    });
     if (typeof processRawConfig === 'function') {
-      await processRawConfig(rawConfig);
+      await processRawConfig(document, resolvedRefMap);
     }
-    return transformConfig(rawConfig);
+    const bundledConfig = await bundleConfig(document, resolvedRefMap);
+    return transformConfig(bundledConfig);
   } catch (e) {
     if (e instanceof ConfigValidationError) {
       throw e;

package/src/lint.ts

@@ -1,13 +1,18 @@
-import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
+import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve';
 import { normalizeVisitors } from './visitors';
-import { NodeType } from './types';
-import { ProblemSeverity, WalkContext, walkDocument } from './walk';
+import { walkDocument } from './walk';
 import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } 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 { Spec } from './rules/common/spec';
+import { NoUnresolvedRefs } from './rules/no-unresolved-refs';
+
+import type { Document, ResolvedRefMap } from './resolve';
+import type { ProblemSeverity, WalkContext } from './walk';
+import type { NodeType } from './types';
+import type { NestedVisitObject, Oas3Visitor, RuleInstanceConfig } from './visitors';
 
 export async function lint(opts: {
   ref: string;
@@ -102,8 +107,13 @@ export async function lintDocument(opts: {
   return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
 }
 
-export async function lintConfig(opts: { document: Document; severity?: ProblemSeverity }) {
-  const { document, severity } = opts;
+export async function lintConfig(opts: {
+  document: Document;
+  resolvedRefMap?: ResolvedRefMap;
+  severity?: ProblemSeverity;
+  externalRefResolver?: BaseResolver;
+}) {
+  const { document, severity, externalRefResolver = new BaseResolver() } = opts;
 
   const ctx: WalkContext = {
     problems: [],
@@ -117,21 +127,33 @@ export async function lintConfig(opts: { document: Document; severity?: ProblemS
   });
 
   const types = normalizeTypes(ConfigTypes, config);
-  const rules = [
+  const rules: (RuleInstanceConfig & {
+    visitor: NestedVisitObject<unknown, Oas3Visitor | Oas3Visitor[]>;
+  })[] = [
     {
       severity: severity || 'error',
       ruleId: 'configuration spec',
       visitor: Spec({ severity: 'error' }),
     },
+    {
+      severity: severity || 'error',
+      ruleId: 'configuration no-unresolved-refs',
+      visitor: NoUnresolvedRefs({ severity: 'error' }),
+    },
   ];
-  // TODO: check why any is needed
-  const normalizedVisitors = normalizeVisitors(rules as any, types);
-
+  const normalizedVisitors = normalizeVisitors(rules, types);
+  const resolvedRefMap =
+    opts.resolvedRefMap ||
+    (await resolveDocument({
+      rootDocument: document,
+      rootType: types.ConfigRoot,
+      externalRefResolver,
+    }));
   walkDocument({
     document,
     rootType: types.ConfigRoot,
     normalizedVisitors,
-    resolvedRefMap: new Map(),
+    resolvedRefMap,
     ctx,
   });
 

package/src/types/portal-config-schema.ts

@@ -4,6 +4,8 @@ import {
   DEFAULT_TEAM_CLAIM_NAME,
 } from '../config';
 
+import type { NodeType } from '.';
+
 const oidcIssuerMetadataSchema = {
   type: 'object',
   properties: {
@@ -87,8 +89,9 @@ const authProviderConfigSchema = {
 
 export const ssoConfigSchema = {
   type: 'object',
+  properties: {},
   additionalProperties: authProviderConfigSchema,
-} as const;
+} as NodeType;
 
 const redirectConfigSchema = {
   type: 'object',
@@ -97,8 +100,14 @@ const redirectConfigSchema = {
     type: { type: 'number', default: 301 },
   },
   required: ['to'],
-  additionalProperties: false,
-} as const;
+} as NodeType;
+
+const redirectsConfigSchema = {
+  type: 'object',
+  properties: {},
+  additionalProperties: 'redirectConfigSchema',
+  default: {},
+} as NodeType;
 
 export const apiConfigSchema = {
   type: 'object',
@@ -147,18 +156,21 @@ const seoConfigSchema = {
       },
     },
   },
-  additionalProperties: false,
 } as const;
 
-const rbacScopeItemsSchema = { type: 'object', additionalProperties: { type: 'string' } } as const;
+const rbacScopeItemsSchema = {
+  type: 'object',
+  properties: {},
+  additionalProperties: { type: 'string' },
+} as NodeType;
 
 const rbacConfigSchema = {
   type: 'object',
   properties: {
-    defaults: rbacScopeItemsSchema,
+    defaults: 'rbacScopeItemsSchema',
   },
   additionalProperties: rbacScopeItemsSchema,
-} as const;
+} as NodeType;
 
 const graviteeAdapterConfigSchema = {
   type: 'object',
@@ -234,14 +246,38 @@ const devOnboardingAdapterConfigSchema = {
 const devOnboardingConfigSchema = {
   type: 'object',
   required: ['adapters'],
-  additionalProperties: false,
   properties: {
     adapters: {
       type: 'array',
       items: devOnboardingAdapterConfigSchema,
     },
   },
-} as const;
+} as NodeType;
+
+const i18ConfigSchema = {
+  type: 'object',
+  properties: {
+    defaultLocale: {
+      type: 'string',
+    },
+    locales: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          code: {
+            type: 'string',
+          },
+          name: {
+            type: 'string',
+          },
+        },
+        required: ['code'],
+      },
+    },
+  },
+  required: ['defaultLocale', 'locales'],
+} as NodeType;
 
 const responseHeaderSchema = {
   type: 'object',
@@ -253,14 +289,25 @@ const responseHeaderSchema = {
   required: ['name', 'value'],
 } as const;
 
+export const PortalConfigNodeTypes: Record<string, NodeType> = {
+  seoConfigSchema,
+  rbacConfigSchema,
+  rbacScopeItemsSchema,
+  ssoConfigSchema,
+  devOnboardingConfigSchema,
+  i18ConfigSchema,
+  redirectsConfigSchema,
+  redirectConfigSchema,
+  // TODO: Extract other types that need to be linted in the config
+};
+
 export const redoclyConfigSchema = {
   type: 'object',
   properties: {
     licenseKey: { type: 'string' },
-    theme: { type: 'object', default: {} }, // ThemeConfig
-    redirects: { type: 'object', additionalProperties: redirectConfigSchema, default: {} },
-    seo: seoConfigSchema,
-    rbac: rbacConfigSchema,
+    redirects: 'redirectsConfigSchema',
+    seo: 'seoConfigSchema',
+    rbac: 'rbacConfigSchema',
     responseHeaders: {
       type: 'object',
       additionalProperties: {
@@ -282,38 +329,13 @@ export const redoclyConfigSchema = {
       type: 'object',
       additionalProperties: apiConfigSchema,
     },
-    sso: ssoConfigSchema,
-    developerOnboarding: devOnboardingConfigSchema,
-    i18n: {
-      type: 'object',
-      properties: {
-        defaultLocale: {
-          type: 'string',
-        },
-        locales: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              code: {
-                type: 'string',
-              },
-              name: {
-                type: 'string',
-              },
-            },
-            required: ['code'],
-          },
-        },
-      },
-      additionalProperties: false,
-      required: ['defaultLocale', 'locales'],
-    },
+    sso: 'ssoConfigSchema',
+    developerOnboarding: 'devOnboardingConfigSchema',
+    i18n: 'i18ConfigSchema',
     metadata: metadataConfigSchema,
   },
   default: {},
-  additionalProperties: true,
-} as const;
+} as NodeType;
 
 export const environmentSchema = {
   oneOf: [
@@ -335,6 +357,7 @@ export const rootRedoclyConfigSchema = {
     ...redoclyConfigSchema.properties,
     env: {
       type: 'object',
+      properties: {},
       additionalProperties: environmentSchema,
     },
   },

package/src/types/redocly-yaml.ts

@@ -1,8 +1,8 @@
 import { rootRedoclyConfigSchema, apiConfigSchema } from './portal-config-schema';
 import { themeConfigSchema } from './theme-config';
 import { NodeType, listOf } from '.';
-import { Oas3_1Types } from './oas3_1';
 import { omitObjectProps, pickObjectProps, isCustomRuleId } from '../utils';
+import { PortalConfigNodeTypes } from './portal-config-schema';
 
 const builtInCommonRules = [
   'spec',
@@ -236,8 +236,6 @@ const ConfigApisProperties: NodeType = {
         type: 'string',
       },
     },
-    lint: 'ConfigStyleguide', // deprecated
-    styleguide: 'ConfigStyleguide', // deprecated
     ...ConfigStyleguide.properties,
     'features.openapi': 'ConfigReferenceDocs', // deprecated
     'features.mockServer': 'ConfigMockServer', // deprecated
@@ -997,7 +995,6 @@ const ConfigMockServer: NodeType = {
 };
 
 export const ConfigTypes: Record<string, NodeType> = {
-  ...Oas3_1Types,
   Assert,
   ConfigRoot,
   ConfigApis,
@@ -1062,4 +1059,5 @@ export const ConfigTypes: Record<string, NodeType> = {
   Typography,
   AssertionDefinitionAssertions,
   AssertionDefinitionSubject,
+  ...PortalConfigNodeTypes,
 };

package/src/visitors.ts

@@ -1,3 +1,9 @@
+import { SpecExtension } from './types';
+
+import type { NormalizedNodeType } from './types';
+import type { Stack } from './utils';
+import type { UserContext, ResolveResult, ProblemSeverity } from './walk';
+import type { Location } from './ref-utils';
 import type {
   Oas3Definition,
   Oas3ExternalDocs,
@@ -26,7 +32,6 @@ import type {
   Oas3Discriminator,
   Oas3Callback,
 } from './typings/openapi';
-
 import type {
   Oas2Definition,
   Oas2Tag,
@@ -44,12 +49,7 @@ import type {
   Oas2Parameter,
   Oas2SecurityScheme,
 } from './typings/swagger';
-
-import { NormalizedNodeType, SpecExtension } from './types';
-import type { Stack } from './utils';
-import type { UserContext, ResolveResult, ProblemSeverity } from './walk';
-import type { Location } from './ref-utils';
-import { Async2Definition } from './typings/asyncapi';
+import type { Async2Definition } from './typings/asyncapi';
 
 export type SkipFunctionContext = Pick<
   UserContext,
@@ -297,7 +297,7 @@ export type RuleInstanceConfig = {
 };
 
 export function normalizeVisitors<T extends BaseVisitor>(
-  visitorsConfig: (RuleInstanceConfig & { visitor: NestedVisitObject<any, T> })[],
+  visitorsConfig: (RuleInstanceConfig & { visitor: NestedVisitObject<unknown, T> })[],
   types: Record<keyof T, NormalizedNodeType>
 ): NormalizedOasVisitors<T> {
   const normalizedVisitors: NormalizedOasVisitors<T> = {} as any;
@@ -377,12 +377,10 @@ export function normalizeVisitors<T extends BaseVisitor>(
 
     function addWeakFromStack(ruleConf: RuleInstanceConfig, stack: NormalizedNodeType[]) {
       for (const interType of stack.slice(1)) {
-        (normalizedVisitors as any)[interType.name] =
-          normalizedVisitors[interType.name] ||
-          ({
-            enter: [],
-            leave: [],
-          } as any);
+        (normalizedVisitors as any)[interType.name] = normalizedVisitors[interType.name] || {
+          enter: [],
+          leave: [],
+        };
         normalizedVisitors[interType.name].enter.push({
           ...ruleConf,
           visit: () => undefined,
@@ -398,7 +396,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
   }
 
   function findLegacyVisitorNode<T>(
-    visitor: NestedVisitObject<any, T>,
+    visitor: NestedVisitObject<unknown, T>,
     typeName: keyof T | Array<keyof T>
   ) {
     if (Array.isArray(typeName)) {
@@ -411,7 +409,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
 
   function normalizeVisitorLevel(
     ruleConf: RuleInstanceConfig,
-    visitor: NestedVisitObject<any, T>,
+    visitor: NestedVisitObject<unknown, T>,
     parentContext: VisitorLevelContext | null,
     depth = 0
   ) {
@@ -434,14 +432,14 @@ export function normalizeVisitors<T extends BaseVisitor>(
         findLegacyVisitorNode(
           visitor,
           legacyTypesMap[typeName as keyof typeof legacyTypesMap] as keyof T
-        )) as any as NestedVisitObject<any, T>;
+        )) as NestedVisitObject<unknown, T>;
       const normalizedTypeVisitor = normalizedVisitors[typeName];
 
       if (!typeVisitor) continue;
 
-      let visitorEnter: VisitFunction<any> | undefined;
-      let visitorLeave: VisitFunction<any> | undefined;
-      let visitorSkip: SkipFunction<any> | undefined;
+      let visitorEnter: VisitFunction<unknown> | undefined;
+      let visitorLeave: VisitFunction<unknown> | undefined;
+      let visitorSkip: SkipFunction<unknown> | undefined;
 
       const isObjectVisitor = typeof typeVisitor === 'object';
 
@@ -450,7 +448,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
       }
 
       if (typeof typeVisitor === 'function') {
-        visitorEnter = typeVisitor as any;
+        visitorEnter = typeVisitor;
       } else if (isObjectVisitor) {
         visitorEnter = typeVisitor.enter;
         visitorLeave = typeVisitor.leave;
@@ -465,7 +463,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
       };
 
       if (typeof typeVisitor === 'object') {
-        normalizeVisitorLevel(ruleConf, typeVisitor as any, context, depth + 1);
+        normalizeVisitorLevel(ruleConf, typeVisitor, context, depth + 1);
       }
 
       if (parentContext) {

package/src/walk.ts

@@ -1,3 +1,9 @@
+import { Location, isRef } from './ref-utils';
+import { pushStack, popStack } from './utils';
+import { ResolveError, YamlParseError, Source, makeRefId } from './resolve';
+import { SpecVersion } from './oas-types';
+import { isNamedType, SpecExtension } from './types';
+
 import type { Referenced } from './typings/openapi';
 import type {
   VisitorLevelContext,
@@ -12,12 +18,6 @@ import type { ResolvedRefMap, Document } from './resolve';
 import type { NormalizedNodeType } from './types';
 import type { RuleSeverity } from './config';
 
-import { Location, isRef } from './ref-utils';
-import { pushStack, popStack } from './utils';
-import { ResolveError, YamlParseError, Source, makeRefId } from './resolve';
-import { SpecVersion } from './oas-types';
-import { isNamedType, SpecExtension } from './types';
-
 export type NonUndefined =
   | string
   | number
@@ -204,7 +204,7 @@ export function walkDocument<T extends BaseVisitor>(opts: {
       const activatedContexts: Array<VisitorSkippedLevelContext | VisitorLevelContext> = [];
 
       for (const { context, visit, skip, ruleId, severity } of currentEnterVisitors) {
-        if (ignoredNodes.has(currentLocation.pointer)) break;
+        if (ignoredNodes.has(`${currentLocation.absolutePointer}${currentLocation.pointer}`)) break;
 
         if (context.isSkippedLevel) {
           if (
@@ -413,7 +413,7 @@ export function walkDocument<T extends BaseVisitor>(opts: {
           parentLocations: collectParentsLocations(context),
           oasVersion: ctx.oasVersion,
           ignoreNextVisitorsOnNode: () => {
-            ignoredNodes.add(currentLocation.pointer);
+            ignoredNodes.add(`${currentLocation.absolutePointer}${currentLocation.pointer}`);
           },
           getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
         },