Skip to content

The open alternative to Salesforce, designed for AI.

fix(server): stop upgrade-pending columns from breaking repository updates (#25583)

Félix Malfait607e776e3879
diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts
index dc4e8eaaec9..d8f21a1a496 100644
--- a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/__tests__/upgrade-aware-repository.proxy.spec.ts
@@ -3,7 +3,7 @@ import 'reflect-metadata';
import { Test } from '@nestjs/testing';
import { getDataSourceToken } from '@nestjs/typeorm';
-import { type DataSource, type Repository } from 'typeorm';
+import { type DataSource, type Repository, type UpdateResult } from 'typeorm';
import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';
import { WasIntroducedInUpgrade } from 'src/engine/core-modules/upgrade/decorators/was-introduced-in-upgrade.decorator';
@@ -108,6 +108,71 @@ describe('wrapRepositoryWithUpgradeAwareProxy', () => {
});
});
+ describe('update', () => {
+ const buildWrappedRepository = (hiddenColumnPropertyNames: string[]) => {
+ const update = jest.fn().mockResolvedValue({ affected: 1 });
+ const repository = {
+ update,
+ metadata: {
+ relations: [],
+ targetName: EntityWithHiddenColumn.name,
+ },
+ } as unknown as Repository<EntityWithHiddenColumn>;
+ const state = {
+ getHiddenColumnPropertyNames: jest
+ .fn()
+ .mockReturnValue(new Set(hiddenColumnPropertyNames)),
+ isEntityAvailable: jest.fn().mockReturnValue(true),
+ } as unknown as UpgradeAwareRepositoryState;
+
+ return {
+ update,
+ wrapped: wrapRepositoryWithUpgradeAwareProxy({
+ repository,
+ entityClass: EntityWithHiddenColumn,
+ state,
+ }) as unknown as {
+ update: (
+ criteria: unknown,
+ values: Record<string, unknown>,
+ ) => Promise<UpdateResult>;
+ },
+ };
+ };
+
+ it('strips hidden columns from the values so a lagging cursor cannot reject the write', async () => {
+ const { update, wrapped } = buildWrappedRepository(['introducedColumn']);
+
+ await wrapped.update({ id: 1 }, { name: 'app', introducedColumn: {} });
+
+ expect(update).toHaveBeenCalledTimes(1);
+ expect(update).toHaveBeenCalledWith({ id: 1 }, { name: 'app' });
+ });
+
+ it('skips the query when every value is a hidden column', async () => {
+ const { update, wrapped } = buildWrappedRepository(['introducedColumn']);
+
+ const result = await wrapped.update({ id: 1 }, { introducedColumn: {} });
+
+ expect(update).not.toHaveBeenCalled();
+ expect(result.affected).toBe(0);
+ expect(result.raw).toEqual([]);
+ expect(result.generatedMaps).toEqual([]);
+ });
+
+ it('leaves the values untouched when no column is hidden', async () => {
+ const { update, wrapped } = buildWrappedRepository([]);
+
+ await wrapped.update({ id: 1 }, { name: 'app', introducedColumn: {} });
+
+ expect(update).toHaveBeenCalledTimes(1);
+ expect(update).toHaveBeenCalledWith(
+ { id: 1 },
+ { name: 'app', introducedColumn: {} },
+ );
+ });
+ });
+
it('strips hidden columns from an object select while preserving unknown keys', async () => {
const find = jest.fn().mockResolvedValue([]);
const repository = {
diff --git a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts
index 38a3b43127e..2a1c6638f17 100644
--- a/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/upgrade-aware/upgrade-aware-repository.proxy.ts
@@ -1,6 +1,6 @@
import { Logger } from '@nestjs/common';
-import { type Repository } from 'typeorm';
+import { UpdateResult, type Repository } from 'typeorm';
import { EntityNotFoundError } from 'typeorm/error/EntityNotFoundError';
import { type EntityMetadata } from 'typeorm/metadata/EntityMetadata';
import { isDefined } from 'twenty-shared/utils';
@@ -164,6 +164,56 @@ const stripUnavailableSelect = (
return options;
};
+// A skipped update never reaches the driver, so the counts TypeORM would have
+// filled in have to be stated rather than left undefined: no rows matched.
+const buildSkippedUpdateResult = (): UpdateResult => {
+ const updateResult = new UpdateResult();
+
+ updateResult.raw = [];
+ updateResult.affected = 0;
+
+ return updateResult;
+};
+
+const stripUnavailableUpdateValues = (
+ entityClass: Function,
+ state: UpgradeAwareRepositoryState,
+ values: unknown,
+): unknown => {
+ if (
+ !isDefined(values) ||
+ typeof values !== 'object' ||
+ Array.isArray(values)
+ ) {
+ return values;
+ }
+
+ const hiddenColumnPropertyNames =
+ state.getHiddenColumnPropertyNames(entityClass);
+
+ if (hiddenColumnPropertyNames.size === 0) {
+ return values;
+ }
+
+ const entries = Object.entries(values as Record<string, unknown>);
+ const keptEntries = entries.filter(
+ ([propertyName]) => !hiddenColumnPropertyNames.has(propertyName),
+ );
+
+ if (keptEntries.length === entries.length) {
+ return values;
+ }
+
+ logger.log(
+ `[upgrade-proxy] strip update values on ${entityClass.name}: ${entries
+ .filter(([propertyName]) => hiddenColumnPropertyNames.has(propertyName))
+ .map(([propertyName]) => propertyName)
+ .join(',')}`,
+ );
+
+ return Object.fromEntries(keptEntries);
+};
+
const stripUnavailableRelations = (
metadata: EntityMetadata,
state: UpgradeAwareRepositoryState,
@@ -314,6 +364,29 @@ const handleRepositoryMethodCall = <Entity extends object>({
return behavior.produceEmpty(entityClass);
}
+ if (methodName === 'update' && args.length > 1) {
+ const updateValues = stripUnavailableUpdateValues(
+ entityClass,
+ state,
+ args[1],
+ );
+
+ // Nothing the caller asked to write exists at this cursor, and TypeORM
+ // rejects an empty value set, so report the no-op instead of running it.
+ if (
+ updateValues !== args[1] &&
+ Object.keys(updateValues as Record<string, unknown>).length === 0
+ ) {
+ return Promise.resolve(buildSkippedUpdateResult());
+ }
+
+ return callRepositoryMethod({
+ target,
+ methodName,
+ args: [args[0], updateValues, ...args.slice(2)],
+ });
+ }
+
const rewrittenArgs =
METHODS_THAT_ACCEPT_FIND_OPTIONS.has(methodName) && args.length > 0
? [
@@ -326,9 +399,20 @@ const handleRepositoryMethodCall = <Entity extends object>({
]
: args;
- return (
+ return callRepositoryMethod({ target, methodName, args: rewrittenArgs });
+};
+
+const callRepositoryMethod = <Entity extends object>({
+ target,
+ methodName,
+ args,
+}: {
+ target: Repository<Entity>;
+ methodName: string;
+ args: unknown[];
+}): unknown =>
+ (
target[methodName as keyof Repository<Entity>] as unknown as (
...callArgs: unknown[]
) => unknown
- ).apply(target, rewrittenArgs);
-};
+ ).apply(target, args);