Fix cursor-based pagination

packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts

@@ -132,6 +132,7 @@ export class CommonFindManyQueryRunnerService extends CommonBaseQueryRunnerServi
       flatObjectMetadata,
       flatObjectMetadataMaps,
       flatFieldMetadataMaps,
+      orderBy: args.orderBy,
     });
 
     if (isDefined(args.offset)) {

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select.ts

@@ -1,26 +1,32 @@
 import { FieldMetadataType } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
 
+import { type ObjectRecordOrderBy } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
 import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
 import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';
 import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
 import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { pascalCase } from 'src/utils/pascal-case';
 
 export const buildColumnsToSelect = ({
   select,
   relations,
   flatObjectMetadata,
   flatObjectMetadataMaps,
   flatFieldMetadataMaps,
+  orderBy,
 }: {
   select: Record<string, unknown>;
   relations: Record<string, unknown>;
   flatObjectMetadata: FlatObjectMetadata;
   flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
   flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+  orderBy?: ObjectRecordOrderBy;
 }) => {
   const requiredRelationColumns = getRequiredRelationColumns(
     relations,
@@ -39,6 +45,16 @@ export const buildColumnsToSelect = ({
     fieldsToSelect[columnName] = true;
   }
 
+  const orderByColumnNames = extractColumnNamesFromOrderBy(
+    orderBy,
+    flatObjectMetadata,
+    flatFieldMetadataMaps,
+  );
+
+  for (const columnName of orderByColumnNames) {
+    fieldsToSelect[columnName] = true;
+  }
+
   return { ...fieldsToSelect, id: true };
 };
 
@@ -101,3 +117,56 @@ const getRequiredRelationColumns = (
 
   return requiredColumns;
 };
+
+const extractColumnNamesFromOrderBy = (
+  orderBy: ObjectRecordOrderBy | undefined,
+  flatObjectMetadata: FlatObjectMetadata,
+  flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>,
+) => {
+  if (!isDefined(orderBy) || orderBy.length === 0) {
+    return [];
+  }
+
+  const orderByFlattened = orderBy.reduce(
+    (acc, orderByItem) => ({ ...acc, ...orderByItem }),
+    {},
+  );
+
+  const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
+    flatFieldMetadataMaps,
+    flatObjectMetadata,
+  );
+
+  const columnNames = [];
+
+  for (const [fieldName, orderByValue] of Object.entries(orderByFlattened)) {
+    const fieldMetadataId = fieldIdByName[fieldName];
+
+    if (!fieldMetadataId) {
+      columnNames.push(fieldName);
+      continue;
+    }
+
+    const fieldMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: fieldMetadataId,
+      flatEntityMaps: flatFieldMetadataMaps,
+    });
+
+    if (
+      isCompositeFieldMetadataType(fieldMetadata.type) &&
+      isDefined(orderByValue)
+    ) {
+      const subFieldNames = Object.keys(orderByValue);
+
+      for (const subFieldName of subFieldNames) {
+        const columnName = `${fieldName}${pascalCase(subFieldName)}`;
+
+        columnNames.push(columnName);
+      }
+    } else {
+      columnNames.push(fieldName);
+    }
+  }
+
+  return columnNames;
+};

packages/twenty-server/src/engine/api/utils/build-cursor-composite-field-where-condition.utils.ts

@@ -1,6 +1,8 @@
+import { isNull } from '@sniptt/guards';
 import {
   FieldMetadataType,
   type ObjectRecord,
+  OrderByDirection,
   compositeTypeDefinitions,
 } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
@@ -29,6 +31,87 @@ type BuildCursorCompositeFieldWhereConditionParams = {
   isEqualityCondition?: boolean;
 };
 
+const buildNullCompositeFieldFilter = (
+  fieldKey: keyof ObjectRecord,
+  compositeFieldProperties: Array<{ name: string }>,
+): ObjectRecordFilter => {
+  const nullFilters = compositeFieldProperties.reduce<
+    Record<string, ObjectRecordFilter>
+  >(
+    (acc, property) => ({
+      ...acc,
+      [property.name]: { is: 'NULL' },
+    }),
+    {},
+  );
+
+  return { [fieldKey]: nullFilters };
+};
+
+const buildAllNullComparisonFilter = (
+  fieldKey: keyof ObjectRecord,
+  firstProperty: { name: string },
+  computedOperator: string,
+): ObjectRecordFilter | Record<string, never> => {
+  if (computedOperator === 'gt') {
+    return {
+      [fieldKey]: {
+        [firstProperty.name]: { is: 'NOT NULL' },
+      },
+    };
+  }
+
+  if (computedOperator === 'lt') {
+    return {
+      [fieldKey]: {
+        [firstProperty.name]: { is: 'NULL' },
+      },
+    };
+  }
+
+  return {};
+};
+
+const shouldIncludeNullsInComparison = (
+  computedOperator: string,
+  orderByDirection: OrderByDirection,
+): boolean => {
+  const isNullsFirst =
+    orderByDirection === OrderByDirection.AscNullsFirst ||
+    orderByDirection === OrderByDirection.DescNullsFirst;
+
+  return (
+    (computedOperator === 'lt' && isNullsFirst) ||
+    (computedOperator === 'gt' && !isNullsFirst)
+  );
+};
+
+const buildComparisonFilterWithNulls = (
+  fieldKey: keyof ObjectRecord,
+  cursorKey: string,
+  computedOperator: string,
+  cursorValue: unknown,
+): ObjectRecordFilter => {
+  return {
+    or: [
+      {
+        [fieldKey]: {
+          [cursorKey]: {
+            [computedOperator]: cursorValue,
+          },
+        },
+      },
+      {
+        [fieldKey]: {
+          [cursorKey]: {
+            is: 'NULL',
+          },
+        },
+      },
+    ],
+  };
+};
+
 export const buildCursorCompositeFieldWhereCondition = ({
   fieldType,
   fieldKey,
@@ -64,36 +147,61 @@ export const buildCursorCompositeFieldWhereCondition = ({
     return {};
   }
 
+  const allSubFieldsAreNull = compositeFieldProperties.every((property) =>
+    isNull(cursorValue[property.name]),
+  );
+
+  if (allSubFieldsAreNull) {
+    if (isEqualityCondition) {
+      return buildNullCompositeFieldFilter(fieldKey, compositeFieldProperties);
+    }
+
+    const firstProperty = compositeFieldProperties[0];
+    const firstOrderByDirection = fieldOrderBy[fieldKey]?.[firstProperty.name];
+
+    if (!isDefined(firstOrderByDirection)) {
+      return {};
+    }
+
+    const isAscending = isAscendingOrder(firstOrderByDirection);
+    const computedOperator = computeOperator(isAscending, isForwardPagination);
+
+    return buildAllNullComparisonFilter(
+      fieldKey,
+      firstProperty,
+      computedOperator,
+    );
+  }
+
   const cursorEntries = compositeFieldProperties
     .map((property) => {
       if (cursorValue[property.name] === undefined) {
         return null;
       }
 
+      if (isNull(cursorValue[property.name])) {
+        return null;
+      }
+
       return {
         [property.name]: cursorValue[property.name],
       };
     })
     .filter(isDefined);
 
   if (isEqualityCondition) {
-    const result = cursorEntries.reduce<Record<string, ObjectRecordFilter>>(
-      (acc, cursorEntry) => {
-        const [cursorKey, cursorValue] = Object.entries(cursorEntry)[0];
+    const equalityFilters = cursorEntries.reduce<
+      Record<string, ObjectRecordFilter>
+    >((acc, cursorEntry) => {
+      const [cursorKey, cursorValue] = Object.entries(cursorEntry)[0];
 
-        return {
-          ...acc,
-          [cursorKey]: {
-            eq: cursorValue,
-          },
-        };
-      },
-      {},
-    );
+      return {
+        ...acc,
+        [cursorKey]: { eq: cursorValue },
+      };
+    }, {});
 
-    return {
-      [fieldKey]: result,
-    };
+    return { [fieldKey]: equalityFilters };
   }
 
   const orConditions = buildCursorCumulativeWhereCondition({
@@ -121,6 +229,15 @@ export const buildCursorCompositeFieldWhereCondition = ({
         isForwardPagination,
       );
 
+      if (shouldIncludeNullsInComparison(computedOperator, orderByDirection)) {
+        return buildComparisonFilterWithNulls(
+          fieldKey,
+          cursorKey,
+          computedOperator,
+          cursorValue,
+        );
+      }
+
       return {
         [fieldKey]: {
           [cursorKey]: {