refactor: add needed mixins (#491)

src/constants.ts

@@ -8,3 +8,5 @@ export const xParserOriginalSchemaFormat = 'x-parser-original-schema-format';
 export const xParserOriginalTraits = 'x-parser-original-traits';
 
 export const xParserCircular = 'x-parser-circular';
+
+export const EXTENSION_REGEX = /^x-[\w\d\.\-\_]+$/;

src/models/asyncapi.ts

@@ -1,26 +1,29 @@
 import { InfoInterface } from "./info";
 import { BaseModel } from "./base";
+
 import { AsyncAPIDocumentV2 } from "./v2";
 import { AsyncAPIDocumentV3 } from "./v3";
 
-export interface AsyncAPIDocumentInterface extends BaseModel {
-    version(): string;
-    info(): InfoInterface
+import { ExternalDocsMixinInterface, SpecificationExtensionsMixinInterface, TagsMixinInterface } from "./mixins";
+
+export interface AsyncAPIDocumentInterface extends BaseModel, ExternalDocsMixinInterface, SpecificationExtensionsMixinInterface, TagsMixinInterface {
+  version(): string;
+  info(): InfoInterface;
 }
 
 export function newAsyncAPIDocument(json: Record<string, any>): AsyncAPIDocumentInterface {
-    const version = json['asyncapi']; // Maybe this should be an arg.
-    if (version == undefined || version == null || version == '') {
-        throw new Error('Missing AsyncAPI version in document');
-    }
+  const version = json['asyncapi']; // Maybe this should be an arg.
+  if (version == undefined || version == null || version == '') {
+    throw new Error('Missing AsyncAPI version in document');
+  }
 
-    const major = version.split(".")[0];
-    switch (major) {
-        case '2':
-            return new AsyncAPIDocumentV2(json);
-        case '3':
-            return new AsyncAPIDocumentV3(json);
-        default:
-            throw new Error(`Unsupported version: ${version}`);
-    }
-}
+  const major = version.split(".")[0];
+  switch (major) {
+    case '2':
+      return new AsyncAPIDocumentV2(json);
+    case '3':
+      return new AsyncAPIDocumentV3(json);
+    default:
+      throw new Error(`Unsupported version: ${version}`);
+  }
+}

src/models/base.ts

@@ -1,6 +1,6 @@
 export class BaseModel {
   constructor(
-    private readonly _json: Record<string, any>,
+    protected readonly _json: Record<string, any>,
   ) {}
 
   json<T = Record<string, any>>(): T;

src/models/mixins/bindings.ts

@@ -0,0 +1,33 @@
+import { BaseModel } from "../base";
+
+export interface BindingsMixinInterface {
+  hasBindings(): boolean;
+  hasBindings(protocol: string): boolean;
+  bindings(): any[]; // TODO: Change type to Tag
+  bindings(protocol: string): any; // TODO: Change type to Tag
+}
+
+export abstract class BindingsMixin extends BaseModel implements BindingsMixinInterface {
+  hasBindings(): boolean;
+  hasBindings(protocol: string): boolean;
+  hasBindings(protocol?: string): boolean {
+    const bindings = this.bindings(protocol!);
+    if (typeof protocol === 'string') {
+      return Boolean(bindings);
+    }
+    return Object.keys(bindings || {}).length > 0;
+  };
+
+
+  bindings(): any[];
+  bindings(protocol: string): any;
+  bindings(protocol?: string): any | any[] {
+    if (typeof protocol === 'string') {
+      if (this._json.bindings && typeof this._json.bindings === 'object') {
+        return this._json.bindings[protocol];
+      }
+      return;
+    }
+    return this._json.bindings || {};
+  };
+}

src/models/mixins/description.ts

@@ -0,0 +1,16 @@
+import { BaseModel } from "../base";
+
+export interface DescriptionMixinInterface {
+  hasDescription(): boolean;
+  description(): string | undefined;
+}
+
+export abstract class DescriptionMixin extends BaseModel implements DescriptionMixinInterface {
+  hasDescription() {
+    return Boolean(this._json.description);
+  };
+
+  description(): string | undefined {
+    return this._json.description;
+  }
+}

src/models/mixins/external-docs.ts

@@ -0,0 +1,17 @@
+import { BaseModel } from "../base";
+
+export interface ExternalDocsMixinInterface {
+  hasExternalDocs(): boolean;
+  externalDocs(): any; // TODO: Change type to ExternalDocs
+}
+
+export abstract class ExternalDocsMixin extends BaseModel implements ExternalDocsMixinInterface {
+  hasExternalDocs(): boolean {
+    return !!(this._json.externalDocs && Object.keys(this._json.externalDocs).length);
+  };
+
+  // TODO: implement it when the ExternalDocs class will be implemented 
+  externalDocs(): any { 
+    return;
+  };
+}

src/models/mixins/index.ts

@@ -0,0 +1,41 @@
+import type { BaseModel } from '../base';
+
+export * from './bindings';
+export * from './description';
+export * from './external-docs';
+export * from './specification-extensions';
+export * from './tags';
+
+export interface Constructor<T = any> extends Function {
+  new (...any: any[]): T;
+}
+
+export interface MixinType<T = any> extends Function {
+  prototype: T;
+}
+
+export function Mixin(a: typeof BaseModel): typeof BaseModel;
+export function Mixin<A>(a: typeof BaseModel, b: MixinType<A>): typeof BaseModel & Constructor<A>;
+export function Mixin<A, B>(a: typeof BaseModel, b: MixinType<A>, c: MixinType<B>): typeof BaseModel & Constructor<A> & Constructor<B>;
+export function Mixin<A, B, C>(a: typeof BaseModel, b: MixinType<A>, c: MixinType<B>, d: MixinType<C>): typeof BaseModel & Constructor<A> & Constructor<B> & Constructor<C>;
+export function Mixin<A, B, C, D>(a: typeof BaseModel, b: MixinType<A>, c: MixinType<B>, d: MixinType<C>, e: MixinType<D>): typeof BaseModel & Constructor<B> & Constructor<C> & Constructor<D> & Constructor<D>;
+export function Mixin<A, B, C, D, E>(a: typeof BaseModel, b: MixinType<A>, c: MixinType<B>, d: MixinType<C>, e: MixinType<D>, f: MixinType<E>): typeof BaseModel & Constructor<A> & Constructor<B> & Constructor<C> & Constructor<D> & Constructor<E>;
+export function Mixin(baseModel: typeof BaseModel, ...constructors: any[]) {
+  return mixin(class extends baseModel {}, constructors);
+}
+
+function mixin(derivedCtor: any, constructors: any[]): typeof BaseModel {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      if (name === 'constructor') {
+        return;
+      }
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null),
+      );
+    });
+  });
+  return derivedCtor;
+}

src/models/mixins/specification-extensions.ts

@@ -0,0 +1,39 @@
+import { BaseModel } from "../base";
+
+import { EXTENSION_REGEX } from '../../constants';
+
+export interface SpecificationExtensionsMixinInterface {
+  hasExtensions(): boolean;
+  hasExtensions(name: string): boolean;
+  extensions(): Record<string, any>;
+  extensions(name: string): any;
+}
+
+export abstract class SpecificationExtensionsMixin extends BaseModel implements SpecificationExtensionsMixinInterface {
+  hasExtensions(): boolean;
+  hasExtensions(name: string): boolean;
+  hasExtensions(name?: string): boolean {
+    const extensions = this.extensions(name!);
+    if (typeof name === 'string') {
+      return Boolean(extensions);
+    }
+    return Object.keys(extensions || {}).length > 0;
+  };
+
+  extensions(): any[];
+  extensions(name: string): any;
+  extensions(name?: string): any | any[] {
+    if (typeof name === 'string') {
+      name = name.startsWith('x-') ? name : `x-${name}`;
+      return this._json[name];
+    }
+
+    const result: Record<string, any> = {};
+    Object.entries(this._json).forEach(([key, value]) => {
+      if (EXTENSION_REGEX.test(key)) {
+        result[String(key)] = value;
+      }
+    });
+    return result;
+  };
+}

src/models/mixins/tags.ts

@@ -0,0 +1,36 @@
+import { BaseModel } from "../base";
+
+export interface TagsMixinInterface {
+  hasTags(): boolean;
+  hasTags(name: string): boolean;
+  tags(): any[]; // TODO: Change type to Tag
+  tags(name: string): any; // TODO: Change type to Tag
+}
+
+export abstract class TagsMixin extends BaseModel implements TagsMixinInterface {
+  hasTags(): boolean;
+  hasTags(name: string): boolean;
+  hasTags(name?: string): boolean {
+    if (!Array.isArray(this._json.tags) || !this._json.tags.length) {
+      return false;
+    }
+    if (typeof name === 'string') {
+      return this._json.tags.some((t: any) => t.name === name);
+    }
+    return true;
+  };
+
+
+  // TODO: return instance(s) of Tag model when the Tag class will be implemented 
+  tags(): any[]; // TODO: Change type to Tag
+  tags(name: string): any; // TODO: Change type to Tag
+  tags(name?: string): any | any[] { // TODO: Change type to Tag
+    if (typeof name === 'string') {
+      if (Array.isArray(this._json.tags)) {
+        return this._json.tags.find((t: any) => t.name === name);
+      }
+      return;
+    }
+    return this._json.tags || [];
+  };
+}

src/models/v2/asyncapi.ts

@@ -2,12 +2,17 @@ import { AsyncAPIDocumentInterface } from "../../models";
 import { BaseModel } from "../base";
 import { Info } from "./info";
 
-export class AsyncAPIDocument extends BaseModel implements AsyncAPIDocumentInterface {
-    version(): string {
-        return this.json("asyncapi");
-    }
-
-    info(): Info {
-        return new Info(this.json("info"));
-    }
+import { Mixin, ExternalDocsMixin, SpecificationExtensionsMixin, TagsMixin } from '../mixins';
+
+export class AsyncAPIDocument 
+  extends Mixin(BaseModel, ExternalDocsMixin, SpecificationExtensionsMixin, TagsMixin) 
+  implements AsyncAPIDocumentInterface {
+
+  version(): string {
+    return this.json("asyncapi");
+  }
+
+  info(): Info {
+    return new Info(this.json("info"));
+  }
 }

src/models/v3/asyncapi.ts

@@ -2,12 +2,17 @@ import { AsyncAPIDocumentInterface } from "../../models/asyncapi";
 import { BaseModel } from "../base";
 import { Info } from "./info";
 
-export class AsyncAPIDocument extends BaseModel implements AsyncAPIDocumentInterface {
-    version(): string {
-        return this.json("asyncapi");
-    }
+import { Mixin, ExternalDocsMixin, SpecificationExtensionsMixin, TagsMixin } from '../mixins';
 
-    info(): Info {
-        return new Info(this.json("info"));
-    }
+export class AsyncAPIDocument 
+  extends Mixin(BaseModel, ExternalDocsMixin, SpecificationExtensionsMixin, TagsMixin) 
+  implements AsyncAPIDocumentInterface {
+
+  version(): string {
+    return this.json("asyncapi");
+  }
+
+  info(): Info {
+    return new Info(this.json("info"));
+  }
 }

test/models/mixins/bindings.spec.ts

@@ -0,0 +1,49 @@
+import { BaseModel } from '../../../src/models/base';
+import { BindingsMixin, Mixin } from '../../../src/models/mixins';
+
+class Model extends Mixin(BaseModel, BindingsMixin) {};
+
+const doc1 = { bindings: { amqp: { test: 'test1' } } };
+const doc2 = { bindings: {} };
+const doc3 = {};
+const d1 = new Model(doc1);
+const d2 = new Model(doc2);
+const d3 = new Model(doc3);
+
+describe('Bindings mixin', function() {
+  describe('.hasBindings()', function() {
+    it('should return a boolean indicating if the object has bindings', function() {
+      expect(d1.hasBindings()).toEqual(true);
+      expect(d2.hasBindings()).toEqual(false);
+      expect(d3.hasBindings()).toEqual(false);
+    });
+
+    it('should return a boolean indicating if the bindings object has appropriate binding by name', function() {
+      expect(d1.hasBindings('amqp')).toEqual(true);
+      expect(d1.hasBindings('http')).toEqual(false);
+      expect(d2.hasBindings('amqp')).toEqual(false);
+      expect(d3.hasBindings('amqp')).toEqual(false);
+    });
+  });
+
+  describe('.bindings()', function() {
+    it('should return a map of bindings', function() {
+      expect(d1.bindings()).toEqual(doc1.bindings);
+    });
+
+    it('should return an empty object', function() {
+      expect(d2.bindings()).toEqual({});
+      expect(d3.bindings()).toEqual({});
+    });
+
+    it('should return a binding object', function() {
+      expect(d1.bindings('amqp')).toEqual(doc1.bindings.amqp);
+    });
+
+    it('should return a undefined', function() {
+      expect(d1.bindings('http')).toEqual(undefined);
+      expect(d2.bindings('amqp')).toEqual(undefined);
+      expect(d3.bindings('amqp')).toEqual(undefined);
+    });
+  });
+});

test/models/mixins/description.spec.ts

@@ -0,0 +1,32 @@
+import { BaseModel } from '../../../src/models/base';
+import { DescriptionMixin, Mixin } from '../../../src/models/mixins';
+
+class Model extends Mixin(BaseModel, DescriptionMixin) {};
+
+const doc1 = { description: 'Testing' };
+const doc2 = { description: '' };
+const doc3 = {};
+const d1 = new Model(doc1);
+const d2 = new Model(doc2);
+const d3 = new Model(doc3);
+
+describe('Description mixin', function() {
+  describe('.hasDescription()', function() {
+    it('should return a boolean indicating if the object has description', function() {
+      expect(d1.hasDescription()).toEqual(true);  
+      expect(d2.hasDescription()).toEqual(false);  
+      expect(d3.hasDescription()).toEqual(false);  
+    });
+  });
+
+  describe('.description()', function() {
+    it('should return a value', function() {
+      expect(d1.description()).toEqual(doc1.description);  
+      expect(d2.description()).toEqual(''); 
+    });
+
+    it('should return an undefined', function() {
+      expect(d3.description()).toEqual(undefined);  
+    });
+  });
+});