@redocly/openapi-core 1.0.0-beta.99 → 1.0.0-rc.1

package/src/rules/oas2/__tests__/spec/referenceableScalars.test.ts

@@ -1,31 +0,0 @@
-import { outdent } from 'outdent';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../../__tests__/utils';
-import { lintDocument } from '../../../../lint';
-import { BaseResolver } from '../../../../resolve';
-
-describe('Referenceable scalars', () => {
-  it('should not report $ref description', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        swagger: '2.0'
-        info:
-          title: Test
-          version: '1.0'
-          description:
-            $ref: fixtures/description.md
-        paths: {}
-      `,
-      __dirname + '/foobar.yaml',
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        spec: 'error',
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-});

package/src/rules/oas2/__tests__/spec/utils.ts

@@ -1,32 +0,0 @@
-import { LintConfig, RuleConfig, resolveLint } from '../../../../config';
-import { parseYamlToDocument } from '../../../../../__tests__/utils';
-import { lintDocument } from '../../../../lint';
-import { BaseResolver } from '../../../../resolve';
-
-export async function lintDoc(
-  source: string,
-  rules: Record<string, RuleConfig> = { spec: 'error' },
-) {
-  const document = parseYamlToDocument(source, 'foobar.yaml');
-
-  const results = await lintDocument({
-    externalRefResolver: new BaseResolver(),
-    document,
-    config: new LintConfig(
-      await resolveLint({
-        lintConfig: {
-          plugins: [],
-          extends: [],
-          rules,
-        },
-      }),
-    ),
-  });
-
-  return results.map((res) => {
-    return {
-      message: res.message,
-      location: res.location[0].pointer || '',
-    };
-  });
-}

package/src/rules/oas2/boolean-parameter-prefixes.ts

@@ -1,26 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-
-export type BooleanParameterPrefixesOptions = {
-  prefixes?: string[];
-};
-
-export const BooleanParameterPrefixes: Oas2Rule = (options: BooleanParameterPrefixesOptions) => {
-  const prefixes = options.prefixes || ['is', 'has'];
-  const regexp = new RegExp(`^(${prefixes.join('|')})[A-Z-_]`);
-  const wrappedPrefixes = prefixes.map((p) => `\`${p}\``);
-  const prefixesString =
-    wrappedPrefixes.length === 1
-      ? wrappedPrefixes[0]
-      : wrappedPrefixes.slice(0, -1).join(', ') + ' or ' + wrappedPrefixes[prefixes.length - 1];
-
-  return {
-    Parameter(param, { report, location }) {
-      if (param.type === 'boolean' && !regexp.test(param.name)) {
-        report({
-          message: `Boolean parameter \`${param.name}\` should have ${prefixesString} prefix.`,
-          location: location.child('name'),
-        });
-      }
-    },
-  };
-};

package/src/rules/oas2/index.ts

@@ -1,89 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-import { OasSpec } from '../common/spec';
-import { NoInvalidSchemaExamples } from '../common/no-invalid-schema-examples';
-import { NoInvalidParameterExamples } from '../common/no-invalid-parameter-examples';
-import { InfoDescription } from '../common/info-description';
-import { InfoContact } from '../common/info-contact';
-import { InfoLicense } from '../common/info-license-url';
-import { InfoLicenseUrl } from '../common/license-url';
-import { BooleanParameterPrefixes } from './boolean-parameter-prefixes';
-import { TagDescription } from '../common/tag-description';
-import { TagsAlphabetical } from '../common/tags-alphabetical';
-import { PathsKebabCase } from '../common/paths-kebab-case';
-import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch';
-import { NoPathTrailingSlash } from '../common/no-path-trailing-slash';
-import { Operation2xxResponse } from '../common/operation-2xx-response';
-import { Operation4xxResponse } from '../common/operation-4xx-response';
-import { Assertions } from '../common/assertions';
-import { OperationIdUnique } from '../common/operation-operationId-unique';
-import { OperationParametersUnique } from '../common/operation-parameters-unique';
-import { PathParamsDefined } from '../common/path-params-defined';
-import { OperationTagDefined } from '../common/operation-tag-defined';
-import { PathDeclarationMustExist } from '../common/path-declaration-must-exist';
-import { OperationIdUrlSafe } from '../common/operation-operationId-url-safe';
-import { OperationDescription } from '../common/operation-description';
-import { PathNotIncludeQuery } from '../common/path-not-include-query';
-import { ParameterDescription } from '../common/parameter-description';
-import { OperationSingularTag } from '../common/operation-singular-tag';
-import { OperationSecurityDefined } from '../common/operation-security-defined';
-import { NoUnresolvedRefs } from '../no-unresolved-refs';
-import { PathHttpVerbsOrder } from '../common/path-http-verbs-order';
-import { NoIdenticalPaths } from '../common/no-identical-paths';
-import { OperationOperationId } from '../common/operation-operationId';
-import { OperationSummary } from '../common/operation-summary';
-import { NoAmbiguousPaths } from '../common/no-ambiguous-paths';
-import { NoHttpVerbsInPaths } from '../common/no-http-verbs-in-paths';
-import { PathExcludesPatterns } from '../common/path-excludes-patterns';
-import { RequestMimeType } from './request-mime-type';
-import { ResponseMimeType } from './response-mime-type';
-import { PathSegmentPlural } from '../common/path-segment-plural';
-import { ResponseContainsHeader } from '../common/response-contains-header';
-import { ResponseContainsProperty } from './response-contains-property';
-import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example';
-
-export const rules = {
-  spec: OasSpec as Oas2Rule,
-  'no-invalid-schema-examples': NoInvalidSchemaExamples,
-  'no-invalid-parameter-examples': NoInvalidParameterExamples,
-  'info-description': InfoDescription as Oas2Rule,
-  'info-contact': InfoContact as Oas2Rule,
-  'info-license': InfoLicense as Oas2Rule,
-  'info-license-url': InfoLicenseUrl as Oas2Rule,
-  'tag-description': TagDescription as Oas2Rule,
-  'tags-alphabetical': TagsAlphabetical as Oas2Rule,
-  'paths-kebab-case': PathsKebabCase as Oas2Rule,
-  'no-enum-type-mismatch': NoEnumTypeMismatch as Oas2Rule,
-  'boolean-parameter-prefixes': BooleanParameterPrefixes as Oas2Rule,
-  'no-path-trailing-slash': NoPathTrailingSlash as Oas2Rule,
-  'operation-2xx-response': Operation2xxResponse as Oas2Rule,
-  'operation-4xx-response': Operation4xxResponse as Oas2Rule,
-  'assertions': Assertions as Oas2Rule,
-  'operation-operationId-unique': OperationIdUnique as Oas2Rule,
-  'operation-parameters-unique': OperationParametersUnique as Oas2Rule,
-  'path-parameters-defined': PathParamsDefined as Oas2Rule,
-  'operation-tag-defined': OperationTagDefined as Oas2Rule,
-  'path-declaration-must-exist': PathDeclarationMustExist as Oas2Rule,
-  'operation-operationId-url-safe': OperationIdUrlSafe as Oas2Rule,
-  'operation-operationId': OperationOperationId as Oas2Rule,
-  'operation-summary': OperationSummary as Oas2Rule,
-  'operation-description': OperationDescription as Oas2Rule,
-  'path-not-include-query': PathNotIncludeQuery as Oas2Rule,
-  'path-params-defined': PathParamsDefined as Oas2Rule,
-  'parameter-description': ParameterDescription as Oas2Rule,
-  'operation-singular-tag': OperationSingularTag as Oas2Rule,
-  'operation-security-defined': OperationSecurityDefined as Oas2Rule,
-  'no-unresolved-refs': NoUnresolvedRefs as Oas2Rule,
-  'no-identical-paths': NoIdenticalPaths as Oas2Rule,
-  'no-ambiguous-paths': NoAmbiguousPaths as Oas2Rule,
-  'path-http-verbs-order': PathHttpVerbsOrder as Oas2Rule,
-  'no-http-verbs-in-paths': NoHttpVerbsInPaths as Oas2Rule,
-  'path-excludes-patterns': PathExcludesPatterns as Oas2Rule,
-  'request-mime-type': RequestMimeType as Oas2Rule,
-  'response-mime-type': ResponseMimeType as Oas2Rule,
-  'path-segment-plural': PathSegmentPlural as Oas2Rule,
-  'response-contains-header': ResponseContainsHeader as Oas2Rule,
-  'response-contains-property': ResponseContainsProperty as Oas2Rule,
-  'scalar-property-missing-example': ScalarPropertyMissingExample,
-};
-
-export const preprocessors = {};

package/src/rules/oas2/remove-unused-components.ts

@@ -1,76 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-import { Location } from '../../ref-utils';
-import { Oas2Components } from '../../typings/swagger';
-import { isEmptyObject } from '../../utils';
-
-export const RemoveUnusedComponents: Oas2Rule = () => {
-  let components = new Map<string, { used: boolean; componentType?: keyof Oas2Components; name: string }>();
-
-  function registerComponent(location: Location, componentType: keyof Oas2Components, name: string): void {
-    components.set(location.absolutePointer, {
-      used: components.get(location.absolutePointer)?.used || false,
-      componentType,
-      name,
-    });
-  }
-
-  return {
-    ref: {
-      leave(ref, { type, resolve, key }) {
-        if (
-          ['Schema', 'Parameter', 'Response', 'SecurityScheme'].includes(type.name)
-        ) {
-          const resolvedRef = resolve(ref);
-          if (!resolvedRef.location) return;
-          components.set(resolvedRef.location.absolutePointer, {
-            used: true,
-            name: key.toString(),
-          });
-        }
-      }
-    },
-    DefinitionRoot: {
-      leave(root, ctx) {
-        const data = ctx.getVisitorData() as { removedCount: number };
-        data.removedCount = 0;
-
-        let rootComponents = new Set<keyof Oas2Components>();
-        components.forEach(usageInfo => {
-          const { used, name, componentType } = usageInfo;
-          if (!used && componentType) {
-            rootComponents.add(componentType);
-            delete root[componentType]![name];
-            data.removedCount++;
-          }
-        });
-        for (const component of rootComponents) {
-          if (isEmptyObject(root[component])) {
-            delete root[component];
-          }
-        }
-      },
-    },
-    NamedSchemas: {
-      Schema(schema, { location, key }) {
-        if (!schema.allOf) {
-          registerComponent(location, 'definitions', key.toString());
-        }
-      },
-    },
-    NamedParameters: {
-      Parameter(_parameter, { location, key }) {
-        registerComponent(location, 'parameters', key.toString());
-      },
-    },
-    NamedResponses: {
-      Response(_response, { location, key }) {
-        registerComponent(location, 'responses', key.toString());
-      },
-    },
-    NamedSecuritySchemes: {
-      SecurityScheme(_securityScheme, { location, key }) {
-        registerComponent(location, 'securityDefinitions', key.toString());
-      },
-    }
-  };
-};

package/src/rules/oas2/request-mime-type.ts

@@ -1,17 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
-import { validateMimeType } from '../../utils';
-
-export const RequestMimeType: Oas2Rule = ({ allowedValues }) => {
-  return {
-    DefinitionRoot(root: Oas2Definition, ctx: UserContext) {
-      validateMimeType({ type: 'consumes', value: root }, ctx, allowedValues);
-    },
-    Operation: {
-      leave(operation: Oas2Operation, ctx: UserContext) {
-        validateMimeType({ type: 'consumes', value: operation }, ctx, allowedValues);
-      },
-    },
-  };
-};

package/src/rules/oas2/response-contains-property.ts

@@ -1,36 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { getMatchingStatusCodeRange } from '../../utils';
-
-export const ResponseContainsProperty: Oas2Rule = (options) => {
-  const names: Record<string, string[]> = options.names || {};
-  let key: string | number;
-  return {
-    Operation: {
-      Response: {
-        skip: (_response, key) => {
-          return `${key}` === '204';
-        },
-        enter: (_response, ctx: UserContext) => {
-          key = ctx.key;
-        },
-        Schema(schema, { report, location }) {
-          if (schema.type !== 'object') return;
-          const expectedProperties =
-            names[key] ||
-            names[getMatchingStatusCodeRange(key)] ||
-            names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-            [];
-          for (const expectedProperty of expectedProperties) {
-            if (!schema.properties?.[expectedProperty]) {
-              report({
-                message: `Response object must contain a top-level "${expectedProperty}" property.`,
-                location: location.child('properties').key(),
-              });
-            }
-          }
-        },
-      },
-    },
-  };
-};

package/src/rules/oas2/response-mime-type.ts

@@ -1,17 +0,0 @@
-import { Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
-import { validateMimeType } from '../../utils';
-
-export const ResponseMimeType: Oas2Rule = ({ allowedValues }) => {
-  return {
-    DefinitionRoot(root: Oas2Definition, ctx: UserContext) {
-      validateMimeType({ type: 'produces', value: root }, ctx, allowedValues);
-    },
-    Operation: {
-      leave(operation: Oas2Operation, ctx: UserContext) {
-        validateMimeType({ type: 'produces', value: operation }, ctx, allowedValues);
-      },
-    },
-  };
-};

package/src/rules/oas3/__tests__/boolean-parameter-prefixes.test.ts

@@ -1,111 +0,0 @@
-import { outdent } from 'outdent';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { lintDocument } from '../../../lint';
-import { BaseResolver } from '../../../resolve';
-
-describe('oas3 boolean-parameter-prefixes', () => {
-  it('should report on boolean param without prefix', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        paths:
-          '/test':
-            parameters:
-            - name: a
-              in: path
-              schema:
-                type: boolean
-      `,
-      'foobar.yaml',
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'boolean-parameter-prefixes': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "location": Array [
-            Object {
-              "pointer": "#/paths/~1test/parameters/0/name",
-              "reportOnKey": false,
-              "source": "foobar.yaml",
-            },
-          ],
-          "message": "Boolean parameter \`a\` should have \`is\` or \`has\` prefix.",
-          "ruleId": "boolean-parameter-prefixes",
-          "severity": "error",
-          "suggest": Array [],
-        },
-      ]
-    `);
-  });
-
-  it('should not report on boolean param with prefix', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-          openapi: 3.0.0
-          paths:
-            '/test':
-              parameters:
-                - name: hasA
-                  in: path
-                  schema:
-                    type: boolean
-                - name: isA
-                  in: path
-                  schema:
-                    type: boolean
-                - name: has_a
-                  in: path
-                  schema:
-                    type: boolean
-                - name: is-a
-                  in: path
-                  schema:
-                    type: boolean
-      `,
-      'foobar.yaml',
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'boolean-parameter-prefixes': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-
-  it('should not report on boolean param with custom prefix', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-          openapi: 3.0.0
-          paths:
-            '/test':
-              parameters:
-              - name: should-a
-                in: query
-                schema:
-                  type: boolean
-      `,
-      'foobar.yaml',
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        'boolean-parameter-prefixes': {
-          severity: 'error',
-          prefixes: ['should'],
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-});

package/src/rules/oas3/__tests__/fixtures/common.yaml

@@ -1,11 +0,0 @@
-components:
-  schemas:
-    A:
-      type: object
-      properties:
-        a:
-          type: string
-        b:
-          $ref: '#/components/schemas/B'
-    B:
-      type: string

package/src/rules/oas3/__tests__/no-empty-enum-servers.com.test.ts

@@ -1,205 +0,0 @@
-import { outdent } from 'outdent';
-import { lintDocument } from '../../../lint';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { BaseResolver } from '../../../resolve';
-
-describe('Oas3 as3-no-servers-empty-enum', () => {
-  it('oas3-no-servers-empty-enum: should report on server object with empty enum and unknown enum value', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables:
-              var:
-                enum: []
-                default: a
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "location": Array [
-            Object {
-              "pointer": "#/servers",
-              "reportOnKey": true,
-              "source": "",
-            },
-          ],
-          "message": "Server variable with \`enum\` must be a non-empty array.",
-          "ruleId": "no-servers-empty-enum",
-          "severity": "error",
-          "suggest": Array [],
-        },
-        Object {
-          "location": Array [
-            Object {
-              "pointer": "#/servers",
-              "reportOnKey": true,
-              "source": "",
-            },
-          ],
-          "message": "Server variable define \`enum\` and \`default\`. \`enum\` must include default value",
-          "ruleId": "no-servers-empty-enum",
-          "severity": "error",
-          "suggest": Array [],
-        },
-      ]
-    `);
-  });
-
-  it('oas3-no-servers-empty-enum: should report on server object with empty enum', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables:
-              var:
-                enum: []
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "location": Array [
-            Object {
-              "pointer": "#/servers",
-              "reportOnKey": true,
-              "source": "",
-            },
-          ],
-          "message": "Server variable with \`enum\` must be a non-empty array.",
-          "ruleId": "no-servers-empty-enum",
-          "severity": "error",
-          "suggest": Array [],
-        },
-      ]
-    `);
-  });
-
-  it('oas3-no-servers-empty-enum: should be success because variables is empty object', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables: {}
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-
-  it('oas3-no-servers-empty-enum: should be success because variable is empty object', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables:
-              var: {}
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-
-  it('oas3-no-servers-empty-enum: should be success because enum contains default value', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables:
-              var:
-                enum:
-                  - a
-                default: a
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-
-  it('oas3-no-servers-empty-enum: should be success because enum contains default value', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          title: API
-          version: 1.0.0
-        servers:
-          - url: https://example.com/{var}
-            variables:
-              var:
-                type: ['string', 'null']
-                enum:
-                  - 'some string'
-                  - null
-                default: 'some string'
-        components: {}
-      `
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ 'no-servers-empty-enum': 'error' }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
-  });
-});