Skip to content

The open alternative to Salesforce, designed for AI.

fix(server): prevent cleared PromiseMemoizer work from overwriting newer values (#24515)

Félix Malfait7fd8e1b06bce
diff --git a/packages/twenty-server/src/engine/twenty-orm/storage/__tests__/promise-memoizer.storage.spec.ts b/packages/twenty-server/src/engine/twenty-orm/storage/__tests__/promise-memoizer.storage.spec.ts
index 8d5e3619934..bfa13e2ed2a 100644
--- a/packages/twenty-server/src/engine/twenty-orm/storage/__tests__/promise-memoizer.storage.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/storage/__tests__/promise-memoizer.storage.spec.ts
@@ -137,6 +137,52 @@ describe('PromiseMemoizer', () => {
expect(result2).toBe('test-value');
expect(mockFactory).toHaveBeenCalledTimes(1);
});
+
+ it('should not cache a stale promise after its key is cleared', async () => {
+ let markFirstFactoryStarted: (() => void) | undefined;
+ const firstFactoryStarted = new Promise<void>((resolve) => {
+ markFirstFactoryStarted = resolve;
+ });
+ let resolveFirstFactory: (value: string) => void;
+ let resolveSecondFactory: (value: string) => void;
+ const firstFactoryPromise = new Promise<string>((resolve) => {
+ resolveFirstFactory = resolve;
+ });
+ const secondFactoryPromise = new Promise<string>((resolve) => {
+ resolveSecondFactory = resolve;
+ });
+
+ mockFactory
+ .mockImplementationOnce(() => {
+ markFirstFactoryStarted?.();
+
+ return firstFactoryPromise;
+ })
+ .mockImplementationOnce(() => secondFactoryPromise);
+
+ const firstResultPromise = memoizer.memoizePromiseAndExecute(
+ 'test-key-1',
+ mockFactory,
+ );
+
+ await firstFactoryStarted;
+ await memoizer.clearKey('test-key-1');
+
+ const secondResultPromise = memoizer.memoizePromiseAndExecute(
+ 'test-key-1',
+ mockFactory,
+ );
+
+ resolveFirstFactory!('stale-value');
+ resolveSecondFactory!('fresh-value');
+
+ await expect(firstResultPromise).resolves.toBe('stale-value');
+ await expect(secondResultPromise).resolves.toBe('fresh-value');
+ await expect(
+ memoizer.memoizePromiseAndExecute('test-key-1', mockFactory),
+ ).resolves.toBe('fresh-value');
+ expect(mockFactory).toHaveBeenCalledTimes(2);
+ });
});
describe('clearKey', () => {
diff --git a/packages/twenty-server/src/engine/twenty-orm/storage/promise-memoizer.storage.ts b/packages/twenty-server/src/engine/twenty-orm/storage/promise-memoizer.storage.ts
index b8171e755c9..5572715c181 100644
--- a/packages/twenty-server/src/engine/twenty-orm/storage/promise-memoizer.storage.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/storage/promise-memoizer.storage.ts
@@ -1,15 +1,25 @@
import { type Milliseconds } from 'cache-manager';
-import { isDefined } from 'twenty-shared/utils';
import { type CacheKey } from 'src/engine/twenty-orm/storage/types/cache-key.type';
type AsyncFactoryCallback<T> = () => Promise<T | null>;
+type PromiseMemoizerEntry<T> =
+ | {
+ state: 'pending';
+ generation: symbol;
+ promise: Promise<T | null>;
+ }
+ | {
+ state: 'resolved';
+ value: T;
+ expiresAt: number;
+ };
+
const ONE_HOUR_IN_MS = 3600_000;
export class PromiseMemoizer<T> {
- private cache = new Map<CacheKey, { value: T; expiresAt: number }>();
- private pending = new Map<CacheKey, Promise<T | null>>();
+ private cache = new Map<CacheKey, PromiseMemoizerEntry<T>>();
private ttlMs: number;
constructor(ttlMs: Milliseconds = ONE_HOUR_IN_MS) {
@@ -23,24 +33,29 @@ export class PromiseMemoizer<T> {
): Promise<T | null> {
await this.clearExpiredKeys(onDelete);
- const cachedEntry = this.cache.get(cacheKey);
+ const existingEntry = this.cache.get(cacheKey);
- if (cachedEntry) {
- return cachedEntry.value;
+ if (existingEntry) {
+ return existingEntry.state === 'resolved'
+ ? existingEntry.value
+ : existingEntry.promise;
}
- const existingPromise = this.pending.get(cacheKey);
-
- if (existingPromise) {
- return existingPromise;
- }
+ const generation = Symbol();
const newPromise = (async () => {
try {
const value = await factory();
- if (value) {
+ const currentEntry = this.cache.get(cacheKey);
+
+ if (
+ value &&
+ currentEntry?.state === 'pending' &&
+ currentEntry.generation === generation
+ ) {
this.cache.set(cacheKey, {
+ state: 'resolved',
value,
expiresAt: Date.now() + this.ttlMs,
});
@@ -48,11 +63,22 @@ export class PromiseMemoizer<T> {
return value;
} finally {
- this.pending.delete(cacheKey);
+ const currentEntry = this.cache.get(cacheKey);
+
+ if (
+ currentEntry?.state === 'pending' &&
+ currentEntry.generation === generation
+ ) {
+ this.cache.delete(cacheKey);
+ }
}
})();
- this.pending.set(cacheKey, newPromise);
+ this.cache.set(cacheKey, {
+ state: 'pending',
+ generation,
+ promise: newPromise,
+ });
return newPromise;
}
@@ -61,7 +87,7 @@ export class PromiseMemoizer<T> {
const now = Date.now();
for (const [cacheKey, cachedEntry] of this.cache.entries()) {
- if (cachedEntry.expiresAt <= now) {
+ if (cachedEntry.state === 'resolved' && cachedEntry.expiresAt <= now) {
await this.clearKey(cacheKey, onDelete);
}
}
@@ -73,7 +99,7 @@ export class PromiseMemoizer<T> {
): Promise<void> {
const cachedValue = this.cache.get(cacheKey);
- if (isDefined(cachedValue)) {
+ if (cachedValue?.state === 'resolved') {
await onDelete?.(cachedValue.value);
}
this.cache.delete(cacheKey);
@@ -88,17 +114,13 @@ export class PromiseMemoizer<T> {
await this.clearKey(cacheKey, onDelete);
}
}
-
- for (const cacheKey of [...this.pending.keys()]) {
- if (cacheKey.startsWith(cacheKeyPrefix)) {
- this.pending.delete(cacheKey);
- }
- }
}
async clearAll(onDelete?: (value: T) => Promise<void> | void): Promise<void> {
for (const [, entry] of this.cache.entries()) {
- await onDelete?.(entry.value);
+ if (entry.state === 'resolved') {
+ await onDelete?.(entry.value);
+ }
}
this.cache.clear();