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

package/src/types/json-schema-adapter.ts

@@ -1,217 +0,0 @@
-// For internal usage only
-
-import Ajv from '@redocly/ajv/dist/2020';
-import { isPlainObject } from '../utils';
-
-import type { JSONSchema } from 'json-schema-to-ts';
-import type { NodeType, PropType, ResolveTypeFn } from '.';
-import type { Oas3Schema } from '../typings/openapi';
-
-const ajv = new Ajv({
-  strictSchema: false,
-  allowUnionTypes: true,
-  useDefaults: true,
-  allErrors: true,
-  discriminator: true,
-  strictTypes: false,
-  verbose: true,
-});
-
-function findOneOf(schemaOneOf: JSONSchema[], oneOfs: (PropType | ResolveTypeFn)[]): ResolveTypeFn {
-  if (oneOfs.some((option) => typeof option === 'function')) {
-    throw new Error('Unexpected oneOf inside oneOf.');
-  }
-
-  return (value: unknown) => {
-    let index = schemaOneOf.findIndex((option) => ajv.validate(option, value));
-    if (index === -1) {
-      index = 0;
-    }
-    return oneOfs[index] as PropType;
-  };
-}
-
-function transformJSONSchemaToNodeType(
-  propertyName: string,
-  schema: JSONSchema,
-  ctx: Record<string, NodeType>
-): PropType | ResolveTypeFn {
-  if (!schema || typeof schema === 'boolean') {
-    throw new Error(`Unexpected schema in ${propertyName}.`);
-  }
-
-  if (schema instanceof Array) {
-    throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
-  }
-
-  if (schema.type === 'null') {
-    throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
-  }
-
-  if (schema.type instanceof Array) {
-    throw new Error(
-      `Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`
-    );
-  }
-
-  if (
-    schema.type === 'string' ||
-    schema.type === 'number' ||
-    schema.type === 'integer' ||
-    schema.type === 'boolean'
-  ) {
-    const { default: _, format: _format, ...rest } = schema;
-    return rest as PropType;
-  }
-
-  if (schema.type === 'object' && !schema.properties && !schema.oneOf) {
-    if (schema.additionalProperties === undefined || schema.additionalProperties === true) {
-      return { type: 'object' };
-    } else if (schema.additionalProperties === false) {
-      return { type: 'object', properties: {} };
-    }
-  }
-
-  if (schema.allOf) {
-    throw new Error(`Unexpected allOf in ${propertyName}.`);
-  }
-
-  if (schema.anyOf) {
-    throw new Error(`Unexpected anyOf in ${propertyName}.`);
-  }
-
-  if (
-    isPlainObject(schema.properties) ||
-    isPlainObject(schema.additionalProperties) ||
-    (isPlainObject(schema.items) &&
-      (isPlainObject(schema.items.properties) ||
-        isPlainObject(schema.items.additionalProperties) ||
-        schema.items.oneOf)) // exclude scalar array types
-  ) {
-    return extractNodeToContext(propertyName, schema, ctx);
-  }
-
-  if (schema.oneOf) {
-    if ((schema as Oas3Schema).discriminator) {
-      const discriminatedPropertyName = (schema as Oas3Schema).discriminator?.propertyName;
-      if (!discriminatedPropertyName) {
-        throw new Error(`Unexpected discriminator without a propertyName in ${propertyName}.`);
-      }
-      const oneOfs = schema.oneOf.map((option, i) => {
-        if (typeof option === 'boolean') {
-          throw new Error(
-            `Unexpected boolean schema in ${propertyName} at position ${i} in oneOf.`
-          );
-        }
-        const discriminatedProperty = option?.properties?.[discriminatedPropertyName];
-        if (!discriminatedProperty || typeof discriminatedProperty === 'boolean') {
-          throw new Error(
-            `Unexpected property '${discriminatedProperty}' schema in ${propertyName} at position ${i} in oneOf.`
-          );
-        }
-        const name = discriminatedProperty.const as string;
-        return transformJSONSchemaToNodeType(name, option, ctx);
-      });
-
-      return (value: unknown, key: string) => {
-        if (isPlainObject(value)) {
-          const discriminatedTypeName = value[discriminatedPropertyName];
-          if (typeof discriminatedTypeName === 'string' && ctx[discriminatedTypeName]) {
-            return discriminatedTypeName;
-          }
-        }
-        return findOneOf(schema.oneOf as JSONSchema[], oneOfs)(value, key);
-      };
-    } else {
-      const oneOfs = schema.oneOf.map((option, i) =>
-        transformJSONSchemaToNodeType(propertyName + '_' + i, option, ctx)
-      );
-      return findOneOf(schema.oneOf as JSONSchema[], oneOfs);
-    }
-  }
-
-  return schema as PropType;
-}
-
-function extractNodeToContext(
-  propertyName: string,
-  schema: JSONSchema,
-  ctx: Record<string, NodeType>
-): string {
-  if (!schema || typeof schema === 'boolean') {
-    throw new Error(`Unexpected schema in ${propertyName}.`);
-  }
-
-  if (schema instanceof Array) {
-    throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
-  }
-
-  if (schema.type === 'null') {
-    throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
-  }
-
-  if (schema.type instanceof Array) {
-    throw new Error(
-      `Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`
-    );
-  }
-
-  const properties: Record<string, PropType | ResolveTypeFn> = {};
-  for (const [name, property] of Object.entries(schema.properties || {})) {
-    properties[name] = transformJSONSchemaToNodeType(propertyName + '.' + name, property, ctx);
-  }
-
-  let additionalProperties;
-  if (isPlainObject(schema.additionalProperties)) {
-    additionalProperties = transformJSONSchemaToNodeType(
-      propertyName + '_additionalProperties',
-      schema.additionalProperties,
-      ctx
-    );
-  }
-  if (schema.additionalProperties === true) {
-    additionalProperties = {};
-  }
-
-  let items;
-  if (
-    isPlainObject(schema.items) &&
-    (isPlainObject(schema.items.properties) ||
-      isPlainObject(schema.items.additionalProperties) ||
-      schema.items.oneOf) // exclude scalar array types
-  ) {
-    items = transformJSONSchemaToNodeType(propertyName + '_items', schema.items, ctx);
-  }
-
-  let required = schema.required as NodeType['required'];
-  // Translate required in oneOfs into a ResolveTypeFn.
-  if (schema.oneOf && schema.oneOf.every((option) => !!(option as Oas3Schema).required)) {
-    required = (value): string[] => {
-      const requiredList: string[][] = schema.oneOf!.map((option) => [
-        ...(schema.required || []),
-        ...(option as Oas3Schema).required!,
-      ]);
-
-      let index = requiredList.findIndex((r) =>
-        r.every((requiredProp) => value[requiredProp] !== undefined)
-      );
-      if (index === -1) {
-        index = 0;
-      }
-
-      return requiredList[index];
-    };
-  }
-
-  ctx[propertyName] = { properties, additionalProperties, items, required };
-  return propertyName;
-}
-
-export function getNodeTypesFromJSONSchema(
-  schemaName: string,
-  entrySchema: JSONSchema
-): Record<string, NodeType> {
-  const ctx: Record<string, NodeType> = {};
-  transformJSONSchemaToNodeType(schemaName, entrySchema, ctx);
-  return ctx;
-}

package/src/types/oas2.ts

@@ -1,481 +0,0 @@
-import { listOf, mapOf } from '.';
-
-import type { NodeType } from '.';
-import type { Oas2NodeType } from './redocly-yaml';
-
-const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
-
-const Root: NodeType = {
-  properties: {
-    swagger: { type: 'string' },
-    info: 'Info',
-    host: { type: 'string' },
-    basePath: { type: 'string' },
-    schemes: { type: 'array', items: { type: 'string' } },
-    consumes: { type: 'array', items: { type: 'string' } },
-    produces: { type: 'array', items: { type: 'string' } },
-    paths: 'Paths',
-    definitions: 'NamedSchemas',
-    parameters: 'NamedParameters',
-    responses: 'NamedResponses',
-    securityDefinitions: 'NamedSecuritySchemes',
-    security: 'SecurityRequirementList',
-    tags: 'TagList',
-    externalDocs: 'ExternalDocs',
-    'x-servers': 'XServerList',
-    'x-tagGroups': 'TagGroups',
-    'x-ignoredHeaderParameters': { type: 'array', items: { type: 'string' } },
-  },
-  required: ['swagger', 'paths', 'info'],
-  extensionsPrefix: 'x-',
-};
-
-const Info: NodeType = {
-  properties: {
-    title: { type: 'string' },
-    description: { type: 'string' },
-    termsOfService: { type: 'string' },
-    contact: 'Contact',
-    license: 'License',
-    version: { type: 'string' },
-    'x-logo': 'Logo',
-  },
-  required: ['title', 'version'],
-  extensionsPrefix: 'x-',
-};
-
-const Logo: NodeType = {
-  properties: {
-    url: { type: 'string' },
-    altText: { type: 'string' },
-    backgroundColor: { type: 'string' },
-    href: { type: 'string' },
-  },
-  extensionsPrefix: 'x-',
-};
-
-const Contact: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    url: { type: 'string' },
-    email: { type: 'string' },
-  },
-  extensionsPrefix: 'x-',
-};
-
-const License: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    url: { type: 'string' },
-  },
-  required: ['name'],
-  extensionsPrefix: 'x-',
-};
-
-const Paths: NodeType = {
-  properties: {},
-  additionalProperties: (_value: any, key: string) =>
-    key.startsWith('/') ? 'PathItem' : undefined,
-};
-
-const PathItem: NodeType = {
-  properties: {
-    $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
-    parameters: 'ParameterList',
-
-    get: 'Operation',
-    put: 'Operation',
-    post: 'Operation',
-    delete: 'Operation',
-    options: 'Operation',
-    head: 'Operation',
-    patch: 'Operation',
-  },
-  extensionsPrefix: 'x-',
-};
-
-const Operation: NodeType = {
-  properties: {
-    tags: { type: 'array', items: { type: 'string' } },
-    summary: { type: 'string' },
-    description: { type: 'string' },
-    externalDocs: 'ExternalDocs',
-    operationId: { type: 'string' },
-    consumes: { type: 'array', items: { type: 'string' } },
-    produces: { type: 'array', items: { type: 'string' } },
-    parameters: 'ParameterList',
-    responses: 'Responses',
-    schemes: { type: 'array', items: { type: 'string' } },
-    deprecated: { type: 'boolean' },
-    security: 'SecurityRequirementList',
-    'x-codeSamples': 'XCodeSampleList',
-    'x-code-samples': 'XCodeSampleList', // deprecated
-    'x-hideTryItPanel': { type: 'boolean' },
-  },
-  required: ['responses'],
-  extensionsPrefix: 'x-',
-};
-
-const XCodeSample: NodeType = {
-  properties: {
-    lang: { type: 'string' },
-    label: { type: 'string' },
-    source: { type: 'string' },
-  },
-};
-
-const XServer: NodeType = {
-  properties: {
-    url: { type: 'string' },
-    description: { type: 'string' },
-  },
-  required: ['url'],
-};
-
-const ExternalDocs: NodeType = {
-  properties: {
-    description: { type: 'string' },
-    url: { type: 'string' },
-  },
-  required: ['url'],
-  extensionsPrefix: 'x-',
-};
-
-const Parameter: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    in: { type: 'string', enum: ['query', 'header', 'path', 'formData', 'body'] },
-    description: { type: 'string' },
-    required: { type: 'boolean' },
-    schema: 'Schema',
-    type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array', 'file'] },
-    format: { type: 'string' },
-    allowEmptyValue: { type: 'boolean' },
-    items: 'ParameterItems',
-    collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
-    default: null,
-    maximum: { type: 'integer' },
-    exclusiveMaximum: { type: 'boolean' },
-    minimum: { type: 'integer' },
-    exclusiveMinimum: { type: 'boolean' },
-    maxLength: { type: 'integer' },
-    minLength: { type: 'integer' },
-    pattern: { type: 'string' },
-    maxItems: { type: 'integer' },
-    minItems: { type: 'integer' },
-    uniqueItems: { type: 'boolean' },
-    enum: { type: 'array' },
-    multipleOf: { type: 'number' },
-    'x-example': {}, // any
-    'x-examples': 'ExamplesMap',
-  },
-  required(value) {
-    if (!value || !value.in) {
-      return ['name', 'in'];
-    }
-    if (value.in === 'body') {
-      return ['name', 'in', 'schema'];
-    } else {
-      if (value.type === 'array') {
-        return ['name', 'in', 'type', 'items'];
-      } else {
-        return ['name', 'in', 'type'];
-      }
-    }
-  },
-  extensionsPrefix: 'x-',
-};
-
-const ParameterItems: NodeType = {
-  properties: {
-    type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array'] },
-    format: { type: 'string' },
-    items: 'ParameterItems',
-    collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
-    default: null,
-    maximum: { type: 'integer' },
-    exclusiveMaximum: { type: 'boolean' },
-    minimum: { type: 'integer' },
-    exclusiveMinimum: { type: 'boolean' },
-    maxLength: { type: 'integer' },
-    minLength: { type: 'integer' },
-    pattern: { type: 'string' },
-    maxItems: { type: 'integer' },
-    minItems: { type: 'integer' },
-    uniqueItems: { type: 'boolean' },
-    enum: { type: 'array' },
-    multipleOf: { type: 'number' },
-  },
-  required(value) {
-    if (value && value.type === 'array') {
-      return ['type', 'items'];
-    } else {
-      return ['type'];
-    }
-  },
-  extensionsPrefix: 'x-',
-};
-
-const Responses: NodeType = {
-  properties: {
-    default: 'Response',
-  },
-  additionalProperties: (_v: any, key: string) =>
-    responseCodeRegexp.test(key) ? 'Response' : undefined,
-};
-
-const Response: NodeType = {
-  properties: {
-    description: { type: 'string' },
-    schema: 'Schema',
-    headers: mapOf('Header'),
-    examples: 'Examples',
-    'x-summary': { type: 'string' },
-  },
-  required: ['description'],
-  extensionsPrefix: 'x-',
-};
-
-const Examples: NodeType = {
-  properties: {},
-  additionalProperties: { isExample: true },
-};
-
-const Header: NodeType = {
-  properties: {
-    description: { type: 'string' },
-    type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array'] },
-    format: { type: 'string' },
-    items: 'ParameterItems',
-    collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
-    default: null,
-    maximum: { type: 'integer' },
-    exclusiveMaximum: { type: 'boolean' },
-    minimum: { type: 'integer' },
-    exclusiveMinimum: { type: 'boolean' },
-    maxLength: { type: 'integer' },
-    minLength: { type: 'integer' },
-    pattern: { type: 'string' },
-    maxItems: { type: 'integer' },
-    minItems: { type: 'integer' },
-    uniqueItems: { type: 'boolean' },
-    enum: { type: 'array' },
-    multipleOf: { type: 'number' },
-  },
-  required(value) {
-    if (value && value.type === 'array') {
-      return ['type', 'items'];
-    } else {
-      return ['type'];
-    }
-  },
-  extensionsPrefix: 'x-',
-};
-
-const Tag: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    description: { type: 'string' },
-    externalDocs: 'ExternalDocs',
-    'x-traitTag': { type: 'boolean' },
-    'x-displayName': { type: 'string' },
-  },
-  required: ['name'],
-  extensionsPrefix: 'x-',
-};
-
-const TagGroup: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    tags: { type: 'array', items: { type: 'string' } },
-  },
-};
-
-const Schema: NodeType = {
-  properties: {
-    format: { type: 'string' },
-    title: { type: 'string' },
-    description: { type: 'string' },
-    default: null,
-    multipleOf: { type: 'number' },
-    maximum: { type: 'number' },
-    minimum: { type: 'number' },
-    exclusiveMaximum: { type: 'boolean' },
-    exclusiveMinimum: { type: 'boolean' },
-    maxLength: { type: 'number' },
-    minLength: { type: 'number' },
-    pattern: { type: 'string' },
-    maxItems: { type: 'number' },
-    minItems: { type: 'number' },
-    uniqueItems: { type: 'boolean' },
-    maxProperties: { type: 'number' },
-    minProperties: { type: 'number' },
-    required: { type: 'array', items: { type: 'string' } },
-    enum: { type: 'array' },
-    type: {
-      type: 'string',
-      enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
-    },
-    items: (value: any) => {
-      if (Array.isArray(value)) {
-        return listOf('Schema');
-      } else {
-        return 'Schema';
-      }
-    },
-    allOf: listOf('Schema'),
-    properties: 'SchemaProperties',
-    additionalProperties: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
-    discriminator: { type: 'string' },
-    readOnly: { type: 'boolean' },
-    xml: 'Xml',
-    externalDocs: 'ExternalDocs',
-    example: { isExample: true },
-    'x-tags': { type: 'array', items: { type: 'string' } },
-    'x-nullable': { type: 'boolean' },
-    'x-extendedDiscriminator': { type: 'string' },
-    'x-additionalPropertiesName': { type: 'string' },
-    'x-explicitMappingOnly': { type: 'boolean' },
-    'x-enumDescriptions': 'EnumDescriptions',
-  },
-  extensionsPrefix: 'x-',
-};
-
-const EnumDescriptions: NodeType = {
-  properties: {},
-  additionalProperties: { type: 'string' },
-};
-
-const SchemaProperties: NodeType = {
-  properties: {},
-  additionalProperties: 'Schema',
-};
-
-const Xml: NodeType = {
-  properties: {
-    name: { type: 'string' },
-    namespace: { type: 'string' },
-    prefix: { type: 'string' },
-    attribute: { type: 'boolean' },
-    wrapped: { type: 'boolean' },
-  },
-  extensionsPrefix: 'x-',
-};
-
-const SecurityScheme: NodeType = {
-  properties: {
-    type: { enum: ['basic', 'apiKey', 'oauth2'] },
-    description: { type: 'string' },
-    name: { type: 'string' },
-    in: { type: 'string', enum: ['query', 'header'] },
-    flow: { enum: ['implicit', 'password', 'application', 'accessCode'] },
-    authorizationUrl: { type: 'string' },
-    tokenUrl: { type: 'string' },
-    scopes: { type: 'object', additionalProperties: { type: 'string' } },
-    'x-defaultClientId': { type: 'string' },
-  },
-  required(value) {
-    switch (value?.type) {
-      case 'apiKey':
-        return ['type', 'name', 'in'];
-      case 'oauth2':
-        switch (value?.flow) {
-          case 'implicit':
-            return ['type', 'flow', 'authorizationUrl', 'scopes'];
-          case 'accessCode':
-            return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'scopes'];
-          case 'application':
-          case 'password':
-            return ['type', 'flow', 'tokenUrl', 'scopes'];
-          default:
-            return ['type', 'flow', 'scopes'];
-        }
-      default:
-        return ['type'];
-    }
-  },
-  allowed(value) {
-    switch (value?.type) {
-      case 'basic':
-        return ['type', 'description'];
-      case 'apiKey':
-        return ['type', 'name', 'in', 'description'];
-      case 'oauth2':
-        switch (value?.flow) {
-          case 'implicit':
-            return ['type', 'flow', 'authorizationUrl', 'description', 'scopes'];
-          case 'accessCode':
-            return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'description', 'scopes'];
-          case 'application':
-          case 'password':
-            return ['type', 'flow', 'tokenUrl', 'description', 'scopes'];
-          default:
-            return ['type', 'flow', 'tokenUrl', 'authorizationUrl', 'description', 'scopes'];
-        }
-      default:
-        return ['type', 'description'];
-    }
-  },
-  extensionsPrefix: 'x-',
-};
-
-const SecurityRequirement: NodeType = {
-  properties: {},
-  additionalProperties: { type: 'array', items: { type: 'string' } },
-};
-
-const Example: NodeType = {
-  properties: {
-    value: { isExample: true },
-    summary: { type: 'string' },
-    description: { type: 'string' },
-    externalValue: { type: 'string' },
-  },
-  extensionsPrefix: 'x-',
-};
-
-export const Oas2Types: Record<Oas2NodeType, NodeType> = {
-  Root,
-  Tag,
-  TagList: listOf('Tag'),
-  TagGroups: listOf('TagGroup'),
-  TagGroup,
-  ExternalDocs,
-  Example,
-  ExamplesMap: mapOf('Example'),
-  EnumDescriptions,
-  SecurityRequirement,
-  SecurityRequirementList: listOf('SecurityRequirement'),
-  Info,
-  Contact,
-  License,
-  Logo,
-  Paths,
-  PathItem,
-  Parameter,
-  ParameterItems,
-  ParameterList: listOf('Parameter'),
-  Operation,
-  Examples,
-  Header,
-  Responses,
-  Response,
-  Schema,
-  Xml,
-  SchemaProperties,
-  NamedSchemas: mapOf('Schema'),
-  NamedResponses: mapOf('Response'),
-  NamedParameters: mapOf('Parameter'),
-  NamedSecuritySchemes: mapOf('SecurityScheme'),
-  SecurityScheme,
-  XCodeSample,
-  XCodeSampleList: listOf('XCodeSample'),
-  XServerList: listOf('XServer'),
-  XServer,
-};