Skip to content

The open alternative to Salesforce, designed for AI.

refactor(server): compile SQL order clauses from the resolved orderBy leaves (#24382)

Félix Malfaitaec5ba9488b2
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/__tests__/graphql-query-order.parser.spec.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/__tests__/graphql-query-order.parser.spec.ts
new file mode 100644
index 00000000000..a9b5d5d2164
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/__tests__/graphql-query-order.parser.spec.ts
@@ -0,0 +1,247 @@
+import { FieldMetadataType, OrderByDirection } from 'twenty-shared/types';
+
+import { GraphqlQueryOrderFieldParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+describe('GraphqlQueryOrderFieldParser', () => {
+ const workspaceId = 'workspace-id';
+ const objectMetadataId = 'object-id';
+
+ const createMockField = (
+ overrides: Partial<FlatFieldMetadata> & {
+ id: string;
+ name: string;
+ type: FieldMetadataType;
+ },
+ ): FlatFieldMetadata =>
+ ({
+ workspaceId,
+ objectMetadataId,
+ isNullable: true,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ universalIdentifier: overrides.id,
+ label: overrides.name,
+ ...overrides,
+ }) as FlatFieldMetadata;
+
+ const closeDateField = createMockField({
+ id: 'closedate-id',
+ type: FieldMetadataType.DATE_TIME,
+ name: 'closeDate',
+ });
+
+ const stageField = createMockField({
+ id: 'stage-id',
+ type: FieldMetadataType.TEXT,
+ name: 'stage',
+ });
+
+ const fullNameField = createMockField({
+ id: 'fullname-id',
+ type: FieldMetadataType.FULL_NAME,
+ name: 'fullName',
+ });
+
+ const companyField = createMockField({
+ id: 'company-id',
+ type: FieldMetadataType.RELATION,
+ name: 'company',
+ relationTargetObjectMetadataId: 'company-object-id',
+ settings: {
+ relationType: 'MANY_TO_ONE',
+ joinColumnName: 'companyId',
+ // oxlint-disable-next-line typescript/no-explicit-any
+ } as any,
+ });
+
+ const companyNameField = createMockField({
+ id: 'company-name-id',
+ type: FieldMetadataType.TEXT,
+ name: 'name',
+ objectMetadataId: 'company-object-id',
+ });
+
+ const companyContactNameField = createMockField({
+ id: 'company-contactname-id',
+ type: FieldMetadataType.FULL_NAME,
+ name: 'contactName',
+ objectMetadataId: 'company-object-id',
+ });
+
+ const rootFields = [closeDateField, stageField, fullNameField, companyField];
+ const fields = [...rootFields, companyNameField, companyContactNameField];
+
+ const flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata> = {
+ byUniversalIdentifier: Object.fromEntries(
+ fields.map((field) => [field.universalIdentifier, field]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ fields.map((field) => [field.id, field.universalIdentifier]),
+ ),
+ universalIdentifiersByApplicationId: {},
+ };
+
+ const flatObjectMetadata = {
+ id: objectMetadataId,
+ workspaceId,
+ nameSingular: 'opportunity',
+ fieldIds: rootFields.map((field) => field.id),
+ } as unknown as FlatObjectMetadata;
+
+ const companyObjectMetadata = {
+ id: 'company-object-id',
+ universalIdentifier: 'company-object-id',
+ workspaceId,
+ nameSingular: 'company',
+ fieldIds: ['company-name-id', 'company-contactname-id'],
+ } as unknown as FlatObjectMetadata;
+
+ const flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata> = {
+ byUniversalIdentifier: {
+ [objectMetadataId]: flatObjectMetadata,
+ 'company-object-id': companyObjectMetadata,
+ },
+ universalIdentifierById: {
+ [objectMetadataId]: objectMetadataId,
+ 'company-object-id': 'company-object-id',
+ },
+ universalIdentifiersByApplicationId: {},
+ };
+
+ const parser = new GraphqlQueryOrderFieldParser(
+ flatObjectMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ );
+
+ it('should compile scalar, composite and relation leaves to their columns', () => {
+ const result = parser.parse(
+ [
+ { closeDate: OrderByDirection.DescNullsLast },
+ { fullName: { firstName: OrderByDirection.AscNullsLast } },
+ { company: { name: OrderByDirection.AscNullsLast } },
+ // oxlint-disable-next-line typescript/no-explicit-any
+ ] as any,
+ 'opportunity',
+ );
+
+ expect(result.orderBy).toEqual({
+ 'opportunity.closeDate': {
+ order: 'DESC',
+ nulls: 'NULLS LAST',
+ useLower: false,
+ castToText: false,
+ },
+ 'opportunity.fullNameFirstName': {
+ order: 'ASC',
+ nulls: 'NULLS LAST',
+ useLower: true,
+ castToText: false,
+ },
+ 'company.name': {
+ order: 'ASC',
+ nulls: 'NULLS LAST',
+ useLower: true,
+ castToText: false,
+ },
+ });
+ expect(result.relationJoins).toEqual([{ joinAlias: 'company' }]);
+ });
+
+ it('should compile a composite target field of a relation onto the join alias', () => {
+ const result = parser.parse(
+ [
+ {
+ company: {
+ contactName: { firstName: OrderByDirection.AscNullsLast },
+ },
+ },
+ {
+ company: { contactName: { lastName: OrderByDirection.AscNullsLast } },
+ },
+ // oxlint-disable-next-line typescript/no-explicit-any
+ ] as any,
+ 'opportunity',
+ );
+
+ expect(Object.keys(result.orderBy)).toEqual([
+ 'company.contactNameFirstName',
+ 'company.contactNameLastName',
+ ]);
+ // Two leaves through the same relation share one join
+ expect(result.relationJoins).toEqual([{ joinAlias: 'company' }]);
+ });
+
+ it('should treat a join column access as a scalar of the root object', () => {
+ const result = parser.parse(
+ [{ companyId: OrderByDirection.AscNullsFirst }],
+ 'opportunity',
+ );
+
+ expect(result.orderBy).toEqual({
+ 'opportunity.companyId': {
+ order: 'ASC',
+ nulls: 'NULLS FIRST',
+ useLower: false,
+ castToText: false,
+ },
+ });
+ expect(result.relationJoins).toEqual([]);
+ });
+
+ it('should reverse direction and NULLS placement for backward pagination', () => {
+ const result = parser.parse(
+ [{ stage: OrderByDirection.AscNullsLast }],
+ 'opportunity',
+ false,
+ );
+
+ expect(result.orderBy['opportunity.stage']).toMatchObject({
+ order: 'DESC',
+ nulls: 'NULLS FIRST',
+ });
+ });
+
+ it('should keep the first direction when the same field is ordered twice', () => {
+ const result = parser.parse(
+ [
+ { stage: OrderByDirection.AscNullsLast },
+ { stage: OrderByDirection.DescNullsFirst },
+ ],
+ 'opportunity',
+ );
+
+ expect(result.orderBy['opportunity.stage']).toMatchObject({
+ order: 'ASC',
+ nulls: 'NULLS LAST',
+ });
+ });
+
+ it('should reject ordering by a field the role cannot read', () => {
+ expect(() =>
+ parser.parse(
+ [{ stage: OrderByDirection.AscNullsLast }],
+ 'opportunity',
+ true,
+ {
+ [objectMetadataId]: {
+ restrictedFields: { 'stage-id': { canRead: false } },
+ // oxlint-disable-next-line typescript/no-explicit-any
+ } as any,
+ },
+ ),
+ ).toThrow('does not have permission');
+ });
+
+ it('should reject unknown fields', () => {
+ expect(() =>
+ parser.parse(
+ [{ unknownField: OrderByDirection.AscNullsLast }],
+ 'opportunity',
+ ),
+ ).toThrow('does not exist or is not sortable');
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts
index 96c9158d9ea..89d833947d4 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts
@@ -1,29 +1,18 @@
-import { isObject } from 'class-validator';
import { type ObjectsPermissions } 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 { STANDARD_ERROR_MESSAGE } from 'src/engine/api/common/common-query-runners/errors/standard-error-message.constant';
-import {
- GraphqlQueryRunnerException,
- GraphqlQueryRunnerExceptionCode,
-} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
-import { assertFieldIsReadableOrThrow } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util';
import {
buildOrderByColumnExpression,
shouldCastToText,
shouldUseCaseInsensitiveOrder,
} from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/utils/build-order-by-column-expression.util';
import { convertOrderByToFindOptionsOrder } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/utils/convert-order-by-to-find-options-order';
-import { isOrderByDirection } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/utils/is-order-by-direction.util';
-import { parseCompositeFieldForOrder } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/utils/parse-composite-field-for-order.util';
-import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { computeOrderByLeafColumn } from 'src/engine/api/utils/compute-order-by-leaf-column.util';
+import { resolveOrderByLeaves } from 'src/engine/api/utils/resolve-order-by-leaves.utils';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.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 { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { type OrderByClause } from './types/order-by-condition.type';
@@ -33,12 +22,14 @@ import { type RelationJoinInfo } from './types/relation-join-info.type';
// Re-export types for backward compatibility
export { OrderByClause, ParseOrderByResult, RelationJoinInfo };
+// Compiles SQL ORDER BY clauses from the resolved orderBy leaves: walking,
+// validation and permission checks live in resolveOrderByLeaves, shared with
+// column selection and the cursor utilities, so the scan order can never
+// diverge from what cursors continue.
export class GraphqlQueryOrderFieldParser {
private flatObjectMetadata: FlatObjectMetadata;
private flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
private flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- private fieldIdByName: Record<string, string>;
- private fieldIdByJoinColumnName: Record<string, string>;
constructor(
flatObjectMetadata: FlatObjectMetadata,
@@ -48,14 +39,6 @@ export class GraphqlQueryOrderFieldParser {
this.flatObjectMetadata = flatObjectMetadata;
this.flatObjectMetadataMaps = flatObjectMetadataMaps;
this.flatFieldMetadataMaps = flatFieldMetadataMaps;
-
- const fieldMaps = buildFieldMapsFromFlatObjectMetadata(
- flatFieldMetadataMaps,
- flatObjectMetadata,
- );
-
- this.fieldIdByName = fieldMaps.fieldIdByName;
- this.fieldIdByJoinColumnName = fieldMaps.fieldIdByJoinColumnName;
}
parse(
@@ -68,239 +51,51 @@ export class GraphqlQueryOrderFieldParser {
const relationJoins: RelationJoinInfo[] = [];
const addedJoinAliases = new Set<string>();
- for (const item of orderBy) {
- for (const [fieldName, orderByDirection] of Object.entries(item)) {
- // Check if accessed by relation name (company) vs FK name (companyId)
- const isAccessedByRelationName = !!this.fieldIdByName[fieldName];
- const fieldMetadataId =
- this.fieldIdByName[fieldName] ||
- this.fieldIdByJoinColumnName[fieldName];
- const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMetadataId,
- flatEntityMaps: this.flatFieldMetadataMaps,
- });
-
- if (!fieldMetadata || orderByDirection === undefined) {
- throw new GraphqlQueryRunnerException(
- `Field "${fieldName}" does not exist or is not sortable`,
- GraphqlQueryRunnerExceptionCode.FIELD_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- assertFieldIsReadableOrThrow({
- objectsPermissions,
- objectMetadataId: this.flatObjectMetadata.id,
- fieldMetadataId: fieldMetadata.id,
- });
-
- // Only treat as relation if accessed by relation name (not FK like companyId)
- if (
- isAccessedByRelationName &&
- isMorphOrRelationFlatFieldMetadata(fieldMetadata)
- ) {
- if (!isObject(orderByDirection)) {
- throw new GraphqlQueryRunnerException(
- `Relation field "${fieldName}" requires nested field ordering (e.g., { ${fieldName}: { fieldName: 'AscNullsFirst' } })`,
- GraphqlQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const relationOrderResult = this.parseRelationFieldOrder({
- fieldMetadata,
- orderByDirection: orderByDirection as Record<string, unknown>,
- isForwardPagination,
- objectsPermissions,
- });
-
- if (relationOrderResult) {
- Object.assign(orderByConditions, relationOrderResult.orderBy);
-
- if (!addedJoinAliases.has(relationOrderResult.joinInfo.joinAlias)) {
- relationJoins.push(relationOrderResult.joinInfo);
- addedJoinAliases.add(relationOrderResult.joinInfo.joinAlias);
- }
- }
- } else if (isCompositeFieldMetadataType(fieldMetadata.type)) {
- if (!isObject(orderByDirection)) {
- throw new GraphqlQueryRunnerException(
- `Composite field "${fieldName}" requires subfield ordering (e.g., { ${fieldName}: { subFieldName: 'AscNullsFirst' } })`,
- GraphqlQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const compositeOrder = parseCompositeFieldForOrder(
- fieldMetadata,
- orderByDirection as Record<string, unknown>,
- objectNameSingular,
- isForwardPagination,
- );
-
- Object.assign(orderByConditions, compositeOrder);
- } else {
- if (!isOrderByDirection(orderByDirection)) {
- throw new GraphqlQueryRunnerException(
- `Scalar field "${fieldName}" requires a direction value (AscNullsFirst, AscNullsLast, DescNullsFirst, DescNullsLast)`,
- GraphqlQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const columnExpression = buildOrderByColumnExpression(
- objectNameSingular,
- fieldName,
- );
-
- orderByConditions[columnExpression] = {
- ...convertOrderByToFindOptionsOrder(
- orderByDirection,
- isForwardPagination,
- ),
- useLower: shouldUseCaseInsensitiveOrder(fieldMetadata.type),
- castToText: shouldCastToText(fieldMetadata.type),
- };
- }
- }
- }
-
- return {
- orderBy: orderByConditions,
- relationJoins,
- };
- }
-
- private parseRelationFieldOrder({
- fieldMetadata,
- orderByDirection,
- isForwardPagination,
- objectsPermissions,
- }: {
- fieldMetadata: FlatFieldMetadata;
- orderByDirection: Record<string, unknown>;
- isForwardPagination: boolean;
- objectsPermissions?: ObjectsPermissions;
- }): {
- orderBy: Record<string, OrderByClause>;
- joinInfo: RelationJoinInfo;
- } | null {
- if (!isDefined(fieldMetadata.relationTargetObjectMetadataId)) {
- return null;
- }
-
- const targetObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMetadata.relationTargetObjectMetadataId,
- flatEntityMaps: this.flatObjectMetadataMaps,
- });
-
- if (!isDefined(targetObjectMetadata)) {
- return null;
- }
-
- const nestedFieldNames = Object.keys(orderByDirection);
-
- // Cursor continuation carries exactly one sub-field value per relation, so
- // reject ambiguous input here instead of silently ordering by the first key
- if (nestedFieldNames.length !== 1) {
- throw new GraphqlQueryRunnerException(
- `Relation field "${fieldMetadata.name}" supports ordering by exactly one field of the related object`,
- GraphqlQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const [nestedFieldName] = nestedFieldNames;
- const nestedFieldOrderByValue = orderByDirection[nestedFieldName];
-
- if (!isDefined(nestedFieldOrderByValue)) {
- return null;
- }
-
- const { fieldIdByName: targetFieldIdByName } =
- buildFieldMapsFromFlatObjectMetadata(
- this.flatFieldMetadataMaps,
- targetObjectMetadata,
- );
-
- const nestedFieldMetadataId = targetFieldIdByName[nestedFieldName];
-
- if (!isDefined(nestedFieldMetadataId)) {
- throw new GraphqlQueryRunnerException(
- `Nested field "${nestedFieldName}" not found in target object "${targetObjectMetadata.nameSingular}"`,
- GraphqlQueryRunnerExceptionCode.FIELD_NOT_FOUND,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const nestedFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: nestedFieldMetadataId,
- flatEntityMaps: this.flatFieldMetadataMaps,
- });
-
- if (!isDefined(nestedFieldMetadata)) {
- return null;
- }
-
- assertFieldIsReadableOrThrow({
+ const orderByLeaves = resolveOrderByLeaves({
+ orderBy,
+ flatObjectMetadata: this.flatObjectMetadata,
+ flatObjectMetadataMaps: this.flatObjectMetadataMaps,
+ flatFieldMetadataMaps: this.flatFieldMetadataMaps,
+ strictValidation: true,
objectsPermissions,
- objectMetadataId: targetObjectMetadata.id,
- fieldMetadataId: nestedFieldMetadata.id,
});
- const joinAlias = fieldMetadata.name;
-
- const joinInfo: RelationJoinInfo = {
- joinAlias,
- };
-
- if (isCompositeFieldMetadataType(nestedFieldMetadata.type)) {
- if (!isObject(nestedFieldOrderByValue)) {
- throw new GraphqlQueryRunnerException(
- `Composite field "${nestedFieldMetadata.name}" requires a subfield to be specified`,
- GraphqlQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
- { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
- );
- }
-
- const compositeOrder = parseCompositeFieldForOrder(
- nestedFieldMetadata,
- nestedFieldOrderByValue as Record<string, unknown>,
- joinAlias,
- isForwardPagination,
+ for (const orderByLeaf of orderByLeaves) {
+ const leafColumn = computeOrderByLeafColumn(
+ orderByLeaf,
+ objectNameSingular,
);
- if (Object.keys(compositeOrder).length === 0) {
- return null;
+ if (!isDefined(leafColumn)) {
+ continue;
}
- return {
- orderBy: compositeOrder,
- joinInfo,
- };
- }
-
- if (isOrderByDirection(nestedFieldOrderByValue)) {
- const columnExpression = buildOrderByColumnExpression(
- joinAlias,
- nestedFieldMetadata.name,
- );
+ if (
+ orderByLeaf.kind === 'relation' &&
+ !addedJoinAliases.has(leafColumn.tableAlias)
+ ) {
+ relationJoins.push({ joinAlias: leafColumn.tableAlias });
+ addedJoinAliases.add(leafColumn.tableAlias);
+ }
- return {
- orderBy: {
- [columnExpression]: {
- ...convertOrderByToFindOptionsOrder(
- nestedFieldOrderByValue,
- isForwardPagination,
- ),
- useLower: shouldUseCaseInsensitiveOrder(nestedFieldMetadata.type),
- castToText: shouldCastToText(nestedFieldMetadata.type),
- },
- },
- joinInfo,
+ orderByConditions[
+ buildOrderByColumnExpression(
+ leafColumn.tableAlias,
+ leafColumn.columnName,
+ )
+ ] = {
+ ...convertOrderByToFindOptionsOrder(
+ orderByLeaf.direction,
+ isForwardPagination,
+ ),
+ useLower: shouldUseCaseInsensitiveOrder(leafColumn.columnType),
+ castToText: shouldCastToText(leafColumn.columnType),
};
}
- return null;
+ return {
+ orderBy: orderByConditions,
+ relationJoins,
+ };
}
}
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
index ed08003862d..3b6ffe1d848 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
@@ -178,12 +178,12 @@ export class GraphqlQueryParser {
}
public getOrderByRawSQL(
- orderBy: ObjectRecordOrderBy | OrderByWithGroupBy,
+ orderBy: ObjectRecordOrderBy,
objectNameSingular: string,
isForwardPagination = true,
): { orderByRawSQL: string; relationJoins: RelationJoinInfo[] } {
const parseResult = this.orderFieldParser.parse(
- orderBy as ObjectRecordOrderBy,
+ orderBy,
objectNameSingular,
isForwardPagination,
);
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/build-order-by-columns-to-select.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/build-order-by-columns-to-select.ts
index 72591e519d9..d347d5a09f1 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/build-order-by-columns-to-select.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/utils/build-order-by-columns-to-select.ts
@@ -1,10 +1,12 @@
+import { isDefined } from 'twenty-shared/utils';
+
import { type ObjectRecordOrderBy } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+import { computeOrderByLeafColumn } from 'src/engine/api/utils/compute-order-by-leaf-column.util';
import {
checkIfLeafCanCarryCursorValue,
resolveOrderByLeaves,
} from 'src/engine/api/utils/resolve-order-by-leaves.utils';
-import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
@@ -35,11 +37,14 @@ export const buildOrderByColumnsToSelect = ({
continue;
}
- columnsToSelect[
- leaf.kind === 'composite'
- ? computeCompositeColumnName(leaf.path[0], leaf.compositeProperty)
- : leaf.path[0]
- ] = true;
+ const leafColumn = computeOrderByLeafColumn(
+ leaf,
+ flatObjectMetadata.nameSingular,
+ );
+
+ if (isDefined(leafColumn)) {
+ columnsToSelect[leafColumn.columnName] = true;
+ }
}
return columnsToSelect;
diff --git a/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts b/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
index 58cdccf4c74..1dd5fbffc41 100644
--- a/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
+++ b/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
@@ -350,6 +350,57 @@ describe('resolveOrderByLeaves', () => {
});
});
+ describe('field read permissions', () => {
+ const permissionsRestricting = (
+ fieldMetadataId: string,
+ objectId: string,
+ ) => ({
+ [objectId]: {
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: true,
+ canSoftDeleteObjectRecords: true,
+ canDestroyObjectRecords: true,
+ restrictedFields: { [fieldMetadataId]: { canRead: false } },
+ // oxlint-disable-next-line typescript/no-explicit-any
+ } as any,
+ });
+
+ it('should reject ordering by a role-restricted root field', () => {
+ expect(() =>
+ resolveOrderByLeaves({
+ orderBy: [{ closeDate: OrderByDirection.AscNullsLast }],
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ objectsPermissions: permissionsRestricting(
+ 'closedate-id',
+ objectMetadataId,
+ ),
+ }),
+ ).toThrow('does not have permission');
+ });
+
+ it('should reject ordering by a role-restricted relation target field', () => {
+ expect(() =>
+ resolveOrderByLeaves({
+ orderBy: [{ company: { name: OrderByDirection.AscNullsLast } }],
+ flatObjectMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ objectsPermissions: permissionsRestricting(
+ 'company-name-id',
+ 'company-object-id',
+ ),
+ }),
+ ).toThrow('does not have permission');
+ });
+ });
+
+ it('should reject a relation entry with no valid nested direction in strict mode', () => {
+ expect(() => resolve([{ company: { name: 5 } }], true)).toThrow(
+ 'requires nested field ordering',
+ );
+ });
+
describe('getCursorValueForLeaf', () => {
const firstNameLeaf = resolve([
{ fullName: { firstName: OrderByDirection.AscNullsLast } },
diff --git a/packages/twenty-server/src/engine/api/utils/build-order-by-values-by-record-id.util.ts b/packages/twenty-server/src/engine/api/utils/build-order-by-values-by-record-id.util.ts
index bc519335a2b..694b555ba5b 100644
--- a/packages/twenty-server/src/engine/api/utils/build-order-by-values-by-record-id.util.ts
+++ b/packages/twenty-server/src/engine/api/utils/build-order-by-values-by-record-id.util.ts
@@ -1,38 +1,14 @@
import { type ObjectRecord } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
+import { computeOrderByLeafColumn } from 'src/engine/api/utils/compute-order-by-leaf-column.util';
import {
checkIfLeafCanCarryCursorValue,
type OrderByLeaf,
} from 'src/engine/api/utils/resolve-order-by-leaves.utils';
-import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
export type OrderByValuesByRecordId = Record<string, Record<string, unknown>>;
-const computeRawColumnAlias = (
- leaf: OrderByLeaf,
- objectNameSingular: string,
-): string => {
- switch (leaf.kind) {
- // The relation ordering always selects its joined columns under the
- // deterministic "<joinAlias>_<column>" raw alias, whatever the client
- // selected (see addRelationOrderColumnsToBuilder)
- case 'relation':
- return `${leaf.path[0]}_${
- isDefined(leaf.targetCompositeProperty)
- ? computeCompositeColumnName(
- leaf.path[1],
- leaf.targetCompositeProperty,
- )
- : leaf.path[1]
- }`;
- case 'composite':
- return `${objectNameSingular}_${computeCompositeColumnName(leaf.path[0], leaf.compositeProperty)}`;
- case 'scalar':
- return `${objectNameSingular}_${leaf.path[0]}`;
- }
-};
-
// Cursors are encoded from the raw rows of the scan rather than from the
// formatted records: result formatting presents SQL NULLs of TEXT-like columns
// as empty values, but only actual SQL NULLs sort into the NULL block the
@@ -82,7 +58,17 @@ export const buildOrderByValuesByRecordId = ({
const orderByValues: Record<string, unknown> = {};
for (const leaf of cursorLeaves) {
- const rawValue = rawRow[computeRawColumnAlias(leaf, objectNameSingular)];
+ const leafColumn = computeOrderByLeafColumn(leaf, objectNameSingular);
+
+ if (!isDefined(leafColumn)) {
+ continue;
+ }
+
+ // Every ordered column is selected under this raw alias, by the find
+ // options for root columns and by addRelationOrderColumnsToBuilder for
+ // joined ones
+ const rawValue =
+ rawRow[`${leafColumn.tableAlias}_${leafColumn.columnName}`];
let container = orderByValues;
diff --git a/packages/twenty-server/src/engine/api/utils/compute-order-by-leaf-column.util.ts b/packages/twenty-server/src/engine/api/utils/compute-order-by-leaf-column.util.ts
new file mode 100644
index 00000000000..a05c719eb5e
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/utils/compute-order-by-leaf-column.util.ts
@@ -0,0 +1,58 @@
+import { type FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type OrderByLeaf } from 'src/engine/api/utils/resolve-order-by-leaves.utils';
+import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
+
+export type OrderByLeafColumn = {
+ // The SQL alias the column lives on: the root object for scalar and
+ // composite leaves, the relation's join alias for relation leaves
+ tableAlias: string;
+ columnName: string;
+ columnType: FieldMetadataType;
+};
+
+// The one mapping from an orderBy leaf to the column its values live in. The
+// SQL ORDER BY expression, the hidden column selection and the raw-row alias
+// the cursor side channel reads back (`"<tableAlias>_<columnName>"`) all
+// derive from it, so they cannot drift apart.
+export const computeOrderByLeafColumn = (
+ leaf: OrderByLeaf,
+ objectNameSingular: string,
+): OrderByLeafColumn | null => {
+ switch (leaf.kind) {
+ case 'relation': {
+ if (!isDefined(leaf.targetFieldMetadata)) {
+ // A relation without a resolvable target contributes no ordering
+ return null;
+ }
+
+ return {
+ tableAlias: leaf.path[0],
+ columnName: isDefined(leaf.targetCompositeProperty)
+ ? computeCompositeColumnName(
+ leaf.path[1],
+ leaf.targetCompositeProperty,
+ )
+ : leaf.path[1],
+ columnType: (leaf.targetCompositeProperty ?? leaf.targetFieldMetadata)
+ .type,
+ };
+ }
+ case 'composite':
+ return {
+ tableAlias: objectNameSingular,
+ columnName: computeCompositeColumnName(
+ leaf.path[0],
+ leaf.compositeProperty,
+ ),
+ columnType: leaf.compositeProperty.type,
+ };
+ case 'scalar':
+ return {
+ tableAlias: objectNameSingular,
+ columnName: leaf.path[0],
+ columnType: leaf.fieldMetadata.type,
+ };
+ }
+};
diff --git a/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts b/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
index 9cb6cd2ebd2..2ac6c4c4fab 100644
--- a/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
+++ b/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
@@ -1,6 +1,7 @@
import {
type CompositeProperty,
FieldMetadataType,
+ type ObjectsPermissions,
type OrderByDirection,
compositeTypeDefinitions,
} from 'twenty-shared/types';
@@ -13,6 +14,7 @@ import {
GraphqlQueryRunnerException,
GraphqlQueryRunnerExceptionCode,
} from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
+import { assertFieldIsReadableOrThrow } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util';
import { isOrderByDirection } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/utils/is-order-by-direction.util';
import { resolveFilterKeyFieldMetadata } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/resolve-filter-key-field-metadata.util';
import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
@@ -77,8 +79,6 @@ const flattenNestedOrderByValue = (
);
}
- // The SQL order parser silently ignores relation entries whose nested
- // value is not a direction; mirror that here so both stay aligned
return isOrderByDirection(nestedValue)
? [{ path: [key], direction: nestedValue }]
: [];
@@ -95,6 +95,7 @@ const resolveRelationLeaf = ({
flatObjectMetadataMaps,
flatFieldMetadataMaps,
strictValidation,
+ objectsPermissions,
}: {
fieldMetadata: FlatFieldMetadata;
path: string[];
@@ -102,6 +103,7 @@ const resolveRelationLeaf = ({
flatObjectMetadataMaps?: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
strictValidation: boolean;
+ objectsPermissions?: ObjectsPermissions;
}): OrderByLeaf | null => {
const targetObjectMetadata =
isDefined(flatObjectMetadataMaps) &&
@@ -140,6 +142,12 @@ const resolveRelationLeaf = ({
return null;
}
+ assertFieldIsReadableOrThrow({
+ objectsPermissions,
+ objectMetadataId: targetObjectMetadata.id,
+ fieldMetadataId: targetFieldMetadata.id,
+ });
+
if (isCompositeFieldMetadataType(targetFieldMetadata.type)) {
const targetCompositeProperty = compositeTypeDefinitions
.get(targetFieldMetadata.type)
@@ -185,20 +193,22 @@ const resolveRelationLeaf = ({
};
// Single source of truth for walking an orderBy: every entry is flattened into
-// ordered leaves that carry their own direction, so the SQL ordering, column
+// ordered leaves that carry their own direction, and the SQL order parser
+// compiles its clauses from these leaves, so the SQL ordering, column
// selection, cursor encoding, cursor validation and keyset conditions all
// consume the same list and cannot drift apart. Duplicated leaves keep their
// first occurrence, which lets callers append the id tie-breaker untouched: a
// caller-provided id ordering wins over the appended default.
-// Strict validation rejects unknown or malformed entries the way the SQL order
-// parser does; the lenient mode skips them instead, for callers that re-walk an
-// already-validated orderBy against another object (e.g. nested connections).
+// Strict validation rejects unknown or malformed entries; the lenient mode
+// skips them instead, for callers that re-walk an already-validated orderBy
+// against another object (e.g. nested connections).
export const resolveOrderByLeaves = ({
orderBy,
flatObjectMetadata,
flatObjectMetadataMaps,
flatFieldMetadataMaps,
strictValidation = false,
+ objectsPermissions,
}: {
orderBy: ObjectRecordOrderBy | undefined;
flatObjectMetadata: FlatObjectMetadata;
@@ -207,6 +217,9 @@ export const resolveOrderByLeaves = ({
flatObjectMetadataMaps?: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
strictValidation?: boolean;
+ // Sort values embed into cursors, so ordering by a field the role cannot
+ // read is rejected like filtering by one is
+ objectsPermissions?: ObjectsPermissions;
}): OrderByLeaf[] => {
if (!isDefined(orderBy) || !isNonEmptyArray(orderBy)) {
return [];
@@ -252,6 +265,12 @@ export const resolveOrderByLeaves = ({
continue;
}
+ assertFieldIsReadableOrThrow({
+ objectsPermissions,
+ objectMetadataId: flatObjectMetadata.id,
+ fieldMetadataId: fieldMetadata.id,
+ });
+
if (
isReferencedByFieldName &&
isMorphOrRelationFlatFieldMetadata(fieldMetadata)
@@ -265,9 +284,17 @@ export const resolveOrderByLeaves = ({
continue;
}
- for (const { path, direction } of flattenNestedOrderByValue(
- orderByValue,
- )) {
+ const flattenedRelationPaths = flattenNestedOrderByValue(orderByValue);
+
+ // An entry whose nested values are no directions at all would
+ // otherwise order by nothing without telling the caller
+ if (flattenedRelationPaths.length === 0 && strictValidation) {
+ throwInvalidOrderByInput(
+ `Relation field "${fieldName}" requires nested field ordering (e.g., { ${fieldName}: { fieldName: 'AscNullsFirst' } })`,
+ );
+ }
+
+ for (const { path, direction } of flattenedRelationPaths) {
const relationLeaf = resolveRelationLeaf({
fieldMetadata,
path: [fieldName, ...path],
@@ -275,6 +302,7 @@ export const resolveOrderByLeaves = ({
flatObjectMetadataMaps,
flatFieldMetadataMaps,
strictValidation,
+ objectsPermissions,
});
if (isDefined(relationLeaf)) {