feat!: add schema union support

src/models/message-trait.ts

@@ -6,7 +6,8 @@ import type { SchemaInterface } from './schema';
 
 export interface MessageTraitInterface extends BaseModel, BindingsMixinInterface, DescriptionMixinInterface, ExtensionsMixinInterface, ExternalDocumentationMixinInterface, TagsMixinInterface {
   id(): string;
-  schemaFormat(): string;
+  hasSchemaFormat(): boolean;
+  schemaFormat(): string | undefined;
   hasMessageId(): boolean;
   messageId(): string | undefined;
   hasCorrelationId(): boolean;

src/models/v2/message-trait.ts

@@ -5,8 +5,7 @@ import { MessageExample } from './message-example';
 import { Schema } from './schema';
 
 import { xParserMessageName } from '../../constants';
-import { getDefaultSchemaFormat } from '../../schema-parser';
-import { bindings, hasDescription, description, extensions, hasExternalDocs, externalDocs, tags } from './mixins';
+import { CoreModel } from './mixins';
 
 import type { BindingsInterface } from '../bindings';
 import type { CorrelationIdInterface } from '../correlation-id';
@@ -18,12 +17,17 @@ import type { SchemaInterface } from '../schema';
 import type { TagsInterface } from '../tags';
 
 import type { v2 } from '../../spec-types';
+import { getDefaultSchemaFormat } from 'schema-parser';
 
 export class MessageTrait<J extends v2.MessageTraitObject = v2.MessageTraitObject> extends BaseModel<J, { id: string }> implements MessageTraitInterface {
   id(): string {
     return this.messageId() || this._meta.id || this.json(xParserMessageName) as string;
   }
 
+  hasSchemaFormat(): boolean {
+    return true;
+  }
+
   schemaFormat(): string {
     return this._json.schemaFormat || getDefaultSchemaFormat(this._meta.asyncapi.semver.version);
   }

src/models/v3/message-trait.ts

@@ -19,14 +19,18 @@ export class MessageTrait<J extends v3.MessageTraitObject = v3.MessageTraitObjec
     return this.messageId() || this._meta.id || this.extensions().get(xParserMessageName)?.value<string>() as string;
   }
 
-  schemaFormat(): string {
-    return this._json.schemaFormat || getDefaultSchemaFormat(this._meta.asyncapi.semver.version);
-  }
-
   hasMessageId(): boolean {
     return !!this._json.messageId;
   }
 
+  hasSchemaFormat(): boolean {
+    return false;
+  }
+
+  schemaFormat(): string | undefined {
+    return undefined;
+  }
+
   messageId(): string | undefined {
     return this._json.messageId;
   }

src/models/v3/message.ts

@@ -17,12 +17,18 @@ import type { ServerInterface } from '../server';
 import type { SchemaInterface } from '../schema';
 
 import type { v3 } from '../../spec-types';
+import { getDefaultSchemaFormat } from 'schema-parser';
 
 export class Message extends MessageTrait<v3.MessageObject> implements MessageInterface {
   hasPayload(): boolean {
     return !!this._json.payload;
   }
 
+  schemaFormat(): string | undefined {
+    const payloadIsSchemaUnion = this._json.payload.schemaFormat !== undefined;
+    return payloadIsSchemaUnion ? this._json.payload.schemaFormat : getDefaultSchemaFormat(this._meta.asyncapi.semver.version);
+  }
+
   payload(): SchemaInterface | undefined {
     if (!this._json.payload) return undefined;
     return this.createModel(Schema, this._json.payload, { pointer: this.jsonPath('payload') });

src/spec-types/v3.ts

@@ -175,15 +175,14 @@ export interface OperationBindingsObject extends SpecificationExtensions {
 export type MessagesObject = Record<string, MessageObject | ReferenceObject>;
 
 export interface MessageObject extends MessageTraitObject, SpecificationExtensions {
-  payload?: any;
+  payload?: AllSchemaObjects;
   traits?: Array<MessageTraitObject | ReferenceObject>;
 }
 
 export interface MessageTraitObject extends SpecificationExtensions {
   messageId?: string;
   headers?: SchemaObject;
   correlationId?: CorrelationIDObject | ReferenceObject;
-  schemaFormat?: string;
   contentType?: string;
   name?: string;
   title?: string;
@@ -398,6 +397,12 @@ export interface OAuthFlowObjectAuthorizationCode extends OAuthFlowObjectBase, S
   authorizationUrl: string;
   tokenUrl: string;
 }
+export interface MultiFormatSchemaObject {
+  schemaFormat: string;
+  schema: AsyncAPISchemaObject | ReferenceObject | any;
+}
+
+export type AllSchemaObjects = MultiFormatSchemaObject | AsyncAPISchemaObject | ReferenceObject | any;
 
 export type SchemaObject = AsyncAPISchemaObject | ReferenceObject;
 

test/models/v2/message-trait.spec.ts

@@ -21,6 +21,19 @@ describe('MessageTrait model', function() {
     });
   });
 
+  describe('.hasSchemaFormat()', function() {
+    it('should always contain schemaFormat even when not', function() {
+      const doc = { };
+      const d = new MessageTrait(doc, { asyncapi: {} as any, pointer: '', id: 'message' });
+      expect(d.hasSchemaFormat()).toEqual(true);
+    });
+    it('should always contain schemaFormat', function() {
+      const doc = { schemaFormat: 'customSchemaFormat' };
+      const d = new MessageTrait(doc, { asyncapi: {} as any, pointer: '', id: 'message' });
+      expect(d.hasSchemaFormat()).toEqual(true);
+    });
+  });
+
   describe('.schemaFormat()', function() {
     it('should return defined schemaFormat', function() {
       const doc = { schemaFormat: 'customSchemaFormat' };

test/models/v3/message-trait.spec.ts

@@ -21,17 +21,19 @@ describe('MessageTrait model', function() {
     });
   });
 
-  describe('.schemaFormat()', function() {
-    it('should return defined schemaFormat', function() {
-      const doc = { schemaFormat: 'customSchemaFormat' };
+  describe('.hasSchemaFormat()', function() {
+    it('should not contain schemaFormat', function() {
+      const doc = { };
       const d = new MessageTrait(doc, { asyncapi: {} as any, pointer: '', id: 'message' });
-      expect(d.schemaFormat()).toEqual('customSchemaFormat');
+      expect(d.hasSchemaFormat()).toEqual(false);
     });
+  });
 
-    it('should return default schemaFormat if schemaFormat field is absent', function() {
-      const doc = {};
-      const d = new MessageTrait(doc, { asyncapi: { semver: { version: '2.0.0' } } as any, pointer: '', id: 'message' });
-      expect(d.schemaFormat()).toEqual('application/vnd.aai.asyncapi;version=2.0.0');
+  describe('.schemaFormat()', function() {
+    it('should return undefined schemaFormat', function() {
+      const doc = { };
+      const d = new MessageTrait(doc, { asyncapi: {} as any, pointer: '', id: 'message' });
+      expect(d.schemaFormat()).toEqual(undefined);
     });
   });
 

test/models/v3/message.spec.ts

@@ -28,15 +28,15 @@ describe('Message model', function() {
 
   describe('.schemaFormat()', function() {
     it('should return defined schemaFormat', function() {
-      const doc = { schemaFormat: 'customSchemaFormat' };
+      const doc = { payload: {schemaFormat: 'customSchemaFormat'} };
       const d = new Message(doc, { asyncapi: {} as any, pointer: '', id: 'message' });
       expect(d.schemaFormat()).toEqual('customSchemaFormat');
     });
 
     it('should return default schemaFormat if schemaFormat field is absent', function() {
       const doc = {};
-      const d = new Message(doc, { asyncapi: { semver: { version: '2.0.0' } } as any, pointer: '', id: 'message' });
-      expect(d.schemaFormat()).toEqual('application/vnd.aai.asyncapi;version=2.0.0');
+      const d = new Message(doc, { asyncapi: { semver: { version: '3.0.0' } } as any, pointer: '', id: 'message' });
+      expect(d.schemaFormat()).toEqual('application/vnd.aai.asyncapi;version=3.0.0');
     });
   });