@redocly/openapi-core 1.0.0 → 1.0.2

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

@@ -0,0 +1,167 @@
+import { loadConfig, findConfig, getConfig, createConfig } from '../load';
+import { RedoclyClient } from '../../redocly';
+import { RuleConfig, FlatRawConfig } from './../types';
+import { Config } from '../config';
+
+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 }])
+      );
+    const config = await loadConfig();
+    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 }])
+      );
+    const config = await loadConfig();
+    expect(config.resolve.http.headers).toStrictEqual([
+      {
+        matches: 'https://api.eu.redocly.com/registry/**',
+        name: 'Authorization',
+        envVariable: undefined,
+        value: 'accessToken',
+      },
+    ]);
+  });
+
+  it('should call callback if such passed', async () => {
+    const mockFn = jest.fn();
+    await loadConfig({
+      configPath: path.join(__dirname, './fixtures/load-redocly.yaml'),
+      processRawConfig: mockFn,
+    });
+    expect(mockFn).toHaveBeenCalled();
+  });
+});
+
+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');
+  });
+});
+
+describe('getConfig', () => {
+  jest.spyOn(fs, 'hasOwnProperty').mockImplementation(() => false);
+  it('should return empty object if there is no configPath and config file is not found', () => {
+    expect(getConfig()).toEqual(Promise.resolve({}));
+  });
+});
+
+describe('createConfig', () => {
+  it('should create config from string', async () => {
+    const config = await createConfig(`
+      extends:
+      - recommended
+      rules:
+        info-license: off
+    `);
+
+    verifyExtendedConfig(config, {
+      extendsRuleSet: 'recommended',
+      overridesRules: { 'info-license': 'off' },
+    });
+  });
+
+  it('should create config from object', async () => {
+    const rawConfig: FlatRawConfig = {
+      extends: ['minimal'],
+      rules: {
+        'info-license': 'off',
+        'tag-description': 'off',
+        'operation-2xx-response': 'off',
+      },
+    };
+    const config = await createConfig(rawConfig);
+
+    verifyExtendedConfig(config, {
+      extendsRuleSet: 'minimal',
+      overridesRules: rawConfig.rules as Record<string, RuleConfig>,
+    });
+  });
+});
+
+function verifyExtendedConfig(
+  config: Config,
+  {
+    extendsRuleSet,
+    overridesRules,
+  }: { extendsRuleSet: string; overridesRules: Record<string, RuleConfig> }
+) {
+  const defaultPlugin = config.styleguide.plugins.find((plugin) => plugin.id === '');
+  expect(defaultPlugin).toBeDefined();
+
+  const recommendedRules = defaultPlugin?.configs?.[extendsRuleSet];
+  expect(recommendedRules).toBeDefined();
+
+  verifyOasRules(config.styleguide.rules.oas2, overridesRules, recommendedRules?.rules || {});
+  verifyOasRules(
+    config.styleguide.rules.oas3_0,
+    overridesRules,
+    Object.assign({}, recommendedRules?.rules, recommendedRules?.oas3_0Rules)
+  );
+  verifyOasRules(
+    config.styleguide.rules.oas3_1,
+    overridesRules,
+    Object.assign({}, recommendedRules?.rules, recommendedRules?.oas3_1Rules)
+  );
+}
+
+function verifyOasRules(
+  finalRuleset: Record<string, RuleConfig>,
+  overridesRules: Record<string, RuleConfig>,
+  defaultRuleset: Record<string, RuleConfig>
+) {
+  Object.entries(finalRuleset).forEach(([ruleName, ruleValue]) => {
+    if (ruleName in overridesRules) {
+      expect(ruleValue).toBe(overridesRules[ruleName]);
+    } else {
+      expect(ruleValue).toBe(defaultRuleset[ruleName]);
+    }
+  });
+}

package/src/config/__tests__/resolve-plugins.test.ts

@@ -0,0 +1,27 @@
+import * as path from 'path';
+import { loadConfig } from '../load';
+
+describe('resolving a plugin', () => {
+  const configPath = path.join(__dirname, 'fixtures/plugin-config.yaml');
+
+  it('should prefix rule names with the plugin id', async () => {
+    const config = await loadConfig({ configPath });
+    const plugin = config.styleguide.plugins[0];
+
+    expect(plugin.rules?.oas3).toHaveProperty('test-plugin/openid-connect-url-well-known');
+  });
+
+  it('should prefix preprocessor names with the plugin id', async () => {
+    const config = await loadConfig({ configPath });
+    const plugin = config.styleguide.plugins[0];
+
+    expect(plugin.preprocessors?.oas2).toHaveProperty('test-plugin/description-preprocessor');
+  });
+
+  it('should prefix decorator names with the plugin id', async () => {
+    const config = await loadConfig({ configPath });
+    const plugin = config.styleguide.plugins[0];
+
+    expect(plugin.decorators?.oas3).toHaveProperty('test-plugin/inject-x-stats');
+  });
+});

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

@@ -0,0 +1,204 @@
+import type { DeprecatedInRawConfig, RawConfig, FlatRawConfig } from '../types';
+import * as utils from '../utils';
+
+const makeTestRawConfig = (
+  apiStyleguideName: string,
+  rootStyleguideName: string
+): RawConfig & DeprecatedInRawConfig => ({
+  apis: {
+    'test@v1': {
+      root: 'root.yaml',
+      [apiStyleguideName]: {
+        rules: {
+          'operation-2xx-response': 'error',
+        },
+      },
+    },
+  },
+  [rootStyleguideName]: {
+    rules: {
+      'operation-4xx-response': 'warn',
+    },
+  },
+});
+
+const rawTestConfig: RawConfig = {
+  apis: {
+    'test@v1': {
+      root: 'root.yaml',
+      styleguide: {
+        extends: ['recommended'],
+        rules: { 'operation-2xx-response': 'error' },
+      },
+    },
+  },
+  styleguide: {
+    plugins: ['test-plugin'],
+    extends: ['minimal'],
+    rules: { 'operation-4xx-response': 'warn' },
+    doNotResolveExamples: true,
+  },
+  resolve: {
+    http: { headers: [{ matches: '*', name: 'all', envVariable: 'all' }] },
+  },
+  theme: {
+    openapi: {
+      disableSidebar: true,
+    },
+  },
+};
+
+const flatTestConfig: FlatRawConfig = {
+  apis: {
+    'test@v1': {
+      root: 'root.yaml',
+      extends: ['recommended'],
+      rules: { 'operation-2xx-response': 'error' },
+    },
+  },
+  plugins: ['test-plugin'],
+  extends: ['minimal'],
+  rules: {
+    'operation-4xx-response': 'warn',
+  },
+  resolve: {
+    http: { headers: [{ matches: '*', name: 'all', envVariable: 'all' }] },
+    doNotResolveExamples: true,
+  },
+  theme: {
+    openapi: {
+      disableSidebar: true,
+    },
+  },
+};
+
+describe('transformConfig', () => {
+  it('should work for the `styleguide` syntax', () => {
+    const transformedRawConfig: RawConfig = utils.transformConfig(
+      makeTestRawConfig('styleguide', 'styleguide')
+    );
+    expect(transformedRawConfig).toMatchInlineSnapshot(`
+      Object {
+        "apis": Object {
+          "test@v1": Object {
+            "root": "root.yaml",
+            "styleguide": Object {
+              "rules": Object {
+                "operation-2xx-response": "error",
+              },
+            },
+          },
+        },
+        "styleguide": Object {
+          "rules": Object {
+            "operation-4xx-response": "warn",
+          },
+        },
+        "theme": Object {
+          "mockServer": Object {},
+          "openapi": Object {},
+        },
+      }
+    `);
+  });
+  it('should be equal for both `lint` and `styleguide` names', () => {
+    expect(utils.transformConfig(makeTestRawConfig('lint', 'styleguide'))).toEqual(
+      utils.transformConfig(makeTestRawConfig('styleguide', 'lint'))
+    );
+  });
+  it('should work for `apiDefinitions`', () => {
+    const testRawConfig = makeTestRawConfig('styleguide', 'lint');
+    testRawConfig.apis = undefined;
+    testRawConfig.apiDefinitions = { legacyApiDefinition: 'file.yaml' };
+    expect(utils.transformConfig(testRawConfig)).toMatchInlineSnapshot(`
+      Object {
+        "apis": Object {
+          "legacyApiDefinition": Object {
+            "root": "file.yaml",
+          },
+        },
+        "styleguide": Object {
+          "rules": Object {
+            "operation-4xx-response": "warn",
+          },
+        },
+        "theme": Object {
+          "mockServer": Object {},
+          "openapi": Object {},
+        },
+      }
+    `);
+  });
+  it('should throw an error if both `styleguide` and `lint` syntaxes used together', () => {
+    const testRawConfig = makeTestRawConfig('styleguide', 'lint');
+    testRawConfig.apiDefinitions = { legacyApiDefinition: 'file.yaml' };
+    expect(() => utils.transformConfig(testRawConfig)).toThrowError(
+      `Do not use 'apiDefinitions' field. Use 'apis' instead. `
+    );
+  });
+  it('should transform flatten config into styleguide', () => {
+    expect(utils.transformConfig(flatTestConfig)).toEqual({
+      ...rawTestConfig,
+      resolve: { ...rawTestConfig.resolve, doNotResolveExamples: true },
+    });
+  });
+  it('should transform styleguide config into styleguide identically', () => {
+    expect(utils.transformConfig(rawTestConfig)).toEqual(rawTestConfig);
+  });
+  it('should fail when there is a mixed config', () => {
+    expect(() => utils.transformConfig({ ...rawTestConfig, extends: ['recommended'] })).toThrow(
+      `Do not use 'lint', 'styleguide' and flat syntax together. \nSee more about the configuration in the docs: https://redocly.com/docs/cli/configuration/ \n`
+    );
+  });
+  it('should throw an error if both `features.openapi` and `theme` syntaxes used together', () => {
+    const testRawConfig: RawConfig & DeprecatedInRawConfig = {
+      apis: {
+        'test@v1': {
+          root: 'root.yaml',
+          styleguide: {
+            extends: ['recommended'],
+            rules: { 'operation-2xx-response': 'error' },
+          },
+        },
+      },
+      'features.openapi': {
+        disableSidebar: true,
+      },
+      theme: {
+        openapi: {
+          disableSidebar: true,
+        },
+      },
+    };
+    expect(() => utils.transformConfig(testRawConfig)).toThrowError(
+      `Do not use 'features.openapi' field. Use 'theme.openapi' instead. `
+    );
+  });
+  it('should transform referenceDocs config into theme.openapi', () => {
+    const testRawConfig: RawConfig & DeprecatedInRawConfig = {
+      referenceDocs: {
+        disableSidebar: true,
+      },
+    };
+    expect(utils.transformConfig(testRawConfig)).toEqual({
+      apis: undefined,
+      styleguide: undefined,
+      theme: { mockServer: {}, openapi: { disableSidebar: true } },
+    });
+  });
+  it('should transform "features.openapi" config into theme.openapi', () => {
+    const testRawConfig: RawConfig & DeprecatedInRawConfig = {
+      'features.openapi': {
+        disableSidebar: true,
+      },
+    };
+    expect(utils.transformConfig(testRawConfig)).toEqual({
+      apis: undefined,
+      'features.openapi': {
+        disableSidebar: true,
+      },
+      styleguide: undefined,
+      theme: { mockServer: {}, openapi: { disableSidebar: true } },
+    });
+  });
+});

package/src/config/all.ts

@@ -0,0 +1,74 @@
+import type { PluginStyleguideConfig } from './types';
+
+export default {
+  rules: {
+    'info-contact': 'error',
+    'info-license': 'error',
+    'info-license-url': 'error',
+    'tag-description': 'error',
+    'tags-alphabetical': 'error',
+    'parameter-description': 'error',
+    'no-identical-paths': 'error',
+    'no-ambiguous-paths': 'error',
+    'no-path-trailing-slash': 'error',
+    'path-segment-plural': 'error',
+    'path-declaration-must-exist': 'error',
+    'path-not-include-query': 'error',
+    'path-parameters-defined': 'error',
+    'operation-description': 'error',
+    'operation-2xx-response': 'error',
+    'operation-4xx-response': 'error',
+    'operation-operationId': 'error',
+    'operation-summary': 'error',
+    'operation-operationId-unique': 'error',
+    'operation-operationId-url-safe': 'error',
+    'operation-parameters-unique': 'error',
+    'operation-tag-defined': 'error',
+    'security-defined': 'error',
+    'operation-singular-tag': 'error',
+    'no-unresolved-refs': 'error',
+    'no-enum-type-mismatch': 'error',
+    'boolean-parameter-prefixes': 'error',
+    'paths-kebab-case': 'error',
+    'no-http-verbs-in-paths': 'error',
+    'path-excludes-patterns': {
+      severity: 'error',
+      patterns: [],
+    },
+    'request-mime-type': {
+      severity: 'error',
+      allowedValues: ['application/json'],
+    },
+    'response-mime-type': {
+      severity: 'error',
+      allowedValues: ['application/json'],
+    },
+    spec: 'error',
+    'no-invalid-schema-examples': 'error',
+    'no-invalid-parameter-examples': 'error',
+    'scalar-property-missing-example': 'error',
+    'spec-strict-refs': 'error',
+    'component-name-unique': 'error',
+  },
+  oas3_0Rules: {
+    'no-invalid-media-type-examples': 'error',
+    'no-server-example.com': 'error',
+    'no-server-trailing-slash': 'error',
+    'no-empty-servers': 'error',
+    'no-example-value-and-externalValue': 'error',
+    'no-unused-components': 'error',
+    'no-undefined-server-variable': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'operation-4xx-problem-details-rfc7807': 'error',
+  },
+  oas3_1Rules: {
+    'no-server-example.com': 'error',
+    'no-server-trailing-slash': 'error',
+    'no-empty-servers': 'error',
+    'no-example-value-and-externalValue': 'error',
+    'no-unused-components': 'error',
+    'no-undefined-server-variable': 'error',
+    'no-server-variables-empty-enum': 'error',
+    'operation-4xx-problem-details-rfc7807': 'error',
+  },
+} as PluginStyleguideConfig;

package/src/config/builtIn.ts

@@ -0,0 +1,37 @@
+import recommended from './recommended';
+import all from './all';
+import minimal from './minimal';
+import { rules as oas3Rules } from '../rules/oas3';
+import { rules as oas2Rules } from '../rules/oas2';
+import { preprocessors as oas3Preprocessors } from '../rules/oas3';
+import { preprocessors as oas2Preprocessors } from '../rules/oas2';
+import { decorators as oas3Decorators } from '../decorators/oas3';
+import { decorators as oas2Decorators } from '../decorators/oas2';
+
+import type { CustomRulesConfig, StyleguideRawConfig, Plugin } from './types';
+
+export const builtInConfigs: Record<string, StyleguideRawConfig> = {
+  recommended,
+  minimal,
+  all,
+  'redocly-registry': {
+    decorators: { 'registry-dependencies': 'on' },
+  },
+};
+
+export const defaultPlugin: Plugin = {
+  id: '', // default plugin doesn't have id
+  rules: {
+    oas3: oas3Rules,
+    oas2: oas2Rules,
+  } as CustomRulesConfig,
+  preprocessors: {
+    oas3: oas3Preprocessors,
+    oas2: oas2Preprocessors,
+  },
+  decorators: {
+    oas3: oas3Decorators,
+    oas2: oas2Decorators,
+  },
+  configs: builtInConfigs,
+};