@redocly/openapi-core 1.0.0-beta.85 → 1.0.0-beta.88

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

@@ -1,35 +1,76 @@
-import { loadConfig } from '../load';
+import { loadConfig, findConfig } from '../load';
 import { RedoclyClient } from '../../redocly';
 
+const fs = require('fs');
+const path = require('path');
+
 describe('loadConfig', () => {
   it('should resolve config http header by US region', async () => {
-    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
-      () => Promise.resolve([{ region: 'us', token: "accessToken", valid: true }])
-    );
+    jest
+      .spyOn(RedoclyClient.prototype, 'getTokens')
+      .mockImplementation(() =>
+        Promise.resolve([{ region: 'us', token: 'accessToken', valid: true }]),
+      );
     const config = await loadConfig();
-    expect(config.resolve.http.headers).toStrictEqual([{
-      "matches": 'https://api.redoc.ly/registry/**',
-      "name": "Authorization",
-      "envVariable": undefined,
-      "value": "accessToken"
-    }, {
-      "matches": 'https://api.redocly.com/registry/**',
-      "name": "Authorization",
-      "envVariable": undefined,
-      "value": "accessToken"
-    }]);
+    expect(config.resolve.http.headers).toStrictEqual([
+      {
+        matches: 'https://api.redocly.com/registry/**',
+        name: 'Authorization',
+        envVariable: undefined,
+        value: 'accessToken',
+      },
+      {
+        matches: 'https://api.redoc.ly/registry/**',
+        name: 'Authorization',
+        envVariable: undefined,
+        value: 'accessToken',
+      },
+    ]);
   });
 
   it('should resolve config http header by EU region', async () => {
-    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
-      () => Promise.resolve([{ region: 'eu', token: "accessToken", valid: true }])
-    );
+    jest
+      .spyOn(RedoclyClient.prototype, 'getTokens')
+      .mockImplementation(() =>
+        Promise.resolve([{ region: 'eu', token: 'accessToken', valid: true }]),
+      );
     const config = await loadConfig();
-    expect(config.resolve.http.headers).toStrictEqual([{
-      "matches": 'https://api.eu.redocly.com/registry/**',
-      "name": "Authorization",
-      "envVariable": undefined,
-      "value": "accessToken"
-    }]);
+    expect(config.resolve.http.headers).toStrictEqual([
+      {
+        matches: 'https://api.eu.redocly.com/registry/**',
+        name: 'Authorization',
+        envVariable: undefined,
+        value: 'accessToken',
+      },
+    ]);
+  });
+});
+
+describe('findConfig', () => {
+  it('should find redocly.yaml', async () => {
+    jest.spyOn(fs, 'existsSync').mockImplementation((name) => name === 'redocly.yaml');
+    const configName = findConfig();
+    expect(configName).toStrictEqual('redocly.yaml');
+  });
+  it('should find .redocly.yaml', async () => {
+    jest.spyOn(fs, 'existsSync').mockImplementation((name) => name === '.redocly.yaml');
+    const configName = findConfig();
+    expect(configName).toStrictEqual('.redocly.yaml');
+  });
+  it('should throw an error when found multiple config files', async () => {
+    jest
+      .spyOn(fs, 'existsSync')
+      .mockImplementation((name) => name === 'redocly.yaml' || name === '.redocly.yaml');
+    expect(findConfig).toThrow(`
+      Multiple configuration files are not allowed. 
+      Found the following files: redocly.yaml, .redocly.yaml. 
+      Please use 'redocly.yaml' instead.
+    `);
+  });
+  it('should find a nested config ', async () => {
+    jest.spyOn(fs, 'existsSync').mockImplementation((name) => name === 'dir/redocly.yaml');
+    jest.spyOn(path, 'resolve').mockImplementationOnce((dir, name) => `${dir}/${name}`);
+    const configName = findConfig('dir');
+    expect(configName).toStrictEqual('dir/redocly.yaml');
   });
 });

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,
@@ -16,9 +14,7 @@ import {
   Oas2DecoratorsSet,
   Oas3RuleSet
 } from '../oas-types';
-
 import { ProblemSeverity, NormalizedProblem } from '../walk';
-
 import recommended from './recommended';
 import { NodeType } from '../types';
 
@@ -127,10 +123,9 @@ export type Region = 'us' | 'eu';
 export type AccessTokens = {[region in Region]?: string };
 const REDOCLY_DOMAIN = process.env.REDOCLY_DOMAIN;
 export const DOMAINS: { [region in Region]: string } = {
-  us: 'redoc.ly',
+  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?: any;
+}
+
+export type Api = {
+  root: string;
+  lint?: LintRawConfig;
+  'features.openapi'?: any;
+  'features.mockServer'?: any;
+};
+
+export type RawConfig = {
+  apis?: Record<string, Api>;
+  lint?: LintRawConfig;
+  resolve?: RawResolveConfig;
+  region?: Region;
+  'features.openapi'?: any;
+  'features.mockServer'?: any;
+  organization?: string;
 };
 
 export class LintConfig {
@@ -398,16 +411,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 +431,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 +640,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;
@@ -41,14 +31,13 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
       },
       //support redocly.com domain for future compatibility
       ...(item.region === 'us' ? [{
-        matches: `https://api.redocly.com/registry/**`,
+        matches: `https://api.redoc.ly/registry/**`,
         name: 'Authorization',
         envVariable: undefined,
         value: item.token,
       }] : []));
     }
   }
-
   return new Config(
     {
       ...rawConfig,
@@ -61,11 +50,29 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
   );
 }
 
-function findConfig() {
-  if (fs.existsSync('.redocly.yaml')) {
-    return '.redocly.yaml';
-  } else if (fs.existsSync('.redocly.yml')) {
-    return '.redocly.yml';
+export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
+
+export function findConfig(dir?: string): string | undefined {
+  if (!fs.hasOwnProperty('existsSync')) return;
+  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. 
+      Found the following files: ${existingConfigFiles.join(', ')}. 
+      Please use 'redocly.yaml' instead.
+    `);
+  }
+  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}`);
   }
-  return undefined;
 }

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,26 @@ 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 { loadConfig } from './config/load';
-export { RedoclyClient } from './redocly';
+export {
+  Config,
+  LintConfig,
+  RawConfig,
+  IGNORE_FILE,
+  Region,
+  getMergedConfig,
+  transformConfig,
+} from './config/config';
+
+export { loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
+export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
+
 export {
   Source,
   BaseResolver,

package/src/redocly/__tests__/redocly-client.test.ts

@@ -1,7 +1,7 @@
 import { RedoclyClient } from '../index';
 
 describe('RedoclyClient', () => {
-  const REDOCLY_DOMAIN_US = 'redoc.ly';
+  const REDOCLY_DOMAIN_US = 'redocly.com';
   const REDOCLY_DOMAIN_EU = 'eu.redocly.com';
   const REDOCLY_AUTHORIZATION_TOKEN = 'redocly-auth-token';
   const testRedoclyDomain = 'redoclyDomain.com';

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;
@@ -21,6 +22,12 @@ export class RedoclyClient {
     this.domain = region
       ? DOMAINS[region]
       : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+
+    /*
+     * 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);
   }
 
@@ -168,17 +175,16 @@ export class RedoclyClient {
 }
 
 export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
-  if (!link.startsWith(`https://api.${domain}/registry/`)) return false;
-  const registryPath = link.replace(`https://api.${domain}/registry/`, '');
+  const domain = REDOCLY_DOMAIN || process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
-  const pathParts = registryPath.split('/');
+  const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
 
-  // we can be sure, that there is job UUID present
-  // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
-  // so skip this link.
-  // FIXME
-  if (pathParts.length === 7) return false;
+  if (
+    !link.startsWith(`https://api.${domain}/registry/`) &&
+    !link.startsWith(`https://api.${legacyDomain}/registry/`)
+  ) {
+    return false;
+  }
 
   return true;
 }

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

@@ -0,0 +1,62 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 spec', () => {
+  it('should report missing schema property', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.0.0
+      paths:
+        '/test':
+          get:
+            summary: Gets a specific pet
+            parameters:
+            - name: petId
+              in: path
+            responses:
+              200:
+                description: Ok
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: makeConfig({ 'spec': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`info\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test/get/parameters/0",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Must contain at least one of the following fields: schema, content.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});

package/src/rules/common/spec.ts

@@ -63,7 +63,7 @@ export const OasSpec: Oas3Rule | Oas2Rule = () => {
         }
         if (!hasProperty)
           report({
-            message: 'Must contain at least one of the following fields: path, components, webhooks.',
+            message: `Must contain at least one of the following fields: ${type.requiredOneOf?.join(', ')}.`,
             location: [{ reportOnKey: true }],
           });
       }

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/oas3.ts

@@ -136,6 +136,7 @@ const Parameter: NodeType = {
     content: 'MediaTypeMap',
   },
   required: ['name', 'in'],
+  requiredOneOf: ['schema', 'content'],
 };
 
 const Callback = {

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);
 }