reduce complexity of the code

Author: Philip-Carneiro

src/utils/uda.ts

@@ -35,7 +35,9 @@ export function filterUDAParamsValidTypes(type: number | number[]): number[] {
   return typesArray.filter(validTypes.has, validTypes);
 }
 
-export function getUDAParamType(type: ParamFieldType): string | string[] {
+export function getUDAParamType(
+  type: ParamFieldType | ParamFieldType[],
+): string | string[] {
   if (Array.isArray(type)) {
     return type.map(
       (t) => ext.constants.dataTypes.get(t.toString()) ?? t.toString(),
@@ -150,35 +152,55 @@ export function convertTypesToString(returnType: number[]): string[] {
   );
 }
 
+export function getIncompatibleError(
+  metadata: any,
+  parsedParams: any,
+): InvalidParamFieldErrors | undefined {
+  if (!metadata) {
+    return InvalidParamFieldErrors.NoMetadata;
+  }
+  if (parsedParams === ParamFieldType.Invalid) {
+    return InvalidParamFieldErrors.BadField;
+  }
+  return undefined;
+}
+
+export function createUDAReturn(metadata: any): UDAReturn {
+  return {
+    type: convertTypesToString(metadata?.return.type || []),
+    description: metadata?.return.description || "",
+  };
+}
+
+export function createUDAObject(
+  uda: any,
+  parsedParams: any,
+  incompatibleError: any,
+): UDA {
+  return {
+    name: uda.api,
+    description: uda.metadata?.description || "",
+    params: Array.isArray(parsedParams) ? parsedParams : [],
+    return: createUDAReturn(uda.metadata),
+    incompatibleError,
+  };
+}
+
 export function parseUDAList(getMeta: MetaObjectPayload): UDA[] {
   const UDAs: UDA[] = [];
   if (getMeta.api !== undefined) {
     const getMetaUDAs = getMeta.api.filter((api) => api.custom === true);
     if (getMetaUDAs.length !== 0) {
       for (const uda of getMetaUDAs) {
         const parsedParams = parseUDAParams(uda.metadata?.params);
-        let incompatibleError = undefined;
-        if (!uda.metadata) {
-          incompatibleError = InvalidParamFieldErrors.NoMetadata;
-        }
-        if (parsedParams === ParamFieldType.Invalid) {
-          incompatibleError = InvalidParamFieldErrors.BadField;
-        }
-        const returnData: UDAReturn = {
-          type: convertTypesToString(uda.metadata?.return.type || []),
-          description: uda.metadata?.return.description || "",
-        };
-        UDAs.push({
-          name: uda.api,
-          description: uda.metadata?.description || "",
-          params: Array.isArray(parsedParams) ? parsedParams : [],
-          return: returnData,
-          incompatibleError,
-        });
+        const incompatibleError = getIncompatibleError(
+          uda.metadata,
+          parsedParams,
+        );
+        UDAs.push(createUDAObject(uda, parsedParams, incompatibleError));
       }
     }
   }
-
   return UDAs;
 }
 

test/suite/utils.test.ts

@@ -2097,6 +2097,19 @@ describe("Utils", () => {
         const result = UDAUtils.getUDAParamType(type);
         assert.strictEqual(result, "boolean");
       });
+
+      it("should return the correct types string", () => {
+        const type = [ParamFieldType.Boolean, ParamFieldType.Number];
+        const dataTypes = new Map([
+          ["1", "Boolean"],
+          ["2", "Number"],
+        ]);
+        const expectedRes = ["boolean", "number"];
+        sinon.stub(ext.constants, "dataTypes").value(dataTypes);
+
+        const result = UDAUtils.getUDAParamType(type);
+        assert.strictEqual(result.toString(), expectedRes.toString());
+      });
     });
 
     describe("getUDAFieldType", () => {
@@ -2193,6 +2206,15 @@ describe("Utils", () => {
         const result = UDAUtils.convertTypesToString(types);
         assert.deepStrictEqual(result, ["Boolean", "Number"]);
       });
+
+      it("should convert type to string", () => {
+        const types = [1];
+        const dataTypes = new Map([["1", "Boolean"]]);
+        sinon.stub(ext.constants, "dataTypes").value(dataTypes);
+
+        const result = UDAUtils.convertTypesToString(types);
+        assert.deepStrictEqual(result, ["Boolean"]);
+      });
     });
 
     describe("parseUDAList", () => {