refactor: add models for server object

src/models/asyncapi.ts

@@ -4,10 +4,12 @@ import { AsyncAPIDocumentV3 } from "./v3";
 import type { InfoInterface } from "./info";
 import type { BaseModel } from "./base";
 import type { ExtensionsMixinInterface } from "./mixins";
+import { ServersInterface } from "./servers";
 
 export interface AsyncAPIDocumentInterface extends BaseModel, ExtensionsMixinInterface {
   version(): string;
   info(): InfoInterface;
+  servers(): ServersInterface
 }
 
 export function newAsyncAPIDocument(json: Record<string, any>): AsyncAPIDocumentInterface {

src/models/server.ts

@@ -0,0 +1,10 @@
+import { BaseModel } from "./base";
+import { BindingsMixinInterface, DescriptionMixinInterface } from './mixins';
+
+export interface ServerInterface extends BaseModel, DescriptionMixinInterface, BindingsMixinInterface {
+    id(): string
+    protocol(): string | undefined;
+    protocolVersion(): string;
+    hasProtocolVersion(): boolean;
+    url(): string;
+}

src/models/servers.ts

@@ -0,0 +1,4 @@
+import { Collection } from "./collection";
+import {ServerInterface} from "./server";
+
+export interface ServersInterface extends Collection<ServerInterface> {}

src/models/utils.ts

@@ -32,4 +32,14 @@ function mixin(derivedCtor: any, constructors: any[]): typeof BaseModel {
     });
   });
   return derivedCtor;
+}
+
+export function createArrayFromMap(json: Record<string,any>){
+  const ArrayObject = [];
+  for (const [key, value] of Object.entries(json)) {
+    value['id'] = key;
+    ArrayObject.push(value);
+  };
+
+  return ArrayObject;
 }

src/models/v2/asyncapi.ts

@@ -5,9 +5,12 @@ import { Mixin } from '../utils';
 import { ExtensionsMixin } from './mixins/extensions';
 
 import { AsyncAPIDocumentInterface, InfoInterface } from "../../models";
+import { ServersInterface } from "models/servers";
+import { Servers } from "./servers";
+import { Server } from "./server";
 
-export class AsyncAPIDocument 
-  extends Mixin(BaseModel, ExtensionsMixin) 
+export class AsyncAPIDocument
+  extends Mixin(BaseModel, ExtensionsMixin)
   implements AsyncAPIDocumentInterface {
 
   version(): string {
@@ -17,4 +20,10 @@ export class AsyncAPIDocument
   info(): InfoInterface {
     return new Info(this._json.info);
   }
+
+  servers(): ServersInterface {
+    return new Servers(
+      Object.entries(this._json.servers).map(([serverName, server]) => new Server(serverName, server as Record<string, any>))
+    );
+  }
 }

src/models/v2/index.ts

@@ -5,4 +5,6 @@ export { License as LicenseV2 } from './license';
 export { Bindings as BindingsV2, Binding as BindingV2 } from './mixins/bindings';
 export { Extensions as ExtensionsV2, Extension as ExtensionV2 } from './mixins/extensions';
 export { ExternalDocumentation as ExternalDocumentationV2 } from './mixins/external-docs';
-export { Tags as TagsV2, Tag as TagV2 } from './mixins/tags';
+export { Tags as TagsV2, Tag as TagV2 } from './mixins/tags';
+export { Server as ServerV2 } from './server';
+export { Servers as ServersV2 } from './servers';

src/models/v2/server.ts

@@ -0,0 +1,42 @@
+import { Mixin } from '../utils';
+import { BaseModel } from '../base';
+import { ServerInterface } from '../server';
+import { DescriptionMixin } from './mixins/description';
+import { BindingsMixin } from './mixins/bindings';
+
+export class Server extends Mixin(BaseModel, DescriptionMixin, BindingsMixin) implements ServerInterface {
+    constructor(
+        private readonly _id: string,
+        _json: Record<string, any>
+    ){
+        super(_json);
+    }
+
+    id(): string {
+        return this._id;
+    }
+
+    hasProtocol(): boolean {
+        return !!this.json('protocol');
+    }
+
+    protocol(): string | undefined {
+        return this.json('protocol');
+    }
+
+    hasProtocolVersion(): boolean {
+        return !!this.json('protocolVersion');
+    }
+
+    protocolVersion(): string {
+        return this.json('protocolVersion');
+    }
+
+    hasUrl(): boolean {
+        return !!this.json('url');
+    }
+
+    url(): string {
+        return this.json('url');
+    }
+}

src/models/v2/servers.ts

@@ -0,0 +1,13 @@
+import { Collection } from '../collection';
+import { ServerInterface } from '../server';
+import { ServersInterface } from '../servers';
+
+export class Servers extends Collection<ServerInterface> implements ServersInterface {
+    override get(id: string): ServerInterface | undefined {
+        return this.collections.find(server => server.id() === id);
+    }
+
+    override has(id: string): boolean {
+        return this.collections.some(server => server.id() === id);
+    }
+}

src/models/v3/asyncapi.ts

@@ -4,16 +4,27 @@ import { Info } from "./info";
 
 import { Mixin } from '../utils';
 import { ExtensionsMixin } from './mixins/extensions';
+import { ServersInterface } from "models/servers";
+import { Servers } from "./servers";
+import { Server } from "./server";
 
 export class AsyncAPIDocument 
   extends Mixin(BaseModel, ExtensionsMixin) 
   implements AsyncAPIDocumentInterface {
-		
+
   version(): string {
     return this.json("asyncapi");
   }
 
   info(): Info {
     return new Info(this.json("info"));
   }
+
+  servers(): ServersInterface {
+    return new Servers(
+      Object.entries(this._json.servers).map(
+        ([serverName, server]) => new Server(serverName, server as Record<string, any>)
+      )
+    )
+  }
 }

src/models/v3/index.ts

@@ -5,4 +5,6 @@ export { License as LicenseV3 } from './license';
 export { Bindings as BindingsV3, Binding as BindingV3 } from './mixins/bindings';
 export { Extensions as ExtensionsV3, Extension as ExtensionV3 } from './mixins/extensions';
 export { ExternalDocumentation as ExternalDocumentationV3 } from './mixins/external-docs';
-export { Tags as TagsV3, Tag as TagV3 } from './mixins/tags';
+export { Tags as TagsV3, Tag as TagV3 } from './mixins/tags';
+export { Server as ServerV3 } from './server';
+export { Servers as ServersV3 } from './servers';

src/models/v3/server.ts

@@ -0,0 +1,34 @@
+import { Mixin } from '../utils';
+import { BaseModel } from '../base';
+import { ServerInterface } from '../server';
+import { DescriptionMixin } from './mixins/description';
+import { BindingsMixin } from './mixins/bindings';
+
+export class Server extends Mixin(BaseModel, DescriptionMixin, BindingsMixin) implements ServerInterface {
+    constructor(
+        private readonly _id: string,
+        _json: Record<string, any>
+    ){
+        super(_json);
+    }
+
+    id(): string {
+        return this._id;
+    }
+
+    protocol(): string | undefined {
+        return this.json('protocol');
+    }
+
+    hasProtocolVersion(): boolean {
+        return !!this.json('protocolVersion');
+    }
+
+    protocolVersion(): string {
+        return this.json('protocolVersion');
+    }
+
+    url(): string {
+        return this.json('url');
+    }
+}

src/models/v3/servers.ts

@@ -0,0 +1,13 @@
+import { Collection } from '../collection';
+import { ServerInterface } from '../server';
+import { ServersInterface } from '../servers';
+
+export class Servers extends Collection<ServerInterface> implements ServersInterface {
+    override get(id: string): ServerInterface | undefined {
+        return this.collections.find(server => server.id() === id);
+    }
+
+    override has(id: string): boolean {
+        return this.collections.some(server => server.id() === id);
+    }
+}

test/models/v2/asyncapi.spec.ts

@@ -1,4 +1,4 @@
-import { newAsyncAPIDocument, AsyncAPIDocumentV2, InfoV2, AsyncAPIDocumentV3 } from '../../../src/models';
+import { newAsyncAPIDocument, AsyncAPIDocumentV2, InfoV2, AsyncAPIDocumentV3, ServersV2 } from '../../../src/models';
 
 import { 
   assertExtensionsMixinInheritance,
@@ -27,6 +27,18 @@ describe('AsyncAPIDocument model', function() {
     });
   });
 
+  describe('.servers()', function(){
+    it('should return an servers object', function(){
+      const doc = {servers: {
+        development: {
+
+        }
+      }};
+      const d = new AsyncAPIDocumentV2(doc);
+      expect(d.servers() instanceof ServersV2).toBeTruthy();
+    })
+  })
+
   describe('mixins inheritance', function() {
     assertExtensionsMixinInheritance(AsyncAPIDocumentV2);
   });

test/models/v2/server.spec.ts

@@ -0,0 +1,124 @@
+import { Server } from '../../../src/models/v2/server';
+import { Servers } from '../../../src/models/v2/servers';
+
+const doc = {
+    'development': {
+        protocol: 'mqtt',
+        protocolVersion: '1.0.0',
+        url: 'development.gigantic-server.com'
+    }
+};
+const docItem = new Server('development', doc.development);
+const emptyItem = new Server('',{});
+
+describe('Servers model', function () {
+    describe('.isEmpty()', function () {
+        it('should return true if collection is empty', function () {
+            const servers = new Servers([]);
+            expect(servers.isEmpty()).toBeTruthy();
+        });
+
+        it('should return false if collection is not empty', function () {
+            const servers = new Servers([docItem]);
+            expect(servers.isEmpty()).toBeFalsy();
+        });
+    })
+
+    describe('.get(id)', function () {
+        it('should return a specific server Object if it is present', function () {
+            const servers = new Servers([docItem]);
+            expect(servers.get('development')).toBeTruthy();
+        });
+
+        it('should return undefined if a server is said Id is missing ', function () {
+            const servers = new Servers([]);
+            expect(servers.get('development')).toBeUndefined();
+        });
+    })
+
+    describe('.has(id)', function () {
+
+        const servers = new Servers([docItem]);
+
+        it('should return true if the said name is available', function () {
+            expect(servers.has('development')).toBeTruthy();
+        })
+
+        it('should return false if the server name is missing', function () {
+            expect(servers.has('production')).toBeFalsy();
+        })
+    })
+})
+
+describe('Server Model', function () {
+
+    describe('.id()', function () {
+        it('should return name if present', function () {
+            expect(docItem.id()).toMatch('development');
+        })
+
+        it('should return undefined if name is not present', function () {
+            expect(emptyItem.id()).toMatch('');
+        })
+    })
+
+    describe('.hasProtocol()', function () {
+        it('should return true if protocol is present', function () {
+            expect(docItem.hasProtocol()).toBeTruthy();
+        })
+
+        it('should return false if protocol is not present', function () {
+            expect(emptyItem.hasProtocol()).toBeFalsy();
+        })
+    })
+
+    describe('protocol()', function () {
+        it('should return protocol ', function () {
+            expect(docItem.protocol()).toMatch(doc.development.protocol);
+        })
+
+        it('should return undefined when protocol is missing', function () {
+            expect(emptyItem.protocol()).toBeUndefined();
+        })
+    })
+
+    describe('.hasProtocolVersion()', function () {
+        it('should return true if protocolVersion is not missing', function () {
+            expect(docItem.hasProtocolVersion()).toBeTruthy();
+        })
+
+        it('should be false when protocolVersion is missing', function () {
+            expect(emptyItem.hasProtocolVersion()).toBeFalsy();
+        })
+    })
+
+    describe('.protocolVersion()', function () {
+        it('should return protocolVersion', function () {
+            expect(docItem.protocolVersion()).toMatch(doc.development.protocolVersion);
+        })
+
+        it('should return undefined protocolVersion when protocolVersion is missing', function () {
+            expect(emptyItem.protocolVersion()).toBeUndefined();
+        })
+    })
+
+    describe('.hasUrl()', function () {
+        it('should return true if url is not missing', function () {
+            expect(docItem.hasUrl()).toBeTruthy();
+        })
+
+        it('should return false when url is missing', function () {
+            expect(emptyItem.hasUrl()).toBeFalsy();
+        })
+    })
+
+    describe('.url()', function () {
+        it('should return url', function () {
+            expect(docItem.url()).toMatch(doc.development.url);
+        })
+
+        it('should return undefined when url is missing', function () {
+            expect(emptyItem.url()).toBeUndefined();
+        })
+    })
+})