@redocly/openapi-core 1.0.0-beta.106 → 1.0.0-beta.109

package/src/rules/oas3/__tests__/spec-components-invalid-map-name.test.ts

@@ -0,0 +1,217 @@
+import { makeConfig, parseYamlToDocument } from '../../../../__tests__/utils';
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 spec-components-invalid-map-name', () => {
+  it('should report about invalid keys inside components', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.0
+      info:
+        version: 3.0.0
+      components:
+        parameters:
+          my Param:
+            name: param
+            description: param
+            in: path
+        examples:
+          invalid identifier:
+            description: 'Some description'
+            value: 21      
+        responses: 
+          400 status:
+            description: bad request   
+        schemas: 
+          first schema:
+            type: integer
+            format: int64     
+		`);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'spec-components-invalid-map-name': 'error',
+      }),
+    });
+
+    expect(results).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/parameters/my Param",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.0
+      info:
+        version: 3.0.0
+      components:
+        parameters:
+          my Param:
+            name: param
+            description: param
+            in: path
+        examples:
+          invalid identifier:
+            description: 'Some description'
+            value: 21      
+        responses: 
+          400 status:
+            description: bad request   
+        schemas: 
+          first schema:
+            type: integer
+            format: int64     ",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "The map key in parameters \\"my Param\\" does not match the regular expression \\"^[a-zA-Z0-9\\\\.\\\\-_]+$\\"",
+          "ruleId": "spec-components-invalid-map-name",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/schemas/first schema",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.0
+      info:
+        version: 3.0.0
+      components:
+        parameters:
+          my Param:
+            name: param
+            description: param
+            in: path
+        examples:
+          invalid identifier:
+            description: 'Some description'
+            value: 21      
+        responses: 
+          400 status:
+            description: bad request   
+        schemas: 
+          first schema:
+            type: integer
+            format: int64     ",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "The map key in schemas \\"first schema\\" does not match the regular expression \\"^[a-zA-Z0-9\\\\.\\\\-_]+$\\"",
+          "ruleId": "spec-components-invalid-map-name",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/responses/400 status",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.0
+      info:
+        version: 3.0.0
+      components:
+        parameters:
+          my Param:
+            name: param
+            description: param
+            in: path
+        examples:
+          invalid identifier:
+            description: 'Some description'
+            value: 21      
+        responses: 
+          400 status:
+            description: bad request   
+        schemas: 
+          first schema:
+            type: integer
+            format: int64     ",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "The map key in responses \\"400 status\\" does not match the regular expression \\"^[a-zA-Z0-9\\\\.\\\\-_]+$\\"",
+          "ruleId": "spec-components-invalid-map-name",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/examples/invalid identifier",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.0
+      info:
+        version: 3.0.0
+      components:
+        parameters:
+          my Param:
+            name: param
+            description: param
+            in: path
+        examples:
+          invalid identifier:
+            description: 'Some description'
+            value: 21      
+        responses: 
+          400 status:
+            description: bad request   
+        schemas: 
+          first schema:
+            type: integer
+            format: int64     ",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "The map key in examples \\"invalid identifier\\" does not match the regular expression \\"^[a-zA-Z0-9\\\\.\\\\-_]+$\\"",
+          "ruleId": "spec-components-invalid-map-name",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report a key of the example does not match the regular expression', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.0
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            parameters:
+              - name: petId
+                in: path
+                schema:
+                  type: integer
+                  format: int64
+                examples:
+                  valid-identifier-1.key:
+                      description: 'Some description'
+                      value: 21
+		`);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'spec-components-invalid-map-name': 'error',
+      }),
+    });
+
+    expect(results).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/oas3/index.ts

@@ -25,7 +25,7 @@ import { NoUnusedComponents } from './no-unused-components';
 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 { SecurityDefined } from '../common/security-defined';
 import { NoUnresolvedRefs } from '../no-unresolved-refs';
 import { BooleanParameterPrefixes } from './boolean-parameter-prefixes';
 import { PathsKebabCase } from '../common/paths-kebab-case';
@@ -37,7 +37,7 @@ import { NoUndefinedServerVariable } from './no-undefined-server-variable';
 import { OperationOperationId } from '../common/operation-operationId';
 import { OperationSummary } from '../common/operation-summary';
 import { NoAmbiguousPaths } from '../common/no-ambiguous-paths';
-import { NoEmptyEnumServers } from './no-servers-empty-enum';
+import { NoServerVariablesEmptyEnum } from './no-server-variables-empty-enum';
 import { NoHttpVerbsInPaths } from '../common/no-http-verbs-in-paths';
 import { RequestMimeType } from './request-mime-type';
 import { ResponseMimeType } from './response-mime-type';
@@ -48,6 +48,8 @@ import { NoInvalidParameterExamples } from '../common/no-invalid-parameter-examp
 import { ResponseContainsHeader } from '../common/response-contains-header';
 import { ResponseContainsProperty } from './response-contains-property';
 import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example';
+import { SpecComponentsInvalidMapName } from './spec-components-invalid-map-name';
+import { Operation4xxProblemDetailsRfc7807 } from './operation-4xx-problem-details-rfc7807';
 
 export const rules = {
   spec: OasSpec,
@@ -57,6 +59,7 @@ export const rules = {
   'info-license-url': InfoLicenseUrl,
   'operation-2xx-response': Operation2xxResponse,
   'operation-4xx-response': Operation4xxResponse,
+  'operation-4xx-problem-details-rfc7807': Operation4xxProblemDetailsRfc7807,
   assertions: Assertions,
   'operation-operationId-unique': OperationIdUnique,
   'operation-parameters-unique': OperationParametersUnique,
@@ -80,7 +83,7 @@ export const rules = {
   'path-params-defined': PathParamsDefined,
   'parameter-description': ParameterDescription,
   'operation-singular-tag': OperationSingularTag,
-  'operation-security-defined': OperationSecurityDefined,
+  'security-defined': SecurityDefined,
   'no-unresolved-refs': NoUnresolvedRefs,
   'paths-kebab-case': PathsKebabCase,
   'boolean-parameter-prefixes': BooleanParameterPrefixes,
@@ -89,7 +92,7 @@ export const rules = {
   'no-identical-paths': NoIdenticalPaths,
   'no-ambiguous-paths': NoAmbiguousPaths,
   'no-undefined-server-variable': NoUndefinedServerVariable,
-  'no-servers-empty-enum': NoEmptyEnumServers,
+  'no-server-variables-empty-enum': NoServerVariablesEmptyEnum,
   'no-http-verbs-in-paths': NoHttpVerbsInPaths,
   'path-excludes-patterns': PathExcludesPatterns,
   'request-mime-type': RequestMimeType,
@@ -100,6 +103,7 @@ export const rules = {
   'response-contains-header': ResponseContainsHeader,
   'response-contains-property': ResponseContainsProperty,
   'scalar-property-missing-example': ScalarPropertyMissingExample,
+  'spec-components-invalid-map-name': SpecComponentsInvalidMapName,
 } as Oas3RuleSet;
 
 export const preprocessors = {};

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

@@ -2,7 +2,7 @@ import { Oas3Rule } from '../../visitors';
 
 export const NoEmptyServers: Oas3Rule = () => {
   return {
-    DefinitionRoot(root, { report, location }) {
+    Root(root, { report, location }) {
       if (!root.hasOwnProperty('servers')) {
         report({
           message: 'Servers must be present.',

package/src/rules/oas3/no-invalid-media-type-examples.ts

@@ -1,11 +1,11 @@
 import { Oas3Rule } from '../../visitors';
 import { Location, isRef } from '../../ref-utils';
 import { Oas3Example } from '../../typings/openapi';
-import { validateExample } from '../utils';
+import { getAdditionalPropertiesOption, validateExample } from '../utils';
 import { UserContext } from '../../walk';
 
 export const ValidContentExamples: Oas3Rule = (opts) => {
-  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
+  const allowAdditionalProperties = getAdditionalPropertiesOption(opts) ?? false;
 
   return {
     MediaType: {
@@ -40,7 +40,7 @@ export const ValidContentExamples: Oas3Rule = (opts) => {
             mediaType.schema!,
             location,
             ctx,
-            disallowAdditionalProperties
+            allowAdditionalProperties
           );
         }
       },

package/src/rules/oas3/{no-servers-empty-enum.ts → no-server-variables-empty-enum.ts}

@@ -6,9 +6,9 @@ enum enumError {
   invalidDefaultValue = 'invalidDefaultValue',
 }
 
-export const NoEmptyEnumServers: Oas3Rule = () => {
+export const NoServerVariablesEmptyEnum: Oas3Rule = () => {
   return {
-    DefinitionRoot(root, { report, location }) {
+    Root(root, { report, location }) {
       if (!root.servers || root.servers.length === 0) return;
 
       const invalidVariables: enumError[] = [];
@@ -48,7 +48,7 @@ function checkEnumVariables(server: Oas3Server): enumError[] | undefined {
   if (server.variables && Object.keys(server.variables).length === 0) return;
 
   const errors: enumError[] = [];
-  for (var variable in server.variables) {
+  for (const variable in server.variables) {
     const serverVariable = server.variables[variable];
     if (!serverVariable.enum) continue;
 

package/src/rules/oas3/no-unused-components.ts

@@ -2,7 +2,7 @@ import { Oas3Rule } from '../../visitors';
 import { Location } from '../../ref-utils';
 
 export const NoUnusedComponents: Oas3Rule = () => {
-  let components = new Map<string, { used: boolean; location: Location; name: string }>();
+  const components = new Map<string, { used: boolean; location: Location; name: string }>();
 
   function registerComponent(location: Location, name: string): void {
     components.set(location.absolutePointer, {
@@ -26,7 +26,7 @@ export const NoUnusedComponents: Oas3Rule = () => {
         });
       }
     },
-    DefinitionRoot: {
+    Root: {
       leave(_, { report }) {
         components.forEach((usageInfo) => {
           if (!usageInfo.used) {

package/src/rules/oas3/operation-4xx-problem-details-rfc7807.ts

@@ -0,0 +1,36 @@
+import { Oas3MediaType, Oas3Response, Oas3Schema } from 'core/src/typings/openapi';
+import { Oas3Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { validateDefinedAndNonEmpty } from '../utils';
+
+/**
+ * Validation according rfc7807 - https://datatracker.ietf.org/doc/html/rfc7807
+ */
+export const Operation4xxProblemDetailsRfc7807: Oas3Rule = () => {
+  return {
+    Response: {
+      skip(_response: Oas3Response, key: string | number) {
+        return !/4[Xx0-9]{2}/.test(`${key}`);
+      },
+      enter(response: Oas3Response, { report, location }: UserContext) {
+        if (!response.content || !response.content['application/problem+json'])
+          report({
+            message: 'Response `4xx` must have content-type `application/problem+json`.',
+            location: location.key(),
+          });
+      },
+      MediaType: {
+        skip(_response: Oas3MediaType, key: string | number) {
+          return key !== 'application/problem+json';
+        },
+        enter(media: Oas3MediaType, ctx: UserContext) {
+          validateDefinedAndNonEmpty('schema', media, ctx);
+        },
+        SchemaProperties(schema: Oas3Schema, ctx: UserContext) {
+          validateDefinedAndNonEmpty('type', schema, ctx);
+          validateDefinedAndNonEmpty('title', schema, ctx);
+        },
+      },
+    },
+  };
+};

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

@@ -4,7 +4,7 @@ import { Oas3Components } from '../../typings/openapi';
 import { isEmptyObject } from '../../utils';
 
 export const RemoveUnusedComponents: Oas3Rule = () => {
-  let components = new Map<
+  const components = new Map<
     string,
     { used: boolean; componentType?: keyof Oas3Components; name: string }
   >();
@@ -38,19 +38,19 @@ export const RemoveUnusedComponents: Oas3Rule = () => {
         }
       },
     },
-    DefinitionRoot: {
+    Root: {
       leave(root, ctx) {
         const data = ctx.getVisitorData() as { removedCount: number };
         data.removedCount = 0;
 
         components.forEach((usageInfo) => {
           const { used, componentType, name } = usageInfo;
-          if (!used && componentType) {
-            let componentChild = root.components![componentType];
+          if (!used && componentType && root.components) {
+            const componentChild = root.components[componentType];
             delete componentChild![name];
             data.removedCount++;
             if (isEmptyObject(componentChild)) {
-              delete root.components![componentType];
+              delete root.components[componentType];
             }
           }
         });

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

@@ -5,7 +5,7 @@ import { validateMimeTypeOAS3 } from '../../utils';
 
 export const RequestMimeType: Oas3Rule = ({ allowedValues }) => {
   return {
-    PathMap: {
+    PathsMap: {
       RequestBody: {
         leave(requestBody: Oas3RequestBody, ctx: UserContext) {
           validateMimeTypeOAS3({ type: 'consumes', value: requestBody }, ctx, allowedValues);

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

@@ -5,7 +5,7 @@ import { validateMimeTypeOAS3 } from '../../utils';
 
 export const ResponseMimeType: Oas3Rule = ({ allowedValues }) => {
   return {
-    PathMap: {
+    PathsMap: {
       Response: {
         leave(response: Oas3Response, ctx: UserContext) {
           validateMimeTypeOAS3({ type: 'produces', value: response }, ctx, allowedValues);

package/src/rules/oas3/spec-components-invalid-map-name.ts

@@ -0,0 +1,53 @@
+import { Oas3Rule } from '../../visitors';
+import { Problem, UserContext } from '../../walk';
+import { Location } from '../../ref-utils';
+
+export const SpecComponentsInvalidMapName: Oas3Rule = () => {
+  const KEYS_REGEX = '^[a-zA-Z0-9\\.\\-_]+$';
+
+  function validateKey(
+    key: string | number,
+    report: (problem: Problem) => void,
+    location: Location,
+    component: string
+  ) {
+    if (!new RegExp(KEYS_REGEX).test(key as string)) {
+      report({
+        message: `The map key in ${component} "${key}" does not match the regular expression "${KEYS_REGEX}"`,
+        location: location.key(),
+      });
+    }
+  }
+
+  return {
+    Components: {
+      Parameter(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'parameters');
+      },
+      Response(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'responses');
+      },
+      Schema(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'schemas');
+      },
+      Example(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'examples');
+      },
+      RequestBody(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'requestBodies');
+      },
+      Header(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'headers');
+      },
+      SecurityScheme(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'securitySchemas');
+      },
+      Link(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'links');
+      },
+      Callback(_node, { key, report, location }: UserContext) {
+        validateKey(key, report, location, 'callbacks');
+      },
+    },
+  };
+};

package/src/rules/other/stats.ts

@@ -24,7 +24,7 @@ export const Stats = (statsAccumulator: StatsAccumulator) => {
         statsAccumulator.links.items!.add(link.operationId);
       },
     },
-    DefinitionRoot: {
+    Root: {
       leave() {
         statsAccumulator.parameters.total = statsAccumulator.parameters.items!.size;
         statsAccumulator.refs.total = statsAccumulator.refs.items!.size;
@@ -41,7 +41,7 @@ export const Stats = (statsAccumulator: StatsAccumulator) => {
         },
       },
     },
-    PathMap: {
+    PathsMap: {
       PathItem: {
         leave() {
           statsAccumulator.pathItems.total++;

package/src/rules/utils.ts

@@ -3,6 +3,7 @@ import { UserContext } from '../walk';
 import { Location } from '../ref-utils';
 import { validateJsonSchema } from './ajv';
 import { Oas3Schema, Referenced } from '../typings/openapi';
+import { showErrorForDeprecatedField, showWarningForDeprecatedField } from '../utils';
 
 export function oasTypeOf(value: unknown) {
   if (Array.isArray(value)) {
@@ -91,7 +92,7 @@ export function validateExample(
   schema: Referenced<Oas3Schema>,
   dataLoc: Location,
   { resolve, location, report }: UserContext,
-  disallowAdditionalProperties: boolean
+  allowAdditionalProperties: boolean
 ) {
   try {
     const { valid, errors } = validateJsonSchema(
@@ -100,10 +101,10 @@ export function validateExample(
       location.child('schema'),
       dataLoc.pointer,
       resolve,
-      disallowAdditionalProperties
+      allowAdditionalProperties
     );
     if (!valid) {
-      for (let error of errors) {
+      for (const error of errors) {
         report({
           message: `Example value must conform to the schema: ${error.message}.`,
           location: {
@@ -123,3 +124,16 @@ export function validateExample(
     });
   }
 }
+
+export function getAdditionalPropertiesOption(opts: Record<string, any>): boolean {
+  if (opts.disallowAdditionalProperties === undefined) {
+    return opts.allowAdditionalProperties;
+  }
+
+  if (opts.allowAdditionalProperties !== undefined) {
+    showErrorForDeprecatedField('disallowAdditionalProperties', 'allowAdditionalProperties');
+  }
+
+  showWarningForDeprecatedField('disallowAdditionalProperties', 'allowAdditionalProperties');
+  return !opts.disallowAdditionalProperties;
+}

package/src/types/index.ts

@@ -73,7 +73,7 @@ export function normalizeTypes(
     normalizedTypes[typeName] = {
       ...types[typeName],
       name: typeName,
-    } as any;
+    } as NormalizedNodeType;
   }
 
   for (const type of Object.values(normalizedTypes)) {
@@ -81,7 +81,7 @@ export function normalizeTypes(
   }
   return normalizedTypes;
 
-  function normalizeType(type: any) {
+  function normalizeType(type: NormalizedNodeType) {
     if (type.additionalProperties) {
       type.additionalProperties = resolveType(type.additionalProperties);
     }

package/src/types/oas2.ts

@@ -2,7 +2,7 @@ import { NodeType, listOf, mapOf } from '.';
 
 const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
 
-const DefinitionRoot: NodeType = {
+const Root: NodeType = {
   properties: {
     swagger: { type: 'string' },
     info: 'Info',
@@ -11,7 +11,7 @@ const DefinitionRoot: NodeType = {
     schemes: { type: 'array', items: { type: 'string' } },
     consumes: { type: 'array', items: { type: 'string' } },
     produces: { type: 'array', items: { type: 'string' } },
-    paths: 'PathMap',
+    paths: 'PathsMap',
     definitions: 'NamedSchemas',
     parameters: 'NamedParameters',
     responses: 'NamedResponses',
@@ -51,7 +51,7 @@ const License: NodeType = {
   required: ['name'],
 };
 
-const PathMap: NodeType = {
+const PathsMap: NodeType = {
   properties: {},
   additionalProperties: (_value: any, key: string) =>
     key.startsWith('/') ? 'PathItem' : undefined,
@@ -369,14 +369,14 @@ const SecurityRequirement: NodeType = {
 };
 
 export const Oas2Types: Record<string, NodeType> = {
-  DefinitionRoot,
+  Root,
   Tag,
   ExternalDocs,
   SecurityRequirement,
   Info,
   Contact,
   License,
-  PathMap,
+  PathsMap,
   PathItem,
   Parameter,
   ParameterItems,