Ok

Author: lucasbordeau

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/debug/components/RecoilDebugObserver.tsx

@@ -14,7 +14,7 @@ const formatTitle = (stateName: string) => {
 };
 
 export const RecoilDebugObserverEffect = () => {
-  const isDebugMode = process.env.IS_DEBUG_MODE === 'true';
+  const isDebugMode = false;
 
   useRecoilTransactionObserver_UNSTABLE(({ snapshot }) => {
     if (!isDebugMode) {

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/useRecordTableRecordGqlFields';
+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,
+  };
+};

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

@@ -24,6 +24,7 @@ import { type OnFindManyRecordsCompleted } from '@/object-record/types/OnFindMan
 import { filterUniqueRecordEdgesByCursor } from '@/object-record/utils/filterUniqueRecordEdgesByCursor';
 import { getQueryIdentifier } from '@/object-record/utils/getQueryIdentifier';
 
+import { DEFAULT_SEARCH_REQUEST_LIMIT } from '@/object-record/constants/DefaultSearchRequestLimit';
 import { capitalize, isDefined } from 'twenty-shared/utils';
 import { cursorFamilyState } from '../states/cursorFamilyState';
 import { hasNextPageFamilyState } from '../states/hasNextPageFamilyState';
@@ -88,7 +89,7 @@ export const useLazyFetchMoreRecordsWithPagination = <
   // This function is equivalent to merge function + read function in field policy
   const fetchMoreRecordsLazy = useRecoilCallback(
     ({ snapshot, set }) =>
-      async () => {
+      async (limit = DEFAULT_SEARCH_REQUEST_LIMIT) => {
         const hasNextPageLocal = snapshot
           .getLoadable(hasNextPageFamilyState(queryIdentifier))
           .getValue();
@@ -105,6 +106,7 @@ export const useLazyFetchMoreRecordsWithPagination = <
           try {
             const { data: fetchMoreDataResult } = await fetchMore({
               variables: {
+                limit,
                 filter,
                 orderBy,
                 lastCursor: isNonEmptyString(lastCursorLocal)

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

@@ -96,7 +96,7 @@ export const useLazyFindManyRecords = <T extends ObjectRecord = ObjectRecord>({
 
           return {
             data: null,
-            records: [],
+            records: null,
             totalCount: 0,
             hasNextPage: false,
             error: undefined,

packages/twenty-front/src/modules/object-record/hooks/useLoadSelectedRecordsInContextStore.tsx

@@ -55,8 +55,9 @@ export const useLoadSelectedRecordsInContextStore = ({
           objectRecordIds.length,
         );
 
-        const records = await findManyRecordsLazy();
-        upsertRecords(records.records);
+        const { records } = await findManyRecordsLazy();
+
+        upsertRecords(records ?? []);
       };
     },
     [objectRecordIds, objectMetadataItemId, findManyRecordsLazy, upsertRecords],

packages/twenty-front/src/modules/object-record/record-drag/table/hooks/useRecordTableDragOperations.ts

@@ -14,8 +14,8 @@ import { isDefined } from 'twenty-shared/utils';
 
 import { useRecordDragState } from '@/object-record/record-drag/shared/hooks/useRecordDragState';
 import { extractRecordPositions } from '@/object-record/record-drag/shared/utils/extractRecordPositions';
-import { processSingleDrag } from '@/object-record/record-drag/shared/utils/processSingleDrag';
 import { processMultiDrag } from '@/object-record/record-drag/shared/utils/processMultiDrag';
+import { processSingleDrag } from '@/object-record/record-drag/shared/utils/processSingleDrag';
 import { selectedRowIdsComponentSelector } from '@/object-record/record-table/states/selectors/selectedRowIdsComponentSelector';
 import { useRecoilCallback } from 'recoil';
 

packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/display/components/RelationFromManyFieldDisplay.tsx

@@ -9,6 +9,7 @@ import { useRelationFromManyFieldDisplay } from '@/object-record/record-field/ui
 
 import { ExpandableList } from '@/ui/layout/expandable-list/components/ExpandableList';
 import styled from '@emotion/styled';
+import { isArray } from '@sniptt/guards';
 import { useContext } from 'react';
 import { isDefined } from 'twenty-shared/utils';
 
@@ -38,7 +39,15 @@ export const RelationFromManyFieldDisplay = () => {
     fieldValue as NoteTarget[] | TaskTarget[],
   );
 
-  if (!fieldValue || !relationObjectNameSingular) {
+  if (!isDefined(fieldValue)) {
+    return null;
+  }
+
+  if (!isArray(fieldValue)) {
+    return null;
+  }
+
+  if (!isDefined(!relationObjectNameSingular)) {
     return null;
   }
 
@@ -65,7 +74,7 @@ export const RelationFromManyFieldDisplay = () => {
     return isFocused ? (
       <ExpandableList isChipCountDisplayed={isFocused}>
         {fieldValue
-          .map((record) => {
+          ?.map((record) => {
             if (!isDefined(record) || !isDefined(record[relationFieldName])) {
               return undefined;
             }
@@ -83,7 +92,7 @@ export const RelationFromManyFieldDisplay = () => {
     ) : (
       <StyledContainer>
         {fieldValue
-          .map((record) => {
+          ?.map((record) => {
             if (!isDefined(record) || !isDefined(record[relationFieldName])) {
               return undefined;
             }
@@ -115,7 +124,7 @@ export const RelationFromManyFieldDisplay = () => {
   } else {
     return (
       <ExpandableList isChipCountDisplayed={isFocused}>
-        {fieldValue.filter(isDefined).map((record) => {
+        {fieldValue?.filter(isDefined).map((record) => {
           const recordChipData = generateRecordChipData(record);
           return (
             <RecordChip

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

@@ -12,12 +12,14 @@ export const useRecordIndexTableFetchMore = (objectNameSingular: string) => {
 
   const recordGqlFields = useRecordFieldGqlFields({ objectMetadataItem });
 
-  const { fetchMoreRecordsLazy, queryIdentifier } = useLazyFindManyRecords({
-    ...params,
-    recordGqlFields,
-  });
+  const { fetchMoreRecordsLazy, queryIdentifier, findManyRecordsLazy } =
+    useLazyFindManyRecords({
+      ...params,
+      recordGqlFields,
+    });
 
   return {
+    findManyRecordsLazy,
     fetchMoreRecordsLazy,
     queryIdentifier,
   };

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

@@ -16,18 +16,18 @@ export const useRecordIndexTableQuery = (objectNameSingular: string) => {
 
   const recordGqlFields = useRecordFieldGqlFields({ objectMetadataItem });
 
-  const { records, hasNextPage, queryIdentifier, loading } = useFindManyRecords(
-    {
+  const { records, hasNextPage, queryIdentifier, loading, totalCount } =
+    useFindManyRecords({
       ...params,
       recordGqlFields,
       skip: showAuthModal,
-    },
-  );
+    });
 
   return {
     records: showAuthModal ? SIGN_IN_BACKGROUND_MOCK_COMPANIES : records,
     loading: showAuthModal ? false : loading,
     hasNextPage,
     queryIdentifier,
+    totalCount,
   };
 };