@redocly/openapi-core 1.5.0 → 1.7.0

package/src/config/config-resolvers.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import { isAbsoluteUrl } from '../ref-utils';
 import { pickDefined } from '../utils';
-import { BaseResolver } from '../resolve';
+import { resolveDocument, BaseResolver } from '../resolve';
 import { defaultPlugin } from './builtIn';
 import {
   getResolveConfig,
@@ -11,6 +11,14 @@ import {
   prefixRules,
   transformConfig,
 } from './utils';
+import { isBrowser } from '../env';
+import { isNotString, isString, isDefined, parseYaml, keysOf } from '../utils';
+import { Config } from './config';
+import { colorize, logger } from '../logger';
+import { asserts, buildAssertCustomFunction } from '../rules/common/assertions/asserts';
+import { normalizeTypes } from '../types';
+import { ConfigTypes } from '../types/redocly-yaml';
+
 import type {
   StyleguideRawConfig,
   ApiStyleguideRawConfig,
@@ -21,17 +29,39 @@ import type {
   RuleConfig,
   DeprecatedInRawConfig,
 } from './types';
-import { isBrowser } from '../env';
-import { isNotString, isString, isDefined, parseYaml, keysOf } from '../utils';
-import { Config } from './config';
-import { colorize, logger } from '../logger';
-import {
-  Asserts,
-  AssertionFn,
-  asserts,
-  buildAssertCustomFunction,
-} from '../rules/common/assertions/asserts';
 import type { Assertion, AssertionDefinition, RawAssertion } from '../rules/common/assertions';
+import type { Asserts, AssertionFn } from '../rules/common/assertions/asserts';
+import type { BundleOptions } from '../bundle';
+import type { Document, ResolvedRefMap } from '../resolve';
+
+export async function resolveConfigFileAndRefs({
+  configPath,
+  externalRefResolver = new BaseResolver(),
+  base = null,
+}: Omit<BundleOptions, 'config'> & { configPath?: string }): Promise<{
+  document: Document;
+  resolvedRefMap: ResolvedRefMap;
+}> {
+  if (!configPath) {
+    throw new Error('Reference to a config is required.\n');
+  }
+
+  const document = await externalRefResolver.resolveDocument(base, configPath, true);
+
+  if (document instanceof Error) {
+    throw document;
+  }
+
+  const types = normalizeTypes(ConfigTypes);
+
+  const resolvedRefMap = await resolveDocument({
+    rootDocument: document,
+    rootType: types.ConfigRoot,
+    externalRefResolver,
+  });
+
+  return { document, resolvedRefMap };
+}
 
 export async function resolveConfig(rawConfig: RawConfig, configPath?: string): Promise<Config> {
   if (rawConfig.styleguide?.extends?.some(isNotString)) {

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/rules/ajv.ts

@@ -1,6 +1,8 @@
-import Ajv, { ValidateFunction, ErrorObject } from '@redocly/ajv/dist/2020';
+import Ajv from '@redocly/ajv/dist/2020';
 import { Location, escapePointer } from '../ref-utils';
-import { ResolveFn } from '../walk';
+
+import type { ValidateFunction, ErrorObject } from '@redocly/ajv/dist/2020';
+import type { ResolveFn } from '../walk';
 
 let ajvInstance: Ajv | null = null;
 
@@ -21,10 +23,10 @@ function getAjv(resolve: ResolveFn, allowAdditionalProperties: boolean) {
       allowUnionTypes: true,
       validateFormats: false, // TODO: fix it
       defaultUnevaluatedProperties: allowAdditionalProperties,
-      loadSchemaSync(base: string, $ref: string) {
+      loadSchemaSync(base: string, $ref: string, $id: string) {
         const resolvedRef = resolve({ $ref }, base.split('#')[0]);
         if (!resolvedRef || !resolvedRef.location) return false;
-        return { $id: resolvedRef.location.absolutePointer, ...resolvedRef.node };
+        return { $id: resolvedRef.location.source.absoluteRef + '#' + $id, ...resolvedRef.node };
       },
       logger: false,
     });

package/src/rules/utils.ts

@@ -2,7 +2,7 @@ import levenshtein = require('js-levenshtein');
 import { UserContext } from '../walk';
 import { Location } from '../ref-utils';
 import { validateJsonSchema } from './ajv';
-import { Oas3Schema, Referenced } from '../typings/openapi';
+import { Oas3Schema, Oas3_1Schema, Referenced } from '../typings/openapi';
 import { showErrorForDeprecatedField, showWarningForDeprecatedField } from '../utils';
 
 export function oasTypeOf(value: unknown) {
@@ -91,7 +91,7 @@ export function getSuggest(given: string, variants: string[]): string[] {
 
 export function validateExample(
   example: any,
-  schema: Referenced<Oas3Schema>,
+  schema: Referenced<Oas3Schema | Oas3_1Schema>,
   dataLoc: Location,
   { resolve, location, report }: UserContext,
   allowAdditionalProperties: boolean

package/src/types/asyncapi.ts

@@ -274,10 +274,7 @@ const OperationBindings: NodeType = {
 
 const OperationTrait: NodeType = {
   properties: {
-    tags: {
-      type: 'array',
-      items: { type: 'string' },
-    },
+    tags: 'TagList',
     summary: { type: 'string' },
     description: { type: 'string' },
     externalDocs: 'ExternalDocs',
@@ -311,10 +308,7 @@ const MessageTrait: NodeType = {
 
 const Operation: NodeType = {
   properties: {
-    tags: {
-      type: 'array',
-      items: { type: 'string' },
-    },
+    tags: 'TagList',
     summary: { type: 'string' },
     description: { type: 'string' },
     externalDocs: 'ExternalDocs',

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/typings/openapi.ts

@@ -111,14 +111,14 @@ export interface Oas3Xml {
   wrapped?: string;
 }
 
-export interface Oas3Schema {
+// common fields for OpenAPI Schema v3.x
+interface Oas3XSchemaBase<T> {
   $ref?: string;
-  type?: string;
-  properties?: { [name: string]: Oas3Schema };
-  additionalProperties?: boolean | Oas3Schema;
+  properties?: { [name: string]: T };
+  additionalProperties?: boolean | T;
   description?: string;
   default?: any;
-  items?: Oas3Schema;
+  items?: T;
   required?: string[];
   readOnly?: boolean;
   writeOnly?: boolean;
@@ -127,10 +127,10 @@ export interface Oas3Schema {
   externalDocs?: Oas3ExternalDocs;
   discriminator?: Oas3Discriminator;
   nullable?: boolean;
-  oneOf?: Oas3Schema[];
-  anyOf?: Oas3Schema[];
-  allOf?: Oas3Schema[];
-  not?: Oas3Schema;
+  oneOf?: T[];
+  anyOf?: T[];
+  allOf?: T[];
+  not?: T;
 
   title?: string;
   multipleOf?: number;
@@ -153,11 +153,15 @@ export interface Oas3Schema {
   'x-tags'?: string[];
 }
 
-export type Oas3_1Schema = Oas3Schema & {
+export interface Oas3Schema extends Oas3XSchemaBase<Oas3Schema> {
+  type?: string;
+}
+
+export interface Oas3_1Schema extends Oas3XSchemaBase<Oas3_1Schema> {
   type?: string | string[];
   examples?: any[];
   prefixItems?: Oas3_1Schema[];
-};
+}
 
 export interface Oas3_1Definition extends Oas3Definition {
   webhooks?: Oas3_1Webhooks;

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) {