Refactor typescript code to reduce the library size (#350)

* refactor serializiation logic and attributeTypeMap

* remove serialization methods, fix raw object

* add required and name properties, and make format optional

* fix typo

* fix issues, add optional EnumValues

* make enumValues of type any

* fix enum checks

* remove enumValues from classes

* last working change

* change enumsMap map type to any[]

* remove discriminator and findCorrectType

* Regenerate client from commit 40ae541 of spec repo

Co-authored-by: NouemanKHAL <[email protected]>
Co-authored-by: api-clients-generation-pipeline[bot] <54105614+api-clients-generation-pipeline[bot]@users.noreply.github.com>
Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: 3 people

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.5.1.dev2",
-            "regenerated": "2021-11-03 12:23:56.257041",
-            "spec_repo_commit": "5a8a968"
+            "regenerated": "2021-11-03 13:12:22.209070",
+            "spec_repo_commit": "40ae541"
         },
         "v2": {
             "apigentools_version": "1.5.1.dev2",
-            "regenerated": "2021-11-03 12:23:56.280638",
-            "spec_repo_commit": "5a8a968"
+            "regenerated": "2021-11-03 13:12:22.241215",
+            "spec_repo_commit": "40ae541"
         }
     }
 }

.generator/templates/model/ObjectSerializer.mustache

@@ -22,23 +22,22 @@ const supportedMediaTypes: { [mediaType: string]: number } = {
   "application/octet-stream": 0
 }
 
-
-let enumsMap: Set<string> = new Set<string>([
+const enumsMap: {[key: string]: any[]} = {
     {{#models}}
         {{#model}}
             {{#isEnum}}
-    "{{classname}}{{enumName}}",
+    "{{classname}}{{enumName}}": [{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}]{{/allowableValues}},
             {{/isEnum}}
             {{#hasEnums}}
                 {{#vars}}
                     {{#isEnum}}
-    "{{classname}}{{enumName}}",
+    "{{classname}}{{enumName}}": [{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}]{{/allowableValues}},
                     {{/isEnum}}
                 {{/vars}}
             {{/hasEnums}}
         {{/model}}
     {{/models}}
-]);
+};
 
 let typeMap: {[index: string]: any} = {
     {{#models}}
@@ -58,41 +57,6 @@ let oneOfMap: {[index: string]: string[]} = {
 };
 
 export class ObjectSerializer {
-    public static findCorrectType(data: any, expectedType: string) {
-        if (data == undefined) {
-            return expectedType;
-        } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
-            return expectedType;
-        } else if (expectedType === "Date") {
-            return expectedType;
-        } else {
-            if (enumsMap.has(expectedType)) {
-                return expectedType;
-            }
-
-            if (!typeMap[expectedType]) {
-                return expectedType; // w/e we don't know the type
-            }
-
-            // Check the discriminator
-            let discriminatorProperty = typeMap[expectedType].discriminator;
-            if (discriminatorProperty == null) {
-                return expectedType; // the type does not have a discriminator. use it.
-            } else {
-                if (data[discriminatorProperty]) {
-                    var discriminatorType = data[discriminatorProperty];
-                    if(typeMap[discriminatorType]){
-                        return discriminatorType; // use the type given in the discriminator
-                    } else {
-                        return expectedType; // discriminator did not map to a type
-                    }
-                } else {
-                    return expectedType; // discriminator was not present (or an empty string)
-                }
-            }
-        }
-    }
-
     public static serialize(data: any, type: string, format: string) {
         if (data == undefined) {
             return data;
@@ -131,14 +95,17 @@ export class ObjectSerializer {
                 return data.toISOString();
             }
         } else {
-            if (enumsMap.has(type)) {
-                return data;
+            if (enumsMap[type]) {
+                if (enumsMap[type].includes(data)) {
+                  return data;
+                }
+                throw new TypeError(`unknown enum value '${data}'`)
             }
             if (oneOfMap[type]) {
                 let oneOfs: any[] = [];
                 for(let oneOf of oneOfMap[type]) {
                     try {
-                        oneOfs.push(ObjectSerializer.serialize(data, oneOf, format))
+                        oneOfs.push(ObjectSerializer.serialize(data, oneOf, format));
                     } catch (e) {
                         console.debug(`could not serialize ${oneOf} (${e})`)
                     }
@@ -152,17 +119,28 @@ export class ObjectSerializer {
                 return oneOfs[0];
             }
 
-            if (!typeMap[type]) { // dont know the type
-                throw new TypeError(`unknown type '${type}'`);
-            }
+            // get the map for the correct type.
+            let attributesMap = typeMap[type].getAttributeTypeMap();
+            let instance: {[index: string]: any} = {};
 
-            return typeMap[type].serialize(data);
+            for (let attributeName in attributesMap) {
+                let attributeObj = attributesMap[attributeName];
+                instance[attributeObj.baseName] = ObjectSerializer.serialize(data[attributeName], attributeObj.type, attributeObj.format);
+
+                // check for required properties
+                if (attributeObj?.required && instance[attributeObj.baseName] === undefined) {
+                    throw new Error(`missing required property '${attributeObj.baseName}'`);
+                }
+
+                if (enumsMap[attributeObj.type] && !enumsMap[attributeObj.type].includes(instance[attributeObj.baseName])) {
+                    instance.unparsedObject = instance[attributeObj.baseName];
+                }
+            }
+            return instance;
         }
     }
 
-    public static deserialize(data: any, type: string, format: string) {
-        // polymorphism may change the actual type.
-        type = ObjectSerializer.findCorrectType(data, type);
+    public static deserialize(data: any, type: string, format: string = "") {
         if (data == undefined) {
             return data;
         } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
@@ -188,8 +166,8 @@ export class ObjectSerializer {
         } else if (type === "Date") {
             return new Date(data);
         } else {
-            if (enumsMap.has(type)) {// is Enum
-                return data;
+            if (enumsMap[type]) {
+               return data;
             }
 
             if (oneOfMap[type]) {
@@ -214,7 +192,26 @@ export class ObjectSerializer {
             if (!typeMap[type]) { // dont know the type
                 throw new TypeError(`unknown type '${type}'`);
             }
-            return typeMap[type].deserialize(data);
+
+            let instance = new typeMap[type]();
+            let attributesMap = typeMap[type].getAttributeTypeMap();
+
+            for (let attributeName in attributesMap) {
+                let attributeObj = attributesMap[attributeName];
+                instance[attributeName] = ObjectSerializer.deserialize(data[attributeObj.baseName], attributeObj.type, attributeObj.format);
+
+                // check for required properties
+                if (attributeObj?.required && instance[attributeName] == undefined) {
+                    throw new Error(`missing required property '${attributeName}'`);
+                }
+
+                // check for enum values
+                if (enumsMap[attributeObj.type] && !enumsMap[attributeObj.type].includes(instance[attributeName])) {
+                    instance.unparsedObject = instance[attributeName];
+                }
+            }
+
+            return instance;
         }
     }
 

.generator/templates/model/model.mustache

@@ -25,20 +25,14 @@ export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
 
     'unparsedObject'?:any;
 
-    {{#discriminator}}
-    static readonly discriminator: string | undefined = "{{discriminatorName}}";
-    {{/discriminator}}
-    {{^discriminator}}
-    static readonly discriminator: string | undefined = undefined;
-    {{/discriminator}}
-
     {{^isArray}}
-    static readonly attributeTypeMap: {[key: string]: {baseName: string, type: string, format: string}} = {
+    static readonly attributeTypeMap: {[key: string]: {baseName: string, type: string, required?: boolean, format?: string}} = {
         {{#vars}}
         "{{name}}": {
             "baseName": "{{baseName}}",
             "type": "{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}",
-            "format": "{{dataFormat}}"
+            {{#required}}"required": {{required}},{{/required}}
+            {{#dataFormat}}"format": "{{.}}",{{/dataFormat}}
         }{{^-last}},
         {{/-last}}
         {{/vars}}
@@ -54,66 +48,6 @@ export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
     }
     {{/isArray}}
 
-    static deserialize(data: {[key: string]: any}): {{classname}} {
-      let res = new {{classname}}();
-
-      {{#vars}}
-        {{#required}}
-      if (data.{{{baseName}}} === undefined) {
-          throw new TypeError("missing required attribute '{{baseName}}' on '{{classname}}' object");
-      }
-        {{/required}}
-        {{#allowableValues}}
-      if ([{{#enumVars}}{{{value}}}, {{/enumVars}}undefined].includes(data.{{{baseName}}})) {
-          res.{{name}} = data.{{{baseName}}};
-      } else {
-          let raw = new {{classname}}();
-          raw.unparsedObject = data;
-          return raw;
-      }
-
-        {{/allowableValues}}
-        {{^allowableValues}}
-      res.{{{name}}} = ObjectSerializer.deserialize(data.{{{baseName}}}, "{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}", "{{dataFormat}}")
-        {{/allowableValues}}
-
-      {{/vars}}
-
-      return res;
-    }
-
-    static serialize(data: {{classname}}): {[key: string]: any} {
-        let attributeTypes = {{{classname}}}.getAttributeTypeMap();
-        let res: {[index: string]: any} = {};
-        for (let [key, value] of Object.entries(data)) {
-            if (!(key in attributeTypes)) {
-                throw new TypeError(`${key} attribute not in schema`);
-            }
-        }
-        if (data?.unparsedObject !== undefined) {
-            return data.unparsedObject;
-        }
-        {{#vars}}
-          {{#required}}
-        if (data.{{{name}}} === undefined) {
-            throw new TypeError("missing required attribute '{{baseName}}' on '{{classname}}' object");
-        }
-          {{/required}}
-          {{#allowableValues}}
-        if ([{{#enumVars}}{{{value}}}, {{/enumVars}}undefined].includes(data.{{{name}}})) {
-            res.{{baseName}} = data.{{{name}}};
-        } else {
-            throw TypeError(`invalid enum value ${ data.{{{name}}} } for {{name}}`);
-        }
-          {{/allowableValues}}
-          {{^allowableValues}}
-        res.{{{baseName}}} = ObjectSerializer.serialize(data.{{{name}}}, "{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}", "{{dataFormat}}")
-          {{/allowableValues}}
-
-        {{/vars}}
-        return res
-    }
-
     public constructor() {
         {{#parent}}
         super();

packages/datadog-api-client-v1/models/APIErrorResponse.ts

@@ -8,12 +8,6 @@
  * Do not edit the class manually.
  */
 
-import { ObjectSerializer } from "./ObjectSerializer";
-
-/**
- * Error response object.
- */
-
 export class APIErrorResponse {
   /**
    * Array of errors returned by the API.
@@ -22,55 +16,24 @@ export class APIErrorResponse {
 
   "unparsedObject"?: any;
 
-  static readonly discriminator: string | undefined = undefined;
-
   static readonly attributeTypeMap: {
-    [key: string]: { baseName: string; type: string; format: string };
+    [key: string]: {
+      baseName: string;
+      type: string;
+      required?: boolean;
+      format?: string;
+    };
   } = {
     errors: {
       baseName: "errors",
       type: "Array<string>",
-      format: "",
+      required: true,
     },
   };
 
   static getAttributeTypeMap() {
     return APIErrorResponse.attributeTypeMap;
   }
 
-  static deserialize(data: { [key: string]: any }): APIErrorResponse {
-    const res = new APIErrorResponse();
-
-    if (data.errors === undefined) {
-      throw new TypeError(
-        "missing required attribute 'errors' on 'APIErrorResponse' object"
-      );
-    }
-    res.errors = ObjectSerializer.deserialize(data.errors, "Array<string>", "");
-
-    return res;
-  }
-
-  static serialize(data: APIErrorResponse): { [key: string]: any } {
-    const attributeTypes = APIErrorResponse.getAttributeTypeMap();
-    const res: { [index: string]: any } = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (!(key in attributeTypes)) {
-        throw new TypeError(`${key} attribute not in schema`);
-      }
-    }
-    if (data?.unparsedObject !== undefined) {
-      return data.unparsedObject;
-    }
-    if (data.errors === undefined) {
-      throw new TypeError(
-        "missing required attribute 'errors' on 'APIErrorResponse' object"
-      );
-    }
-    res.errors = ObjectSerializer.serialize(data.errors, "Array<string>", "");
-
-    return res;
-  }
-
   public constructor() {}
 }