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

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

@@ -1,31 +0,0 @@
-import { validateMimeTypeOAS3 } from '../../utils';
-
-import type { Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const RequestMimeType: Oas3Rule = ({ allowedValues }) => {
-  return {
-    Paths: {
-      RequestBody: {
-        leave(requestBody, ctx: UserContext) {
-          validateMimeTypeOAS3({ type: 'consumes', value: requestBody }, ctx, allowedValues);
-        },
-      },
-      Callback: {
-        RequestBody() {},
-        Response: {
-          leave(response, ctx: UserContext) {
-            validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
-          },
-        },
-      },
-    },
-    WebhooksMap: {
-      Response: {
-        leave(response, ctx: UserContext) {
-          validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
-        },
-      },
-    },
-  };
-};

package/src/rules/oas3/response-contains-property.ts

@@ -1,39 +0,0 @@
-import { getMatchingStatusCodeRange } from '../../utils';
-
-import type { Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const ResponseContainsProperty: Oas3Rule = (options) => {
-  const names: Record<string, string[]> = options.names || {};
-  let key: string | number;
-  return {
-    Operation: {
-      Response: {
-        skip: (_response, key) => {
-          return `${key}` === '204';
-        },
-        enter: (_response, ctx: UserContext) => {
-          key = ctx.key;
-        },
-        MediaType: {
-          Schema(schema, { report, location }) {
-            if (schema.type !== 'object') return;
-            const expectedProperties =
-              names[key] ||
-              names[getMatchingStatusCodeRange(key)] ||
-              names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-              [];
-            for (const expectedProperty of expectedProperties) {
-              if (!schema.properties?.[expectedProperty]) {
-                report({
-                  message: `Response object must contain a top-level "${expectedProperty}" property.`,
-                  location: location.child('properties').key(),
-                });
-              }
-            }
-          },
-        },
-      },
-    },
-  };
-};

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

@@ -1,31 +0,0 @@
-import { validateMimeTypeOAS3 } from '../../utils';
-
-import type { Oas3Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const ResponseMimeType: Oas3Rule = ({ allowedValues }) => {
-  return {
-    Paths: {
-      Response: {
-        leave(response, ctx: UserContext) {
-          validateMimeTypeOAS3({ type: 'produces', value: response }, ctx, allowedValues);
-        },
-      },
-      Callback: {
-        Response() {},
-        RequestBody: {
-          leave(requestBody, ctx: UserContext) {
-            validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
-          },
-        },
-      },
-    },
-    WebhooksMap: {
-      RequestBody: {
-        leave(requestBody, ctx: UserContext) {
-          validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
-        },
-      },
-    },
-  };
-};

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

@@ -1,69 +0,0 @@
-import type { Oas3Rule } from '../../visitors';
-import type { Problem, UserContext } from '../../walk';
-import type { 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 {
-    NamedSchemas: {
-      Schema(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'schemas');
-      },
-    },
-    NamedParameters: {
-      Parameter(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'parameters');
-      },
-    },
-    NamedResponses: {
-      Response(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'responses');
-      },
-    },
-    NamedExamples: {
-      Example(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'examples');
-      },
-    },
-    NamedRequestBodies: {
-      RequestBody(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'requestBodies');
-      },
-    },
-    NamedHeaders: {
-      Header(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'headers');
-      },
-    },
-    NamedSecuritySchemes: {
-      SecurityScheme(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'securitySchemes');
-      },
-    },
-    NamedLinks: {
-      Link(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'links');
-      },
-    },
-    NamedCallbacks: {
-      Callback(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'callbacks');
-      },
-    },
-  };
-};

package/src/rules/other/stats.ts

@@ -1,75 +0,0 @@
-import type { Oas3Parameter, OasRef, Oas3Tag } from '../../typings/openapi';
-import type { Oas2Parameter } from '../../typings/swagger';
-import type { StatsAccumulator } from '../../typings/common';
-
-export const Stats = (statsAccumulator: StatsAccumulator) => {
-  return {
-    ExternalDocs: {
-      leave() {
-        statsAccumulator.externalDocs.total++;
-      },
-    },
-    ref: {
-      enter(ref: OasRef) {
-        statsAccumulator.refs.items!.add(ref['$ref']);
-      },
-    },
-    Tag: {
-      leave(tag: Oas3Tag) {
-        statsAccumulator.tags.items!.add(tag.name);
-      },
-    },
-    Link: {
-      leave(link: any) {
-        statsAccumulator.links.items!.add(link.operationId);
-      },
-    },
-    Root: {
-      leave() {
-        statsAccumulator.parameters.total = statsAccumulator.parameters.items!.size;
-        statsAccumulator.refs.total = statsAccumulator.refs.items!.size;
-        statsAccumulator.links.total = statsAccumulator.links.items!.size;
-        statsAccumulator.tags.total = statsAccumulator.tags.items!.size;
-      },
-    },
-    WebhooksMap: {
-      Operation: {
-        leave(operation: any) {
-          statsAccumulator.webhooks.total++;
-          operation.tags &&
-            operation.tags.forEach((tag: string) => {
-              statsAccumulator.tags.items!.add(tag);
-            });
-        },
-      },
-    },
-    Paths: {
-      PathItem: {
-        leave() {
-          statsAccumulator.pathItems.total++;
-        },
-        Operation: {
-          leave(operation: any) {
-            statsAccumulator.operations.total++;
-            operation.tags &&
-              operation.tags.forEach((tag: string) => {
-                statsAccumulator.tags.items!.add(tag);
-              });
-          },
-        },
-        Parameter: {
-          leave(parameter: Oas2Parameter | Oas3Parameter) {
-            statsAccumulator.parameters.items!.add(parameter.name);
-          },
-        },
-      },
-    },
-    NamedSchemas: {
-      Schema: {
-        leave() {
-          statsAccumulator.schemas.total++;
-        },
-      },
-    },
-  };
-};

package/src/rules/overlay1/__tests__/info-contact.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('Overlay 1.0 Description', () => {
-  it('should not report if the Contact Object is valid', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        overlay: 1.0.0
-        info:
-          title: Example Overlay 1 definition. Valid.
-          version: '1.0'
-          contact:
-            name: API Support
-            url: http://www.example.com/support
-            email: support@example.com
-        extends: 'openapi.yaml'
-        actions: []
-            `,
-      'overlay.yaml'
-    );
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'info-contact': { severity: 'error' },
-        },
-      }),
-    });
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('should report if the Contact Object is not defined', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        overlay: 1.0.0
-        info:
-          title: Example Overlay 1 definition. Invalid.
-          version: '1.0'
-        extends: 'openapi.yaml'
-        actions: []
-            `,
-      'overlay.yaml'
-    );
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'info-contact': { severity: 'error' },
-        },
-      }),
-    });
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/info/contact",
-              "reportOnKey": true,
-              "source": "overlay.yaml",
-            },
-          ],
-          "message": "Info object should contain \`contact\` field.",
-          "ruleId": "info-contact",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-  it('should report if the Overlay Document is invalid', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        overlay: 1.0.0
-        info:
-          title: Example Overlay 1 definition. Invalid.
-          version: '1.0'
-            `,
-      'overlay.yaml'
-    );
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          struct: { severity: 'error' },
-        },
-      }),
-    });
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "from": undefined,
-          "location": [
-            {
-              "pointer": "#/",
-              "reportOnKey": true,
-              "source": "overlay.yaml",
-            },
-          ],
-          "message": "The field \`actions\` must be present on this level.",
-          "ruleId": "struct",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-});

package/src/rules/overlay1/index.ts

@@ -1,14 +0,0 @@
-import { Assertions } from '../common/assertions';
-import { InfoContact } from '../common/info-contact';
-import { Struct } from '../common/struct';
-
-import type { Overlay1RuleSet } from '../../oas-types';
-import type { Overlay1Rule } from '../../visitors';
-
-export const rules: Overlay1RuleSet<'built-in'> = {
-  'info-contact': InfoContact as Overlay1Rule,
-  struct: Struct as Overlay1Rule,
-  assertions: Assertions as Overlay1Rule,
-};
-
-export const preprocessors = {};

package/src/rules/respect/no-criteria-xpath.ts

@@ -1,20 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const NoCriteriaXpath: Arazzo1Rule = () => {
-  return {
-    CriterionObject: {
-      enter(criteria, { report, location }: UserContext) {
-        if (!criteria.type) {
-          return;
-        }
-        if (criteria?.type?.type === 'xpath' || criteria?.type === 'xpath') {
-          report({
-            message: 'The `xpath` type criteria is not supported by Respect.',
-            location: location.child(['type']),
-          });
-        }
-      },
-    },
-  };
-};

package/src/rules/respect/respect-supported-versions.ts

@@ -1,24 +0,0 @@
-import { ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT } from '../../typings/arazzo';
-import { pluralize } from '../../utils';
-
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const RespectSupportedVersions: Arazzo1Rule = () => {
-  const supportedVersions = ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.join(', ');
-  return {
-    Root: {
-      enter(root, { report, location }: UserContext) {
-        if (!ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.includes(root.arazzo)) {
-          report({
-            message: `Only ${supportedVersions} Arazzo ${pluralize(
-              'version is',
-              ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.length
-            )} fully supported by Respect.`,
-            location: location.child('arazzo'),
-          });
-        }
-      },
-    },
-  };
-};

package/src/rules/utils.ts

@@ -1,230 +0,0 @@
-import levenshtein = require('js-levenshtein');
-import { Location } from '../ref-utils';
-import { validateJsonSchema } from './ajv';
-import {
-  isPlainObject,
-  showErrorForDeprecatedField,
-  showWarningForDeprecatedField,
-} from '../utils';
-
-import type { Oas3Schema, Oas3_1Schema, Referenced } from '../typings/openapi';
-import type { UserContext } from '../walk';
-
-export function oasTypeOf(value: unknown) {
-  if (Array.isArray(value)) {
-    return 'array';
-  } else if (value === null) {
-    return 'null';
-  } else if (Number.isInteger(value)) {
-    return 'integer';
-  } else {
-    return typeof value;
-  }
-}
-
-/**
- * Checks if value matches specified JSON schema type
- *
- * @param {*} value - value to check
- * @param {JSONSchemaType} type - JSON Schema type
- * @returns boolean
- */
-export function matchesJsonSchemaType(value: unknown, type: string, nullable: boolean): boolean {
-  if (nullable && value === null) {
-    return true;
-  }
-
-  switch (type) {
-    case 'array':
-      return Array.isArray(value);
-    case 'object':
-      return typeof value === 'object' && value !== null && !Array.isArray(value);
-    case 'null':
-      return value === null;
-    case 'integer':
-      return Number.isInteger(value);
-    default:
-      return typeof value === type;
-  }
-}
-
-export function missingRequiredField(type: string, field: string): string {
-  return `${type} object should contain \`${field}\` field.`;
-}
-
-export function missingRequiredOneOfFields(type: string, fields: string[]): string {
-  return `${type} object should contain one of the fields: ${fields
-    .map((field) => `\`${field}\``)
-    .join(', ')}.`;
-}
-
-export function fieldNonEmpty(type: string, field: string): string {
-  return `${type} object \`${field}\` must be non-empty string.`;
-}
-
-export function validateDefinedAndNonEmpty(fieldName: string, value: any, ctx: UserContext) {
-  if (!isPlainObject(value)) {
-    return;
-  }
-
-  if (value[fieldName] === undefined) {
-    ctx.report({
-      message: missingRequiredField(ctx.type.name, fieldName),
-      location: ctx.location.child([fieldName]).key(),
-    });
-  } else if (!value[fieldName]) {
-    ctx.report({
-      message: fieldNonEmpty(ctx.type.name, fieldName),
-      location: ctx.location.child([fieldName]).key(),
-    });
-  }
-}
-
-export function validateOneOfDefinedAndNonEmpty(
-  fieldNames: string[],
-  value: any,
-  ctx: UserContext
-) {
-  if (!isPlainObject(value)) {
-    return;
-  }
-
-  if (!fieldNames.some((fieldName) => value.hasOwnProperty(fieldName))) {
-    ctx.report({
-      message: missingRequiredOneOfFields(ctx.type.name, fieldNames),
-      location: ctx.location.key(),
-    });
-  }
-
-  for (const fieldName of fieldNames) {
-    if (value.hasOwnProperty(fieldName) && !value[fieldName]) {
-      ctx.report({
-        message: fieldNonEmpty(ctx.type.name, fieldName),
-        location: ctx.location.child([fieldName]).key(),
-      });
-    }
-  }
-}
-
-export function getSuggest(given: string, variants: string[]): string[] {
-  if (given === null) return variants;
-
-  if (typeof given !== 'string' || !variants.length) return [];
-
-  const distances: Array<{ variant: string; distance: number }> = [];
-
-  for (let i = 0; i < variants.length; i++) {
-    const distance = levenshtein(given, variants[i]);
-    if (distance < 4) {
-      distances.push({ distance, variant: variants[i] });
-    }
-  }
-
-  distances.sort((a, b) => a.distance - b.distance);
-
-  // if (bestMatch.distance <= 4) return bestMatch.string;
-  return distances.map((d) => d.variant);
-}
-
-export function validateExample(
-  example: any,
-  schema: Referenced<Oas3Schema | Oas3_1Schema>,
-  dataLoc: Location,
-  { resolve, location, report }: UserContext,
-  allowAdditionalProperties: boolean
-) {
-  try {
-    const { valid, errors } = validateJsonSchema(
-      example,
-      schema,
-      location.child('schema'),
-      dataLoc.pointer,
-      resolve,
-      allowAdditionalProperties
-    );
-    if (!valid) {
-      for (const error of errors) {
-        report({
-          message: `Example value must conform to the schema: ${error.message}.`,
-          location: {
-            ...new Location(dataLoc.source, error.instancePath),
-            reportOnKey:
-              error.keyword === 'unevaluatedProperties' || error.keyword === 'additionalProperties',
-          },
-          from: location,
-          suggest: error.suggest,
-        });
-      }
-    }
-  } catch (e) {
-    if (e.message === 'discriminator: requires oneOf or anyOf composite keyword') {
-      return;
-    }
-
-    report({
-      message: `Example validation errored: ${e.message}.`,
-      location: location.child('schema'),
-      from: location,
-    });
-  }
-}
-
-export function getAdditionalPropertiesOption(opts: Record<string, any>): boolean {
-  if (opts.disallowAdditionalProperties === undefined) {
-    return opts.allowAdditionalProperties;
-  }
-
-  if (opts.allowAdditionalProperties !== undefined) {
-    showErrorForDeprecatedField(
-      'disallowAdditionalProperties',
-      'allowAdditionalProperties',
-      undefined
-    );
-  }
-
-  showWarningForDeprecatedField('disallowAdditionalProperties', 'allowAdditionalProperties');
-  return !opts.disallowAdditionalProperties;
-}
-
-export function validateSchemaEnumType(
-  schemaEnum: string[],
-  propertyValue: string,
-  propName: string,
-  refLocation: Location | undefined,
-  { report, location }: UserContext
-) {
-  if (!schemaEnum) {
-    return;
-  }
-  if (!schemaEnum.includes(propertyValue)) {
-    report({
-      location,
-      message: `\`${propName}\` can be one of the following only: ${schemaEnum
-        .map((type) => `"${type}"`)
-        .join(', ')}.`,
-      from: refLocation,
-      suggest: getSuggest(propertyValue, schemaEnum),
-    });
-  }
-}
-
-export function validateResponseCodes(
-  responseCodes: string[],
-  codeRange: string,
-  { report }: UserContext
-) {
-  const responseCodeRegexp = new RegExp(`^${codeRange[0]}[0-9Xx]{2}$`);
-
-  const containsNeededCode = responseCodes.some(
-    (code) =>
-      (codeRange === '2XX' && code === 'default') || // It's OK to replace 2xx codes with the default
-      responseCodeRegexp.test(code)
-  );
-
-  if (!containsNeededCode) {
-    report({
-      message: `Operation must have at least one \`${codeRange}\` response.`,
-      location: { reportOnKey: true },
-    });
-  }
-}