Ok

Author: lucasbordeau

packages/twenty-front/src/hooks/useHTMLElementByIdWhenAvailable.ts

@@ -14,6 +14,7 @@ export const useHTMLElementByIdWhenAvailable = (id: string) => {
 
     if (isDefined(elementFoundBeforeObservingMutation)) {
       setElement(elementFoundBeforeObservingMutation);
+
       return;
     }
 

packages/twenty-front/src/modules/activities/hooks/useActivityTargetObjectRecords.ts

@@ -7,19 +7,20 @@ import { type TaskTarget } from '@/activities/types/TaskTarget';
 import { getActivityTargetObjectRecords } from '@/activities/utils/getActivityTargetObjectRecords';
 import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
 import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
+import { type Nullable } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
 
 export const useActivityTargetObjectRecords = (
   activityRecordId?: string,
-  activityTargets?: NoteTarget[] | TaskTarget[],
+  activityTargets?: Nullable<NoteTarget[] | TaskTarget[]>,
 ) => {
   const objectMetadataItems = useRecoilValue(objectMetadataItemsState);
 
   const activity = useRecoilValue(
     recordStoreFamilyState(activityRecordId ?? ''),
   ) as Note | Task | null;
 
-  if (!isDefined(activity) && !isDefined(activityTargets)) {
+  if (!isDefined(activity) || !isDefined(activityTargets)) {
     return { activityTargetObjectRecords: [] };
   }
 

packages/twenty-front/src/modules/object-record/hooks/useBatchCreateManyRecords.ts

@@ -6,6 +6,7 @@ import {
   type useCreateManyRecordsProps,
 } from '@/object-record/hooks/useCreateManyRecords';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { useSnackBar } from '@/ui/feedback/snack-bar-manager/hooks/useSnackBar';
 import { ApolloError } from '@apollo/client';
@@ -26,6 +27,8 @@ export const useBatchCreateManyRecords = <
   setBatchedRecordsCount?: (count: number) => void;
   abortController?: AbortController;
 }) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
+
   const { createManyRecords } = useCreateManyRecords({
     objectNameSingular,
     recordGqlFields,
@@ -97,6 +100,8 @@ export const useBatchCreateManyRecords = <
 
     await refetchAggregateQueries();
 
+    registerObjectOperation(objectNameSingular, { type: 'create-many' });
+
     return allCreatedRecords;
   };
 

packages/twenty-front/src/modules/object-record/hooks/useCreateManyRecords.ts

@@ -16,6 +16,7 @@ import { generateDepthOneRecordGqlFields } from '@/object-record/graphql/utils/g
 import { useCreateManyRecordsMutation } from '@/object-record/hooks/useCreateManyRecordsMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type FieldActorForInputValue } from '@/object-record/record-field/ui/types/FieldMetadata';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { computeOptimisticRecordFromInput } from '@/object-record/utils/computeOptimisticRecordFromInput';
@@ -49,6 +50,8 @@ export const useCreateManyRecords = <
   shouldMatchRootQueryFilter,
   shouldRefetchAggregateQueries = true,
 }: useCreateManyRecordsProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
+
   const apolloCoreClient = useApolloCoreClient();
 
   const { objectMetadataItem } = useObjectMetadataItem({
@@ -224,7 +227,11 @@ export const useCreateManyRecords = <
         throw error;
       });
 
-    if (shouldRefetchAggregateQueries) await refetchAggregateQueries();
+    if (shouldRefetchAggregateQueries) {
+      await refetchAggregateQueries();
+    }
+
+    registerObjectOperation(objectNameSingular, { type: 'create-many' });
 
     return createdObjects.data?.[mutationResponseField] ?? [];
   };

packages/twenty-front/src/modules/object-record/hooks/useCreateOneRecord.ts

@@ -16,6 +16,7 @@ import { generateDepthOneRecordGqlFields } from '@/object-record/graphql/utils/g
 import { useCreateOneRecordMutation } from '@/object-record/hooks/useCreateOneRecordMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { computeOptimisticCreateRecordBaseRecordInput } from '@/object-record/utils/computeOptimisticCreateRecordBaseRecordInput';
 import { computeOptimisticRecordFromInput } from '@/object-record/utils/computeOptimisticRecordFromInput';
@@ -39,6 +40,7 @@ export const useCreateOneRecord = <
   skipPostOptimisticEffect = false,
   shouldMatchRootQueryFilter,
 }: useCreateOneRecordProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
   const apolloCoreClient = useApolloCoreClient();
   const [loading, setLoading] = useState(false);
 
@@ -170,6 +172,9 @@ export const useCreateOneRecord = <
       });
 
     await refetchAggregateQueries();
+
+    registerObjectOperation(objectNameSingular, { type: 'create-one' });
+
     return createdObject.data?.[mutationResponseField] ?? null;
   };
 

packages/twenty-front/src/modules/object-record/hooks/useDeleteManyRecords.ts

@@ -12,6 +12,7 @@ import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode'
 import { useDeleteManyRecordsMutation } from '@/object-record/hooks/useDeleteManyRecordsMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { getDeleteManyRecordsMutationResponseField } from '@/object-record/utils/getDeleteManyRecordsMutationResponseField';
 import { useRecoilValue } from 'recoil';
@@ -32,6 +33,7 @@ export type DeleteManyRecordsProps = {
 export const useDeleteManyRecords = ({
   objectNameSingular,
 }: useDeleteManyRecordProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
   const apiConfig = useRecoilValue(apiConfigState);
 
   const mutationPageSize =
@@ -215,6 +217,11 @@ export const useDeleteManyRecords = ({
       }
     }
     await refetchAggregateQueries();
+
+    registerObjectOperation(objectNameSingular, {
+      type: 'delete-many',
+    });
+
     return deletedRecords;
   };
 

packages/twenty-front/src/modules/object-record/hooks/useDeleteOneRecord.ts

@@ -12,6 +12,7 @@ import { updateRecordFromCache } from '@/object-record/cache/utils/updateRecordF
 import { useDeleteOneRecordMutation } from '@/object-record/hooks/useDeleteOneRecordMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { getDeleteOneRecordMutationResponseField } from '@/object-record/utils/getDeleteOneRecordMutationResponseField';
 import { isNull } from '@sniptt/guards';
@@ -24,6 +25,7 @@ type useDeleteOneRecordProps = {
 export const useDeleteOneRecord = ({
   objectNameSingular,
 }: useDeleteOneRecordProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
   const apolloCoreClient = useApolloCoreClient();
 
   const { objectMetadataItem } = useObjectMetadataItem({
@@ -154,6 +156,11 @@ export const useDeleteOneRecord = ({
         });
 
       await refetchAggregateQueries();
+
+      registerObjectOperation(objectNameSingular, {
+        type: 'delete-one',
+      });
+
       return deletedRecord.data?.[mutationResponseField] ?? null;
     },
     [
@@ -165,6 +172,8 @@ export const useDeleteOneRecord = ({
       objectMetadataItems,
       objectPermissionsByObjectMetadataId,
       refetchAggregateQueries,
+      objectNameSingular,
+      registerObjectOperation,
     ],
   );
 

packages/twenty-front/src/modules/object-record/hooks/useDestroyManyRecords.ts

@@ -9,6 +9,7 @@ import { DEFAULT_MUTATION_BATCH_SIZE } from '@/object-record/constants/DefaultMu
 import { useDestroyManyRecordsMutation } from '@/object-record/hooks/useDestroyManyRecordsMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { getDestroyManyRecordsMutationResponseField } from '@/object-record/utils/getDestroyManyRecordsMutationResponseField';
 import { useRecoilValue } from 'recoil';
@@ -29,6 +30,7 @@ export type DestroyManyRecordsProps = {
 export const useDestroyManyRecords = ({
   objectNameSingular,
 }: useDestroyManyRecordProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
   const apiConfig = useRecoilValue(apiConfigState);
 
   const mutationPageSize =
@@ -137,6 +139,11 @@ export const useDestroyManyRecords = ({
     }
 
     await refetchAggregateQueries();
+
+    registerObjectOperation(objectNameSingular, {
+      type: 'destroy-many',
+    });
+
     return destroyedRecords;
   };
 

packages/twenty-front/src/modules/object-record/hooks/useDestroyOneRecord.ts

@@ -8,6 +8,7 @@ import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadat
 import { useGetRecordFromCache } from '@/object-record/cache/hooks/useGetRecordFromCache';
 import { useDestroyOneRecordMutation } from '@/object-record/hooks/useDestroyOneRecordMutation';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
+import { useRegisterObjectOperation } from '@/object-record/hooks/useRegisterObjectOperation';
 import { getDestroyOneRecordMutationResponseField } from '@/object-record/utils/getDestroyOneRecordMutationResponseField';
 import { capitalize, isDefined } from 'twenty-shared/utils';
 
@@ -19,6 +20,8 @@ type useDestroyOneRecordProps = {
 export const useDestroyOneRecord = ({
   objectNameSingular,
 }: useDestroyOneRecordProps) => {
+  const { registerObjectOperation } = useRegisterObjectOperation();
+
   const apolloCoreClient = useApolloCoreClient();
 
   const { objectMetadataItem } = useObjectMetadataItem({
@@ -81,6 +84,10 @@ export const useDestroyOneRecord = ({
           throw error;
         });
 
+      registerObjectOperation(objectMetadataItem.nameSingular, {
+        type: 'destroy-one',
+      });
+
       return deletedRecord.data?.[mutationResponseField] ?? null;
     },
     [
@@ -92,6 +99,7 @@ export const useDestroyOneRecord = ({
       objectNameSingular,
       objectMetadataItems,
       objectPermissionsByObjectMetadataId,
+      registerObjectOperation,
     ],
   );
 

packages/twenty-front/src/modules/object-record/hooks/useFindManyRecordsWithOffset.ts

@@ -0,0 +1,102 @@
+import { useLazyQuery } from '@apollo/client';
+import { useRecoilCallback } from 'recoil';
+
+import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { getRecordsFromRecordConnection } from '@/object-record/cache/utils/getRecordsFromRecordConnection';
+import { type RecordGqlOperationFindManyResult } from '@/object-record/graphql/types/RecordGqlOperationFindManyResult';
+import { type UseFindManyRecordsParams } from '@/object-record/hooks/useFindManyRecords';
+import { useFindManyRecordsQuery } from '@/object-record/hooks/useFindManyRecordsQuery';
+import { useHandleFindManyRecordsError } from '@/object-record/hooks/useHandleFindManyRecordsError';
+import { useObjectPermissionsForObject } from '@/object-record/hooks/useObjectPermissionsForObject';
+import { useRecordFieldGqlFields } from '@/object-record/record-field/hooks/useRecordFieldGqlFields';
+import { useFindManyRecordIndexTableParams } from '@/object-record/record-index/hooks/useFindManyRecordIndexTableParams';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+
+type UseLazyFindManyRecordsWithOffsetParams = Pick<
+  UseFindManyRecordsParams<ObjectRecord>,
+  'objectNameSingular'
+>;
+
+export const useLazyFindManyRecordsWithOffset = ({
+  objectNameSingular,
+}: UseLazyFindManyRecordsWithOffsetParams) => {
+  const { objectMetadataItem } = useObjectMetadataItem({
+    objectNameSingular,
+  });
+
+  const params = useFindManyRecordIndexTableParams(objectNameSingular);
+
+  const recordGqlFields = useRecordFieldGqlFields({ objectMetadataItem });
+
+  const apolloCoreClient = useApolloCoreClient();
+
+  const { findManyRecordsQuery } = useFindManyRecordsQuery({
+    objectNameSingular,
+    recordGqlFields,
+  });
+
+  const { handleFindManyRecordsError } = useHandleFindManyRecordsError({
+    objectMetadataItem,
+  });
+
+  const objectPermissions = useObjectPermissionsForObject(
+    objectMetadataItem.id,
+  );
+
+  const hasReadPermission = objectPermissions.canReadObjectRecords;
+
+  const [findManyRecords] = useLazyQuery<RecordGqlOperationFindManyResult>(
+    findManyRecordsQuery,
+    {
+      variables: {
+        ...params,
+      },
+      onError: handleFindManyRecordsError,
+      client: apolloCoreClient,
+    },
+  );
+
+  const findManyRecordsLazyWithOffset = useRecoilCallback(
+    () => async (limit: number, offset: number) => {
+      if (!hasReadPermission) {
+        return {
+          data: null,
+          records: null,
+          totalCount: 0,
+          error: undefined,
+        };
+      }
+
+      const result = await findManyRecords({
+        variables: {
+          limit,
+          offset,
+        },
+      });
+
+      const records = getRecordsFromRecordConnection({
+        recordConnection: {
+          edges: result?.data?.[objectMetadataItem.namePlural]?.edges ?? [],
+          pageInfo: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startCursor: '',
+            endCursor: '',
+          },
+        },
+      });
+
+      return {
+        data: result?.data,
+        records,
+        error: result?.error,
+      };
+    },
+    [hasReadPermission, findManyRecords, objectMetadataItem.namePlural],
+  );
+
+  return {
+    findManyRecordsLazyWithOffset,
+  };
+};