chore(mesh-config): create standarized api call

plugins/lime-plugin-mesh-wide-upgrade/src/meshUpgradeApi.tsx

@@ -1,7 +1,4 @@
-import {
-    MeshUpgradeApiError,
-    callToRemoteNode,
-} from "components/shared-state/SharedStateApi";
+import { callToRemoteNode } from "components/shared-state/SharedStateApi";
 import { sharedStateQueries } from "components/shared-state/SharedStateQueriesKeys";
 
 import { meshUpgradeSharedStateKey } from "plugins/lime-plugin-mesh-wide-upgrade/src/meshUpgradeQueriesKeys";
@@ -11,20 +8,16 @@ import {
     NodeMeshUpgradeInfo,
 } from "plugins/lime-plugin-mesh-wide-upgrade/src/meshUpgradeTypes";
 
+import { ApiServiceParamsType, standarizedApiCall } from "utils/standarizedApi";
 import api, { UhttpdService } from "utils/uhttpd.service";
 
-// todo(kon): refactor this to use doSharedStateApiCall??
 export const getMeshWideUpgradeInfo = async () => {
     const query = sharedStateQueries.getFromSharedState(
         meshUpgradeSharedStateKey
     );
-    const res = await api.call(...query);
-    if (res.error) {
-        throw new Error(
-            `Error getting mesh wide upgrade info from shared state async, code error ${res.error}`
-        );
-    }
-    return res.data as MeshWideUpgradeInfo;
+    return standarizedApiCall<MeshWideUpgradeInfo>({
+        args: query as ApiServiceParamsType,
+    });
 };
 
 export const getMeshUpgradeNodeStatus = async () => {
@@ -76,13 +69,10 @@ const meshUpgradeApiCall = async (
     customApi?: UhttpdService
 ) => {
     const httpService = customApi || api;
-    const res = (await httpService.call(
-        "lime-mesh-upgrade",
-        method,
-        {}
-    )) as MeshWideRPCReturnTypes;
-    if (res.error) {
-        throw new MeshUpgradeApiError(res.error, res.code);
-    }
-    return res.code;
+    return (
+        (await standarizedApiCall({
+            apiService: httpService,
+            args: ["lime-mesh-upgrade", method, {}],
+        })) as MeshWideRPCReturnTypes
+    ).code;
 };

src/components/shared-state/SharedStateApi.ts

@@ -7,9 +7,8 @@ import {
     SharedStateReturnType,
 } from "components/shared-state/SharedStateTypes";
 
-import { MeshUpgradeApiErrorTypes } from "plugins/lime-plugin-mesh-wide-upgrade/src/meshUpgradeTypes";
-
 import { login } from "utils/queries";
+import { StandarizedApiError } from "utils/standarizedApi";
 import { UhttpdService, default as defaultApi } from "utils/uhttpd.service";
 
 async function syncDataType({
@@ -92,7 +91,7 @@ export async function callToRemoteNode<T>({
         return await apiCall(customApi);
     } catch (error) {
         let additionalInfo = "";
-        if (error instanceof MeshUpgradeApiError) {
+        if (error instanceof StandarizedApiError) {
             additionalInfo = `: ${error.message}`;
         }
         throw new RemoteNodeCallError(
@@ -116,15 +115,3 @@ export class RemoteNodeCallError extends Error {
         Object.setPrototypeOf(this, RemoteNodeCallError.prototype);
     }
 }
-
-export class MeshUpgradeApiError extends Error {
-    message: string;
-    code: MeshUpgradeApiErrorTypes;
-    constructor(message: string, code: MeshUpgradeApiErrorTypes) {
-        super(message); // Pass the message to the Error constructor
-        this.name = "MeshUpgradeApiError"; // Set the name of the error
-        this.message = message;
-        this.code = code;
-        Object.setPrototypeOf(this, MeshUpgradeApiError.prototype);
-    }
-}

src/components/shared-state/SharedStateQueriesKeys.ts

@@ -3,10 +3,24 @@ import {
     SharedStateDataTypeKeys,
 } from "components/shared-state/SharedStateTypes";
 
-const getFromSharedStateKey = ["shared-state-async", "get"];
-const insertIntoSharedStateKey = ["shared-state-async", "insert"];
-export const syncFromSharedStateKey = ["shared-state-async", "sync"];
-const publishAllFromSharedStateKey = ["shared-state-async", "publish_all"];
+import { ApiServiceParamsType } from "utils/standarizedApi";
+
+const getFromSharedStateKey: ApiServiceParamsType = [
+    "shared-state-async",
+    "get",
+];
+const insertIntoSharedStateKey: ApiServiceParamsType = [
+    "shared-state-async",
+    "insert",
+];
+export const syncFromSharedStateKey: ApiServiceParamsType = [
+    "shared-state-async",
+    "sync",
+];
+const publishAllFromSharedStateKey: ApiServiceParamsType = [
+    "shared-state-async",
+    "publish_all",
+];
 
 /**
  * Use this constant to get the query keys to be used as api call parameters.

src/utils/standarizedApi.ts

@@ -0,0 +1,42 @@
+import { MeshUpgradeApiErrorTypes } from "plugins/lime-plugin-mesh-wide-upgrade/src/meshUpgradeTypes";
+
+import api, { UhttpdService } from "utils/uhttpd.service";
+
+export type ApiServiceParamsType = [string, string, object?];
+
+// This a util function for standarizes API return calls
+// During the development some methods are thought to have a specific return type:
+// {
+//    data: T;
+//    error: number;
+// }
+// This is a wrapper function to do the calls to the methods that contains this return type
+// Pass the array of arguments that api.call method needs.
+export const standarizedApiCall = async <T>({
+    apiService = api,
+    args,
+}: {
+    apiService?: UhttpdService;
+    args: ApiServiceParamsType;
+}) => {
+    const res = await apiService.call(...args);
+    if (res?.error) {
+        throw new StandarizedApiError(res.error, res.code);
+    }
+    if (res.data) return res.data as T;
+    // Fallback to return the response if there is no data
+    return res as T;
+};
+
+export class StandarizedApiError extends Error {
+    message: string;
+    code: MeshUpgradeApiErrorTypes;
+
+    constructor(message: string, code: MeshUpgradeApiErrorTypes) {
+        super(message); // Pass the message to the Error constructor
+        this.name = "MeshUpgradeApiError"; // Set the name of the error
+        this.message = message;
+        this.code = code;
+        Object.setPrototypeOf(this, StandarizedApiError.prototype);
+    }
+}