@redocly/openapi-core 1.0.0-beta.125 → 1.0.0-beta.127

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

@@ -1,74 +0,0 @@
-import { Oas3Rule } from '../../visitors';
-import { Problem, UserContext } from '../../walk';
-import { 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');
-      },
-    },
-    ExampleMap: {
-      Example(_node, { key, report, location }: UserContext) {
-        validateKey(key, report, location, 'examples');
-      },
-    },
-  };
-};

package/src/rules/other/stats.ts

@@ -1,73 +0,0 @@
-import { Oas3Parameter, OasRef, Oas3Tag } from '../../typings/openapi';
-import { Oas2Parameter } from '../../typings/swagger';
-import { 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) {
-          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/utils.ts

@@ -1,191 +0,0 @@
-import levenshtein = require('js-levenshtein');
-import { UserContext } from '../walk';
-import { Location } from '../ref-utils';
-import { validateJsonSchema } from './ajv';
-import { Oas3Schema, Referenced } from '../typings/openapi';
-import { showErrorForDeprecatedField, showWarningForDeprecatedField } from '../utils';
-
-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 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 (typeof value !== 'object') {
-    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 getSuggest(given: string, variants: string[]): string[] {
-  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>,
-  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 === null ? 'null' : 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 },
-    });
-  }
-}

package/src/types/index.ts

@@ -1,149 +0,0 @@
-export type ScalarSchema = {
-  name?: never;
-  type?: 'string' | 'boolean' | 'number' | 'integer' | 'object' | 'array';
-  items?: ScalarSchema;
-  enum?: string[];
-  isExample?: boolean;
-  directResolveAs?: string;
-  minimum?: number;
-};
-
-export type NormalizedScalarSchema = {
-  name?: never;
-  type?: 'string' | 'boolean' | 'number' | 'integer' | 'object' | 'array';
-  items?: ScalarSchema;
-  enum?: string[];
-  directResolveAs?: NormalizedNodeType;
-  resolvable: boolean;
-  minimum?: number;
-};
-
-export type NodeType = {
-  properties: Record<string, PropType | ResolveTypeFn>;
-  additionalProperties?: PropType | ResolveTypeFn;
-  items?: string;
-  required?: string[] | ((value: any, key: string | number | undefined) => string[]);
-  requiredOneOf?: string[];
-  allowed?: (value: any) => string[] | undefined;
-  extensionsPrefix?: string;
-};
-type PropType = string | NodeType | ScalarSchema | undefined | null;
-type ResolveTypeFn = (value: any, key: string) => string | PropType;
-
-export type NormalizedNodeType = {
-  name: string;
-  properties: Record<string, NormalizedPropType | NormalizedResolveTypeFn>;
-  additionalProperties?: NormalizedPropType | NormalizedResolveTypeFn;
-  items?: NormalizedNodeType;
-  required?: string[] | ((value: any, key: string | number | undefined) => string[]);
-  requiredOneOf?: string[];
-  allowed?: (value: any) => string[] | undefined;
-  extensionsPrefix?: string;
-};
-
-type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | undefined | null;
-type NormalizedResolveTypeFn = (
-  value: any,
-  key: string
-) => NormalizedNodeType | NormalizedScalarSchema | undefined | null;
-
-export function listOf(typeName: string) {
-  return {
-    name: `${typeName}List`,
-    properties: {},
-    items: typeName,
-  };
-}
-
-export function mapOf(typeName: string) {
-  return {
-    name: `${typeName}Map`,
-    properties: {},
-    additionalProperties: () => typeName,
-  };
-}
-
-export const SpecExtension: NormalizedNodeType = {
-  name: 'SpecExtension',
-  properties: {},
-  // skip validation of additional properties for unknown extensions
-  additionalProperties: { resolvable: true },
-};
-
-export function normalizeTypes(
-  types: Record<string, NodeType>,
-  options: { doNotResolveExamples?: boolean } = {}
-): Record<string, NormalizedNodeType> {
-  const normalizedTypes: Record<string, NormalizedNodeType> = {};
-
-  for (const typeName of Object.keys(types)) {
-    normalizedTypes[typeName] = {
-      ...types[typeName],
-      name: typeName,
-    } as NormalizedNodeType;
-  }
-
-  for (const type of Object.values(normalizedTypes)) {
-    normalizeType(type);
-  }
-
-  // all type trees have a SpecExtension type by default
-  normalizedTypes['SpecExtension'] = SpecExtension;
-
-  return normalizedTypes;
-
-  function normalizeType(type: NormalizedNodeType) {
-    if (type.additionalProperties) {
-      type.additionalProperties = resolveType(type.additionalProperties);
-    }
-    if (type.items) {
-      type.items = resolveType(type.items);
-    }
-
-    if (type.properties) {
-      const mappedProps: Record<string, any> = {};
-      for (const [propName, prop] of Object.entries(type.properties)) {
-        mappedProps[propName] = resolveType(prop);
-
-        if (options.doNotResolveExamples && prop && (prop as ScalarSchema).isExample) {
-          mappedProps[propName] = {
-            ...(prop as object),
-            resolvable: false,
-          };
-        }
-      }
-      type.properties = mappedProps;
-    }
-  }
-
-  // typings are painful here...
-  function resolveType(type?: any): any {
-    if (typeof type === 'string') {
-      if (!normalizedTypes[type]) {
-        throw new Error(`Unknown type name found: ${type}`);
-      }
-      return normalizedTypes[type];
-    } else if (typeof type === 'function') {
-      return (value: any, key: string) => {
-        return resolveType(type(value, key));
-      };
-    } else if (type && type.name) {
-      type = { ...type };
-      normalizeType(type);
-      return type;
-    } else if (type && type.directResolveAs) {
-      return {
-        ...type,
-        directResolveAs: resolveType(type.directResolveAs),
-      };
-    } else {
-      return type;
-    }
-  }
-}
-
-export function isNamedType(
-  t: NormalizedNodeType | NormalizedScalarSchema | null | undefined
-): t is NormalizedNodeType {
-  return typeof t?.name === 'string';
-}