chore: add support for asyncapi 3.0.0 operations and channels

package.json

@@ -26,6 +26,7 @@
     "README.md"
   ],
   "scripts": {
+    "dev": "tsc --watch",
     "build": "npm run build:esm && npm run build:cjs && npm run build:browser",
     "build:esm": "tsc",
     "build:cjs": "tsc --project ./tsconfig.cjs.json",

src/custom-operations/anonymous-naming.ts

@@ -37,7 +37,7 @@ function assignNameToAnonymousMessages(document: AsyncAPIDocumentInterface) {
 function assignUidToComponentParameterSchemas(document: AsyncAPIDocumentInterface) {
   document.components().channelParameters().forEach(parameter => {
     const schema = parameter.schema();
-    if (schema && !schema.uid()) {
+    if (schema && !schema.id()) {
       setExtension(xParserSchemaId, parameter.id(), schema);
     }
   });
@@ -47,7 +47,7 @@ function assignUidToChannelParameterSchemas(document: AsyncAPIDocumentInterface)
   document.channels().forEach(channel => {
     channel.parameters().forEach(parameter => {
       const schema = parameter.schema();
-      if (schema && !schema.uid()) {
+      if (schema && !schema.id()) {
         setExtension(xParserSchemaId, parameter.id(), schema);
       }
     });
@@ -56,14 +56,14 @@ function assignUidToChannelParameterSchemas(document: AsyncAPIDocumentInterface)
 
 function assignUidToComponentSchemas(document: AsyncAPIDocumentInterface) {
   document.components().schemas().forEach(schema => {
-    setExtension(xParserSchemaId, schema.uid(), schema);
+    setExtension(xParserSchemaId, schema.id(), schema);
   });
 }
 
 function assignUidToAnonymousSchemas(doc: AsyncAPIDocumentInterface) {
   let anonymousSchemaCounter = 0;
   function callback(schema: SchemaInterface) {
-    if (!schema.uid()) {
+    if (!schema.id()) {
       setExtension(xParserSchemaId, `<anonymous-schema-${++anonymousSchemaCounter}>`, schema);
     }
   }

src/custom-operations/index.ts

@@ -7,6 +7,7 @@ import type { Parser } from '../parser';
 import type { ParseOptions } from '../parse';
 import type { AsyncAPIDocumentInterface } from '../models';
 import type { DetailedAsyncAPI } from '../types';
+import type { v2 } from '../spec-types';
 
 export async function customOperations(parser: Parser, document: AsyncAPIDocumentInterface, detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
   switch (detailed.semver.major) {
@@ -20,7 +21,7 @@ async function operationsV2(parser: Parser, document: AsyncAPIDocumentInterface,
   anonymousNaming(document);
 
   if (options.applyTraits) {
-    applyTraitsV2(detailed.parsed);
+    applyTraitsV2(detailed.parsed as v2.AsyncAPIObject);
   }
   if (options.parseSchemas) {
     await parseSchemasV2(parser, detailed);

src/document.ts

@@ -9,13 +9,14 @@ import {
 
 import type { AsyncAPIDocumentInterface } from './models';
 import type { DetailedAsyncAPI } from './types';
+import type { v2, v3 } from './spec-types';
 
 export function createAsyncAPIDocument(asyncapi: DetailedAsyncAPI): AsyncAPIDocumentInterface {
   switch (asyncapi.semver.major) {
   case 2:
-    return new AsyncAPIDocumentV2(asyncapi.parsed, { asyncapi, pointer: '/' });
-    // case 3:
-    //   return new AsyncAPIDocumentV3(asyncapi.parsed, { asyncapi, pointer: '/' });
+    return new AsyncAPIDocumentV2(asyncapi.parsed as v2.AsyncAPIObject, { asyncapi, pointer: '/' });
+  case 3:
+    return new AsyncAPIDocumentV3(asyncapi.parsed as v3.AsyncAPIObject, { asyncapi, pointer: '/' });
   default:
     throw new Error(`Unsupported AsyncAPI version: ${asyncapi.semver.version}`);
   }

src/models/channel-parameters.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { ChannelParameterInterface } from './channel-parameter';
 
-export type ChannelParametersInterface = Collection<ChannelParameterInterface>
+export type ChannelParametersInterface = Collection<ChannelParameterInterface>;
+
+export class ChannelParameters extends Collection<ChannelParameterInterface> implements ChannelParametersInterface {
+  override get(id: string): ChannelParameterInterface | undefined {
+    return this.collections.find(parameter => parameter.id() === id);
+  }
+}

src/models/channel.ts

@@ -1,13 +1,13 @@
 import type { BaseModel } from './base';
 import type { ChannelParametersInterface } from './channel-parameters';
 import type { MessagesInterface } from './messages';
-import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface } from './mixins';
+import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface } from './mixins';
 import type { OperationsInterface } from './operations';
 import type { ServersInterface } from './servers';
 
-export interface ChannelInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface {
+export interface ChannelInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface {
   id(): string;
-  address(): string;
+  address(): string | null | undefined;
   servers(): ServersInterface;
   operations(): OperationsInterface;
   messages(): MessagesInterface;

src/models/channels.ts

@@ -1,7 +1,21 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { ChannelInterface } from './channel';
 
 export interface ChannelsInterface extends Collection<ChannelInterface> {
   filterBySend(): ChannelInterface[];
   filterByReceive(): ChannelInterface[];
-}
+}
+
+export class Channels extends Collection<ChannelInterface> implements ChannelsInterface {
+  override get(id: string): ChannelInterface | undefined {
+    return this.collections.find(channel => channel.id() === id);
+  }
+
+  filterBySend(): ChannelInterface[] {
+    return this.filterBy(channel => channel.operations().filterBySend().length > 0);
+  }
+
+  filterByReceive(): ChannelInterface[] {
+    return this.filterBy(channel => channel.operations().filterByReceive().length > 0);
+  }
+}

src/models/correlation-ids.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { CorrelationIdInterface } from './correlation-id';
 
-export type CorrelationIdsInterface = Collection<CorrelationIdInterface>
+export type CorrelationIdsInterface = Collection<CorrelationIdInterface>
+
+export class CorrelationIds extends Collection<CorrelationIdInterface> implements CorrelationIdsInterface {
+  override get(id: string): CorrelationIdInterface | undefined {
+    return this.collections.find(correlationId => correlationId.meta('id' as any) === id);
+  }
+}

src/models/extensions.ts

@@ -1,4 +1,11 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { ExtensionInterface } from './extension';
 
-export type ExtensionsInterface = Collection<ExtensionInterface>
+export type ExtensionsInterface = Collection<ExtensionInterface>
+
+export class Extensions extends Collection<ExtensionInterface> implements ExtensionsInterface {
+  override get<T = any>(id: string): ExtensionInterface<T> | undefined {
+    id = id.startsWith('x-') ? id : `x-${id}`;
+    return this.collections.find(ext => ext.id() === id);
+  }
+}

src/models/message-examples.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { MessageExampleInterface } from './message-example';
 
 export type MessageExamplesInterface = Collection<MessageExampleInterface>
+
+export class MessageExamples extends Collection<MessageExampleInterface> implements MessageExamplesInterface {
+  override get(name: string): MessageExampleInterface | undefined {
+    return this.collections.find(example => example.name() === name);
+  }
+}

src/models/message-traits.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { MessageTraitInterface } from './message-trait';
 
-export type MessageTraitsInterface = Collection<MessageTraitInterface>
+export type MessageTraitsInterface = Collection<MessageTraitInterface>
+
+export class MessageTraits extends Collection<MessageTraitInterface> implements MessageTraitsInterface {
+  override get(id: string): MessageTraitInterface | undefined {
+    return this.collections.find(trait => trait.id() === id);
+  }
+}

src/models/messages.ts

@@ -1,7 +1,21 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { MessageInterface } from './message';
 
 export interface MessagesInterface extends Collection<MessageInterface> {
   filterBySend(): MessageInterface[];
   filterByReceive(): MessageInterface[];
-}
+}
+
+export class Messages extends Collection<MessageInterface> implements MessagesInterface {
+  override get(name: string): MessageInterface | undefined {
+    return this.collections.find(message => message.id() === name);
+  }
+
+  filterBySend(): MessageInterface[] {
+    return this.filterBy(message => message.operations().filterBySend().length > 0);
+  }
+
+  filterByReceive(): MessageInterface[] {
+    return this.filterBy(message => message.operations().filterByReceive().length > 0);
+  }
+}

src/models/operation-trait.ts

@@ -1,12 +1,17 @@
 import type { BaseModel } from './base';
+import type { ChannelsInterface } from './channels';
+import type { OperationAction } from './operation';
+import type { SecurityRequirements } from './security-requirements';
 import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface } from './mixins';
-import { SecurityRequirements } from './v2/security-requirements';
 
 export interface OperationTraitInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface {
-  id(): string;
-  hasOperationId(): boolean;
-  operationId(): string | undefined;
+  id(): string | undefined;
+  hasId(): boolean;
+  action(): OperationAction | undefined;
+  isSend(): boolean;
+  isReceive(): boolean;
   hasSummary(): boolean;
   summary(): string | undefined;
   security(): SecurityRequirements[];
+  channels(): ChannelsInterface;
 }

src/models/operation-traits.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { OperationTraitInterface } from './operation-trait';
 
-export type OperationTraitsInterface = Collection<OperationTraitInterface>
+export type OperationTraitsInterface = Collection<OperationTraitInterface>
+
+export class OperationTraits extends Collection<OperationTraitInterface> implements OperationTraitsInterface {
+  override get(id: string): OperationTraitInterface | undefined {
+    return this.collections.find(trait => trait.id() === id);
+  }
+}

src/models/operation.ts

@@ -1,5 +1,4 @@
 import type { BaseModel } from './base';
-import type { ChannelsInterface } from './channels';
 import type { MessagesInterface } from './messages';
 import type { OperationTraitsInterface } from './operation-traits';
 import type { OperationTraitInterface } from './operation-trait';
@@ -9,10 +8,7 @@ export type OperationAction = 'send' | 'receive' | 'publish' | 'subscribe';
 
 export interface OperationInterface extends BaseModel, OperationTraitInterface {
   action(): OperationAction;
-  isSend(): boolean;
-  isReceive(): boolean;
   servers(): ServersInterface;
-  channels(): ChannelsInterface;
   messages(): MessagesInterface;
   traits(): OperationTraitsInterface;
 }

src/models/operations.ts

@@ -1,7 +1,22 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
+
 import type { OperationInterface } from './operation';
 
 export interface OperationsInterface extends Collection<OperationInterface> {
   filterBySend(): OperationInterface[];
   filterByReceive(): OperationInterface[];
 }
+
+export class Operations extends Collection<OperationInterface> implements OperationsInterface {
+  override get(id: string): OperationInterface | undefined {
+    return this.collections.find(operation => operation.id() === id);
+  }
+
+  filterBySend(): OperationInterface[] {
+    return this.filterBy(operation => operation.isSend());
+  }
+
+  filterByReceive(): OperationInterface[] {
+    return this.filterBy(operation => operation.isReceive());
+  }
+}

src/models/schema.ts

@@ -3,7 +3,7 @@ import type { ExtensionsMixinInterface, ExternalDocumentationMixinInterface } fr
 import type { v2 } from '../spec-types';
 
 export interface SchemaInterface extends BaseModel<v2.AsyncAPISchemaObject>, ExtensionsMixinInterface, ExternalDocumentationMixinInterface {
-  uid(): string;
+  id(): string;
   $comment(): string | undefined;
   $id(): string | undefined;
   $schema(): string;

src/models/schemas.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { SchemaInterface } from './schema';
 
 export type SchemasInterface = Collection<SchemaInterface>
+
+export class Schemas extends Collection<SchemaInterface> implements SchemasInterface {
+  override get(id: string): SchemaInterface | undefined {
+    return this.collections.find(schema => schema.uid() === id);
+  }
+}

src/models/security-requirements.ts

@@ -1,4 +1,10 @@
-import type { Collection} from './collection';
+import { Collection} from './collection';
 import type { SecurityRequirementInterface } from './security-requirement';
 
-export type SecurityRequirementsInterface = Collection<SecurityRequirementInterface>
+export type SecurityRequirementsInterface = Collection<SecurityRequirementInterface>
+
+export class SecurityRequirements extends Collection<SecurityRequirementInterface> implements SecurityRequirementsInterface {
+  override get(id: string): SecurityRequirementInterface | undefined {
+    return this.collections.find(securityRequirement => securityRequirement.meta('id' as any) === id);
+  }
+}

src/models/security-schemes.ts

@@ -1,4 +1,10 @@
-import type { Collection} from './collection';
+import { Collection} from './collection';
 import type { SecuritySchemeInterface } from './security-scheme';
 
 export type SecuritySchemesInterface = Collection<SecuritySchemeInterface>
+
+export class SecuritySchemes extends Collection<SecuritySchemeInterface> implements SecuritySchemesInterface {
+  override get(id: string): SecuritySchemeInterface | undefined {
+    return this.collections.find(securityScheme => securityScheme.id() === id);
+  }
+}

src/models/server-variables.ts

@@ -1,4 +1,10 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { ServerVariableInterface } from './server-variable';
 
-export type ServerVariablesInterface = Collection<ServerVariableInterface>
+export type ServerVariablesInterface = Collection<ServerVariableInterface>;
+
+export class ServerVariables extends Collection<ServerVariableInterface> implements ServerVariablesInterface {
+  override get(id: string): ServerVariableInterface | undefined {
+    return this.collections.find(variable => variable.id() === id);
+  }
+}

src/models/server.ts

@@ -1,12 +1,12 @@
 import type { BaseModel } from './base';
 import type { ChannelsInterface } from './channels';
 import type { MessagesInterface } from './messages';
-import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface } from './mixins';
+import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, TagsMixinInterface } from './mixins';
 import type { OperationsInterface } from './operations';
 import type { ServerVariablesInterface } from './server-variables';
 import type { SecurityRequirementsInterface } from './security-requirements';
 
-export interface ServerInterface extends BaseModel, DescriptionMixinInterface, BindingsMixinInterface, ExtensionsMixinInterface {
+export interface ServerInterface extends BaseModel, DescriptionMixinInterface, BindingsMixinInterface, ExtensionsMixinInterface, TagsMixinInterface {
   id(): string
   url(): string;
   protocol(): string;

src/models/servers.ts

@@ -1,7 +1,21 @@
-import type { Collection } from './collection';
+import { Collection } from './collection';
 import type { ServerInterface } from './server';
 
 export interface ServersInterface extends Collection<ServerInterface> {
   filterBySend(): ServerInterface[];
   filterByReceive(): ServerInterface[];
 }
+
+export class Servers extends Collection<ServerInterface> implements ServersInterface {
+  override get(id: string): ServerInterface | undefined {
+    return this.collections.find(server => server.id() === id);
+  }
+
+  filterBySend(): ServerInterface[] {
+    return this.filterBy(server => server.operations().filterBySend().length > 0);
+  }
+
+  filterByReceive(): ServerInterface[] {
+    return this.filterBy(server => server.operations().filterByReceive().length > 0);
+  }
+}