@redocly/openapi-core 1.34.4 → 2.0.0-next.1

package/src/rules/common/no-invalid-schema-examples.ts

@@ -1,40 +0,0 @@
-import { getAdditionalPropertiesOption, validateExample } from '../utils';
-
-import type { UserContext } from '../../walk';
-import type { Oas3_1Schema, Oas3Schema } from '../../typings/openapi';
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-
-export const NoInvalidSchemaExamples: Oas3Rule | Oas2Rule = (opts: any) => {
-  const allowAdditionalProperties = getAdditionalPropertiesOption(opts) ?? false;
-  return {
-    Schema: {
-      leave(schema: Oas3_1Schema | Oas3Schema, ctx: UserContext) {
-        const examples = (schema as Oas3_1Schema).examples;
-        if (examples) {
-          for (const example of examples) {
-            validateExample(
-              example,
-              schema,
-              ctx.location.child(['examples', examples.indexOf(example)]),
-              ctx,
-              allowAdditionalProperties
-            );
-          }
-        }
-
-        if (schema.example !== undefined) {
-          // Handle nullable example for OAS3
-          if (
-            (schema as Oas3Schema).nullable === true &&
-            schema.example === null &&
-            schema.type !== undefined
-          ) {
-            return;
-          }
-
-          validateExample(schema.example, schema, ctx.location.child('example'), ctx, true);
-        }
-      },
-    },
-  };
-};

package/src/rules/common/no-path-trailing-slash.ts

@@ -1,15 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const NoPathTrailingSlash: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathItem(_path: any, { report, key, rawLocation }: UserContext) {
-      if ((key as string).endsWith('/') && key !== '/') {
-        report({
-          message: `\`${key}\` should not have a trailing slash.`,
-          location: rawLocation.key(),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/no-required-schema-properties-undefined.ts

@@ -1,54 +0,0 @@
-import { isRef } from '../../ref-utils';
-
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-import type { Oas3Schema, Oas3_1Schema } from '../../typings/openapi';
-import type { Oas2Schema } from 'core/src/typings/swagger';
-import type { UserContext } from 'core/src/walk';
-
-export const NoRequiredSchemaPropertiesUndefined: Oas3Rule | Oas2Rule = () => {
-  return {
-    Schema: {
-      enter(
-        schema: Oas3Schema | Oas3_1Schema | Oas2Schema,
-        { location, report, resolve }: UserContext
-      ) {
-        if (!schema.required) return;
-        const visitedSchemas: Set<Oas3Schema | Oas3_1Schema | Oas2Schema> = new Set();
-
-        const elevateProperties = (
-          schema: Oas3Schema | Oas3_1Schema | Oas2Schema
-        ): Record<string, Oas3Schema | Oas3_1Schema | Oas2Schema> => {
-          // Check if the schema has been visited before processing it
-          if (visitedSchemas.has(schema)) {
-            return {};
-          }
-          visitedSchemas.add(schema);
-
-          if (isRef(schema)) {
-            return elevateProperties(
-              resolve(schema).node as Oas3Schema | Oas3_1Schema | Oas2Schema
-            );
-          }
-
-          return Object.assign(
-            {},
-            schema.properties,
-            ...(schema.allOf?.map(elevateProperties) ?? []),
-            ...((schema as Oas3Schema).anyOf?.map(elevateProperties) ?? [])
-          );
-        };
-
-        const allProperties = elevateProperties(schema);
-
-        for (const [i, requiredProperty] of schema.required.entries()) {
-          if (!allProperties || allProperties[requiredProperty] === undefined) {
-            report({
-              message: `Required property '${requiredProperty}' is undefined.`,
-              location: location.child(['required', i]),
-            });
-          }
-        }
-      },
-    },
-  };
-};

package/src/rules/common/no-schema-type-mismatch.ts

@@ -1,24 +0,0 @@
-import type { Oas3Schema } from '../../typings/openapi';
-import type { Oas2Schema } from '../../typings/swagger';
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const NoSchemaTypeMismatch: Oas3Rule | Oas2Rule = () => {
-  return {
-    Schema(schema: Oas2Schema | Oas3Schema, { report, location }: UserContext) {
-      if (schema.type === 'object' && schema.items) {
-        report({
-          message: "Schema type mismatch: 'object' type should not contain 'items' field.",
-          location: location.child('items'),
-        });
-      }
-
-      if (schema.type === 'array' && schema.properties) {
-        report({
-          message: "Schema type mismatch: 'array' type should not contain 'properties' field.",
-          location: location.child('properties'),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/operation-2xx-response.ts

@@ -1,25 +0,0 @@
-import { validateResponseCodes } from '../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const Operation2xxResponse: Oas3Rule | Oas2Rule = ({ validateWebhooks }) => {
-  return {
-    Paths: {
-      Responses(responses: Record<string, object>, { report }: UserContext) {
-        const codes = Object.keys(responses || {});
-
-        validateResponseCodes(codes, '2XX', { report } as UserContext);
-      },
-    },
-    WebhooksMap: {
-      Responses(responses: Record<string, object>, { report }: UserContext) {
-        if (!validateWebhooks) return;
-
-        const codes = Object.keys(responses || {});
-
-        validateResponseCodes(codes, '2XX', { report } as UserContext);
-      },
-    },
-  };
-};

package/src/rules/common/operation-4xx-response.ts

@@ -1,25 +0,0 @@
-import { validateResponseCodes } from '../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const Operation4xxResponse: Oas3Rule | Oas2Rule = ({ validateWebhooks }) => {
-  return {
-    Paths: {
-      Responses(responses: Record<string, object>, { report }: UserContext) {
-        const codes = Object.keys(responses || {});
-
-        validateResponseCodes(codes, '4XX', { report } as UserContext);
-      },
-    },
-    WebhooksMap: {
-      Responses(responses: Record<string, object>, { report }: UserContext) {
-        if (!validateWebhooks) return;
-
-        const codes = Object.keys(responses || {});
-
-        validateResponseCodes(codes, '4XX', { report } as UserContext);
-      },
-    },
-  };
-};

package/src/rules/common/operation-description.ts

@@ -1,14 +0,0 @@
-import { validateDefinedAndNonEmpty } from '../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-
-export const OperationDescription: Oas3Rule | Oas2Rule = () => {
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
-      validateDefinedAndNonEmpty('description', operation, ctx);
-    },
-  };
-};

package/src/rules/common/operation-operationId-unique.ts

@@ -1,21 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const OperationIdUnique: Oas3Rule | Oas2Rule = () => {
-  const seenOperations = new Set();
-
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
-      if (!operation.operationId) return;
-      if (seenOperations.has(operation.operationId)) {
-        report({
-          message: 'Every operation must have a unique `operationId`.',
-          location: location.child([operation.operationId]),
-        });
-      }
-      seenOperations.add(operation.operationId);
-    },
-  };
-};

package/src/rules/common/operation-operationId-url-safe.ts

@@ -1,20 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-// eslint-disable-next-line no-useless-escape
-const validUrlSymbols = /^[A-Za-z0-9-._~:/?#\[\]@!\$&'()*+,;=]*$/;
-
-export const OperationIdUrlSafe: Oas3Rule | Oas2Rule = () => {
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
-      if (operation.operationId && !validUrlSymbols.test(operation.operationId)) {
-        report({
-          message: 'Operation `operationId` should not have URL invalid characters.',
-          location: location.child(['operationId']),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/operation-operationId.ts

@@ -1,18 +0,0 @@
-import { validateDefinedAndNonEmpty } from '../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-
-export const OperationOperationId: Oas3Rule | Oas2Rule = () => {
-  return {
-    Root: {
-      PathItem: {
-        Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
-          validateDefinedAndNonEmpty('operationId', operation, ctx);
-        },
-      },
-    },
-  };
-};

package/src/rules/common/operation-parameters-unique.ts

@@ -1,48 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Parameter } from '../../typings/swagger';
-import type { Oas3Parameter } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const OperationParametersUnique: Oas3Rule | Oas2Rule = () => {
-  let seenPathParams: Set<string>;
-  let seenOperationParams: Set<string>;
-
-  return {
-    PathItem: {
-      enter() {
-        seenPathParams = new Set();
-      },
-      Parameter(
-        parameter: Oas2Parameter | Oas3Parameter,
-        { report, key, parentLocations }: UserContext
-      ) {
-        const paramId = `${parameter.in}___${parameter.name}`;
-        if (seenPathParams.has(paramId)) {
-          report({
-            message: `Paths must have unique \`name\` + \`in\` parameters.\nRepeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
-            location: parentLocations.PathItem.child(['parameters', key]),
-          });
-        }
-        seenPathParams.add(`${parameter.in}___${parameter.name}`);
-      },
-      Operation: {
-        enter() {
-          seenOperationParams = new Set();
-        },
-        Parameter(
-          parameter: Oas2Parameter | Oas3Parameter,
-          { report, key, parentLocations }: UserContext
-        ) {
-          const paramId = `${parameter.in}___${parameter.name}`;
-          if (seenOperationParams.has(paramId)) {
-            report({
-              message: `Operations must have unique \`name\` + \`in\` parameters. Repeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
-              location: parentLocations.Operation.child(['parameters', key]),
-            });
-          }
-          seenOperationParams.add(paramId);
-        },
-      },
-    },
-  };
-};

package/src/rules/common/operation-singular-tag.ts

@@ -1,17 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const OperationSingularTag: Oas3Rule | Oas2Rule = () => {
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
-      if (operation.tags && operation.tags.length > 1) {
-        report({
-          message: 'Operation `tags` object should have only one tag.',
-          location: location.child(['tags']).key(),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/operation-summary.ts

@@ -1,14 +0,0 @@
-import { validateDefinedAndNonEmpty } from '../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-import type { Oas2Operation } from '../../typings/swagger';
-import type { Oas3Operation } from '../../typings/openapi';
-
-export const OperationSummary: Oas3Rule | Oas2Rule = () => {
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
-      validateDefinedAndNonEmpty('summary', operation, ctx);
-    },
-  };
-};

package/src/rules/common/operation-tag-defined.ts

@@ -1,31 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Definition, Oas2Operation } from '../../typings/swagger';
-import type { Oas3Definition, Oas3_1Definition, Oas3Operation } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const OperationTagDefined: Oas3Rule | Oas2Rule = () => {
-  let definedTags: Set<string>;
-
-  return {
-    Root(root: Oas2Definition | Oas3Definition | Oas3_1Definition) {
-      definedTags = new Set((root.tags ?? []).map((t) => t.name));
-    },
-    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
-      if (operation?.tags) {
-        for (let i = 0; i < operation.tags.length; i++) {
-          if (!definedTags.has(operation.tags[i])) {
-            report({
-              message: `Operation tags should be defined in global tags.`,
-              location: location.child(['tags', i]),
-            });
-          }
-        }
-      } else {
-        report({
-          message: `Operation tags should be defined`,
-          location: location.key(),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/parameter-description.ts

@@ -1,22 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Parameter } from '../../typings/swagger';
-import type { Oas3Parameter } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const ParameterDescription: Oas3Rule | Oas2Rule = () => {
-  return {
-    Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
-      if (parameter.description === undefined) {
-        report({
-          message: 'Parameter object description must be present.',
-          location: { reportOnKey: true },
-        });
-      } else if (!parameter.description) {
-        report({
-          message: 'Parameter object description must be non-empty string.',
-          location: location.child(['description']),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/path-declaration-must-exist.ts

@@ -1,15 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const PathDeclarationMustExist: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathItem(_path: object, { report, key }: UserContext) {
-      if ((key as string).indexOf('{}') !== -1) {
-        report({
-          message: 'Path parameter declarations must be non-empty. `{}` is invalid.',
-          location: { reportOnKey: true },
-        });
-      }
-    },
-  };
-};

package/src/rules/common/path-excludes-patterns.ts

@@ -1,23 +0,0 @@
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-import type { Oas2PathItem } from '../../typings/swagger';
-import type { Oas3PathItem } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const PathExcludesPatterns: Oas3Rule | Oas2Rule = ({ patterns }) => {
-  return {
-    PathItem(_path: Oas2PathItem | Oas3PathItem, { report, key, location }: UserContext) {
-      if (!patterns)
-        throw new Error(`Parameter "patterns" is not provided for "path-excludes-patterns" rule`);
-      const pathKey = key.toString();
-      if (pathKey.startsWith('/')) {
-        const matches = patterns.filter((pattern: string) => pathKey.match(pattern));
-        for (const match of matches) {
-          report({
-            message: `path \`${pathKey}\` should not match regex pattern: \`${match}\``,
-            location: location.key(),
-          });
-        }
-      }
-    },
-  };
-};

package/src/rules/common/path-http-verbs-order.ts

@@ -1,30 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2PathItem } from '../../typings/swagger';
-import type { Oas3PathItem } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-const defaultOrder = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
-
-export const PathHttpVerbsOrder: Oas3Rule | Oas2Rule = (opts: any) => {
-  const order: string[] = (opts && opts.order) || defaultOrder;
-  if (!Array.isArray(order)) {
-    throw new Error('path-http-verbs-order `order` option must be an array');
-  }
-
-  return {
-    PathItem(path: Oas2PathItem | Oas3PathItem, { report, location }: UserContext) {
-      const httpVerbs = Object.keys(path).filter((k) => order.includes(k));
-
-      for (let i = 0; i < httpVerbs.length - 1; i++) {
-        const aIdx = order.indexOf(httpVerbs[i]);
-        const bIdx = order.indexOf(httpVerbs[i + 1]);
-        if (bIdx < aIdx) {
-          report({
-            message: 'Operation http verbs must be ordered.',
-            location: { reportOnKey: true, ...location.child(httpVerbs[i + 1]) },
-          });
-        }
-      }
-    },
-  };
-};

package/src/rules/common/path-not-include-query.ts

@@ -1,17 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const PathNotIncludeQuery: Oas3Rule | Oas2Rule = () => {
-  return {
-    Paths: {
-      PathItem(_operation: object, { report, key }: UserContext) {
-        if (key.toString().includes('?')) {
-          report({
-            message: `Don't put query string items in the path, they belong in parameters with \`in: query\`.`,
-            location: { reportOnKey: true },
-          });
-        }
-      },
-    },
-  };
-};

package/src/rules/common/path-params-defined.ts

@@ -1,65 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Parameter } from '../../typings/swagger';
-import type { Oas3Parameter } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
-
-export const PathParamsDefined: Oas3Rule | Oas2Rule = () => {
-  let pathTemplateParams: Set<string>;
-  let definedPathParams: Set<string>;
-  let currentPath: string;
-  let definedOperationParams: Set<string>;
-
-  return {
-    PathItem: {
-      enter(_: object, { key }: UserContext) {
-        definedPathParams = new Set();
-        currentPath = key as string;
-        pathTemplateParams = new Set(
-          Array.from(key!.toString().matchAll(pathRegex)).map((m) => m[1])
-        );
-      },
-      Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
-        if (parameter.in === 'path' && parameter.name) {
-          definedPathParams.add(parameter.name);
-          if (!pathTemplateParams.has(parameter.name)) {
-            report({
-              message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
-              location: location.child(['name']),
-            });
-          }
-        }
-      },
-      Operation: {
-        enter() {
-          definedOperationParams = new Set();
-        },
-        leave(_op: object, { report, location }: UserContext) {
-          for (const templateParam of Array.from(pathTemplateParams.keys())) {
-            if (
-              !definedOperationParams.has(templateParam) &&
-              !definedPathParams.has(templateParam)
-            ) {
-              report({
-                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${currentPath}\`.`,
-                location: location.child(['parameters']).key(), // report on operation
-              });
-            }
-          }
-        },
-        Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
-          if (parameter.in === 'path' && parameter.name) {
-            definedOperationParams.add(parameter.name);
-            if (!pathTemplateParams.has(parameter.name)) {
-              report({
-                message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
-                location: location.child(['name']),
-              });
-            }
-          }
-        },
-      },
-    },
-  };
-};

package/src/rules/common/path-segment-plural.ts

@@ -1,33 +0,0 @@
-import * as pluralize from 'pluralize';
-import { isPathParameter } from '../../utils';
-
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
-  const { ignoreLastPathSegment, exceptions } = opts;
-  return {
-    PathItem: {
-      leave(_path: any, { report, key, location }: UserContext) {
-        const pathKey = key.toString();
-        if (pathKey.startsWith('/')) {
-          const pathSegments = pathKey.split('/');
-          pathSegments.shift();
-          if (ignoreLastPathSegment && pathSegments.length > 1) {
-            pathSegments.pop();
-          }
-
-          for (const pathSegment of pathSegments) {
-            if (exceptions && exceptions.includes(pathSegment)) continue;
-            if (!isPathParameter(pathSegment) && pluralize.isSingular(pathSegment)) {
-              report({
-                message: `path segment \`${pathSegment}\` should be plural.`,
-                location: location.key(),
-              });
-            }
-          }
-        }
-      },
-    },
-  };
-};

package/src/rules/common/paths-kebab-case.ts

@@ -1,19 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const PathsKebabCase: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathItem(_path: object, { report, key }: UserContext) {
-      const segments = (key as string)
-        .substr(1)
-        .split('/')
-        .filter((s) => s !== ''); // filter out empty segments
-      if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
-        report({
-          message: `\`${key}\` does not use kebab-case.`,
-          location: { reportOnKey: true },
-        });
-      }
-    },
-  };
-};

package/src/rules/common/required-string-property-missing-min-length.ts

@@ -1,44 +0,0 @@
-import type { UserContext } from '../../walk';
-import type { Oas3Schema, Oas3_1Schema } from '../../typings/openapi';
-import type { Oas2Schema } from 'core/src/typings/swagger';
-import type { Oas3Rule } from 'core/src/visitors';
-
-export const RequiredStringPropertyMissingMinLength: Oas3Rule = () => {
-  let skipSchemaProperties: boolean;
-  let requiredPropertiesSet: Set<string>;
-
-  return {
-    Schema: {
-      enter(schema: Oas3Schema | Oas3_1Schema | Oas2Schema) {
-        if (!schema?.required) {
-          skipSchemaProperties = true;
-          return;
-        }
-        requiredPropertiesSet = new Set(schema.required);
-        skipSchemaProperties = false;
-      },
-
-      SchemaProperties: {
-        skip() {
-          return skipSchemaProperties;
-        },
-
-        Schema: {
-          enter(
-            schema: Oas3Schema | Oas3_1Schema | Oas2Schema,
-            { key, location, report }: UserContext
-          ) {
-            if (requiredPropertiesSet.has(key as string) && schema.type === 'string') {
-              if (!schema?.minLength) {
-                report({
-                  message: 'Property minLength is required.',
-                  location: location.key(),
-                });
-              }
-            }
-          },
-        },
-      },
-    },
-  };
-};