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/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 { 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,11 +9,12 @@ import {
 
 import type { AsyncAPIDocumentInterface } from './models';
 import type { DetailedAsyncAPI } from './types';
+import { v2 } from 'spec-types';
 
 export function createAsyncAPIDocument(asyncapi: DetailedAsyncAPI): AsyncAPIDocumentInterface {
   switch (asyncapi.semver.major) {
   case 2:
-    return new AsyncAPIDocumentV2(asyncapi.parsed, { asyncapi, pointer: '/' });
+    return new AsyncAPIDocumentV2(asyncapi.parsed as v2.AsyncAPIObject, { asyncapi, pointer: '/' });
     // case 3:
     //   return new AsyncAPIDocumentV3(asyncapi.parsed, { asyncapi, pointer: '/' });
   default:

src/models/base.ts

@@ -3,7 +3,7 @@ import type { DetailedAsyncAPI } from '../types';
 
 export interface ModelMetadata {
   asyncapi: DetailedAsyncAPI;
-  pointer: string;
+  pointer?: string;
 }
 
 export abstract class BaseModel<J extends any = any, M extends Record<string, any> = {}> {
@@ -28,7 +28,7 @@ export abstract class BaseModel<J extends any = any, M extends Record<string, an
     return this._meta[key];
   }
 
-  jsonPath(field?: string | undefined): string {
+  jsonPath(field?: string | undefined): string | undefined {
     if (typeof field !== 'string') {
       return this._meta.pointer;
     }

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

@@ -7,7 +7,7 @@ import type { ServersInterface } from './servers';
 
 export interface ChannelInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface {
   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,11 +1,10 @@
 import type { BaseModel } from './base';
 import type { BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface } from './mixins';
-import { SecurityRequirements } from './v2/security-requirements';
+import { SecurityRequirements } from './security-requirements';
 
 export interface OperationTraitInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface {
-  id(): string;
-  hasOperationId(): boolean;
-  operationId(): string | undefined;
+  id(): string | undefined;
+  hasId(): boolean;
   hasSummary(): boolean;
   summary(): string | undefined;
   security(): SecurityRequirements[];

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/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/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/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);
+  }
+}

src/models/tags.ts

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

src/models/v2/asyncapi.ts

@@ -1,15 +1,15 @@
 import { BaseModel } from '../base';
 import { Info } from './info';
-import { Channels } from './channels';
+import { Channels } from '../channels';
 import { Channel } from './channel';
 import { Components } from './components';
-import { Messages } from './messages';
-import { Operations } from './operations';
-import { Servers } from './servers';
+import { Messages } from '../messages';
+import { Operations } from '../operations';
+import { Servers } from '../servers';
 import { Server } from './server';
-import { SecuritySchemes } from './security-schemes';
+import { SecuritySchemes } from '../security-schemes';
 import { SecurityScheme } from './security-scheme';
-import { Schemas } from './schemas';
+import { Schemas } from '../schemas';
 
 import { extensions } from './mixins';
 

src/models/v2/bindings.ts

@@ -1,5 +1,5 @@
 import { Collection } from '../collection';
-import { Extensions } from './extensions';
+import { Extensions } from '../extensions';
 import { Extension } from './extension';
 
 import { createModel } from '../utils';

src/models/v2/channel.ts

@@ -1,10 +1,10 @@
 import { BaseModel } from '../base';
-import { ChannelParameters } from './channel-parameters';
+import { ChannelParameters } from '../channel-parameters';
 import { ChannelParameter } from './channel-parameter';
-import { Messages } from './messages';
-import { Operations } from './operations';
+import { Messages } from '../messages';
+import { Operations } from '../operations';
 import { Operation } from './operation';
-import { Servers } from './servers';
+import { Servers } from '../servers';
 import { Server } from './server';
 
 import { bindings, hasDescription, description, extensions } from './mixins';