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

package/src/rules/common/response-contains-header.ts

@@ -1,36 +0,0 @@
-import { getMatchingStatusCodeRange } from '../../utils';
-
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-import type { Oas3Response } from '../../typings/openapi';
-import type { Oas2Response } from '../../typings/swagger';
-
-export const ResponseContainsHeader: Oas3Rule | Oas2Rule = (options) => {
-  const names: Record<string, string[]> = options.names || {};
-  return {
-    Operation: {
-      Response: {
-        enter: (response: Oas2Response | Oas3Response, { report, location, key }: UserContext) => {
-          const expectedHeaders =
-            names[key] ||
-            names[getMatchingStatusCodeRange(key)] ||
-            names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-            [];
-          for (const expectedHeader of expectedHeaders) {
-            if (
-              !response?.headers ||
-              !Object.keys(response?.headers).some(
-                (header) => header.toLowerCase() === expectedHeader.toLowerCase()
-              )
-            ) {
-              report({
-                message: `Response object must contain a "${expectedHeader}" header.`,
-                location: location.child('headers').key(),
-              });
-            }
-          }
-        },
-      },
-    },
-  };
-};

package/src/rules/common/scalar-property-missing-example.ts

@@ -1,59 +0,0 @@
-import { SpecVersion } from '../../oas-types';
-
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-import type { Oas2Schema } from '../../typings/swagger';
-import type { Oas3Schema, Oas3_1Schema } from '../../typings/openapi';
-
-const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
-
-export const ScalarPropertyMissingExample: Oas3Rule | Oas2Rule = () => {
-  return {
-    SchemaProperties(
-      properties: { [name: string]: Oas2Schema | Oas3Schema | Oas3_1Schema },
-      { report, location, oasVersion, resolve }: UserContext
-    ) {
-      for (const propName of Object.keys(properties)) {
-        const propSchema = resolve(properties[propName]).node;
-
-        if (!propSchema || !isScalarSchema(propSchema)) {
-          continue;
-        }
-
-        if (
-          propSchema.example === undefined &&
-          (propSchema as Oas3_1Schema).examples === undefined
-        ) {
-          report({
-            message: `Scalar property should have "example"${
-              oasVersion === SpecVersion.OAS3_1 ? ' or "examples"' : ''
-            } defined.`,
-            location: location.child(propName).key(),
-          });
-        }
-      }
-    },
-  };
-};
-
-function isScalarSchema(schema: Oas2Schema | Oas3Schema | Oas3_1Schema) {
-  if (!schema.type) {
-    return false;
-  }
-
-  if (schema.allOf || (schema as Oas3Schema).anyOf || (schema as Oas3Schema).oneOf) {
-    // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
-    // We need core support for checking contrstrains through those keywords.
-    return false;
-  }
-
-  if (schema.format === 'binary') {
-    return false;
-  }
-
-  if (Array.isArray(schema.type)) {
-    return schema.type.every((t) => SCALAR_TYPES.includes(t));
-  }
-
-  return SCALAR_TYPES.includes(schema.type);
-}

package/src/rules/common/security-defined.ts

@@ -1,89 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Location } from '../../ref-utils';
-import type { UserContext } from '../../walk';
-import type {
-  Oas2Definition,
-  Oas2Operation,
-  Oas2PathItem,
-  Oas2SecurityScheme,
-} from '../../typings/swagger';
-import type {
-  Oas3Definition,
-  Oas3_1Definition,
-  Oas3Operation,
-  Oas3PathItem,
-  Oas3SecurityScheme,
-} from '../../typings/openapi';
-
-export const SecurityDefined: Oas3Rule | Oas2Rule = (opts: {
-  exceptions?: { path: string; methods?: string[] }[];
-}) => {
-  const referencedSchemes = new Map<
-    string,
-    {
-      defined?: boolean;
-      from: Location[];
-    }
-  >();
-
-  const operationsWithoutSecurity: Location[] = [];
-  let eachOperationHasSecurity: boolean = true;
-  let path: string | undefined;
-
-  return {
-    Root: {
-      leave(root: Oas2Definition | Oas3Definition | Oas3_1Definition, { 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(),
-            });
-          }
-        }
-
-        if (root.security || eachOperationHasSecurity) {
-          return;
-        } else {
-          for (const operationLocation of operationsWithoutSecurity) {
-            report({
-              message: `Every operation should have security defined on it or on the root level.`,
-              location: operationLocation.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);
-        }
-      }
-    },
-    PathItem: {
-      enter(pathItem: Oas2PathItem | Oas3PathItem, { key }: UserContext) {
-        path = key as string;
-      },
-      Operation(operation: Oas2Operation | Oas3Operation, { location, key }: UserContext) {
-        const isException = opts.exceptions?.some(
-          (item) =>
-            item.path === path &&
-            (!item.methods || item.methods?.some((method) => method.toLowerCase() === key))
-        );
-        if (!operation?.security && !isException) {
-          eachOperationHasSecurity = false;
-          operationsWithoutSecurity.push(location);
-        }
-      },
-    },
-  };
-};

package/src/rules/common/spec-strict-refs.ts

@@ -1,31 +0,0 @@
-import { isRef } from '../../ref-utils';
-
-import type { Oas2Rule, Oas3Rule } from '../../visitors';
-
-export const SpecStrictRefs: Oas3Rule | Oas2Rule = () => {
-  const nodesToSkip = [
-    'Schema',
-    'Response',
-    'Parameter',
-    'RequestBody',
-    'Example',
-    'Header',
-    'SecurityScheme',
-    'Link',
-    'Callback',
-    'PathItem',
-  ];
-
-  return {
-    any(_node, { report, rawNode, rawLocation, type }) {
-      const shouldCheck = !nodesToSkip.includes(type.name);
-
-      if (shouldCheck && isRef(rawNode)) {
-        report({
-          message: 'Field $ref is not expected here.',
-          location: rawLocation.child('$ref').key(),
-        });
-      }
-    },
-  };
-};

package/src/rules/common/struct.ts

@@ -1,189 +0,0 @@
-import { isNamedType, SpecExtension } from '../../types';
-import { oasTypeOf, matchesJsonSchemaType, getSuggest, validateSchemaEnumType } from '../utils';
-import { isRef } from '../../ref-utils';
-import { isPlainObject } from '../../utils';
-
-import type { UserContext } from '../../walk';
-import type {
-  Oas3Rule,
-  Oas2Rule,
-  Async2Rule,
-  Async3Rule,
-  Arazzo1Rule,
-  Overlay1Rule,
-} from '../../visitors';
-
-export const Struct:
-  | Oas3Rule
-  | Oas2Rule
-  | Async2Rule
-  | Async3Rule
-  | Arazzo1Rule
-  | Overlay1Rule = () => {
-  return {
-    any(
-      node: any,
-      { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }
-    ) {
-      const nodeType = oasTypeOf(node);
-      const refLocation = rawLocation !== location ? rawLocation : undefined;
-
-      if (type.items) {
-        if (nodeType !== 'array') {
-          report({
-            message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
-            from: refLocation,
-          });
-          ignoreNextVisitorsOnNode();
-        }
-        return;
-      } else if (nodeType !== 'object') {
-        if (type !== SpecExtension) {
-          // do not validate unknown extensions structure
-          report({
-            message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
-            from: refLocation,
-          });
-        }
-        ignoreNextVisitorsOnNode();
-        return;
-      }
-
-      const required =
-        typeof type.required === 'function' ? type.required(node, key) : type.required;
-
-      for (const propName of required || []) {
-        if (!(node as object).hasOwnProperty(propName)) {
-          report({
-            message: `The field \`${propName}\` must be present on this level.`,
-            from: refLocation,
-            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.`,
-            from: refLocation,
-            location: location.child([propName]).key(),
-          });
-        }
-      }
-
-      const requiredOneOf = type.requiredOneOf || null;
-      if (requiredOneOf) {
-        let hasProperty = false;
-        for (const 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(
-              ', '
-            )}.`,
-            from: refLocation,
-            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)),
-            from: refLocation,
-            location: propLocation.key(),
-          });
-          continue;
-        }
-
-        if (propSchema === null) {
-          continue; // just defined, no validation
-        }
-
-        if (propSchema.resolvable !== false && isRef(propValue)) {
-          propValue = resolve(propValue).node;
-        }
-
-        if (propSchema.items && propSchema.items?.enum && Array.isArray(propValue)) {
-          for (let i = 0; i < propValue.length; i++) {
-            validateSchemaEnumType(propSchema.items?.enum, propValue[i], propName, refLocation, {
-              report,
-              location: location.child([propName, i]),
-            } as UserContext);
-          }
-        }
-
-        if (propSchema.enum) {
-          validateSchemaEnumType(propSchema.enum, propValue, propName, refLocation, {
-            report,
-            location: location.child([propName]),
-          } as UserContext);
-        } else if (propSchema.type && !matchesJsonSchemaType(propValue, propSchema.type, false)) {
-          report({
-            message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
-            from: refLocation,
-            location: propLocation,
-          });
-          ignoreNextVisitorsOnNode();
-        } 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)}\`.`,
-                from: refLocation,
-                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}`,
-              from: refLocation,
-              location: location.child([propName]),
-            });
-          }
-        }
-
-        if (propName === 'nullable' && !node.type) {
-          report({
-            message: 'The `type` field must be defined when the `nullable` field is used.',
-            location: location.child([propName]),
-          });
-        }
-      }
-    },
-  };
-};

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

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

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

@@ -1,27 +0,0 @@
-import type { Oas3Rule, Oas2Rule } from '../../visitors';
-import type { Oas2Definition, Oas2Tag } from '../../typings/swagger';
-import type { Oas3Definition, Oas3Tag, Oas3_1Definition } from '../../typings/openapi';
-import type { UserContext } from '../../walk';
-
-export const TagsAlphabetical: Oas3Rule | Oas2Rule = ({ ignoreCase = false }) => {
-  return {
-    Root(
-      root: Oas2Definition | Oas3Definition | Oas3_1Definition,
-      { report, location }: UserContext
-    ) {
-      if (!root.tags) return;
-      for (let i = 0; i < root.tags.length - 1; i++) {
-        if (getTagName(root.tags[i], ignoreCase) > getTagName(root.tags[i + 1], ignoreCase)) {
-          report({
-            message: 'The `tags` array should be in alphabetical order.',
-            location: location.child(['tags', i]),
-          });
-        }
-      }
-    },
-  };
-};
-
-function getTagName(tag: Oas2Tag | Oas3Tag, ignoreCase: boolean): string {
-  return ignoreCase ? tag.name.toLowerCase() : tag.name;
-}

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

@@ -1,52 +0,0 @@
-import { YamlParseError } from '../resolve';
-
-import type { Oas3Rule } from '../visitors';
-import type { ResolveResult, Problem } from '../walk';
-import type { 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,112 +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({ rules: { 'boolean-parameter-prefixes': 'error' } }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "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": [],
-        },
-      ]
-    `);
-  });
-
-  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({ rules: { 'boolean-parameter-prefixes': 'error' } }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-
-  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({
-        rules: {
-          'boolean-parameter-prefixes': {
-            severity: 'error',
-            prefixes: ['should'],
-          },
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-});