test: improve utils coverage (#4230)

* test: improve utils coverage

* refactor: review - rename isDefined to isNonNullable, update tests and return statement

packages/twenty-front/src/utils/array/__tests__/groupArrayItemsBy.test.ts

@@ -0,0 +1,25 @@
+import { groupArrayItemsBy } from '../groupArrayItemsBy';
+
+describe('groupArrayItemsBy', () => {
+  it('groups an array of objects by a computed key', () => {
+    // Given
+    const array = [
+      { id: '1', type: 'fruit', value: 'apple' },
+      { id: '2', type: 'fruit', value: 'banana' },
+      { id: '3', type: 'vegetable', value: 'carrot' },
+    ];
+    const computeGroupKey = ({ type }: (typeof array)[0]) => type;
+
+    // When
+    const result = groupArrayItemsBy(array, computeGroupKey);
+
+    // Then
+    expect(result).toEqual({
+      fruit: [
+        { id: '1', type: 'fruit', value: 'apple' },
+        { id: '2', type: 'fruit', value: 'banana' },
+      ],
+      vegetable: [{ id: '3', type: 'vegetable', value: 'carrot' }],
+    });
+  });
+});

packages/twenty-front/src/utils/array/__tests__/mapArrayToObject.test.ts

@@ -0,0 +1,23 @@
+import { mapArrayToObject } from '~/utils/array/mapArrayToObject';
+
+describe('mapArrayToObject', () => {
+  it('maps an array of objects to an object with computed keys', () => {
+    // Given
+    const array = [
+      { id: '1', value: 'one' },
+      { id: '2', value: 'two' },
+      { id: '3', value: 'three' },
+    ];
+    const computeItemKey = ({ id }: { id: string }) => id;
+
+    // When
+    const result = mapArrayToObject(array, computeItemKey);
+
+    // Then
+    expect(result).toEqual({
+      '1': { id: '1', value: 'one' },
+      '2': { id: '2', value: 'two' },
+      '3': { id: '3', value: 'three' },
+    });
+  });
+});

packages/twenty-front/src/utils/array/groupArrayItemsBy.ts

@@ -1,8 +1,30 @@
-export const groupArrayItemsBy = <Item, Key extends string>(
-  array: Item[],
-  computeGroupKey: (item: Item) => Key,
+/**
+ * Groups an array of items by a key computed from each item.
+ *
+ * @param array - The array to group.
+ * @param computeGroupKey - A function that computes the group key to which the item belongs.
+ *
+ * @returns An object with items grouped by a computed key.
+ *
+ * @example
+ * groupArrayItemsBy(
+ *   [{ id: '1', type: 'fruit' }, { id: '2', type: 'vegetable' }, { id: '3', type: 'fruit' }],
+ *   ({ type }) => type,
+ * )
+ * ⬇️
+ * {
+ *   fruit: [{ id: '1', type: 'fruit' }, { id: '3', type: 'fruit' }],
+ *   vegetable: [{ id: '2', type: 'vegetable' }],
+ * }
+ */
+export const groupArrayItemsBy = <
+  ArrayItem extends Record<string, unknown>,
+  Key extends string,
+>(
+  array: ArrayItem[],
+  computeGroupKey: (item: ArrayItem) => Key,
 ) =>
-  array.reduce<Partial<Record<Key, Item[]>>>((result, item) => {
+  array.reduce<Partial<Record<Key, ArrayItem[]>>>((result, item) => {
     const groupKey = computeGroupKey(item);
     const previousGroup = result[groupKey] || [];
 

packages/twenty-front/src/utils/array/mapArrayToObject.ts

@@ -1,4 +1,27 @@
-export const mapArrayToObject = <ArrayItem>(
+/**
+ * Transforms an array of items into an object where the keys are computed from each item.
+ *
+ * @param array - The array to transform.
+ * @param computeItemKey - A function that computes a key from an item.
+ *
+ * @returns An object where the keys are computed from the items in the array.
+ *
+ * @example
+ * mapArrayToObject(
+ *   [{ id: '1', type: 'fruit' }, { id: '2', type: 'vegetable' }, { id: '3', type: 'fruit' }],
+ *   ({ id }) => id,
+ * )
+ * ⬇️
+ * {
+ *  '1': { id: '1', type: 'fruit' },
+ *  '2': { id: '2', type: 'vegetable' },
+ *  '3': { id: '3', type: 'fruit' },
+ * }
+ */
+export const mapArrayToObject = <ArrayItem, Key extends string>(
   array: ArrayItem[],
-  computeItemKey: (item: ArrayItem) => string,
-) => Object.fromEntries(array.map((item) => [computeItemKey(item), item]));
+  computeItemKey: (item: ArrayItem) => Key,
+) =>
+  Object.fromEntries(
+    array.map((item) => [computeItemKey(item), item]),
+  ) as Record<Key, ArrayItem>;

packages/twenty-front/src/utils/array/moveArrayItem.ts

@@ -1,5 +1,19 @@
-export const moveArrayItem = <Item>(
-  array: Item[],
+/**
+ * Moves an item in an array from one index to another.
+ *
+ * @param array - The array to move an item in.
+ * @param indices - The indices to move the item from and to.
+ * @param indices.fromIndex - The index to move the item from.
+ * @param indices.toIndex - The index to move the item to.
+ *
+ * @returns A new array with the item moved to the new index.
+ *
+ * @example
+ * moveArrayItem(['a', 'b', 'c'], { fromIndex: 0, toIndex: 2 })
+ * => ['b', 'c', 'a']
+ */
+export const moveArrayItem = <ArrayItem>(
+  array: ArrayItem[],
   { fromIndex, toIndex }: { fromIndex: number; toIndex: number },
 ) => {
   if (!(fromIndex in array) || !(toIndex in array) || fromIndex === toIndex) {