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

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

@@ -1,17 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Operation } from '../../typings/swagger';
-import { Oas3Operation } from '../../typings/openapi';
-import { 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,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 OperationSummary: Oas3Rule | Oas2Rule = () => {
-  return {
-    Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
-      validateDefinedAndNonEmpty('summary', operation, ctx);
-    },
-  };
-};

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

@@ -1,26 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
-import { Oas3Definition, Oas3Operation } from '../../typings/openapi';
-import { UserContext } from '../../walk';
-
-export const OperationTagDefined: Oas3Rule | Oas2Rule = () => {
-  let definedTags: Set<string>;
-
-  return {
-    DefinitionRoot(root: Oas2Definition | Oas3Definition) {
-      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]),
-            });
-          }
-        }
-      }
-    },
-  };
-};

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

@@ -1,22 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Parameter } from '../../typings/swagger';
-import { Oas3Parameter } from '../../typings/openapi';
-import { 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 { Oas3Rule, Oas2Rule } from '../../visitors';
-import { 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 { Oas2Rule, Oas3Rule } from '../../visitors';
-import { Oas2PathItem } from '../../typings/swagger';
-import { Oas3PathItem } from '../../typings/openapi';
-import { 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 { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2PathItem } from '../../typings/swagger';
-import { Oas3PathItem } from '../../typings/openapi';
-import { 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 { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-
-export const PathNotIncludeQuery: Oas3Rule | Oas2Rule = () => {
-  return {
-    PathMap: {
-      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,58 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Parameter } from '../../typings/swagger';
-import { Oas3Parameter } from '../../typings/openapi';
-import { 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;
-
-  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: {
-        leave(_op: object, { report, location }: UserContext) {
-          for (const templateParam of Array.from(pathTemplateParams.keys())) {
-            if (!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) {
-            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']),
-              });
-            }
-          }
-        },
-      },
-    },
-  };
-};

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

@@ -1,31 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
-import { isPathParameter, isSingular } from '../../utils';
-
-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) && isSingular(pathSegment)) {
-              report({
-                message: `path segment \`${pathSegment}\` should be plural.`,
-                location: location.key(),
-              });
-            }
-          }
-        }
-      },
-    },
-  };
-};

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

@@ -1,16 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { 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/spec.ts

@@ -1,143 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import { isNamedType } from '../../types';
-import { oasTypeOf, matchesJsonSchemaType, getSuggest } from '../utils';
-import { isRef } from '../../ref-utils';
-import { isPlainObject } from '../../utils';
-
-export const OasSpec: Oas3Rule | Oas2Rule = () => {
-  return {
-    any(node: any, { report, type, location, key, resolve, ignoreNextVisitorsOnNode } ) {
-      const nodeType = oasTypeOf(node);
-
-      if (type.items) {
-        if (nodeType !== 'array') {
-          report({
-            message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
-          });
-          ignoreNextVisitorsOnNode();
-        }
-        return;
-      } else if (nodeType !== 'object') {
-        report({
-          message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
-        });
-        ignoreNextVisitorsOnNode();
-        return;
-      }
-
-      const required =
-        typeof type.required === 'function' ? type.required(node, key) : type.required;
-
-      for (let propName of required || []) {
-        if (!(node as object).hasOwnProperty(propName)) {
-          report({
-            message: `The field \`${propName}\` must be present on this level.`,
-            location: [{ reportOnKey: true }],
-          });
-        }
-      }
-
-      const allowed = type.allowed?.(node);
-      if (allowed && isPlainObject(node)) {
-        for (const propName in node) {
-          if (allowed.includes(propName) ||
-           (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
-           !Object.keys(type.properties).includes(propName)
-          ) {
-            continue;
-          }
-          report({
-            message: `The field \`${propName}\` is not allowed here.`,
-            location: location.child([propName]).key()
-          });
-        }
-      }
-
-      const requiredOneOf = type.requiredOneOf || null;
-      if (requiredOneOf) {
-        let hasProperty = false;
-        for (let propName of requiredOneOf || []) {
-          if ((node as object).hasOwnProperty(propName)) {
-            hasProperty = true;
-          }
-        }
-        if (!hasProperty)
-          report({
-            message: `Must contain at least one of the following fields: ${type.requiredOneOf?.join(', ')}.`,
-            location: [{ reportOnKey: true }],
-          });
-      }
-
-      for (const propName of Object.keys(node)) {
-        const propLocation = location.child([propName]);
-        let propValue = node[propName];
-
-        let propType = type.properties[propName];
-        if (propType === undefined) propType = type.additionalProperties;
-        if (typeof propType === 'function') propType = propType(propValue, propName);
-
-        if (isNamedType(propType)) {
-          continue; // do nothing for named schema, it is executed with the next any call
-        }
-
-        const propSchema = propType;
-        const propValueType = oasTypeOf(propValue);
-
-        if (propSchema === undefined) {
-          if (propName.startsWith('x-')) continue;
-          report({
-            message: `Property \`${propName}\` is not expected here.`,
-            suggest: getSuggest(propName, Object.keys(type.properties)),
-            location: propLocation.key(),
-          });
-          continue;
-        }
-
-        if (propSchema === null) {
-          continue; // just defined, no validation
-        }
-
-        if (propSchema.resolvable !== false && isRef(propValue)) {
-          propValue = resolve(propValue).node;
-        }
-
-        if (propSchema.enum) {
-          if (!propSchema.enum.includes(propValue)) {
-            report({
-              location: propLocation,
-              message: `\`${propName}\` can be one of the following only: ${propSchema.enum
-                .map((i) => `"${i}"`)
-                .join(', ')}.`,
-              suggest: getSuggest(propValue, propSchema.enum),
-            });
-          }
-        } else if (propSchema.type && !matchesJsonSchemaType(propValue, propSchema.type, false)) {
-          report({
-            message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
-            location: propLocation,
-          });
-        } else if (propValueType === 'array' && propSchema.items?.type) {
-          const itemsType = propSchema.items?.type;
-          for (let i = 0; i < propValue.length; i++) {
-            const item = propValue[i];
-            if (!matchesJsonSchemaType(item, itemsType, false)) {
-              report({
-                message: `Expected type \`${itemsType}\` but got \`${oasTypeOf(item)}\`.`,
-                location: propLocation.child([i]),
-              });
-            }
-          }
-        }
-
-        if (typeof propSchema.minimum === 'number') {
-          if (propSchema.minimum > node[propName]) {
-            report({
-              message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
-              location: location.child([propName]),
-            })
-          }
-        }
-      }
-    },
-  };
-};

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

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

package/src/rules/common/tags-alphabetical.ts

@@ -1,20 +0,0 @@
-import { Oas3Rule, Oas2Rule } from '../../visitors';
-import { Oas2Definition } from '../../typings/swagger';
-import { Oas3Definition } from '../../typings/openapi';
-import { UserContext } from '../../walk';
-
-export const TagsAlphabetical: Oas3Rule | Oas2Rule = () => {
-  return {
-    DefinitionRoot(root: Oas2Definition | Oas3Definition, { report, location }: UserContext) {
-      if (!root.tags) return;
-      for (let i = 0; i < root.tags.length - 1; i++) {
-        if (root.tags[i].name > root.tags[i + 1].name) {
-          report({
-            message: 'The `tags` array should be in alphabetical order.',
-            location: location.child(['tags', i]),
-          });
-        }
-      }
-    },
-  };
-};

package/src/rules/no-unresolved-refs.ts

@@ -1,51 +0,0 @@
-import { Oas3Rule } from '../visitors';
-import { YamlParseError } from '../resolve';
-import { ResolveResult, Problem } from '../walk';
-import { Location } from '../ref-utils';
-
-export const NoUnresolvedRefs: Oas3Rule = () => {
-  return {
-    ref: {
-      leave(_, { report, location }, resolved) {
-        if (resolved.node !== undefined) return;
-        reportUnresolvedRef(resolved, report, location);
-      },
-    },
-    DiscriminatorMapping(mapping, { report, resolve, location }) {
-      for (const mappingName of Object.keys(mapping)) {
-        const resolved = resolve({ $ref: mapping[mappingName] });
-        if (resolved.node !== undefined) return;
-
-        reportUnresolvedRef(resolved, report, location.child(mappingName));
-      }
-    },
-  };
-};
-
-export function reportUnresolvedRef(
-  resolved: ResolveResult<any>,
-  report: (m: Problem) => void,
-  location: Location,
-) {
-  const error = resolved.error;
-  if (error instanceof YamlParseError) {
-    report({
-      message: 'Failed to parse: ' + error.message,
-      location: {
-        source: error.source,
-        pointer: undefined,
-        start: {
-          col: error.col,
-          line: error.line,
-        },
-      },
-    });
-  }
-
-  const message = resolved.error?.message;
-
-  report({
-    location,
-    message: `Can't resolve $ref${message ? ': ' + message : ''}`,
-  });
-}

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

@@ -1,110 +0,0 @@
-import { outdent } from 'outdent';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { lintDocument } from '../../../lint';
-import { BaseResolver } from '../../../resolve';
-
-describe('oas2 boolean-parameter-prefixes', () => {
-  it('should report on boolean param without prefix', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        swagger: '2.0'
-        paths:
-          '/test':
-            parameters:
-            - name: a
-              in: path
-              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/oas2/__tests__/spec/fixtures/description.md

@@ -1 +0,0 @@
-Hello