chore: v3 request reply support

src/models/operation-reply.ts

@@ -1,6 +1,8 @@
 import type { BaseModel } from './base';
 import type { ExtensionsMixinInterface } from './mixins';
 import type { ChannelInterface } from './channel';
+import type { MessagesInterface } from './messages';
+
 import type { OperationReplyAddressInterface } from './operation-reply-address';
 
 export interface OperationReplyInterface extends BaseModel, ExtensionsMixinInterface {
@@ -9,4 +11,5 @@ export interface OperationReplyInterface extends BaseModel, ExtensionsMixinInter
  address(): OperationReplyAddressInterface | undefined;
  hasChannel(): boolean;
  channel(): ChannelInterface | undefined;
+ messages(): MessagesInterface;
 }

src/models/operation.ts

@@ -17,4 +17,5 @@ export interface OperationInterface extends BaseModel, OperationTraitInterface {
  messages(): MessagesInterface;
  reply(): OperationReplyInterface | undefined;
  traits(): OperationTraitsInterface;
+ hasReply(): boolean;
 }

src/models/v3/operation-reply.ts

@@ -1,5 +1,8 @@
 import { BaseModel } from '../base';
 import { Channel } from './channel';
+import { Message } from './message';
+import { Messages } from '../messages';
+import { MessagesInterface } from 'models/messages';
 import { OperationReplyAddress } from './operation-reply-address';
 
 import { extensions } from './mixins';
@@ -36,6 +39,13 @@ export class OperationReply extends BaseModel<v3.OperationReplyObject, { id?: st
  }
  return this._json.channel;
  }
+ messages(): MessagesInterface {
+ return new Messages(
+ Object.entries(this._json.messages || {}).map(([messageName, message]) => {
+ return this.createModel(Message, message, { id: messageName, pointer: this.jsonPath(`messages/${messageName}`) });
+ })
+ );
+ }
 
  extensions(): ExtensionsInterface {
  return extensions(this);

src/models/v3/operation.ts

@@ -76,6 +76,10 @@ export class Operation extends OperationTrait<v3.OperationObject> implements Ope
  return new Messages(messages);
  }
 
+ hasReply(): boolean {
+ return !!this._json.reply;
+ }
+
  reply(): OperationReplyInterface | undefined {
  if (this._json.reply) {
  return this.createModel(OperationReply, this._json.reply as v3.OperationReplyObject, { pointer: this.jsonPath('reply') });

src/spec-types/v3.ts

@@ -143,6 +143,7 @@ export interface OperationTraitObject extends SpecificationExtensions {
 
 export interface OperationReplyObject extends SpecificationExtensions {
  channel?: ChannelObject | ReferenceObject;
+ messages?: MessagesObject;
  address?: OperationReplyAddressObject | ReferenceObject;
 }
 

test/models/v3/operation-reply.spec.ts

@@ -1,6 +1,8 @@
 import { Channel } from '../../../src/models/v3/channel';
 import { OperationReply } from '../../../src/models/v3/operation-reply';
 import { OperationReplyAddress } from '../../../src/models/v3/operation-reply-address';
+import { Messages } from '../../../src/models/messages';
+import { Message } from '../../../src/models/v3/message';
 
 import { assertExtensions } from './utils';
 
@@ -59,6 +61,30 @@ describe('OperationReply model', function() {
  expect(d.channel()).toBeUndefined();
  });
  });
+
+ describe('.messages()', function() {
+ it('should return collection of messages - single message', function() {
+ const d = new OperationReply({ messages: { someMessage: { messageId: 'messageId' } } });
+ expect(d.messages()).toBeInstanceOf(Messages);
+ expect(d.messages().all()).toHaveLength(1);
+ expect(d.messages().all()[0]).toBeInstanceOf(Message);
+ });
+
+ it('should return collection of messages - more than one messages', function() {
+ const d = new OperationReply({ messages: { someMessage1: { messageId: 'messageId1' }, someMessage2: { messageId: 'messageId2' } } });
+ expect(d.messages()).toBeInstanceOf(Messages);
+ expect(d.messages().all()).toHaveLength(2);
+ expect(d.messages().all()[0]).toBeInstanceOf(Message);
+ expect(d.messages().all()[0].messageId()).toEqual('messageId1');
+ expect(d.messages().all()[1]).toBeInstanceOf(Message);
+ expect(d.messages().all()[1].messageId()).toEqual('messageId2');
+ });
+
+ it('should return undefined if address is not present', function() {
+ const d = new OperationReply({}, { asyncapi: {} as any, pointer: '' });
+ expect(d.channel()).toBeUndefined();
+ });
+ });
 
  describe('mixins', function() {
  assertExtensions(OperationReply);