refactor: add models for server object

src/models/server-security-requirement.ts

@@ -0,0 +1,5 @@
+import { BaseModel } from "./base";
+
+export interface ServerSecurityRequirementInterface extends BaseModel {
+
+}

src/models/server-variables.ts

@@ -0,0 +1,10 @@
+import { BaseModel } from "./base";
+
+export interface ServerVariableInterface extends BaseModel {
+    allowedValues(): any[];
+    allows(name: string): boolean;
+    hasAllowedValues(): boolean;
+    defaultValue(): string;
+    hasDefaultValue(): boolean;
+    examples(): [string]
+}

src/models/server.ts

@@ -0,0 +1,13 @@
+import { BaseModel } from "./base";
+import { ServerSecurityRequirementInterface } from "./server-security-requirement";
+import { ServerVariableInterface } from "./server-variables";
+
+export interface ServerInterface extends BaseModel {
+    url(): string;
+    protocol(): string;
+    protocolVersion(): string
+    variables(): Record<string, ServerVariableInterface>;
+    variable(name: string): ServerVariableInterface;
+    hasVariables(): boolean;
+    security(): [ServerSecurityRequirementInterface] | undefined;
+}

src/models/utils.ts

@@ -0,0 +1,22 @@
+
+function getMapValue(obj: any, key: string, type: any, options?: any) {
+    if (typeof key !== 'string' || !obj) return null;
+    const v = obj[String(key)];
+    if (v === undefined) return null;
+    return type ? new type(v, options) : v;
+};
+
+export function createMapOfTypes(obj: any, type: any, options?: any) {
+    const result: Record<string, any> = {};
+    if (!obj) return result;
+
+    for (let [key, value] of Object.entries(obj)) {
+        result[String(key)] = new type(value, options);
+    }
+
+    return result;
+}
+
+export function getMapValueOfType(obj: any, key: string, type: any, options?: any) {
+    return getMapValue(obj, key, type, options);
+}

src/models/v2/server-security-requirement.ts

@@ -0,0 +1,6 @@
+import { BaseModel } from '../base';
+import { ServerSecurityRequirementInterface } from '../server-security-requirement';
+
+export class ServerSecurityRequirement extends BaseModel implements ServerSecurityRequirementInterface {
+
+}

src/models/v2/server-variable.ts

@@ -0,0 +1,29 @@
+import {ServerVariableInterface} from '../server-variables';
+import {BaseModel} from '../base';
+
+export class ServerVariable extends BaseModel implements ServerVariableInterface {
+    allowedValues(): any[] {
+        return this.json('enum');
+    }
+
+    allows(name: string): boolean {
+        if(this.json('enum') === undefined) return true;
+        return this.json('enum').includes(name);
+    }
+
+    hasAllowedValues(): boolean {
+        return this.json('enum') !== undefined;
+    }
+
+    defaultValue(): string {
+        return this.json('default');
+    }
+
+    hasDefaultValue(): boolean {
+        return this.json('default') !== undefined;
+    }
+
+    examples(): [string] {
+        return this.json('examples');
+    }
+}

src/models/v2/server.ts

@@ -0,0 +1,39 @@
+import { createMapOfTypes, getMapValueOfType } from '../utils';
+import { ServerVariableInterface } from 'models/server-variables';
+import { BaseModel } from '../base';
+import { ServerInterface } from "../server";
+import { ServerVariable } from './server-variable';
+import { ServerSecurityRequirementInterface } from 'models/server-security-requirement';
+import { ServerSecurityRequirement } from './server-security-requirement';
+import { BindingsMixin, DescriptionMixin, Mixin, SpecificationExtensionsMixin } from 'models/mixins';
+
+export class Server extends Mixin(BaseModel, DescriptionMixin, BindingsMixin, SpecificationExtensionsMixin) implements ServerInterface {
+    url(): string {
+        return this.json('url');
+    }
+
+    protocol(): string {
+        return this.json('protocol');
+    }
+
+    protocolVersion(): string {
+        return this.json('protocolVersion');
+    }
+
+    variables(): Record<string, ServerVariableInterface> {
+        return createMapOfTypes(this.json('variables'), ServerVariable)
+    }
+
+    variable(name: string): ServerVariableInterface {
+        return getMapValueOfType(this.json('variables'), name, ServerVariable);
+    }
+
+    hasVariables(): boolean {
+        return !!this.json('variables');
+    }
+
+    security(): [ServerSecurityRequirementInterface] {
+        return this.json('security').map((sec: any) => new ServerSecurityRequirement(sec))
+    }
+
+}