@redocly/openapi-core 1.18.0 → 1.19.0

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

@@ -61,7 +61,7 @@ const ChannelBindings: NodeType = {
   additionalProperties: { type: 'object' },
 };
 
-const Tag: NodeType = {
+export const Tag: NodeType = {
   properties: {
     name: { type: 'string' },
     description: { type: 'string' },
@@ -70,7 +70,7 @@ const Tag: NodeType = {
   required: ['name'],
 };
 
-const ExternalDocs: NodeType = {
+export const ExternalDocs: NodeType = {
   properties: {
     description: { type: 'string' },
     url: { type: 'string' },
@@ -126,13 +126,13 @@ const Server: NodeType = {
   required: ['url', 'protocol'],
 };
 
-const ServerMap: NodeType = {
+export const ServerMap: NodeType = {
   properties: {},
   additionalProperties: (_value: any, key: string) =>
     key.match(/^[A-Za-z0-9_\-]+$/) ? 'Server' : undefined,
 };
 
-const ServerVariable: NodeType = {
+export const ServerVariable: NodeType = {
   properties: {
     enum: {
       type: 'array',
@@ -160,7 +160,7 @@ const Info: NodeType = {
   required: ['title', 'version'],
 };
 
-const Contact: NodeType = {
+export const Contact: NodeType = {
   properties: {
     name: { type: 'string' },
     url: { type: 'string' },
@@ -168,7 +168,7 @@ const Contact: NodeType = {
   },
 };
 
-const License: NodeType = {
+export const License: NodeType = {
   properties: {
     name: { type: 'string' },
     url: { type: 'string' },
@@ -184,7 +184,7 @@ const Parameter: NodeType = {
   },
 };
 
-const CorrelationId: NodeType = {
+export const CorrelationId: NodeType = {
   properties: {
     description: { type: 'string' },
     location: { type: 'string' },
@@ -208,7 +208,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 +301,7 @@ const MessageTrait: NodeType = {
     tags: 'TagList',
     externalDocs: 'ExternalDocs',
     bindings: 'MessageBindings',
-    // examples: 'MessageExampleList', // TODO: support examples for message traits
+    examples: 'MessageExampleList',
   },
   additionalProperties: {},
 };
@@ -322,7 +322,7 @@ const Operation: NodeType = {
   required: [],
 };
 
-const MessageExample: NodeType = {
+export const MessageExample: NodeType = {
   properties: {
     payload: { isExample: true },
     summary: { type: 'string' },
@@ -331,14 +331,11 @@ const MessageExample: NodeType = {
   },
 };
 
-const Schema: NodeType = {
+export const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
-    id: { type: 'string' },
     $schema: { type: 'string' },
     definitions: 'NamedSchemas',
-    $defs: 'NamedSchemas',
-    $vocabulary: { type: 'string' },
     externalDocs: 'ExternalDocs',
     discriminator: 'Discriminator',
     myArbitraryKeyword: { type: 'boolean' },
@@ -359,16 +356,14 @@ const Schema: NodeType = {
     required: { type: 'array', items: { type: 'string' } },
     enum: { type: 'array' },
     type: (value: any) => {
-      if (Array.isArray(value)) {
-        return {
-          type: 'array',
-          items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
-        };
-      } else {
-        return {
-          enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
-        };
-      }
+      return Array.isArray(value)
+        ? {
+            type: 'array',
+            items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+          }
+        : {
+            enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+          };
     },
     allOf: listOf('Schema'),
     anyOf: listOf('Schema'),
@@ -377,35 +372,12 @@ const Schema: NodeType = {
     if: 'Schema',
     then: 'Schema',
     else: 'Schema',
-    dependentSchemas: listOf('Schema'),
-    prefixItems: listOf('Schema'),
     contains: 'Schema',
-    minContains: { type: 'integer', minimum: 0 },
-    maxContains: { type: 'integer', minimum: 0 },
     patternProperties: { type: 'object' },
     propertyNames: 'Schema',
-    unevaluatedItems: (value: unknown) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
-    unevaluatedProperties: (value: unknown) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
-    summary: { type: 'string' },
     properties: 'SchemaProperties',
     items: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
+      return Array.isArray(value) ? listOf('Schema') : 'Schema';
     },
     additionalProperties: (value: any) => {
       return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
@@ -417,27 +389,26 @@ const Schema: NodeType = {
     default: null,
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },
-    // xml: 'Xml',
     examples: { type: 'array' },
     example: { isExample: true },
     deprecated: { type: 'boolean' },
     const: null,
     $comment: { type: 'string' },
-    dependencies: { type: 'object' }, // TODO
+    additionalItems: (value: any) => {
+      return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+    },
+    dependencies: 'Dependencies',
   },
 };
 
-const SchemaProperties: NodeType = {
+export const SchemaProperties: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
-    if (typeof value === 'boolean') {
-      return { type: 'boolean' };
-    }
-    return 'Schema';
+    return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
   },
 };
 
-const DiscriminatorMapping: NodeType = {
+export const DiscriminatorMapping: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (isMappingRef(value)) {
@@ -448,7 +419,7 @@ const DiscriminatorMapping: NodeType = {
   },
 };
 
-const Discriminator: NodeType = {
+export const Discriminator: NodeType = {
   properties: {
     propertyName: { type: 'string' },
     mapping: 'DiscriminatorMapping',
@@ -464,7 +435,6 @@ const Components: NodeType = {
     correlationIds: 'NamedCorrelationIds',
     messageTraits: 'NamedMessageTraits',
     operationTraits: 'NamedOperationTraits',
-    streamHeaders: 'NamedStreamHeaders',
     securitySchemes: 'NamedSecuritySchemes',
     servers: 'ServerMap',
     serverVariables: 'ServerVariablesMap',
@@ -513,7 +483,7 @@ const AuthorizationCode: NodeType = {
   required: ['authorizationUrl', 'tokenUrl', 'scopes'],
 };
 
-const SecuritySchemeFlows: NodeType = {
+export const SecuritySchemeFlows: NodeType = {
   properties: {
     implicit: 'ImplicitFlow',
     password: 'PasswordFlow',
@@ -584,6 +554,13 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
+export const Dependencies: NodeType = {
+  properties: {},
+  additionalProperties: (value: any) => {
+    return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
+  },
+};
+
 // --- Per-protocol node types
 
 // http
@@ -1009,22 +986,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,
@@ -1100,6 +1062,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,
@@ -1118,7 +1099,6 @@ export const AsyncApi2Types: Record<string, NodeType> = {
   NamedParameters: mapOf('Parameter'),
   NamedSecuritySchemes: mapOf('SecurityScheme'),
   NamedCorrelationIds: mapOf('CorrelationId'),
-  NamedStreamHeaders: mapOf('StreamHeader'),
   ImplicitFlow,
   PasswordFlow,
   ClientCredentials,
@@ -1132,5 +1112,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,381 @@
+import { NodeType, listOf, mapOf } from '.';
+import {
+  AsyncApi2Bindings,
+  Schema,
+  Dependencies,
+  Discriminator,
+  DiscriminatorMapping,
+  SchemaProperties,
+  CorrelationId,
+  Tag,
+  ServerMap,
+  ExternalDocs,
+  SecuritySchemeFlows,
+  ServerVariable,
+  Contact,
+  License,
+  MessageExample,
+} from './asyncapi2';
+
+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/oas3_1.ts

@@ -133,13 +133,13 @@ const Schema: NodeType = {
     if: 'Schema',
     then: 'Schema',
     else: 'Schema',
-    dependentSchemas: listOf('Schema'),
+    dependentSchemas: mapOf('Schema'),
     dependentRequired: 'DependentRequired',
     prefixItems: listOf('Schema'),
     contains: 'Schema',
     minContains: { type: 'integer', minimum: 0 },
     maxContains: { type: 'integer', minimum: 0 },
-    patternProperties: { type: 'object' },
+    patternProperties: 'PatternProperties',
     propertyNames: 'Schema',
     unevaluatedItems: (value: unknown) => {
       if (typeof value === 'boolean') {
@@ -278,6 +278,7 @@ export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   Root,
   Schema,
   SchemaProperties,
+  PatternProperties: SchemaProperties,
   License,
   Components,
   NamedPathItems: mapOf('PathItem'),