@redocly/openapi-core 1.0.0-beta.86 → 1.0.0-beta.89

package/src/config/config.ts

@@ -2,10 +2,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { dirname } from 'path';
 import { red, blue } from 'colorette';
-
 import { parseYaml, stringifyYaml } from '../js-yaml';
 import { notUndefined, slash } from '../utils';
-
 import {
   OasVersion,
   Oas3PreprocessorsSet,
@@ -14,11 +12,9 @@ import {
   Oas2RuleSet,
   Oas2PreprocessorsSet,
   Oas2DecoratorsSet,
-  Oas3RuleSet
+  Oas3RuleSet,
 } from '../oas-types';
-
 import { ProblemSeverity, NormalizedProblem } from '../walk';
-
 import recommended from './recommended';
 import { NodeType } from '../types';
 
@@ -124,13 +120,12 @@ export type ResolveConfig = {
 
 export const DEFAULT_REGION = 'us';
 export type Region = 'us' | 'eu';
-export type AccessTokens = {[region in Region]?: string };
+export type AccessTokens = { [region in Region]?: string };
 const REDOCLY_DOMAIN = process.env.REDOCLY_DOMAIN;
 export const DOMAINS: { [region in Region]: string } = {
   us: 'redocly.com',
   eu: 'eu.redocly.com',
 };
-export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
 // FIXME: temporary fix for our lab environments
 if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
@@ -139,13 +134,31 @@ if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
 if (REDOCLY_DOMAIN === 'redoc.online') {
   DOMAINS[REDOCLY_DOMAIN as Region] = REDOCLY_DOMAIN;
 }
+export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
-export type RawConfig = {
-  referenceDocs?: any;
+export type DeprecatedRawConfig = {
   apiDefinitions?: Record<string, string>;
   lint?: LintRawConfig;
   resolve?: RawResolveConfig;
   region?: Region;
+  referenceDocs?: Record<string, any>;
+};
+
+export type Api = {
+  root: string;
+  lint?: Omit<LintRawConfig, 'plugins'>;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+};
+
+export type RawConfig = {
+  apis?: Record<string, Api>;
+  lint?: LintRawConfig;
+  resolve?: RawResolveConfig;
+  region?: Region;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
 };
 
 export class LintConfig {
@@ -201,7 +214,9 @@ export class LintConfig {
       [OasVersion.Version3_1]: { ...merged.decorators, ...merged.oas3_1Decorators },
     };
 
-    const dir = this.configFile ? path.dirname(this.configFile) : (typeof process !== 'undefined' && process.cwd() || '');
+    const dir = this.configFile
+      ? path.dirname(this.configFile)
+      : (typeof process !== 'undefined' && process.cwd()) || '';
     const ignoreFile = path.join(dir, IGNORE_FILE);
 
     /* no crash when using it on the client */
@@ -229,7 +244,8 @@ export class LintConfig {
     const ignoreFile = path.join(dir, IGNORE_FILE);
     const mapped: Record<string, any> = {};
     for (const absFileName of Object.keys(this.ignore)) {
-      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] = this.ignore[absFileName]);
+      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] =
+        this.ignore[absFileName]);
       for (const ruleId of Object.keys(ignoredRules)) {
         ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
       }
@@ -398,16 +414,19 @@ export class LintConfig {
 }
 
 export class Config {
-  referenceDocs: any;
-  apiDefinitions: Record<string, string>;
+  apis: Record<string, Api>;
   lint: LintConfig;
   resolve: ResolveConfig;
   licenseKey?: string;
   region?: Region;
+  'features.openapi': Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
-    this.apiDefinitions = rawConfig.apiDefinitions || {};
+    this.apis = rawConfig.apis || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);
-    this.referenceDocs = rawConfig.referenceDocs || {};
+    this['features.openapi'] = rawConfig['features.openapi'] || {};
+    this['features.mockServer'] = rawConfig['features.mockServer'] || {};
     this.resolve = {
       http: {
         headers: rawConfig?.resolve?.http?.headers ?? [],
@@ -415,13 +434,13 @@ export class Config {
       },
     };
     this.region = rawConfig.region;
+    this.organization = rawConfig.organization;
   }
 }
 
 function resolvePresets(presets: string[], plugins: Plugin[]) {
   return presets.map((presetName) => {
     const { pluginId, configName } = parsePresetName(presetName);
-
     const plugin = plugins.find((p) => p.id === pluginId);
     if (!plugin) {
       throw new Error(`Invalid config ${red(presetName)}: plugin ${pluginId} is not included.`);
@@ -624,3 +643,72 @@ function assignExisting<T>(target: Record<string, T>, obj: Record<string, T>) {
     }
   }
 }
+
+export function getMergedConfig(config: Config, entrypointAlias?: string): Config {
+  return entrypointAlias
+    ? new Config({
+        ...config.rawConfig,
+        lint: getMergedLintConfig(config, entrypointAlias),
+        'features.openapi': {
+          ...config['features.openapi'],
+          ...config.apis[entrypointAlias]?.['features.openapi'],
+        },
+        'features.mockServer': {
+          ...config['features.mockServer'],
+          ...config.apis[entrypointAlias]?.['features.mockServer'],
+        },
+        // TODO: merge everything else here
+      })
+    : config;
+}
+
+export function getMergedLintConfig(config: Config, entrypointAlias?: string) {
+  const apiLint = entrypointAlias ? config.apis[entrypointAlias]?.lint : {};
+  const mergedLint = {
+    ...config.rawConfig.lint,
+    ...apiLint,
+    rules: { ...config.rawConfig.lint?.rules, ...apiLint?.rules },
+    preprocessors: { ...config.rawConfig.lint?.preprocessors, ...apiLint?.preprocessors },
+    decorators: { ...config.rawConfig.lint?.decorators, ...apiLint?.decorators },
+  };
+  return mergedLint;
+}
+
+function transformApiDefinitionsToApis(
+  apiDefinitions: Record<string, string> = {},
+): Record<string, Api> {
+  let apis: Record<string, Api> = {};
+  for (const [apiName, apiPath] of Object.entries(apiDefinitions)) {
+    apis[apiName] = { root: apiPath };
+  }
+  return apis;
+}
+
+export function transformConfig(rawConfig: DeprecatedRawConfig | RawConfig): RawConfig {
+  if ((rawConfig as RawConfig).apis && (rawConfig as DeprecatedRawConfig).apiDefinitions) {
+    throw new Error("Do not use 'apiDefinitions' field. Use 'apis' instead.\n");
+  }
+  if (
+    (rawConfig as RawConfig)['features.openapi'] &&
+    (rawConfig as DeprecatedRawConfig).referenceDocs
+  ) {
+    throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
+  }
+  const { apiDefinitions, referenceDocs, ...rest } = rawConfig as DeprecatedRawConfig & RawConfig;
+  // TODO: put links to the changelog and uncomment this after successful release of ReferenceDocs/Redoc, Portal and Workflows
+  // if (apiDefinitions) {
+  //   process.stderr.write(
+  //     `The ${yellow('apiDefinitions')} field is deprecated. Use ${green('apis')} instead, see changelog: <link>\n`
+  //   );
+  // }
+  // if (referenceDocs) {
+  //   process.stderr.write(
+  //     `The ${yellow('referenceDocs')} field is deprecated. Use ${green('features.openapi')} instead, see changelog: <link>\n`
+  //   );
+  // }
+  return {
+    'features.openapi': referenceDocs,
+    apis: transformApiDefinitionsToApis(apiDefinitions),
+    ...rest,
+  };
+}

package/src/config/load.ts

@@ -1,23 +1,13 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import { RedoclyClient } from '../redocly';
 import { loadYaml } from '../utils';
-import { Config, DOMAINS, RawConfig, Region } from './config';
-
+import { Config, DOMAINS, RawConfig, Region, transformConfig } from './config';
 import { defaultPlugin } from './builtIn';
 
-export async function loadConfig(configPath?: string, customExtends?: string[]): Promise<Config> {
-  if (configPath === undefined) {
-    configPath = findConfig();
-  }
-  let rawConfig: RawConfig = {};
+export async function loadConfig(configPath: string | undefined = findConfig(), customExtends?: string[]): Promise<Config> {
+  const rawConfig = await getConfig(configPath);
 
-  if (configPath !== undefined) {
-    try {
-      rawConfig = (await loadYaml(configPath)) as RawConfig;
-    } catch (e) {
-      throw new Error(`Error parsing config file at \`${configPath}\`: ${e.message}`);
-    }
-  }
   if (customExtends !== undefined) {
     rawConfig.lint = rawConfig.lint || {};
     rawConfig.lint.extends = customExtends;
@@ -48,7 +38,6 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
       }] : []));
     }
   }
-
   return new Config(
     {
       ...rawConfig,
@@ -63,12 +52,11 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
 
 export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
 
-export function findConfig(): string | undefined {
+export function findConfig(dir?: string): string | undefined {
   if (!fs.hasOwnProperty('existsSync')) return;
-
-  const existingConfigFiles = CONFIG_FILE_NAMES.map((name) => fs.existsSync(name) && name).filter(
-    Boolean,
-  ) as Array<string | never>;
+  const existingConfigFiles = CONFIG_FILE_NAMES
+    .map(name => dir ? path.resolve(dir, name) : name)
+    .filter(fs.existsSync);
   if (existingConfigFiles.length > 1) {
     throw new Error(`
       Multiple configuration files are not allowed. 
@@ -78,3 +66,13 @@ export function findConfig(): string | undefined {
   }
   return existingConfigFiles[0];
 }
+
+export async function getConfig(configPath: string | undefined = findConfig()) {
+  if (!configPath) return {};
+  try {
+    const rawConfig = ((await loadYaml(configPath)) || {}) as RawConfig;
+    return transformConfig(rawConfig);
+  } catch (e) {
+    throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+  }
+}

package/src/format/codeframes.ts

@@ -183,8 +183,10 @@ export function getAstNodeByPointer(root: YAMLNode, pointer: string, reportOnKey
   for (const key of pointerSegments) {
     if (currentNode.kind === yamlAst.Kind.MAP) {
       const mapping = currentNode.mappings.find((m) => m.key.value === key);
-      if (!mapping?.value) break;
-      currentNode = mapping?.value as YAMLNode;
+      if (!mapping) break;
+      currentNode = mapping as YAMLNode;
+      if (!mapping?.value) break; // If node has value - return value, if not - return node itself
+      currentNode = mapping.value as YAMLNode;
     } else if (currentNode.kind === yamlAst.Kind.SEQ) {
       const elem = currentNode.items[parseInt(key, 10)] as YAMLNode;
       if (!elem) break;

package/src/index.ts

@@ -14,16 +14,24 @@ export {
   Oas3_1Schema,
   Oas3Tag,
   Oas3_1Webhooks,
-  Referenced
+  Referenced,
 } from './typings/openapi';
 export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
 
-export { Config, LintConfig, RawConfig, IGNORE_FILE, Region } from './config/config';
+export {
+  Config,
+  LintConfig,
+  RawConfig,
+  IGNORE_FILE,
+  Region,
+  getMergedConfig,
+  transformConfig,
+} from './config/config';
 
-export { loadConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
+export { loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 
 export {

package/src/redocly/index.ts

@@ -9,6 +9,7 @@ import { isNotEmptyObject } from '../utils';
 
 const TOKEN_FILENAME = '.redocly-config.json';
 
+let REDOCLY_DOMAIN: string; // workaround for the isRedoclyRegistryURL, see more below
 export class RedoclyClient {
   private accessTokens: AccessTokens = {};
   private region: Region;
@@ -22,7 +23,11 @@ export class RedoclyClient {
       ? DOMAINS[region]
       : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
-    process.env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+    /*
+     * We can't use process.env here because it is replaced by a const in some client-side bundles,
+     * which breaks assignment.
+     */
+    REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
     this.registryApi = new RegistryApi(this.accessTokens, this.region);
   }
 
@@ -170,7 +175,7 @@ export class RedoclyClient {
 }
 
 export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+  const domain = REDOCLY_DOMAIN || process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
   const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
 

package/src/rules/oas3/__tests__/spec/spec.test.ts

@@ -192,8 +192,8 @@ describe('Oas3 Structural visitor basic', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/openapi",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],
@@ -259,8 +259,8 @@ describe('Oas3 Structural visitor basic', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/openapi",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],

package/src/rules/oas3/no-empty-servers.ts

@@ -3,9 +3,10 @@ import { Oas3Rule } from '../../visitors';
 export const NoEmptyServers: Oas3Rule = () => {
   return {
     DefinitionRoot(root, { report, location }) {
-      if (!root.servers) {
+      if (!root.hasOwnProperty('servers')) {
         report({
           message: 'Servers must be present.',
+          location: location.child(['openapi']).key()
         });
         return;
       }

package/src/types/oas2.ts

@@ -60,6 +60,8 @@ const PathMap: NodeType = {
 const PathItem: NodeType = {
   properties: {
     $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
+    parameters: listOf('Parameter'),
+
     get: 'Operation',
     put: 'Operation',
     post: 'Operation',
@@ -67,7 +69,6 @@ const PathItem: NodeType = {
     options: 'Operation',
     head: 'Operation',
     patch: 'Operation',
-    parameters: listOf('Parameter'),
   },
 };
 

package/src/types/redocly-yaml.ts

@@ -10,6 +10,7 @@ const ConfigRoot: NodeType = {
     },
     lint: 'ConfigLint',
     referenceDocs: 'ConfigReferenceDocs',
+    'features.mockServer': 'ConfigMockServer',
   },
 };
 
@@ -552,10 +553,18 @@ const ConfigReferenceDocs: NodeType = {
   additionalProperties: { type: 'string' },
 };
 
+const ConfigMockServer: NodeType = {
+  properties: {
+    strictExamples: { type: 'boolean' },
+    errorIfForcedExampleNotFound: { type: 'boolean' },
+  },
+};
+
 export const ConfigTypes: Record<string, NodeType> = {
   ConfigRoot,
   ConfigLint,
   ConfigReferenceDocs,
+  ConfigMockServer,
   ConfigHTTP,
   ConfigLanguage,
   ConfigLabels,

package/src/utils.ts

@@ -28,7 +28,6 @@ export type BundleOutputFormat = 'json' | 'yml' | 'yaml';
 
 export async function loadYaml(filename: string) {
   const contents = await fs.promises.readFile(filename, 'utf-8');
-
   return parseYaml(contents);
 }