@redocly/openapi-core 1.5.0 → 1.6.0

package/lib/types/portal-config-schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rootRedoclyConfigSchema = exports.environmentSchema = exports.redoclyConfigSchema = exports.apiConfigSchema = exports.ssoConfigSchema = void 0;
+exports.rootRedoclyConfigSchema = exports.environmentSchema = exports.redoclyConfigSchema = exports.PortalConfigNodeTypes = exports.apiConfigSchema = exports.ssoConfigSchema = void 0;
 const config_1 = require("../config");
 const oidcIssuerMetadataSchema = {
     type: 'object',
@@ -80,6 +80,7 @@ const authProviderConfigSchema = {
 };
 exports.ssoConfigSchema = {
     type: 'object',
+    properties: {},
     additionalProperties: authProviderConfigSchema,
 };
 const redirectConfigSchema = {
@@ -89,7 +90,12 @@ const redirectConfigSchema = {
         type: { type: 'number', default: 301 },
     },
     required: ['to'],
-    additionalProperties: false,
+};
+const redirectsConfigSchema = {
+    type: 'object',
+    properties: {},
+    additionalProperties: 'redirectConfigSchema',
+    default: {},
 };
 exports.apiConfigSchema = {
     type: 'object',
@@ -136,13 +142,16 @@ const seoConfigSchema = {
             },
         },
     },
-    additionalProperties: false,
 };
-const rbacScopeItemsSchema = { type: 'object', additionalProperties: { type: 'string' } };
+const rbacScopeItemsSchema = {
+    type: 'object',
+    properties: {},
+    additionalProperties: { type: 'string' },
+};
 const rbacConfigSchema = {
     type: 'object',
     properties: {
-        defaults: rbacScopeItemsSchema,
+        defaults: 'rbacScopeItemsSchema',
     },
     additionalProperties: rbacScopeItemsSchema,
 };
@@ -207,7 +216,6 @@ const devOnboardingAdapterConfigSchema = {
 const devOnboardingConfigSchema = {
     type: 'object',
     required: ['adapters'],
-    additionalProperties: false,
     properties: {
         adapters: {
             type: 'array',
@@ -215,6 +223,30 @@ const devOnboardingConfigSchema = {
         },
     },
 };
+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'],
+};
 const responseHeaderSchema = {
     type: 'object',
     properties: {
@@ -224,14 +256,24 @@ const responseHeaderSchema = {
     additionalProperties: false,
     required: ['name', 'value'],
 };
+exports.PortalConfigNodeTypes = {
+    seoConfigSchema,
+    rbacConfigSchema,
+    rbacScopeItemsSchema,
+    ssoConfigSchema: exports.ssoConfigSchema,
+    devOnboardingConfigSchema,
+    i18ConfigSchema,
+    redirectsConfigSchema,
+    redirectConfigSchema,
+    // TODO: Extract other types that need to be linted in the config
+};
 exports.redoclyConfigSchema = {
     type: 'object',
     properties: {
         licenseKey: { type: 'string' },
-        theme: { type: 'object', default: {} },
-        redirects: { type: 'object', additionalProperties: redirectConfigSchema, default: {} },
-        seo: seoConfigSchema,
-        rbac: rbacConfigSchema,
+        redirects: 'redirectsConfigSchema',
+        seo: 'seoConfigSchema',
+        rbac: 'rbacConfigSchema',
         responseHeaders: {
             type: 'object',
             additionalProperties: {
@@ -253,37 +295,12 @@ exports.redoclyConfigSchema = {
             type: 'object',
             additionalProperties: exports.apiConfigSchema,
         },
-        sso: exports.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,
 };
 exports.environmentSchema = {
     oneOf: [
@@ -300,5 +317,6 @@ exports.environmentSchema = {
 };
 exports.rootRedoclyConfigSchema = Object.assign(Object.assign({}, exports.redoclyConfigSchema), { properties: Object.assign(Object.assign({}, exports.redoclyConfigSchema.properties), { env: {
             type: 'object',
+            properties: {},
             additionalProperties: exports.environmentSchema,
         } }), default: {}, required: ['redirects'] });

package/lib/types/redocly-yaml.js

@@ -4,8 +4,8 @@ exports.ConfigTypes = void 0;
 const portal_config_schema_1 = require("./portal-config-schema");
 const theme_config_1 = require("./theme-config");
 const _1 = require(".");
-const oas3_1_1 = require("./oas3_1");
 const utils_1 = require("../utils");
+const portal_config_schema_2 = require("./portal-config-schema");
 const builtInCommonRules = [
     'spec',
     'info-contact',
@@ -196,7 +196,7 @@ const ConfigApisProperties = {
             items: {
                 type: 'string',
             },
-        }, lint: 'ConfigStyleguide', styleguide: 'ConfigStyleguide' }), ConfigStyleguide.properties), { 'features.openapi': 'ConfigReferenceDocs', 'features.mockServer': 'ConfigMockServer', theme: 'ConfigRootTheme', files: {
+        } }), ConfigStyleguide.properties), { 'features.openapi': 'ConfigReferenceDocs', 'features.mockServer': 'ConfigMockServer', theme: 'ConfigRootTheme', files: {
             type: 'array',
             items: {
                 type: 'string',
@@ -838,7 +838,7 @@ const ConfigMockServer = {
         errorIfForcedExampleNotFound: { type: 'boolean' },
     },
 };
-exports.ConfigTypes = Object.assign(Object.assign({}, oas3_1_1.Oas3_1Types), { Assert,
+exports.ConfigTypes = Object.assign({ Assert,
     ConfigRoot,
     ConfigApis,
     ConfigApisProperties,
@@ -901,4 +901,4 @@ exports.ConfigTypes = Object.assign(Object.assign({}, oas3_1_1.Oas3_1Types), { A
     Heading,
     Typography,
     AssertionDefinitionAssertions,
-    AssertionDefinitionSubject });
+    AssertionDefinitionSubject }, portal_config_schema_2.PortalConfigNodeTypes);

package/lib/visitors.d.ts

@@ -1,10 +1,10 @@
-import type { Oas3Definition, Oas3ExternalDocs, Oas3Info, Oas3Contact, Oas3Components, Oas3License, Oas3Schema, Oas3Header, Oas3Parameter, Oas3Operation, Oas3PathItem, Oas3ServerVariable, Oas3Server, Oas3MediaType, Oas3Response, Oas3Example, Oas3RequestBody, Oas3Tag, OasRef, Oas3SecurityScheme, Oas3SecurityRequirement, Oas3Encoding, Oas3Link, Oas3Xml, Oas3Discriminator, Oas3Callback } from './typings/openapi';
-import type { Oas2Definition, Oas2Tag, Oas2ExternalDocs, Oas2SecurityRequirement, Oas2Info, Oas2Contact, Oas2License, Oas2PathItem, Oas2Operation, Oas2Header, Oas2Response, Oas2Schema, Oas2Xml, Oas2Parameter, Oas2SecurityScheme } from './typings/swagger';
-import { NormalizedNodeType } 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 { Async2Definition } from './typings/asyncapi';
+import type { Oas3Definition, Oas3ExternalDocs, Oas3Info, Oas3Contact, Oas3Components, Oas3License, Oas3Schema, Oas3Header, Oas3Parameter, Oas3Operation, Oas3PathItem, Oas3ServerVariable, Oas3Server, Oas3MediaType, Oas3Response, Oas3Example, Oas3RequestBody, Oas3Tag, OasRef, Oas3SecurityScheme, Oas3SecurityRequirement, Oas3Encoding, Oas3Link, Oas3Xml, Oas3Discriminator, Oas3Callback } from './typings/openapi';
+import type { Oas2Definition, Oas2Tag, Oas2ExternalDocs, Oas2SecurityRequirement, Oas2Info, Oas2Contact, Oas2License, Oas2PathItem, Oas2Operation, Oas2Header, Oas2Response, Oas2Schema, Oas2Xml, Oas2Parameter, Oas2SecurityScheme } from './typings/swagger';
+import type { Async2Definition } from './typings/asyncapi';
 export type SkipFunctionContext = Pick<UserContext, 'location' | 'rawNode' | 'resolve' | 'rawLocation'>;
 export type VisitFunction<T> = (node: T, ctx: UserContext & {
     ignoreNextVisitorsOnNode: () => void;
@@ -184,6 +184,6 @@ export type RuleInstanceConfig = {
     severity: ProblemSeverity;
 };
 export declare function normalizeVisitors<T extends BaseVisitor>(visitorsConfig: (RuleInstanceConfig & {
-    visitor: NestedVisitObject<any, T>;
+    visitor: NestedVisitObject<unknown, T>;
 })[], types: Record<keyof T, NormalizedNodeType>): NormalizedOasVisitors<T>;
 export {};

package/lib/visitors.js

@@ -77,12 +77,10 @@ function normalizeVisitors(visitorsConfig, types) {
         }
         function addWeakFromStack(ruleConf, stack) {
             for (const interType of stack.slice(1)) {
-                normalizedVisitors[interType.name] =
-                    normalizedVisitors[interType.name] ||
-                        {
-                            enter: [],
-                            leave: [],
-                        };
+                normalizedVisitors[interType.name] = normalizedVisitors[interType.name] || {
+                    enter: [],
+                    leave: [],
+                };
                 normalizedVisitors[interType.name].enter.push(Object.assign(Object.assign({}, ruleConf), { visit: () => undefined, depth: 0, context: {
                         isSkippedLevel: true,
                         seen: new Set(),

package/lib/walk.d.ts

@@ -1,11 +1,11 @@
+import { Location } from './ref-utils';
+import { ResolveError, YamlParseError, Source } from './resolve';
+import { SpecVersion } from './oas-types';
 import type { Referenced } from './typings/openapi';
 import type { NormalizedOasVisitors, BaseVisitor } from './visitors';
 import type { ResolvedRefMap, Document } from './resolve';
 import type { NormalizedNodeType } from './types';
 import type { RuleSeverity } from './config';
-import { Location } from './ref-utils';
-import { ResolveError, YamlParseError, Source } from './resolve';
-import { SpecVersion } from './oas-types';
 export type NonUndefined = string | number | boolean | symbol | bigint | object | Record<string, any>;
 export type ResolveResult<T extends NonUndefined> = {
     node: T;

package/lib/walk.js

@@ -86,7 +86,7 @@ function walkDocument(opts) {
             const currentEnterVisitors = anyEnterVisitors.concat(((_c = normalizedVisitors[type.name]) === null || _c === void 0 ? void 0 : _c.enter) || []);
             const activatedContexts = [];
             for (const { context, visit, skip, ruleId, severity } of currentEnterVisitors) {
-                if (ignoredNodes.has(currentLocation.pointer))
+                if (ignoredNodes.has(`${currentLocation.absolutePointer}${currentLocation.pointer}`))
                     break;
                 if (context.isSkippedLevel) {
                     if (context.parent.activatedOn &&
@@ -248,7 +248,7 @@ function walkDocument(opts) {
                 parentLocations: collectParentsLocations(context),
                 oasVersion: ctx.oasVersion,
                 ignoreNextVisitorsOnNode: () => {
-                    ignoredNodes.add(currentLocation.pointer);
+                    ignoredNodes.add(`${currentLocation.absolutePointer}${currentLocation.pointer}`);
                 },
                 getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
             }, collectParents(context), context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/__tests__/lint.test.ts

@@ -22,7 +22,7 @@ describe('lint', () => {
         servers:
           - url: http://redocly-example.com
         paths: {}
-    `,
+      `,
       config: await loadConfig(),
     });
 
@@ -139,8 +139,8 @@ describe('lint', () => {
           "ruleId": "configuration spec",
           "severity": "error",
           "suggest": [
-            "theme",
             "env",
+            "theme",
             "seo",
             "sso",
           ],

package/src/bundle.ts

@@ -1,26 +1,30 @@
 import isEqual = require('lodash.isequal');
+import { BaseResolver, resolveDocument, makeRefId, makeDocumentFromString } from './resolve';
+import { normalizeVisitors } from './visitors';
+import { normalizeTypes } from './types';
+import { walkDocument } from './walk';
 import {
-  BaseResolver,
-  resolveDocument,
-  Document,
-  ResolvedRefMap,
-  makeRefId,
-  makeDocumentFromString,
-} from './resolve';
-import { Oas3Rule, normalizeVisitors, Oas3Visitor, Oas2Visitor } from './visitors';
-import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
-import { WalkContext, walkDocument, UserContext, ResolveResult, NormalizedProblem } from './walk';
-import { detectSpec, getTypes, getMajorSpecVersion, SpecMajorVersion } from './oas-types';
+  detectSpec,
+  getTypes,
+  getMajorSpecVersion,
+  SpecMajorVersion,
+  SpecVersion,
+} from './oas-types';
 import { isAbsoluteUrl, isRef, Location, refBaseName } from './ref-utils';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject, isTruthy } from './utils';
-import { OasRef } from './typings/openapi';
 import { isRedoclyRegistryURL } from './redocly';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from './decorators/oas2/remove-unused-components';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from './decorators/oas3/remove-unused-components';
+import { ConfigTypes } from './types/redocly-yaml';
 
+import type { Oas3Rule, Oas3Visitor, Oas2Visitor } from './visitors';
+import type { NormalizedNodeType, NodeType } from './types';
+import type { WalkContext, UserContext, ResolveResult, NormalizedProblem } from './walk';
 import type { Config, StyleguideConfig } from './config';
+import type { OasRef } from './typings/openapi';
+import type { Document, ResolvedRefMap } from './resolve';
 
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 
@@ -33,12 +37,50 @@ export type BundleOptions = {
   externalRefResolver?: BaseResolver;
   config: Config;
   dereference?: boolean;
-  base?: string;
+  base?: string | null;
   skipRedoclyRegistryRefs?: boolean;
   removeUnusedComponents?: boolean;
   keepUrlRefs?: boolean;
 };
 
+export async function bundleConfig(document: Document, resolvedRefMap: ResolvedRefMap) {
+  const types = normalizeTypes(ConfigTypes);
+
+  const ctx: BundleContext = {
+    problems: [],
+    oasVersion: SpecVersion.OAS3_0,
+    refTypes: new Map<string, NormalizedNodeType>(),
+    visitorsData: {},
+  };
+
+  const bundleVisitor = normalizeVisitors(
+    [
+      {
+        severity: 'error',
+        ruleId: 'configBundler',
+        visitor: {
+          ref: {
+            leave(node: OasRef, ctx: UserContext, resolved: ResolveResult<any>) {
+              replaceRef(node, resolved, ctx);
+            },
+          },
+        },
+      },
+    ],
+    types
+  );
+
+  walkDocument({
+    document,
+    rootType: types.ConfigRoot,
+    normalizedVisitors: bundleVisitor,
+    resolvedRefMap,
+    ctx,
+  });
+
+  return document.parsed ?? {};
+}
+
 export async function bundle(
   opts: {
     ref?: string;
@@ -254,6 +296,18 @@ export function mapTypeToComponent(typeName: string, version: SpecMajorVersion)
   }
 }
 
+function replaceRef(ref: OasRef, resolved: ResolveResult<any>, ctx: UserContext) {
+  if (!isPlainObject(resolved.node)) {
+    ctx.parent[ctx.key] = resolved.node;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete ref.$ref;
+    const obj = Object.assign({}, resolved.node, ref);
+    Object.assign(ref, obj); // assign ref itself again so ref fields take precedence
+  }
+}
+
 // function oas3Move
 
 function makeBundleVisitor(
@@ -351,19 +405,6 @@ function makeBundleVisitor(
     });
   }
 
-  function replaceRef(ref: OasRef, resolved: ResolveResult<any>, ctx: UserContext) {
-    if (!isPlainObject(resolved.node)) {
-      ctx.parent[ctx.key] = resolved.node;
-    } else {
-      // TODO: why $ref isn't optional in OasRef?
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      delete ref.$ref;
-      const obj = Object.assign({}, resolved.node, ref);
-      Object.assign(ref, obj); // assign ref itself again so ref fields take precedence
-    }
-  }
-
   function saveComponent(
     componentType: string,
     target: { node: any; location: Location },

package/src/config/__tests__/fixtures/resolve-refs-in-config/config-with-refs.yaml

@@ -0,0 +1,8 @@
+rules:
+  $ref: rules.yaml
+
+seo:
+  $ref: seo.yaml
+
+theme:
+  $ref: wrong-ref.yaml

package/src/config/__tests__/fixtures/resolve-refs-in-config/rules.yaml

@@ -0,0 +1,2 @@
+info-license: error
+non-existing-rule: warn # fail

package/src/config/__tests__/fixtures/resolve-refs-in-config/seo.yaml

@@ -0,0 +1 @@
+title: 1 # fail

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

@@ -1,7 +1,10 @@
 import { loadConfig, findConfig, getConfig, createConfig } from '../load';
 import { RedoclyClient } from '../../redocly';
-import { RuleConfig, FlatRawConfig } from './../types';
 import { Config } from '../config';
+import { lintConfig } from '../../lint';
+import { replaceSourceWithRef } from '../../../__tests__/utils';
+import type { RuleConfig, FlatRawConfig } from './../types';
+import type { NormalizedProblem } from '../../walk';
 
 const fs = require('fs');
 const path = require('path');
@@ -91,6 +94,82 @@ describe('getConfig', () => {
   it('should return empty object if there is no configPath and config file is not found', () => {
     expect(getConfig()).toEqual(Promise.resolve({}));
   });
+
+  it('should resolve refs in config', async () => {
+    let problems: NormalizedProblem[];
+    const result = 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({
+      seo: {
+        title: 1,
+      },
+      styleguide: {
+        rules: {
+          'info-license': 'error',
+          'non-existing-rule': 'warn',
+        },
+      },
+    });
+    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": [],
+        },
+      ]
+    `);
+  });
 });
 
 describe('createConfig', () => {

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