@redocly/openapi-core 1.18.1 → 1.20.0

package/src/types/{asyncapi.ts → asyncapi2.ts}

@@ -1,6 +1,8 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
 import { isMappingRef } from '../ref-utils';
 
+import type { NodeType } from '.';
+
 const Root: NodeType = {
   properties: {
     asyncapi: null, // TODO: validate semver format and supported version
@@ -61,7 +63,7 @@ const ChannelBindings: NodeType = {
   additionalProperties: { type: 'object' },
 };
 
-const Tag: NodeType = {
+export const Tag: NodeType = {
   properties: {
     name: { type: 'string' },
     description: { type: 'string' },
@@ -70,7 +72,7 @@ const Tag: NodeType = {
   required: ['name'],
 };
 
-const ExternalDocs: NodeType = {
+export const ExternalDocs: NodeType = {
   properties: {
     description: { type: 'string' },
     url: { type: 'string' },
@@ -126,13 +128,14 @@ const Server: NodeType = {
   required: ['url', 'protocol'],
 };
 
-const ServerMap: NodeType = {
+export const ServerMap: NodeType = {
   properties: {},
   additionalProperties: (_value: any, key: string) =>
+    // eslint-disable-next-line no-useless-escape
     key.match(/^[A-Za-z0-9_\-]+$/) ? 'Server' : undefined,
 };
 
-const ServerVariable: NodeType = {
+export const ServerVariable: NodeType = {
   properties: {
     enum: {
       type: 'array',
@@ -160,7 +163,7 @@ const Info: NodeType = {
   required: ['title', 'version'],
 };
 
-const Contact: NodeType = {
+export const Contact: NodeType = {
   properties: {
     name: { type: 'string' },
     url: { type: 'string' },
@@ -168,7 +171,7 @@ const Contact: NodeType = {
   },
 };
 
-const License: NodeType = {
+export const License: NodeType = {
   properties: {
     name: { type: 'string' },
     url: { type: 'string' },
@@ -184,7 +187,7 @@ const Parameter: NodeType = {
   },
 };
 
-const CorrelationId: NodeType = {
+export const CorrelationId: NodeType = {
   properties: {
     description: { type: 'string' },
     location: { type: 'string' },
@@ -208,7 +211,7 @@ const Message: NodeType = {
     tags: 'TagList',
     externalDocs: 'ExternalDocs',
     bindings: 'MessageBindings',
-    // examples: 'MessageExampleList', // TODO: add support for message examples
+    examples: 'MessageExampleList',
     traits: 'MessageTraitList',
   },
   additionalProperties: {},
@@ -301,7 +304,7 @@ const MessageTrait: NodeType = {
     tags: 'TagList',
     externalDocs: 'ExternalDocs',
     bindings: 'MessageBindings',
-    // examples: 'MessageExampleList', // TODO: support examples for message traits
+    examples: 'MessageExampleList',
   },
   additionalProperties: {},
 };
@@ -322,7 +325,7 @@ const Operation: NodeType = {
   required: [],
 };
 
-const MessageExample: NodeType = {
+export const MessageExample: NodeType = {
   properties: {
     payload: { isExample: true },
     summary: { type: 'string' },
@@ -331,7 +334,7 @@ const MessageExample: NodeType = {
   },
 };
 
-const Schema: NodeType = {
+export const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
     $schema: { type: 'string' },
@@ -401,14 +404,14 @@ const Schema: NodeType = {
   },
 };
 
-const SchemaProperties: NodeType = {
+export const SchemaProperties: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
   },
 };
 
-const DiscriminatorMapping: NodeType = {
+export const DiscriminatorMapping: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (isMappingRef(value)) {
@@ -419,7 +422,7 @@ const DiscriminatorMapping: NodeType = {
   },
 };
 
-const Discriminator: NodeType = {
+export const Discriminator: NodeType = {
   properties: {
     propertyName: { type: 'string' },
     mapping: 'DiscriminatorMapping',
@@ -435,7 +438,6 @@ const Components: NodeType = {
     correlationIds: 'NamedCorrelationIds',
     messageTraits: 'NamedMessageTraits',
     operationTraits: 'NamedOperationTraits',
-    streamHeaders: 'NamedStreamHeaders',
     securitySchemes: 'NamedSecuritySchemes',
     servers: 'ServerMap',
     serverVariables: 'ServerVariablesMap',
@@ -484,7 +486,7 @@ const AuthorizationCode: NodeType = {
   required: ['authorizationUrl', 'tokenUrl', 'scopes'],
 };
 
-const SecuritySchemeFlows: NodeType = {
+export const SecuritySchemeFlows: NodeType = {
   properties: {
     implicit: 'ImplicitFlow',
     password: 'PasswordFlow',
@@ -555,7 +557,7 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const Dependencies: NodeType = {
+export const Dependencies: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
@@ -987,22 +989,7 @@ OperationBindings.properties.mercure = MercureOperationBinding;
 // pulsar
 
 // --- End per-protocol node types
-
-export const AsyncApi2Types: Record<string, NodeType> = {
-  Root,
-  Tag,
-  TagList: listOf('Tag'),
-  ServerMap,
-  ExternalDocs,
-  Server,
-  ServerVariable,
-  ServerVariablesMap: mapOf('ServerVariable'),
-  SecurityRequirement,
-  SecurityRequirementList: listOf('SecurityRequirement'),
-  Info,
-  Contact,
-  License,
-
+export const AsyncApi2Bindings: Record<string, NodeType> = {
   HttpServerBinding,
   HttpChannelBinding,
   HttpMessageBinding,
@@ -1078,6 +1065,25 @@ export const AsyncApi2Types: Record<string, NodeType> = {
 
   ServerBindings,
   ChannelBindings,
+  MessageBindings,
+  OperationBindings,
+};
+
+export const AsyncApi2Types: Record<string, NodeType> = {
+  ...AsyncApi2Bindings,
+  Root,
+  Tag,
+  TagList: listOf('Tag'),
+  ServerMap,
+  ExternalDocs,
+  Server,
+  ServerVariable,
+  ServerVariablesMap: mapOf('ServerVariable'),
+  SecurityRequirement,
+  SecurityRequirementList: listOf('SecurityRequirement'),
+  Info,
+  Contact,
+  License,
   ChannelMap,
   Channel,
   Parameter,
@@ -1096,7 +1102,6 @@ export const AsyncApi2Types: Record<string, NodeType> = {
   NamedParameters: mapOf('Parameter'),
   NamedSecuritySchemes: mapOf('SecurityScheme'),
   NamedCorrelationIds: mapOf('CorrelationId'),
-  NamedStreamHeaders: mapOf('StreamHeader'),
   ImplicitFlow,
   PasswordFlow,
   ClientCredentials,
@@ -1110,6 +1115,7 @@ export const AsyncApi2Types: Record<string, NodeType> = {
   OperationTraitList: listOf('OperationTrait'),
   MessageTrait,
   MessageTraitList: listOf('MessageTrait'),
+  MessageExampleList: listOf('MessageExample'),
   CorrelationId,
   Dependencies,
 };

package/src/types/asyncapi3.ts

@@ -0,0 +1,383 @@
+import { listOf, mapOf } from '.';
+import {
+  AsyncApi2Bindings,
+  Schema,
+  Dependencies,
+  Discriminator,
+  DiscriminatorMapping,
+  SchemaProperties,
+  CorrelationId,
+  Tag,
+  ServerMap,
+  ExternalDocs,
+  SecuritySchemeFlows,
+  ServerVariable,
+  Contact,
+  License,
+  MessageExample,
+} from './asyncapi2';
+
+import type { NodeType } from '.';
+
+const Root: NodeType = {
+  properties: {
+    asyncapi: { type: 'string', enum: ['3.0.0'] },
+    info: 'Info',
+    id: { type: 'string' },
+    servers: 'ServerMap',
+    channels: 'NamedChannels',
+    components: 'Components',
+    operations: 'NamedOperations',
+    defaultContentType: { type: 'string' },
+  },
+  required: ['asyncapi', 'info'],
+};
+
+const Channel: NodeType = {
+  properties: {
+    address: { type: 'string' },
+    messages: 'NamedMessages',
+    title: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    servers: 'ServerList',
+    parameters: 'ParametersMap',
+    bindings: 'ChannelBindings',
+    tags: 'TagList',
+    externalDocs: 'ExternalDocs',
+  },
+};
+
+const Server: NodeType = {
+  properties: {
+    host: { type: 'string' },
+    pathname: { type: 'string' },
+    protocol: { type: 'string' },
+    protocolVersion: { type: 'string' },
+    description: { type: 'string' },
+    variables: 'ServerVariablesMap',
+    security: 'SecuritySchemeList',
+    bindings: 'ServerBindings',
+    externalDocs: 'ExternalDocs',
+    tags: 'TagList',
+  },
+  required: ['host', 'protocol'],
+};
+
+const Info: NodeType = {
+  properties: {
+    title: { type: 'string' },
+    version: { type: 'string' },
+    description: { type: 'string' },
+    termsOfService: { type: 'string' },
+    contact: 'Contact',
+    license: 'License',
+    tags: 'TagList',
+    externalDocs: 'ExternalDocs',
+  },
+  required: ['title', 'version'],
+};
+
+const Parameter: NodeType = {
+  properties: {
+    description: { type: 'string' },
+    enum: { type: 'array', items: { type: 'string' } },
+    default: { type: 'string' },
+    examples: { type: 'array', items: { type: 'string' } },
+    location: { type: 'string' },
+  },
+};
+
+const Message: NodeType = {
+  properties: {
+    headers: 'Schema',
+    payload: (value: Record<string, unknown>) => {
+      if (!!value && value?.['schemaFormat']) {
+        return {
+          properties: {
+            schema: 'Schema',
+            schemaFormat: { type: 'string' },
+          },
+          required: ['schema', 'schemaFormat'],
+        };
+      } else {
+        return 'Schema';
+      }
+    },
+    correlationId: 'CorrelationId',
+
+    contentType: { type: 'string' },
+    name: { type: 'string' },
+    title: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    tags: 'TagList',
+    externalDocs: 'ExternalDocs',
+    bindings: 'MessageBindings',
+    examples: 'MessageExampleList',
+    traits: 'MessageTraitList',
+  },
+  additionalProperties: {},
+};
+
+const OperationTrait: NodeType = {
+  properties: {
+    tags: 'TagList',
+    title: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    externalDocs: 'ExternalDocs',
+    security: 'SecuritySchemeList',
+
+    bindings: 'OperationBindings',
+  },
+  required: [],
+};
+
+const MessageTrait: NodeType = {
+  properties: {
+    headers: (value: unknown) => {
+      if (typeof value === 'function' || (typeof value === 'object' && !!value)) {
+        return {
+          properties: {
+            schema: 'Schema',
+            schemaFormat: { type: 'string' },
+          },
+        };
+      } else {
+        return 'Schema';
+      }
+    },
+    correlationId: 'CorrelationId',
+
+    contentType: { type: 'string' },
+    name: { type: 'string' },
+    title: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    tags: 'TagList',
+    externalDocs: 'ExternalDocs',
+    bindings: 'MessageBindings',
+    examples: 'MessageExampleList',
+  },
+  additionalProperties: {},
+};
+
+const Operation: NodeType = {
+  properties: {
+    action: { type: 'string', enum: ['send', 'receive'] },
+    channel: 'Channel',
+    title: { type: 'string' },
+    tags: 'TagList',
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    externalDocs: 'ExternalDocs',
+    operationId: { type: 'string' },
+    security: 'SecuritySchemeList',
+
+    bindings: 'OperationBindings',
+    traits: 'OperationTraitList',
+    messages: 'MessageList',
+    reply: 'OperationReply',
+  },
+  required: ['action', 'channel'],
+};
+
+const OperationReply: NodeType = {
+  properties: {
+    channel: 'Channel',
+    messages: 'MessageList',
+    address: 'OperationReplyAddress',
+  },
+};
+
+const OperationReplyAddress: NodeType = {
+  properties: {
+    location: { type: 'string' },
+    description: { type: 'string' },
+  },
+  required: ['location'],
+};
+
+const Components: NodeType = {
+  properties: {
+    messages: 'NamedMessages',
+    parameters: 'NamedParameters',
+    schemas: 'NamedSchemas',
+    replies: 'NamedOperationReplies',
+    replyAddresses: 'NamedOperationRelyAddresses',
+    correlationIds: 'NamedCorrelationIds',
+    messageTraits: 'NamedMessageTraits',
+    operationTraits: 'NamedOperationTraits',
+    tags: 'NamedTags',
+    externalDocs: 'NamedExternalDocs',
+    securitySchemes: 'NamedSecuritySchemes',
+    servers: 'ServerMap',
+    serverVariables: 'ServerVariablesMap',
+    channels: 'NamedChannels',
+    operations: 'NamedOperations',
+    serverBindings: 'ServerBindings',
+    channelBindings: 'ChannelBindings',
+    operationBindings: 'OperationBindings',
+    messageBindings: 'MessageBindings',
+  },
+};
+
+const ImplicitFlow: NodeType = {
+  properties: {
+    refreshUrl: { type: 'string' },
+    availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+    authorizationUrl: { type: 'string' },
+  },
+  required: ['authorizationUrl', 'availableScopes'],
+};
+
+const PasswordFlow: NodeType = {
+  properties: {
+    refreshUrl: { type: 'string' },
+    availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+    tokenUrl: { type: 'string' },
+  },
+  required: ['tokenUrl', 'availableScopes'],
+};
+
+const ClientCredentials: NodeType = {
+  properties: {
+    refreshUrl: { type: 'string' },
+    availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+    tokenUrl: { type: 'string' },
+  },
+  required: ['tokenUrl', 'availableScopes'],
+};
+
+const AuthorizationCode: NodeType = {
+  properties: {
+    refreshUrl: { type: 'string' },
+    authorizationUrl: { type: 'string' },
+    availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+    tokenUrl: { type: 'string' },
+  },
+  required: ['authorizationUrl', 'tokenUrl', 'availableScopes'],
+};
+
+const SecurityScheme: NodeType = {
+  properties: {
+    type: {
+      enum: [
+        'userPassword',
+        'apiKey',
+        'X509',
+        'symmetricEncryption',
+        'asymmetricEncryption',
+        'httpApiKey',
+        'http',
+        'oauth2',
+        'openIdConnect',
+        'plain',
+        'scramSha256',
+        'scramSha512',
+        'gssapi',
+      ],
+    },
+    description: { type: 'string' },
+    name: { type: 'string' },
+    in: { type: 'string', enum: ['query', 'header', 'cookie', 'user', 'password'] },
+    scheme: { type: 'string' },
+    bearerFormat: { type: 'string' },
+    flows: 'SecuritySchemeFlows',
+    openIdConnectUrl: { type: 'string' },
+    scopes: { type: 'array', items: { type: 'string' } },
+  },
+  required(value) {
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'in'];
+      case 'httpApiKey':
+        return ['type', 'name', 'in'];
+      case 'http':
+        return ['type', 'scheme'];
+      case 'oauth2':
+        return ['type', 'flows'];
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl'];
+      default:
+        return ['type'];
+    }
+  },
+  allowed(value) {
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'in', 'description'];
+      case 'httpApiKey':
+        return ['type', 'name', 'in', 'description'];
+      case 'http':
+        return ['type', 'scheme', 'bearerFormat', 'description'];
+      case 'oauth2':
+        return ['type', 'flows', 'description', 'scopes'];
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl', 'description', 'scopes'];
+      default:
+        return ['type', 'description'];
+    }
+  },
+  extensionsPrefix: 'x-',
+};
+
+export const AsyncApi3Types: Record<string, NodeType> = {
+  // from asyncapi2
+  ...AsyncApi2Bindings,
+  CorrelationId,
+  SecuritySchemeFlows,
+  ServerVariable,
+  Contact,
+  License,
+  MessageExample,
+  Tag,
+  Dependencies,
+  Schema,
+  Discriminator,
+  DiscriminatorMapping,
+  SchemaProperties,
+  ServerMap,
+  ExternalDocs,
+  Root,
+
+  Channel,
+  Parameter,
+  Info,
+  Server,
+  MessageTrait,
+  Operation,
+  OperationReply,
+  OperationReplyAddress,
+  Components,
+  ImplicitFlow,
+  PasswordFlow,
+  ClientCredentials,
+  AuthorizationCode,
+  SecurityScheme,
+  Message,
+  OperationTrait,
+  ServerVariablesMap: mapOf('ServerVariable'),
+  NamedTags: mapOf('Tag'),
+  NamedExternalDocs: mapOf('ExternalDocs'),
+  NamedChannels: mapOf('Channel'),
+  ParametersMap: mapOf('Parameter'),
+  NamedOperations: mapOf('Operation'),
+  NamedOperationReplies: mapOf('OperationReply'),
+  NamedOperationRelyAddresses: mapOf('OperationReplyAddress'),
+  NamedSchemas: mapOf('Schema'),
+  NamedMessages: mapOf('Message'),
+  NamedMessageTraits: mapOf('MessageTrait'),
+  NamedOperationTraits: mapOf('OperationTrait'),
+  NamedParameters: mapOf('Parameter'),
+  NamedSecuritySchemes: mapOf('SecurityScheme'),
+  NamedCorrelationIds: mapOf('CorrelationId'),
+  ServerList: listOf('Server'),
+  SecuritySchemeList: listOf('SecurityScheme'),
+  MessageList: listOf('Message'),
+  OperationTraitList: listOf('OperationTrait'),
+  MessageTraitList: listOf('MessageTrait'),
+  MessageExampleList: listOf('MessageExample'),
+  TagList: listOf('Tag'),
+};

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

@@ -3,9 +3,9 @@
 import Ajv from '@redocly/ajv/dist/2020';
 import { isPlainObject } from '../utils';
 
-import type { NodeType, PropType, ResolveTypeFn } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
-import { Oas3Schema } from '../typings/openapi';
+import type { NodeType, PropType, ResolveTypeFn } from '.';
+import type { Oas3Schema } from '../typings/openapi';
 
 const ajv = new Ajv({
   strictSchema: false,

package/src/types/oas3.ts

@@ -44,7 +44,7 @@ const TagGroup: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const ExternalDocs: NodeType = {
+export const ExternalDocs: NodeType = {
   properties: {
     description: { type: 'string' },
     url: { type: 'string' },
@@ -369,7 +369,7 @@ const Schema: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const Xml: NodeType = {
+export const Xml: NodeType = {
   properties: {
     name: { type: 'string' },
     namespace: { type: 'string' },
@@ -385,7 +385,7 @@ const SchemaProperties: NodeType = {
   additionalProperties: 'Schema',
 };
 
-const DiscriminatorMapping: NodeType = {
+export const DiscriminatorMapping: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (isMappingRef(value)) {
@@ -396,7 +396,7 @@ const DiscriminatorMapping: NodeType = {
   },
 };
 
-const Discriminator: NodeType = {
+export const Discriminator: NodeType = {
   properties: {
     propertyName: { type: 'string' },
     mapping: 'DiscriminatorMapping',

package/src/types/oas3_1.ts

@@ -87,7 +87,7 @@ const Operation: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const Schema: NodeType = {
+export const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
     $anchor: { type: 'string' },
@@ -139,7 +139,7 @@ const Schema: NodeType = {
     contains: 'Schema',
     minContains: { type: 'integer', minimum: 0 },
     maxContains: { type: 'integer', minimum: 0 },
-    patternProperties: 'SchemaProperties',
+    patternProperties: 'PatternProperties',
     propertyNames: 'Schema',
     unevaluatedItems: (value: unknown) => {
       if (typeof value === 'boolean') {
@@ -186,7 +186,7 @@ const Schema: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const SchemaProperties: NodeType = {
+export const SchemaProperties: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (typeof value === 'boolean') {
@@ -267,7 +267,7 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const DependentRequired: NodeType = {
+export const DependentRequired: NodeType = {
   properties: {},
   additionalProperties: { type: 'array', items: { type: 'string' } },
 };
@@ -278,6 +278,7 @@ export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   Root,
   Schema,
   SchemaProperties,
+  PatternProperties: SchemaProperties,
   License,
   Components,
   NamedPathItems: mapOf('PathItem'),