@redocly/openapi-core 1.18.1 → 1.19.0

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

@@ -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') {
@@ -278,6 +278,7 @@ export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   Root,
   Schema,
   SchemaProperties,
+  PatternProperties: SchemaProperties,
   License,
   Components,
   NamedPathItems: mapOf('PathItem'),

package/src/types/redocly-yaml.ts

@@ -92,8 +92,20 @@ const builtInAsync2Rules = [
   'no-channel-trailing-slash',
 ] as const;
 
+const builtInAsync3Rules = [
+  'spec',
+  'info-contact',
+  'operation-operationId',
+  'tag-description',
+  'tags-alphabetical',
+  'channels-kebab-case',
+  'no-channel-trailing-slash',
+] as const;
+
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
+export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
+
 const builtInArazzoRules = ['spec'] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
@@ -103,6 +115,7 @@ const builtInRules = [
   ...builtInOAS2Rules,
   ...builtInOAS3Rules,
   ...builtInAsync2Rules,
+  ...builtInAsync3Rules,
   ...builtInArazzoRules,
 ] as const;
 
@@ -221,6 +234,7 @@ const oas3_1NodeTypesList = [
   'Root',
   'Schema',
   'SchemaProperties',
+  'PatternProperties',
   'Info',
   'License',
   'Components',

package/src/typings/asyncapi3.ts

@@ -0,0 +1,61 @@
+export interface Async3Definition {
+  asyncapi: string;
+  servers?: Record<string, any>;
+  info: Async3Info;
+  channels?: Record<string, Channel>;
+  components?: Record<string, any>;
+  operations?: Record<string, any>;
+  defaultContentType?: string;
+}
+
+export interface Async3Info {
+  title: string;
+  version: string;
+
+  description?: string;
+  termsOfService?: string;
+  contact?: Async3Contact;
+  license?: Async3License;
+  tags?: Tag[];
+  externalDocs?: ExternalDoc;
+}
+
+export interface Async3Contact {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+
+export interface Async3License {
+  name: string;
+  url?: string;
+}
+
+export interface Tag {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDoc;
+}
+
+export interface ExternalDoc {
+  url: string;
+  description?: string;
+}
+
+export interface Channel {
+  address?: string | null;
+  messages?: Record<string, any>;
+  title?: string;
+  summary?: string;
+  description?: string;
+  servers?: Record<string, any>[];
+  parameters?: Record<string, any>;
+  tags?: Record<string, any>;
+  externalDocs?: ExternalDocumentation;
+  bindings?: Record<string, any>;
+}
+
+export interface ExternalDocumentation {
+  url: string;
+  description?: string;
+}

package/src/utils.ts

@@ -38,15 +38,15 @@ export function isDefined<T>(x: T | undefined): x is T {
   return x !== undefined;
 }
 
-export function isPlainObject(value: any): value is Record<string, unknown> {
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-export function isEmptyObject(value: any): value is Record<string, unknown> {
+export function isEmptyObject(value: unknown): value is Record<string, unknown> {
   return isPlainObject(value) && Object.keys(value).length === 0;
 }
 
-export function isEmptyArray(value: any) {
+export function isEmptyArray(value: unknown) {
   return Array.isArray(value) && value.length === 0;
 }
 
@@ -317,3 +317,5 @@ export function dequal(foo: any, bar: any): boolean {
 
   return foo !== foo && bar !== bar;
 }
+
+export type CollectFn = (value: unknown) => void;

package/src/visitors.ts

@@ -50,6 +50,7 @@ import type {
   Oas2SecurityScheme,
 } from './typings/swagger';
 import type { Async2Definition } from './typings/asyncapi';
+import type { Async3Definition } from './typings/asyncapi3';
 import type { ArazzoDefinition } from './typings/arazzo';
 
 export type SkipFunctionContext = Pick<
@@ -213,6 +214,10 @@ type Async2FlatVisitor = {
   Root?: VisitFunctionOrObject<Async2Definition>;
 };
 
+type Async3FlatVisitor = {
+  Root?: VisitFunctionOrObject<Async3Definition>;
+};
+
 type ArazzoFlatVisitor = {
   Root?: VisitFunctionOrObject<ArazzoDefinition>;
 };
@@ -249,6 +254,12 @@ type Async2NestedVisitor = {
     : Async2FlatVisitor[T] & NestedVisitor<Async2NestedVisitor>;
 };
 
+type Async3NestedVisitor = {
+  [T in keyof Async3FlatVisitor]: Async3FlatVisitor[T] extends Function
+    ? Async3FlatVisitor[T]
+    : Async3FlatVisitor[T] & NestedVisitor<Async3NestedVisitor>;
+};
+
 type ArazzoNestedVisitor = {
   [T in keyof ArazzoFlatVisitor]: ArazzoFlatVisitor[T] extends Function
     ? ArazzoFlatVisitor[T]
@@ -267,6 +278,10 @@ export type Async2Visitor = BaseVisitor &
   Async2NestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, Async2NestedVisitor>>;
 
+export type Async3Visitor = BaseVisitor &
+  Async3NestedVisitor &
+  Record<string, VisitFunction<any> | NestedVisitObject<any, Async3NestedVisitor>>;
+
 export type ArazzoVisitor = BaseVisitor &
   ArazzoNestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, ArazzoNestedVisitor>>;
@@ -293,14 +308,17 @@ export type NormalizedOasVisitors<T extends BaseVisitor> = {
 export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
 export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export type Async2Rule = (options: Record<string, any>) => Async2Visitor | Async2Visitor[];
+export type Async3Rule = (options: Record<string, any>) => Async3Visitor | Async3Visitor[];
 export type ArazzoRule = (options: Record<string, any>) => ArazzoVisitor | ArazzoVisitor[];
 export type Oas3Preprocessor = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Preprocessor = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Preprocessor = (options: Record<string, any>) => Async2Visitor;
+export type Async3Preprocessor = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoPreprocessor = (options: Record<string, any>) => ArazzoVisitor;
 export type Oas3Decorator = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Decorator = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Decorator = (options: Record<string, any>) => Async2Visitor;
+export type Async3Decorator = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoDecorator = (options: Record<string, any>) => ArazzoVisitor;
 
 // alias for the latest version supported