Fix update metadata (#3560)

src/utils/handlers/metadataUpdateHandler.test.ts

@@ -0,0 +1,235 @@
+import { MetadataFormData } from "@dashboard/components/Metadata";
+
+import createMetadataUpdateHandler, {
+  ObjectWithMetadata,
+} from "./metadataUpdateHandler";
+
+describe("createMetadataUpdateHandler", () => {
+  it("should return array of errors when update function return errors", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [],
+      privateMetadata: [],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve(["error1", "error2"]));
+    const metadataUpdateFun = jest.fn();
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual(["error1", "error2"]);
+  });
+
+  it("should call only updateMetadata mutation", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual([]);
+    expect(metadataUpdateFun).toHaveBeenLastCalledWith({
+      id: intialData.id,
+      input: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      keysToDelete: [],
+    });
+    expect(privateMetadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should call only updatePrivateMetadata mutation", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [],
+      privateMetadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn();
+    const privateMetadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual([]);
+    expect(privateMetadataUpdateFun).toHaveBeenLastCalledWith({
+      id: intialData.id,
+      input: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      keysToDelete: [],
+    });
+    expect(metadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should return updateMetadata errors if exists", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [
+        {
+          key: "privateTestKey",
+          value: "privateTestValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {
+          deleteMetadata: {
+            errors: ["error1", "error2"],
+          },
+        },
+      }),
+    ) as any;
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual(["error1", "error2"]);
+    expect(privateMetadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should return updatePrivateMetadata errors if exists", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+
+    const privateMetadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {
+          deletePrivateMetadata: {
+            errors: ["privateError1", "privateError2"],
+          },
+        },
+      }),
+    ) as any;
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(metadataUpdateFun).toHaveBeenCalled();
+    expect(result).toEqual(["privateError1", "privateError2"]);
+  });
+});

src/utils/handlers/metadataUpdateHandler.ts

@@ -14,7 +14,7 @@ import { arrayDiff } from "@dashboard/utils/arrays";
 import { filterMetadataArray } from "./filterMetadataArray";
 import { areMetadataArraysEqual } from "./metadataUpdateHelpers";
 
-interface ObjectWithMetadata {
+export interface ObjectWithMetadata {
   id: string;
   metadata: MetadataInput[];
   privateMetadata: MetadataInput[];
@@ -54,20 +54,23 @@ function createMetadataUpdateHandler<TData extends MetadataFormData, TError>(
         const modifiedKeys = data.metadata.map(m => m.key);
 
         const keyDiff = arrayDiff(initialKeys, modifiedKeys);
+        const metadataInput = filterMetadataArray(data.metadata);
 
-        const updateMetaResult = await updateMetadata({
+        if (metadataInput.length) {
-          id: initial.id,
+          const updateMetaResult = await updateMetadata({
-          input: filterMetadataArray(data.metadata),
+            id: initial.id,
-          keysToDelete: keyDiff.removed,
+            input: metadataInput,
-        });
+            keysToDelete: keyDiff.removed,
+          });
 
-        const updateMetaErrors = [
+          const updateMetaErrors = [
-          ...(updateMetaResult.data?.deleteMetadata?.errors || []),
+            ...(updateMetaResult.data?.deleteMetadata?.errors || []),
-          ...(updateMetaResult.data?.updateMetadata?.errors || []),
+            ...(updateMetaResult.data?.updateMetadata?.errors || []),
-        ];
+          ];
 
-        if (updateMetaErrors.length > 0) {
+          if (updateMetaErrors.length > 0) {
-          return updateMetaErrors;
+            return updateMetaErrors;
+          }
         }
       }
 
@@ -76,22 +79,25 @@ function createMetadataUpdateHandler<TData extends MetadataFormData, TError>(
         const modifiedKeys = data.privateMetadata.map(m => m.key);
 
         const keyDiff = arrayDiff(initialKeys, modifiedKeys);
+        const privateMetadataInput = filterMetadataArray(data.privateMetadata);
 
-        const updatePrivateMetaResult = await updatePrivateMetadata({
+        if (privateMetadataInput.length) {
-          id: initial.id,
+          const updatePrivateMetaResult = await updatePrivateMetadata({
-          input: filterMetadataArray(data.privateMetadata),
+            id: initial.id,
-          keysToDelete: keyDiff.removed,
+            input: privateMetadataInput,
-        });
+            keysToDelete: keyDiff.removed,
+          });
 
-        const updatePrivateMetaErrors = [
+          const updatePrivateMetaErrors = [
-          ...(updatePrivateMetaResult.data?.deletePrivateMetadata?.errors ||
+            ...(updatePrivateMetaResult.data?.deletePrivateMetadata?.errors ||
-            []),
+              []),
-          ...(updatePrivateMetaResult.data?.updatePrivateMetadata?.errors ||
+            ...(updatePrivateMetaResult.data?.updatePrivateMetadata?.errors ||
-            []),
+              []),
-        ];
+          ];
 
-        if (updatePrivateMetaErrors.length > 0) {
+          if (updatePrivateMetaErrors.length > 0) {
-          return updatePrivateMetaErrors;
+            return updatePrivateMetaErrors;
+          }
         }
       }
     }