The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsindex 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();