Feat/activity optimistic activities (#4009)

* Fix naming

* Fixed cache.evict bug for relation target deletion

* Fixed cascade delete activity targets

* Working version

* Fix

* fix

* WIP

* Fixed optimistic effect target inline cell

* Removed openCreateActivityDrawer v1

* Ok for timeline

* Removed console.log

* Fix update record optimistic effect

* Refactored activity queries into useActivities for everything

* Fixed bugs

* Cleaned

* Fix lint

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-front/src/modules/object-record/utils/sortByObjectRecordId.ts

@@ -0,0 +1,5 @@
+import { ObjectRecord } from '@/object-record/types/ObjectRecord';
+
+export const sortByObjectRecordId = (a: ObjectRecord, b: ObjectRecord) => {
+  return a.id.localeCompare(b.id);
+};

packages/twenty-front/src/modules/object-record/utils/sortObjectRecordByDateField.test.ts

@@ -0,0 +1,77 @@
+import { OrderBy } from '@/object-metadata/types/OrderBy';
+
+import { sortObjectRecordByDateField } from './sortObjectRecordByDateField';
+
+describe('sortByObjectRecordByCreatedAt', () => {
+  const recordOldest = { id: '', createdAt: '2022-01-01T00:00:00.000Z' };
+  const recordNewest = { id: '', createdAt: '2022-01-02T00:00:00.000Z' };
+  const recordNull1 = { id: '', createdAt: null };
+  const recordNull2 = { id: '', createdAt: null };
+
+  it('should sort in ascending order with null values first', () => {
+    const sortDirection = 'AscNullsFirst' satisfies OrderBy;
+    const sortedArray = [
+      recordNull2,
+      recordNewest,
+      recordNull1,
+      recordOldest,
+    ].sort(sortObjectRecordByDateField('createdAt', sortDirection));
+
+    expect(sortedArray).toEqual([
+      recordNull1,
+      recordNull2,
+      recordOldest,
+      recordNewest,
+    ]);
+  });
+
+  it('should sort in descending order with null values first', () => {
+    const sortDirection = 'DescNullsFirst' satisfies OrderBy;
+    const sortedArray = [
+      recordNull2,
+      recordOldest,
+      recordNewest,
+      recordNull1,
+    ].sort(sortObjectRecordByDateField('createdAt', sortDirection));
+
+    expect(sortedArray).toEqual([
+      recordNull2,
+      recordNull1,
+      recordNewest,
+      recordOldest,
+    ]);
+  });
+  it('should sort in ascending order with null values last', () => {
+    const sortDirection = 'AscNullsLast' satisfies OrderBy;
+    const sortedArray = [
+      recordOldest,
+      recordNull2,
+      recordNewest,
+      recordNull1,
+    ].sort(sortObjectRecordByDateField('createdAt', sortDirection));
+
+    expect(sortedArray).toEqual([
+      recordOldest,
+      recordNewest,
+      recordNull1,
+      recordNull2,
+    ]);
+  });
+
+  it('should sort in descending order with null values last', () => {
+    const sortDirection = 'DescNullsLast' satisfies OrderBy;
+    const sortedArray = [
+      recordNull1,
+      recordOldest,
+      recordNewest,
+      recordNull2,
+    ].sort(sortObjectRecordByDateField('createdAt', sortDirection));
+
+    expect(sortedArray).toEqual([
+      recordNewest,
+      recordOldest,
+      recordNull1,
+      recordNull2,
+    ]);
+  });
+});

packages/twenty-front/src/modules/object-record/utils/sortObjectRecordByDateField.ts

@@ -0,0 +1,68 @@
+import { DateTime } from 'luxon';
+
+import { OrderBy } from '@/object-metadata/types/OrderBy';
+import { ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { isDefined } from '~/utils/isDefined';
+
+const SORT_BEFORE = -1;
+const SORT_AFTER = 1;
+const SORT_EQUAL = 0;
+
+export const sortObjectRecordByDateField =
+  <T extends ObjectRecord>(dateField: keyof T, sortDirection: OrderBy) =>
+  (a: T, b: T) => {
+    const aDate = a[dateField];
+    const bDate = b[dateField];
+
+    if (!isDefined(aDate) && !isDefined(bDate)) {
+      return SORT_EQUAL;
+    }
+
+    if (!isDefined(aDate)) {
+      if (sortDirection === 'AscNullsFirst') {
+        return SORT_BEFORE;
+      } else if (sortDirection === 'DescNullsFirst') {
+        return SORT_BEFORE;
+      } else if (sortDirection === 'AscNullsLast') {
+        return SORT_AFTER;
+      } else if (sortDirection === 'DescNullsLast') {
+        return SORT_AFTER;
+      }
+
+      throw new Error(`Invalid sortDirection: ${sortDirection}`);
+    }
+
+    if (!isDefined(bDate)) {
+      if (sortDirection === 'AscNullsFirst') {
+        return SORT_AFTER;
+      } else if (sortDirection === 'DescNullsFirst') {
+        return SORT_AFTER;
+      } else if (sortDirection === 'AscNullsLast') {
+        return SORT_BEFORE;
+      } else if (sortDirection === 'DescNullsLast') {
+        return SORT_BEFORE;
+      }
+
+      throw new Error(`Invalid sortDirection: ${sortDirection}`);
+    }
+
+    const differenceInMs = DateTime.fromISO(aDate)
+      .diff(DateTime.fromISO(bDate))
+      .as('milliseconds');
+
+    if (differenceInMs === 0) {
+      return SORT_EQUAL;
+    } else if (
+      sortDirection === 'AscNullsFirst' ||
+      sortDirection === 'AscNullsLast'
+    ) {
+      return differenceInMs > 0 ? SORT_AFTER : SORT_BEFORE;
+    } else if (
+      sortDirection === 'DescNullsFirst' ||
+      sortDirection === 'DescNullsLast'
+    ) {
+      return differenceInMs > 0 ? SORT_BEFORE : SORT_AFTER;
+    }
+
+    throw new Error(`Invalid sortDirection: ${sortDirection}`);
+  };