Skip to content

The open alternative to Salesforce, designed for AI.

[3/3 Sidebar] Bulk object metadata updates (#26105)

Thomas des Francs42fd727cb070
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
index 89ea4cc3048..90ef3fa4af4 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
@@ -4020,6 +4020,7 @@ type Mutation {
createOneObject(input: CreateOneObjectInput!): Object!
deleteOneObject(input: DeleteOneObjectInput!): Object!
updateOneObject(input: UpdateOneObjectInput!): Object!
+ updateManyObjects(inputs: [UpdateOneObjectInput!]!): [Object!]!
createOneIndex(input: CreateOneIndexInput!): Index!
deleteOneIndex(input: DeleteOneIndexInput!): Index!
deleteOneLogicFunction(input: LogicFunctionIdInput!): LogicFunction!
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.ts b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
index 0ce56d863e5..879f8a78643 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
@@ -3446,6 +3446,7 @@ export interface Mutation {
createOneObject: Object
deleteOneObject: Object
updateOneObject: Object
+ updateManyObjects: Object[]
createOneIndex: Index
deleteOneIndex: Index
deleteOneLogicFunction: LogicFunction
@@ -7257,6 +7258,7 @@ export interface MutationGenqlSelection{
createOneObject?: (ObjectGenqlSelection & { __args: {input: CreateOneObjectInput} })
deleteOneObject?: (ObjectGenqlSelection & { __args: {input: DeleteOneObjectInput} })
updateOneObject?: (ObjectGenqlSelection & { __args: {input: UpdateOneObjectInput} })
+ updateManyObjects?: (ObjectGenqlSelection & { __args: {inputs: UpdateOneObjectInput[]} })
createOneIndex?: (IndexGenqlSelection & { __args: {input: CreateOneIndexInput} })
deleteOneIndex?: (IndexGenqlSelection & { __args: {input: DeleteOneIndexInput} })
deleteOneLogicFunction?: (LogicFunctionGenqlSelection & { __args: {input: LogicFunctionIdInput} })
diff --git a/packages/twenty-client-sdk/src/metadata/generated/types.ts b/packages/twenty-client-sdk/src/metadata/generated/types.ts
index 5f72acf17e8..3fe90d4965a 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/types.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/types.ts
@@ -9261,6 +9261,15 @@ export default {
]
}
],
+ "updateManyObjects": [
+ 23,
+ {
+ "inputs": [
+ 483,
+ "[UpdateOneObjectInput!]!"
+ ]
+ }
+ ],
"createOneIndex": [
259,
{
diff --git a/packages/twenty-front/src/generated-metadata/graphql.ts b/packages/twenty-front/src/generated-metadata/graphql.ts
index 88a8d17a4e4..d7f73cffeb1 100644
--- a/packages/twenty-front/src/generated-metadata/graphql.ts
+++ b/packages/twenty-front/src/generated-metadata/graphql.ts
@@ -3183,6 +3183,7 @@ export type Mutation = {
updateFrontComponent: FrontComponent;
updateLabPublicFeatureFlag: FeatureFlag;
updateManyNavigationMenuItems: Array<NavigationMenuItem>;
+ updateManyObjects: Array<Object>;
updateManyViewGroups: Array<ViewGroup>;
updateMessageChannel: MessageChannel;
updateMessageFolder: MessageFolder;
@@ -4244,6 +4245,11 @@ export type MutationUpdateManyNavigationMenuItemsArgs = {
};
+export type MutationUpdateManyObjectsArgs = {
+ inputs: Array<UpdateOneObjectInput>;
+};
+
+
export type MutationUpdateManyViewGroupsArgs = {
inputs: Array<UpdateViewGroupInput>;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.resolver.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.resolver.ts
index 063a4423382..1e583ce0d20 100644
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.resolver.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.resolver.ts
@@ -401,6 +401,26 @@ export class ObjectMetadataResolver {
}
}
+ @UseGuards(SettingsPermissionGuard(PermissionFlagType.DATA_MODEL))
+ @Mutation(() => [ObjectMetadataDTO])
+ async updateManyObjects(
+ @Args('inputs', { type: () => [UpdateOneObjectInput] })
+ updateObjectInputs: UpdateOneObjectInput[],
+ @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+ ) {
+ try {
+ const flatObjectMetadatas =
+ await this.objectMetadataService.updateManyObjects({
+ updateObjectInputs,
+ workspaceId,
+ });
+
+ return flatObjectMetadatas.map(fromFlatObjectMetadataToObjectMetadataDto);
+ } catch (error) {
+ objectMetadataGraphqlApiExceptionHandler(error);
+ }
+ }
+
@ResolveField(() => [FieldMetadataDTO], { nullable: false })
async fieldsList(
@AuthWorkspace() workspace: WorkspaceEntity,
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
index 9ba97530d14..7791d1fba97 100644
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
@@ -24,6 +24,7 @@ import { CreateObjectInput } from 'src/engine/metadata-modules/object-metadata/d
import { DeleteOneObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/delete-object.input';
import { UpdateOneObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/update-object.input';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { validateUpdateObjectInputs } from 'src/engine/metadata-modules/object-metadata/utils/validate-update-object-inputs.util';
import {
ObjectMetadataException,
ObjectMetadataExceptionCode,
@@ -34,6 +35,14 @@ import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspa
import { type UniversalFlatFieldMetadata } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-field-metadata.type';
import { type UniversalFlatObjectMetadata } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-object-metadata.type';
+const MAX_OBJECTS_PER_BATCH_UPDATE = 100;
+
+const NON_BATCHABLE_UPDATE_PROPERTIES = [
+ 'nameSingular',
+ 'namePlural',
+ 'labelIdentifierFieldMetadataId',
+] as const;
+
@Injectable()
export class ObjectMetadataService {
constructor(
@@ -45,15 +54,79 @@ export class ObjectMetadataService {
private readonly applicationService: ApplicationService,
) {}
- async updateOneObject({
- updateObjectInput,
+ // One migration for the whole batch: one update per item would validate, build
+ // and run a migration each time, and refetch the flat entity maps with it.
+ async updateManyObjects({
+ updateObjectInputs,
workspaceId,
ownerFlatApplication,
}: {
workspaceId: string;
- updateObjectInput: UpdateOneObjectInput;
+ updateObjectInputs: UpdateOneObjectInput[];
ownerFlatApplication?: FlatApplication;
- }): Promise<FlatObjectMetadata> {
+ }): Promise<FlatObjectMetadata[]> {
+ if (updateObjectInputs.length === 0) {
+ return [];
+ }
+
+ if (updateObjectInputs.length > MAX_OBJECTS_PER_BATCH_UPDATE) {
+ throw new ObjectMetadataException(
+ `Cannot update more than ${MAX_OBJECTS_PER_BATCH_UPDATE} objects in one batch`,
+ ObjectMetadataExceptionCode.INVALID_OBJECT_INPUT,
+ );
+ }
+
+ validateUpdateObjectInputs(updateObjectInputs);
+
+ const objectMetadataIds = updateObjectInputs.map(({ id }) => id);
+
+ if (new Set(objectMetadataIds).size !== objectMetadataIds.length) {
+ throw new ObjectMetadataException(
+ 'Cannot update the same object twice in one batch',
+ ObjectMetadataExceptionCode.INVALID_OBJECT_INPUT,
+ );
+ }
+
+ // These rewrite state beyond the object itself, so several of them in one
+ // migration either collide or hold locks across tables: a rename rewrites
+ // indexes and morph fields on related objects and can emit the same index
+ // twice, and a new label identifier rebuilds the search vector, rewriting
+ // the table and holding it locked until the whole batch commits. Splitting
+ // into one migration per object would commit each separately and leave the
+ // workspace half updated on a later failure, so the batch is refused.
+ const [nonBatchableUpdatedProperty] = updateObjectInputs.flatMap(
+ ({ update }) =>
+ NON_BATCHABLE_UPDATE_PROPERTIES.filter((property) =>
+ isDefined(update[property]),
+ ),
+ );
+
+ if (
+ isDefined(nonBatchableUpdatedProperty) &&
+ updateObjectInputs.length > 1
+ ) {
+ throw new ObjectMetadataException(
+ `Cannot update ${nonBatchableUpdatedProperty} in a batch of several objects, send it one at a time`,
+ ObjectMetadataExceptionCode.INVALID_OBJECT_INPUT,
+ );
+ }
+
+ return await this.updateObjectsInOneMigration({
+ updateObjectInputs,
+ workspaceId,
+ ownerFlatApplication,
+ });
+ }
+
+ private async updateObjectsInOneMigration({
+ updateObjectInputs,
+ workspaceId,
+ ownerFlatApplication,
+ }: {
+ workspaceId: string;
+ updateObjectInputs: UpdateOneObjectInput[];
+ ownerFlatApplication?: FlatApplication;
+ }): Promise<FlatObjectMetadata[]> {
const { workspaceCustomFlatApplication } =
await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
{ workspaceId },
@@ -83,26 +156,19 @@ export class ObjectMetadataService {
},
);
- const {
- otherObjectFlatFieldMetadatasToUpdate,
- flatObjectMetadataToUpdate,
- flatIndexMetadatasToUpdate,
- flatViewFieldsToCreate,
- flatViewFieldsToUpdate,
- searchFieldMetadatasToCreate,
- } = fromUpdateObjectInputToFlatObjectMetadataAndRelatedFlatEntities({
- flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
- flatObjectMetadataMaps: existingFlatObjectMetadataMaps,
- updateObjectInput,
- flatIndexMaps: existingFlatIndexMaps,
- flatViewFieldMaps: existingFlatViewFieldMaps,
- flatViewMaps: existingFlatViewMaps,
- flatSearchFieldMetadataMaps: existingFlatSearchFieldMetadataMaps,
- workspaceCustomApplicationUniversalIdentifier:
- workspaceCustomFlatApplication.universalIdentifier,
- });
-
- const isActiveChangeDefined = isDefined(updateObjectInput.update.isActive);
+ const conversions = updateObjectInputs.map((updateObjectInput) =>
+ fromUpdateObjectInputToFlatObjectMetadataAndRelatedFlatEntities({
+ flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
+ flatObjectMetadataMaps: existingFlatObjectMetadataMaps,
+ updateObjectInput,
+ flatIndexMaps: existingFlatIndexMaps,
+ flatViewFieldMaps: existingFlatViewFieldMaps,
+ flatViewMaps: existingFlatViewMaps,
+ flatSearchFieldMetadataMaps: existingFlatSearchFieldMetadataMaps,
+ workspaceCustomApplicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ }),
+ );
const validateAndBuildResult =
await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
@@ -111,25 +177,39 @@ export class ObjectMetadataService {
objectMetadata: {
flatEntityToCreate: [],
flatEntityToDelete: [],
- flatEntityToUpdate: [flatObjectMetadataToUpdate],
+ flatEntityToUpdate: conversions.map(
+ ({ flatObjectMetadataToUpdate }) => flatObjectMetadataToUpdate,
+ ),
},
index: {
flatEntityToCreate: [],
flatEntityToDelete: [],
- flatEntityToUpdate: flatIndexMetadatasToUpdate,
+ flatEntityToUpdate: conversions.flatMap(
+ ({ flatIndexMetadatasToUpdate }) => flatIndexMetadatasToUpdate,
+ ),
},
fieldMetadata: {
flatEntityToCreate: [],
flatEntityToDelete: [],
- flatEntityToUpdate: [...otherObjectFlatFieldMetadatasToUpdate],
+ flatEntityToUpdate: conversions.flatMap(
+ ({ otherObjectFlatFieldMetadatasToUpdate }) =>
+ otherObjectFlatFieldMetadatasToUpdate,
+ ),
},
viewField: {
- flatEntityToCreate: flatViewFieldsToCreate,
+ flatEntityToCreate: conversions.flatMap(
+ ({ flatViewFieldsToCreate }) => flatViewFieldsToCreate,
+ ),
flatEntityToDelete: [],
- flatEntityToUpdate: flatViewFieldsToUpdate,
+ flatEntityToUpdate: conversions.flatMap(
+ ({ flatViewFieldsToUpdate }) => flatViewFieldsToUpdate,
+ ),
},
searchFieldMetadata: {
- flatEntityToCreate: searchFieldMetadatasToCreate,
+ flatEntityToCreate: conversions.flatMap(
+ ({ searchFieldMetadatasToCreate }) =>
+ searchFieldMetadatasToCreate,
+ ),
flatEntityToDelete: [],
flatEntityToUpdate: [],
},
@@ -144,7 +224,7 @@ export class ObjectMetadataService {
if (validateAndBuildResult.status === 'fail') {
throw new WorkspaceMigrationBuilderException(
validateAndBuildResult,
- 'Multiple validation errors occurred while updating object',
+ `Multiple validation errors occurred while updating object${updateObjectInputs.length > 1 ? 's' : ''}`,
);
}
@@ -156,31 +236,59 @@ export class ObjectMetadataService {
},
);
- const updatedFlatObjectMetadata = findFlatEntityByUniversalIdentifier({
- universalIdentifier: flatObjectMetadataToUpdate.universalIdentifier,
- flatEntityMaps: recomputedFlatObjectMetadataMaps,
- });
-
- if (!isDefined(updatedFlatObjectMetadata)) {
- throw new ObjectMetadataException(
- 'Updated object metadata not found in recomputed cache',
- ObjectMetadataExceptionCode.INTERNAL_SERVER_ERROR,
- );
- }
+ const updatedFlatObjectMetadatas = conversions.map(
+ ({ flatObjectMetadataToUpdate }) => {
+ const updatedFlatObjectMetadata = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: flatObjectMetadataToUpdate.universalIdentifier,
+ flatEntityMaps: recomputedFlatObjectMetadataMaps,
+ });
+
+ if (!isDefined(updatedFlatObjectMetadata)) {
+ throw new ObjectMetadataException(
+ 'Updated object metadata not found in recomputed cache',
+ ObjectMetadataExceptionCode.INTERNAL_SERVER_ERROR,
+ );
+ }
+
+ return updatedFlatObjectMetadata;
+ },
+ );
- if (isDefined(updateObjectInput.update.labelIdentifierFieldMetadataId)) {
+ if (
+ updateObjectInputs.some(({ update }) =>
+ isDefined(update.labelIdentifierFieldMetadataId),
+ )
+ ) {
await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [
'rolesPermissions',
]);
}
- if (isActiveChangeDefined) {
+ if (updateObjectInputs.some(({ update }) => isDefined(update.isActive))) {
await this.flatEntityMapsCacheService.invalidateFlatEntityMaps({
workspaceId,
flatMapsKeys: ['flatNavigationMenuItemMaps', 'flatCommandMenuItemMaps'],
});
}
+ return updatedFlatObjectMetadatas;
+ }
+
+ async updateOneObject({
+ updateObjectInput,
+ workspaceId,
+ ownerFlatApplication,
+ }: {
+ workspaceId: string;
+ updateObjectInput: UpdateOneObjectInput;
+ ownerFlatApplication?: FlatApplication;
+ }): Promise<FlatObjectMetadata> {
+ const [updatedFlatObjectMetadata] = await this.updateManyObjects({
+ updateObjectInputs: [updateObjectInput],
+ workspaceId,
+ ownerFlatApplication,
+ });
+
return updatedFlatObjectMetadata;
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/tools/object-metadata-tools.factory.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/tools/object-metadata-tools.factory.ts
index 216ff3523d5..af42cd912d3 100644
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/tools/object-metadata-tools.factory.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/tools/object-metadata-tools.factory.ts
@@ -387,7 +387,7 @@ export class ObjectMetadataToolsFactory {
},
update_many_object_metadata: {
description:
- 'Update multiple objects at once. Batch version of update_object_metadata.',
+ 'Update multiple objects at once. Batch version of update_object_metadata. Applies the whole batch in one migration, so a rename (nameSingular or namePlural) or a labelIdentifierFieldMetadataId change cannot share a batch with another object: send each of those as its own call.',
inputSchema: UpdateManyObjectMetadataInputSchema,
execute: async (parameters: {
objects: Array<{
@@ -406,12 +406,12 @@ export class ObjectMetadataToolsFactory {
}>;
}) => {
try {
- await Promise.all(
- parameters.objects.map(async ({ id, icon, ...update }) => {
- const normalizedIcon = normalizeIconName(icon);
+ await this.objectMetadataService.updateManyObjects({
+ updateObjectInputs: parameters.objects.map(
+ ({ id, icon, ...update }) => {
+ const normalizedIcon = normalizeIconName(icon);
- await this.objectMetadataService.updateOneObject({
- updateObjectInput: {
+ return {
id,
update: {
...update,
@@ -419,11 +419,11 @@ export class ObjectMetadataToolsFactory {
? { icon: normalizedIcon }
: {}),
},
- },
- workspaceId,
- });
- }),
- );
+ };
+ },
+ ),
+ workspaceId,
+ });
return true;
} catch (error) {
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/utils/validate-update-object-inputs.util.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/utils/validate-update-object-inputs.util.ts
new file mode 100644
index 00000000000..22ff143eb00
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/utils/validate-update-object-inputs.util.ts
@@ -0,0 +1,42 @@
+import { plainToInstance } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+
+import { UpdateOneObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/update-object.input';
+import {
+ ObjectMetadataException,
+ ObjectMetadataExceptionCode,
+} from 'src/engine/metadata-modules/object-metadata/object-metadata.exception';
+
+const formatValidationErrors = (errors: ValidationError[]): string =>
+ errors
+ .flatMap((error) => {
+ if (isDefined(error.constraints)) {
+ return Object.values(error.constraints);
+ }
+
+ if (isNonEmptyArray(error.children)) {
+ return formatValidationErrors(error.children);
+ }
+
+ return [];
+ })
+ .join(', ');
+
+// ResolverValidationPipe skips bare array arguments and the AI tools factory
+// calls the service directly, so without this a batch would accept payloads
+// updateOneObject rejects.
+export const validateUpdateObjectInputs = (
+ updateObjectInputs: UpdateOneObjectInput[],
+): void => {
+ const validationErrors = updateObjectInputs.flatMap((updateObjectInput) =>
+ validateSync(plainToInstance(UpdateOneObjectInput, updateObjectInput)),
+ );
+
+ if (validationErrors.length > 0) {
+ throw new ObjectMetadataException(
+ formatValidationErrors(validationErrors),
+ ObjectMetadataExceptionCode.INVALID_OBJECT_INPUT,
+ );
+ }
+};
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/__snapshots__/failing-update-many-object-metadata.integration-spec.ts.snap b/packages/twenty-server/test/integration/metadata/suites/object-metadata/__snapshots__/failing-update-many-object-metadata.integration-spec.ts.snap
new file mode 100644
index 00000000000..6bd17e785ca
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/__snapshots__/failing-update-many-object-metadata.integration-spec.ts.snap
@@ -0,0 +1,49 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Bulk object metadata update should fail when a label identifier update shares a batch with another object 1`] = `
+{
+ "extensions": {
+ "code": "BAD_USER_INPUT",
+ "subCode": "INVALID_OBJECT_INPUT",
+ "userFriendlyMessage": "Invalid object input.",
+ },
+ "message": "Cannot update labelIdentifierFieldMetadataId in a batch of several objects, send it one at a time",
+ "name": "UserInputError",
+}
+`;
+
+exports[`Bulk object metadata update should fail when a rename shares a batch with another object 1`] = `
+{
+ "extensions": {
+ "code": "BAD_USER_INPUT",
+ "subCode": "INVALID_OBJECT_INPUT",
+ "userFriendlyMessage": "Invalid object input.",
+ },
+ "message": "Cannot update nameSingular in a batch of several objects, send it one at a time",
+ "name": "UserInputError",
+}
+`;
+
+exports[`Bulk object metadata update should fail when an input fails the payload validators 1`] = `
+{
+ "extensions": {
+ "code": "BAD_USER_INPUT",
+ "subCode": "INVALID_OBJECT_INPUT",
+ "userFriendlyMessage": "Invalid object input.",
+ },
+ "message": "nameSingular has failed the name validation check",
+ "name": "UserInputError",
+}
+`;
+
+exports[`Bulk object metadata update should fail when the same object appears twice in one batch 1`] = `
+{
+ "extensions": {
+ "code": "BAD_USER_INPUT",
+ "subCode": "INVALID_OBJECT_INPUT",
+ "userFriendlyMessage": "Invalid object input.",
+ },
+ "message": "Cannot update the same object twice in one batch",
+ "name": "UserInputError",
+}
+`;
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/failing-update-many-object-metadata.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/failing-update-many-object-metadata.integration-spec.ts
new file mode 100644
index 00000000000..8873d3dac8b
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/failing-update-many-object-metadata.integration-spec.ts
@@ -0,0 +1,208 @@
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.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 { updateManyObjectsMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('Bulk object metadata update should fail', () => {
+ let companyObjectMetadataId: string;
+ let companyColor: string | undefined;
+
+ beforeAll(async () => {
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: `
+ id
+ nameSingular
+ color
+ `,
+ });
+
+ const companyObject = objects.find(
+ (object) => object.nameSingular === 'company',
+ );
+
+ jestExpectToBeDefined(companyObject);
+ companyObjectMetadataId = companyObject.id;
+ companyColor = companyObject.color;
+ });
+
+ // Every conversion is computed against the pre-update maps, so a second
+ // update to the same object would be built from stale state.
+ it('when the same object appears twice in one batch', async () => {
+ const { errors } = await updateManyObjectsMetadata({
+ expectToFail: true,
+ input: {
+ inputs: [
+ { id: companyObjectMetadataId, update: { color: 'red' } },
+ { id: companyObjectMetadataId, update: { color: 'blue' } },
+ ],
+ },
+ });
+
+ expectOneNotInternalServerErrorSnapshot({ errors });
+ });
+
+ // A rename cannot share a migration with another update, and splitting the
+ // batch would commit the other objects before a failing rename. The renamed
+ // object has to be a custom one: nameSingular is not editable on standard
+ // objects, which would make this pass whether or not the batch is refused.
+ it('when a rename shares a batch with another object', async () => {
+ const suffix = Date.now().toString().slice(-8);
+ const { data } = await createOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ nameSingular: `bulkRenameGuard${suffix}`,
+ namePlural: `bulkRenameGuards${suffix}`,
+ labelSingular: `Bulk Rename Guard ${suffix}`,
+ labelPlural: `Bulk Rename Guards ${suffix}`,
+ isLabelSyncedWithName: false,
+ },
+ gqlFields: 'id',
+ });
+ const customObjectMetadataId = data.createOneObject.id;
+
+ try {
+ const { errors } = await updateManyObjectsMetadata({
+ expectToFail: true,
+ input: {
+ inputs: [
+ { id: companyObjectMetadataId, update: { color: 'red' } },
+ {
+ id: customObjectMetadataId,
+ update: { nameSingular: `bulkRenamed${suffix}` },
+ },
+ ],
+ },
+ });
+
+ expectOneNotInternalServerErrorSnapshot({ errors });
+ } finally {
+ await deleteOneObjectMetadata({
+ expectToFail: false,
+ input: { idToDelete: customObjectMetadataId },
+ });
+ }
+ });
+
+ it('when an input fails the payload validators', async () => {
+ const { errors } = await updateManyObjectsMetadata({
+ expectToFail: true,
+ input: {
+ inputs: [
+ { id: companyObjectMetadataId, update: { color: 'red' } },
+ { id: companyObjectMetadataId, update: { nameSingular: 'and' } },
+ ],
+ },
+ });
+
+ expectOneNotInternalServerErrorSnapshot({ errors });
+ });
+
+ // Pointing an object at a label identifier that is not in its search vector
+ // rebuilds that vector and rewrites the table, so batching several would hold
+ // an exclusive lock on each one until the whole migration commits.
+ it('when a label identifier update shares a batch with another object', async () => {
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: `
+ id
+ nameSingular
+ labelIdentifierFieldMetadataId
+ `,
+ });
+
+ const personObject = objects.find(
+ (object) => object.nameSingular === 'person',
+ );
+
+ jestExpectToBeDefined(personObject);
+
+ const { labelIdentifierFieldMetadataId } = personObject;
+
+ jestExpectToBeDefined(labelIdentifierFieldMetadataId);
+
+ const { errors } = await updateManyObjectsMetadata({
+ expectToFail: true,
+ input: {
+ inputs: [
+ { id: companyObjectMetadataId, update: { color: 'red' } },
+ {
+ id: personObject.id,
+ update: { labelIdentifierFieldMetadataId },
+ },
+ ],
+ },
+ });
+
+ expectOneNotInternalServerErrorSnapshot({ errors });
+ });
+
+ // The guards above refuse a batch before any conversion runs. This one passes
+ // them and the payload validators, and only fails once the migration is being
+ // built: desynchronising a synced object's labels from its names is caught
+ // there, so it covers the objects earlier in the batch rolling back too.
+ it('and leaves every object in the batch untouched', async () => {
+ const suffix = Date.now().toString().slice(-8);
+ const { data } = await createOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ nameSingular: `bulkAtomicGuard${suffix}`,
+ namePlural: `bulkAtomicGuards${suffix}`,
+ labelSingular: `Bulk Atomic Guard ${suffix}`,
+ labelPlural: `Bulk Atomic Guards ${suffix}`,
+ isLabelSyncedWithName: true,
+ },
+ gqlFields: 'id',
+ });
+ const syncedObjectMetadataId = data.createOneObject.id;
+
+ try {
+ const { errors } = await updateManyObjectsMetadata({
+ expectToFail: true,
+ input: {
+ inputs: [
+ { id: companyObjectMetadataId, update: { color: 'red' } },
+ {
+ id: syncedObjectMetadataId,
+ update: { labelSingular: `Desynced Label ${suffix}` },
+ },
+ ],
+ },
+ });
+
+ // Not snapshotted: a migration validation payload carries the whole
+ // failed entity, so it changes with the suffix this object is named after.
+ const [firstError] = errors;
+
+ expect(errors).toHaveLength(1);
+ expect(firstError.extensions.code).toBe('METADATA_VALIDATION_FAILED');
+
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: `
+ id
+ color
+ labelSingular
+ `,
+ });
+
+ expect(
+ objects.find((object) => object.id === companyObjectMetadataId)?.color,
+ ).toBe(companyColor);
+ expect(
+ objects.find((object) => object.id === syncedObjectMetadataId)
+ ?.labelSingular,
+ ).toBe(`Bulk Atomic Guard ${suffix}`);
+ } finally {
+ await deleteOneObjectMetadata({
+ expectToFail: false,
+ input: { idToDelete: syncedObjectMetadataId },
+ });
+ }
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/successful-update-many-object-metadata.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/successful-update-many-object-metadata.integration-spec.ts
new file mode 100644
index 00000000000..dc20c366e2a
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/successful-update-many-object-metadata.integration-spec.ts
@@ -0,0 +1,95 @@
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { updateManyObjectsMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+import { type ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+describe('Bulk object metadata update', () => {
+ let companyObject: ObjectMetadataDTO;
+ let personObject: ObjectMetadataDTO;
+
+ beforeAll(async () => {
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: `
+ id
+ nameSingular
+ labelSingular
+ color
+ icon
+ `,
+ });
+
+ const company = objects.find((object) => object.nameSingular === 'company');
+ const person = objects.find((object) => object.nameSingular === 'person');
+
+ jestExpectToBeDefined(company);
+ jestExpectToBeDefined(person);
+ companyObject = company;
+ personObject = person;
+ });
+
+ afterEach(async () => {
+ for (const object of [companyObject, personObject]) {
+ await updateOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ idToUpdate: object.id,
+ updatePayload: {
+ color: object.color,
+ icon: object.icon,
+ labelSingular: object.labelSingular,
+ },
+ },
+ });
+ }
+ });
+
+ it('should update every object in the batch', async () => {
+ const { data } = await updateManyObjectsMetadata({
+ expectToFail: false,
+ input: {
+ inputs: [
+ { id: companyObject.id, update: { color: 'red' } },
+ { id: personObject.id, update: { color: 'purple' } },
+ ],
+ },
+ gqlFields: `
+ id
+ color
+ `,
+ });
+
+ const updatedById = new Map(
+ data.updateManyObjects.map((object) => [object.id, object]),
+ );
+
+ expect(updatedById.get(companyObject.id)?.color).toBe('red');
+ expect(updatedById.get(personObject.id)?.color).toBe('purple');
+ });
+
+ it('should apply a batch of label updates', async () => {
+ const { data } = await updateManyObjectsMetadata({
+ expectToFail: false,
+ input: {
+ inputs: [
+ { id: companyObject.id, update: { labelSingular: 'Business' } },
+ { id: personObject.id, update: { labelSingular: 'Human' } },
+ ],
+ },
+ gqlFields: `
+ id
+ labelSingular
+ `,
+ });
+
+ const updatedById = new Map(
+ data.updateManyObjects.map((object) => [object.id, object]),
+ );
+
+ expect(updatedById.get(companyObject.id)?.labelSingular).toBe('Business');
+ expect(updatedById.get(personObject.id)?.labelSingular).toBe('Human');
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata-query-factory.util.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata-query-factory.util.ts
new file mode 100644
index 00000000000..6d726ee3b98
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata-query-factory.util.ts
@@ -0,0 +1,24 @@
+import gql from 'graphql-tag';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type UpdateOneObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/update-object.input';
+
+export type UpdateManyObjectsFactoryInput = {
+ inputs: UpdateOneObjectInput[];
+};
+
+export const updateManyObjectsMetadataQueryFactory = ({
+ gqlFields = 'id',
+ input,
+}: PerformMetadataQueryParams<UpdateManyObjectsFactoryInput>) => ({
+ query: gql`
+ mutation UpdateManyObjectMetadataItems($inputs: [UpdateOneObjectInput!]!) {
+ updateManyObjects(inputs: $inputs) {
+ ${gqlFields}
+ }
+ }
+ `,
+ variables: {
+ inputs: input.inputs,
+ },
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata.util.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata.util.ts
new file mode 100644
index 00000000000..f606bf118a9
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata.util.ts
@@ -0,0 +1,43 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import {
+ type UpdateManyObjectsFactoryInput,
+ updateManyObjectsMetadataQueryFactory,
+} from 'test/integration/metadata/suites/object-metadata/utils/update-many-objects-metadata-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+export const updateManyObjectsMetadata = async ({
+ input,
+ gqlFields,
+ expectToFail,
+}: PerformMetadataQueryParams<UpdateManyObjectsFactoryInput>): CommonResponseBody<{
+ updateManyObjects: ObjectMetadataDTO[];
+}> => {
+ const graphqlOperation = updateManyObjectsMetadataQueryFactory({
+ input,
+ gqlFields,
+ });
+
+ const response = await makeMetadataAPIRequest(graphqlOperation);
+
+ if (expectToFail === true) {
+ warnIfNoErrorButExpectedToFail({
+ response,
+ errorMessage:
+ 'Object Metadata bulk update should have failed but did not',
+ });
+ }
+
+ if (expectToFail === false) {
+ warnIfErrorButNotExpectedToFail({
+ response,
+ errorMessage: 'Object Metadata bulk update has failed but should not',
+ });
+ }
+
+ return { data: response.body.data, errors: response.body.errors };
+};