Skip to content

The open alternative to Salesforce, designed for AI.

Fix Kanban queries with many fields (#26279)

Raphaël Bosia2af379d65db
diff --git a/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts b/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
index 4fc1af54d5c..449c68a495e 100644
--- a/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
+++ b/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
@@ -98,6 +98,11 @@ const SCHEMA = getWorkspaceSchemaName(WORKSPACE_ID);
userWorkspaceRoleMap: {},
apiKeyRoleMap: {},
eventEmitterService: { emitDatabaseBatchEvent },
+ recordStock: {
+ assertRecordStockAvailable: jest.fn().mockResolvedValue(undefined),
+ acquireRecordStock: jest.fn().mockResolvedValue(undefined),
+ releaseRecordStock: jest.fn().mockResolvedValue(undefined),
+ },
coreDataSource: dataSource,
},
});
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records.service.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records.service.ts
index a699e9ea287..3b6f534deeb 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records.service.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/group-by/services/group-by-with-records.service.ts
@@ -213,13 +213,12 @@ export class GroupByWithRecordsService {
const pageStart = offsetForRecords;
const pageEnd = offsetForRecords + RECORDS_PER_GROUP_LIMIT;
- const jsonObjectEntries = [
+ const recordColumnsToSelect = [
...Object.keys(columnsToSelect).map(
- (columnName) => `'${columnName}', "${SUB_QUERY_PREFIX}${columnName}"`,
+ (columnName) => `"${SUB_QUERY_PREFIX}${columnName}" AS "${columnName}"`,
),
...groupByDefinitions.map(
- (groupByDefinition) =>
- `'${groupByDefinition.alias}', "${groupByDefinition.alias}"`,
+ (groupByDefinition) => `"${groupByDefinition.alias}"`,
),
].join(', ');
@@ -227,7 +226,7 @@ export class GroupByWithRecordsService {
const sql =
`SELECT ${groupByAliases}, ` +
- `JSON_AGG(CASE WHEN ${pageFilter} THEN JSON_BUILD_OBJECT(${jsonObjectEntries}) END) ` +
+ `JSON_AGG(CASE WHEN ${pageFilter} THEN (SELECT ROW_TO_JSON(record) FROM (SELECT ${recordColumnsToSelect}) AS record) END) ` +
`FILTER (WHERE ${pageFilter}) AS "records" ` +
`FROM (${subQueryBuilder.getQuery()}) AS "ranked_records" ` +
`GROUP BY ${groupByAliases}`;
diff --git a/packages/twenty-server/test/integration/graphql/suites/group-by-with-many-record-fields.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/group-by-with-many-record-fields.integration-spec.ts
new file mode 100644
index 00000000000..e36b2a27ab0
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/group-by-with-many-record-fields.integration-spec.ts
@@ -0,0 +1,183 @@
+import { randomUUID } from 'crypto';
+
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-operation-factory.util';
+import { groupByOperationFactory } from 'test/integration/graphql/utils/group-by-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { createRelationBetweenObjects } from 'test/integration/metadata/suites/object-metadata/utils/create-relation-between-objects.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+const OBJECT_NAME_SINGULAR = 'groupByManyFields';
+const OBJECT_NAME_PLURAL = 'groupByManyFieldsRecords';
+const ADDRESS_FIELD_NAMES = [
+ 'shippingAddress',
+ 'billingAddress',
+ 'deliveryAddress',
+ 'officeAddress',
+ 'warehouseAddress',
+ 'returnAddress',
+];
+const ADDRESS_VALUES = Object.fromEntries(
+ ADDRESS_FIELD_NAMES.map((fieldName) => [
+ fieldName,
+ {
+ addressStreet1: `${fieldName} street`,
+ addressStreet2: '',
+ addressCity: 'Paris',
+ addressState: 'Ile-de-France',
+ addressCountry: 'France',
+ addressPostcode: '75001',
+ addressLat: 48.8566,
+ addressLng: 2.3522,
+ },
+ ]),
+);
+const RECORDS = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1].map((position) => ({
+ id: randomUUID(),
+ name: `Record ${position}`,
+ position,
+ companyId: null,
+ ...ADDRESS_VALUES,
+}));
+const ORDERED_RECORDS = [...RECORDS].reverse();
+const RECORD_GQL_FIELDS = `
+ id
+ name
+ position
+ companyId
+ ${ADDRESS_FIELD_NAMES.map(
+ (fieldName) => `
+ ${fieldName} {
+ addressStreet1
+ addressStreet2
+ addressCity
+ addressState
+ addressCountry
+ addressPostcode
+ addressLat
+ addressLng
+ }
+ `,
+ ).join('\n')}
+`;
+
+describe('group-by with more than 50 selected record columns', () => {
+ let objectMetadataId: string | undefined;
+
+ beforeAll(async () => {
+ const { data, errors } = await createOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ nameSingular: OBJECT_NAME_SINGULAR,
+ namePlural: OBJECT_NAME_PLURAL,
+ labelSingular: 'Group By Many Fields',
+ labelPlural: 'Group By Many Fields Records',
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ expect(errors).toBeUndefined();
+ objectMetadataId = data.createOneObject.id;
+
+ for (const fieldName of ADDRESS_FIELD_NAMES) {
+ const { errors: fieldErrors } = await createOneFieldMetadata({
+ expectToFail: false,
+ input: {
+ objectMetadataId,
+ type: FieldMetadataType.ADDRESS,
+ name: fieldName,
+ label: fieldName,
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ expect(fieldErrors).toBeUndefined();
+ }
+
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: 'id nameSingular',
+ });
+ const companyObject = objects.find(
+ (objectMetadata) => objectMetadata.nameSingular === 'company',
+ );
+
+ if (!isDefined(companyObject)) {
+ throw new Error('Company object not found');
+ }
+
+ await createRelationBetweenObjects({
+ objectMetadataId,
+ targetObjectMetadataId: companyObject.id,
+ type: FieldMetadataType.RELATION,
+ relationType: RelationType.MANY_TO_ONE,
+ name: 'company',
+ targetFieldLabel: 'Group By Many Fields Records',
+ });
+
+ const response = await makeGraphqlAPIRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME_SINGULAR,
+ objectMetadataPluralName: OBJECT_NAME_PLURAL,
+ gqlFields: 'id',
+ data: RECORDS,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ });
+
+ afterAll(async () => {
+ if (!isDefined(objectMetadataId)) {
+ return;
+ }
+
+ await updateOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ idToUpdate: objectMetadataId,
+ updatePayload: { isActive: false },
+ },
+ });
+ await deleteOneObjectMetadata({
+ expectToFail: false,
+ input: { idToDelete: objectMetadataId },
+ });
+ });
+
+ it.each([
+ { offsetForRecords: 0, expectedRecords: ORDERED_RECORDS.slice(0, 10) },
+ { offsetForRecords: 10, expectedRecords: ORDERED_RECORDS.slice(10) },
+ ])(
+ 'preserves composite fields and position ordering in the null relation group at offset $offsetForRecords',
+ async ({ offsetForRecords, expectedRecords }) => {
+ const response = await makeGraphqlAPIRequest(
+ groupByOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME_SINGULAR,
+ objectMetadataPluralName: OBJECT_NAME_PLURAL,
+ groupBy: [{ companyId: true }],
+ filter: { or: [{ companyId: { is: 'NULL' } }] },
+ orderByForRecords: [{ position: 'AscNullsFirst' }],
+ limit: 1,
+ offsetForRecords,
+ gqlFields: `edges { node { ${RECORD_GQL_FIELDS} } }`,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data[`${OBJECT_NAME_PLURAL}GroupBy`]).toEqual([
+ {
+ groupByDimensionValues: [null],
+ totalCount: RECORDS.length,
+ edges: expectedRecords.map((record) => ({ node: record })),
+ },
+ ]);
+ },
+ );
+});