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

package/src/rules/common/assertions/utils.ts

@@ -1,167 +0,0 @@
-import { isRef } from '../../../ref-utils';
-import { Problem, ProblemSeverity, UserContext } from '../../../walk';
-import { asserts } from './asserts';
-
-export type OrderDirection = 'asc' | 'desc';
-
-export type OrderOptions = {
-  direction: OrderDirection;
-  property: string;
-};
-
-export type AssertToApply = {
-  name: string;
-  assertId?: string;
-  conditions: any;
-  message?: string;
-  severity?: ProblemSeverity;
-  suggest?: string[];
-  runsOnKeys: boolean;
-  runsOnValues: boolean;
-};
-
-export function buildVisitorObject(
-  subject: string,
-  context: Record<string, any>[],
-  subjectVisitor: any,
-) {
-  if (!context) {
-    return { [subject]: subjectVisitor };
-  }
-
-  let currentVisitorLevel: Record<string, any> = {};
-  const visitor: Record<string, any> = currentVisitorLevel;
-
-  for (let index = 0; index < context.length; index++) {
-    const node = context[index];
-    if (context.length === index + 1 && node.type === subject) {
-      // Visitors don't work properly for the same type nested nodes, so
-      // as a workaround for that we don't create separate visitor for the last element
-      // which is the same as subject;
-      // we will check includes/excludes it in the last visitor.
-      continue;
-    }
-    const matchParentKeys = node.matchParentKeys;
-    const excludeParentKeys = node.excludeParentKeys;
-
-    if (matchParentKeys && excludeParentKeys) {
-      throw new Error(
-        `Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`,
-      );
-    }
-
-    if (matchParentKeys || excludeParentKeys) {
-      currentVisitorLevel[node.type] = {
-        skip: (_value: any, key: string) => {
-          if (matchParentKeys) {
-            return !matchParentKeys.includes(key);
-          }
-          if (excludeParentKeys) {
-            return excludeParentKeys.includes(key);
-          }
-        },
-      };
-    } else {
-      currentVisitorLevel[node.type] = {};
-    }
-    currentVisitorLevel = currentVisitorLevel[node.type];
-  }
-
-  currentVisitorLevel[subject] = subjectVisitor;
-
-  return visitor;
-}
-
-export function buildSubjectVisitor(
-  properties: string | string[],
-  asserts: AssertToApply[],
-  context?: Record<string, any>[],
-) {
-  return function (node: any, { report, location, key, type, resolve }: UserContext) {
-    // We need to check context's last node if it has the same type as subject node;
-    // if yes - that means we didn't create context's last node visitor,
-    // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
-    if (context) {
-      const lastContextNode = context[context.length - 1];
-      if (lastContextNode.type === type.name) {
-        const matchParentKeys = lastContextNode.matchParentKeys;
-        const excludeParentKeys = lastContextNode.excludeParentKeys;
-
-        if (matchParentKeys && !matchParentKeys.includes(key)) {
-          return;
-        }
-        if (excludeParentKeys && excludeParentKeys.includes(key)) {
-          return;
-        }
-      }
-    }
-
-    if (properties) {
-      properties = Array.isArray(properties) ? properties : [properties];
-    }
-
-    for (const assert of asserts) {
-      if (properties) {
-        for (const property of properties) {
-          // we can have resolvable scalar so need to resolve value here.
-          const value = isRef(node[property]) ? resolve(node[property])?.node : node[property];
-          runAssertion(value, assert, location.child(property), report);
-        }
-      } else {
-        runAssertion(Object.keys(node), assert, location.key(), report);
-      }
-    }
-  };
-}
-
-export function getIntersectionLength(keys: string[], properties: string[]): number {
-  const props = new Set(properties);
-  let count = 0;
-  for (const key of keys) {
-    if (props.has(key)) {
-      count++;
-    }
-  }
-  return count;
-}
-
-export function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean {
-  const direction = (options as OrderOptions).direction || (options as OrderDirection);
-  const property = (options as OrderOptions).property;
-  for (let i = 1; i < value.length; i++) {
-    let currValue = value[i];
-    let prevVal = value[i - 1];
-
-    if (property) {
-      if (!value[i][property] || !value[i - 1][property]) {
-        return false; // property doesn't exist, so collection is not ordered
-      }
-      currValue = value[i][property];
-      prevVal = value[i - 1][property];
-    }
-
-    const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
-    if (!result) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function runAssertion(
-  values: string | string[],
-  assert: AssertToApply,
-  location: any,
-  report: (problem: Problem) => void,
-) {
-  const lintResult = asserts[assert.name](values, assert.conditions);
-  if (!lintResult) {
-    report({
-      message: assert.message || `The ${assert.assertId} doesn't meet required conditions`,
-      location,
-      forceSeverity: assert.severity,
-      suggest: assert.suggest,
-      ruleId: assert.assertId,
-    });
-  }
-}

package/src/rules/common/info-contact.ts

@@ -1,15 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { missingRequiredField } from '../utils';
-
-export const InfoContact: Oas3Rule | Oas2Rule = () => {
-  return {
-    Info(info, { report, location }) {
-      if (!info.contact) {
-        report({
-          message: missingRequiredField('Info', 'contact'),
-          location: location.child('contact').key(),
-        });
-      }
-    },
-  };
-};

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

@@ -1,10 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { validateDefinedAndNonEmpty } from '../utils';
-
-export const InfoDescription: Oas3Rule | Oas2Rule = () => {
-  return {
-    Info(info, ctx) {
-      validateDefinedAndNonEmpty('description', info, ctx);
-    },
-  };
-};

package/src/rules/common/info-license-url.ts

@@ -1,15 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { missingRequiredField } from '../utils';
-
-export const InfoLicense: Oas3Rule | Oas2Rule = () => {
-  return {
-    Info(info, { report }) {
-      if (!info.license) {
-        report({
-          message: missingRequiredField('Info', 'license'),
-          location: { reportOnKey: true }
-        });
-      }
-    },
-  };
-};

package/src/rules/common/license-url.ts

@@ -1,10 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { validateDefinedAndNonEmpty } from '../utils';
-
-export const InfoLicenseUrl: Oas3Rule | Oas2Rule = () => {
-  return {
-    License(license, ctx) {
-      validateDefinedAndNonEmpty('url', license, ctx);
-    },
-  };
-};

package/src/rules/common/no-ambiguous-paths.ts

@@ -1,50 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { Oas3Paths } from '../../typings/openapi';
-import { Oas2Paths } from '../../typings/swagger';
-
-export const NoAmbiguousPaths: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathMap(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
-      const seenPaths: string[] = [];
-
-      for (const currentPath of Object.keys(pathMap)) {
-        const ambiguousPath = seenPaths.find((seenPath) =>
-          arePathsAmbiguous(seenPath, currentPath),
-        );
-        if (ambiguousPath) {
-          report({
-            message: `Paths should resolve unambiguously. Found two ambiguous paths: \`${ambiguousPath}\` and \`${currentPath}\`.`,
-            location: location.child([currentPath]).key(),
-          });
-        }
-        seenPaths.push(currentPath);
-      }
-    },
-  };
-};
-
-function arePathsAmbiguous(a: string, b: string) {
-  const partsA = a.split('/');
-  const partsB = b.split('/');
-
-  if (partsA.length !== partsB.length) return false;
-
-  let aVars = 0;
-  let bVars = 0;
-  let ambiguous = true;
-  for (let i = 0; i < partsA.length; i++) {
-    const aIsVar = partsA[i].match(/^{.+?}$/);
-    const bIsVar = partsB[i].match(/^{.+?}$/);
-
-    if (aIsVar || bIsVar) {
-      if (aIsVar) aVars++;
-      if (bIsVar) bVars++;
-      continue;
-    } else if (partsA[i] !== partsB[i]) {
-      ambiguous = false;
-    }
-  }
-
-  return ambiguous && aVars === bVars;
-}

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

@@ -1,49 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { matchesJsonSchemaType, oasTypeOf } from '../utils';
-import { Oas2Schema } from '../../typings/swagger';
-import { Oas3Schema } from '../../typings/openapi';
-import { UserContext } from '../../walk';
-
-export const NoEnumTypeMismatch: Oas3Rule | Oas2Rule = () => {
-  return {
-    Schema(schema: Oas2Schema | Oas3Schema, { report, location }: UserContext) {
-      if (schema.enum && !Array.isArray(schema.enum)) return;
-      if (schema.enum && schema.type && !Array.isArray(schema.type)) {
-        const typeMismatchedValues = schema.enum.filter(
-          (item) => !matchesJsonSchemaType(item, schema.type as string, schema.nullable as boolean),
-        );
-        for (const mismatchedValue of typeMismatchedValues) {
-          report({
-            message: `All values of \`enum\` field must be of the same type as the \`type\` field: expected "${
-              schema.type
-            }" but received "${oasTypeOf(mismatchedValue)}".`,
-            location: location.child(['enum', schema.enum.indexOf(mismatchedValue)]),
-          });
-        }
-      }
-
-      if (schema.enum && schema.type && Array.isArray(schema.type)) {
-        const mismatchedResults: { [key: string]: string[]; } = {};
-        for (const enumValue of schema.enum) {
-          mismatchedResults[enumValue] = [];
-
-          for (const type of schema.type) {
-            const valid = matchesJsonSchemaType(enumValue, type as string, schema.nullable as boolean);
-            if (!valid)
-              mismatchedResults[enumValue].push(type);
-          }
-
-          if(mismatchedResults[enumValue].length !== schema.type.length)
-            delete mismatchedResults[enumValue];
-        };
-
-        for (const mismatchedKey of Object.keys(mismatchedResults)) {
-          report({
-            message: `Enum value \`${mismatchedKey}\` must be of one type. Allowed types: \`${schema.type}\`.`,
-            location: location.child(['enum', schema.enum.indexOf(mismatchedKey)]),
-          });
-        };
-      }
-    },
-  };
-};

package/src/rules/common/no-http-verbs-in-paths.ts

@@ -1,36 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2PathItem } from '../../typings/swagger';
-import { Oas3PathItem } from '../../typings/openapi';
-import { UserContext } from '../../walk';
-import { isPathParameter, splitCamelCaseIntoWords } from '../../utils';
-
-const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
-
-export const NoHttpVerbsInPaths: Oas3Rule | Oas2Rule = ({ splitIntoWords }) => {
-  return {
-    PathItem(_path: Oas2PathItem | Oas3PathItem, { key, report, location }: UserContext) {
-      const pathKey = key.toString();
-      if (!pathKey.startsWith('/')) return;
-      const pathSegments = pathKey.split('/');
-
-      for (const pathSegment of pathSegments) {
-        if (!pathSegment || isPathParameter(pathSegment)) continue;
-
-        const isHttpMethodIncluded = (method: string) => {
-          return splitIntoWords
-            ? splitCamelCaseIntoWords(pathSegment).has(method)
-            : pathSegment.toLocaleLowerCase().includes(method);
-        };
-
-        for (const method of httpMethods) {
-          if (isHttpMethodIncluded(method)) {
-            report({
-              message: `path \`${pathKey}\` should not contain http verb ${method}`,
-              location: location.key(),
-            });
-          }
-        }
-      }
-    },
-  };
-};

package/src/rules/common/no-identical-paths.ts

@@ -1,24 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { Oas3Paths } from '../../typings/openapi';
-import { Oas2Paths } from '../../typings/swagger';
-
-export const NoIdenticalPaths: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathMap(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
-      const pathsMap = new Map<string, string>();
-      for (const pathName of Object.keys(pathMap)) {
-        const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
-        const existingSamePath = pathsMap.get(id);
-        if (existingSamePath) {
-          report({
-            message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
-            location: location.child([pathName]).key(),
-          });
-        } else {
-          pathsMap.set(id, pathName);
-        }
-      }
-    },
-  };
-};

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

@@ -1,36 +0,0 @@
-import { UserContext } from '../../walk';
-import { Oas3Parameter } from '../../typings/openapi';
-import { validateExample } from '../utils';
-
-export const NoInvalidParameterExamples: any = (opts: any) => {
-  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
-  return {
-    Parameter: {
-      leave(parameter: Oas3Parameter, ctx: UserContext) {
-        if (parameter.example) {
-          validateExample(
-            parameter.example,
-            parameter.schema!,
-            ctx.location.child('example'),
-            ctx,
-            disallowAdditionalProperties,
-          );
-        }
-
-        if (parameter.examples) {
-          for (const [key, example] of Object.entries(parameter.examples)) {
-            if ('value' in example) {
-              validateExample(
-                example.value,
-                parameter.schema!,
-                ctx.location.child(['examples', key]),
-                ctx,
-                false,
-              );
-            }
-          }
-        }
-      },
-    },
-  };
-};

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

@@ -1,27 +0,0 @@
-import { UserContext } from '../../walk';
-import { Oas3_1Schema } from '../../typings/openapi';
-import { validateExample } from '../utils';
-
-export const NoInvalidSchemaExamples: any = (opts: any) => {
-  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
-  return {
-    Schema: {
-      leave(schema: Oas3_1Schema, ctx: UserContext) {
-        if (schema.examples) {
-          for (const example of schema.examples) {
-            validateExample(
-              example,
-              schema,
-              ctx.location.child(['examples', schema.examples.indexOf(example)]),
-              ctx,
-              disallowAdditionalProperties,
-            );
-          }
-        }
-        if (schema.example) {
-          validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
-        }
-      },
-    },
-  };
-};

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

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

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

@@ -1,16 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-
-export const Operation2xxResponse: Oas3Rule | Oas2Rule = () => {
-  return {
-    ResponsesMap(responses: Record<string, object>, { report }: UserContext) {
-      const codes = Object.keys(responses);
-      if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
-        report({
-          message: 'Operation must have at least one `2xx` response.',
-          location: { reportOnKey: true },
-        });
-      }
-    },
-  };
-};

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

@@ -1,17 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-
-export const Operation4xxResponse: Oas3Rule | Oas2Rule = () => {
-  return {
-    ResponsesMap(responses: Record<string, object>, { report }: UserContext) {
-      const codes = Object.keys(responses);
-
-      if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
-        report({
-          message: 'Operation must have at least one `4xx` response.',
-          location: { reportOnKey: true },
-        });
-      }
-    },
-  };
-};

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

@@ -1,13 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { validateDefinedAndNonEmpty } from '../utils';
-import { UserContext } from '../../walk';
-import { Oas2Operation } from '../../typings/swagger';
-import { 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 { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Operation } from '../../typings/swagger';
-import { Oas3Operation } from '../../typings/openapi';
-import { 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,19 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Operation } from '../../typings/swagger';
-import { Oas3Operation } from '../../typings/openapi';
-import { UserContext } from '../../walk';
-
-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,17 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { validateDefinedAndNonEmpty } from '../utils';
-import { UserContext } from '../../walk';
-import { Oas2Operation } from '../../typings/swagger';
-import { Oas3Operation } from '../../typings/openapi';
-
-export const OperationOperationId: Oas3Rule | Oas2Rule = () => {
-  return {
-    DefinitionRoot: {
-      PathItem: {
-        Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
-          validateDefinedAndNonEmpty('operationId', operation, ctx);
-        },
-      },
-    }
-  };
-};

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

@@ -1,48 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Parameter } from '../../typings/swagger';
-import { Oas3Parameter } from '../../typings/openapi';
-import { 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-security-defined.ts

@@ -1,45 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Location } from '../../ref-utils';
-import { UserContext } from '../../walk';
-import { Oas2SecurityScheme } from '../../typings/swagger';
-import { Oas3SecurityScheme } from '../../typings/openapi';
-
-export const OperationSecurityDefined: Oas3Rule | Oas2Rule = () => {
-  let referencedSchemes = new Map<
-    string,
-    {
-      defined?: boolean;
-      from: Location[];
-    }
-  >();
-
-  return {
-    DefinitionRoot: {
-      leave(_: object, { report }: UserContext) {
-        for (const [name, scheme] of referencedSchemes.entries()) {
-          if (scheme.defined) continue;
-          for (const reportedFromLocation of scheme.from) {
-            report({
-              message: `There is no \`${name}\` security scheme defined.`,
-              location: reportedFromLocation.key(),
-            });
-          }
-        }
-      },
-    },
-    SecurityScheme(_securityScheme: Oas2SecurityScheme | Oas3SecurityScheme, { key }: UserContext) {
-      referencedSchemes.set(key.toString(), { defined: true, from: [] });
-    },
-    SecurityRequirement(requirements, { location }) {
-      for (const requirement of Object.keys(requirements)) {
-        const authScheme = referencedSchemes.get(requirement);
-        const requirementLocation = location.child([requirement]);
-        if (!authScheme) {
-          referencedSchemes.set(requirement, { from: [requirementLocation] });
-        } else {
-          authScheme.from.push(requirementLocation);
-        }
-      }
-    },
-  };
-};