Skip to content

The open alternative to Salesforce, designed for AI.

Prevent concurrent workspace cache refreshes from restoring stale data (#26982)

nitin3fa001fe96f0
diff --git a/packages/twenty-server/src/engine/core-modules/cache-storage/services/cache-storage.service.ts b/packages/twenty-server/src/engine/core-modules/cache-storage/services/cache-storage.service.ts
index c265ad0ce3c..18dc2475343 100644
--- a/packages/twenty-server/src/engine/core-modules/cache-storage/services/cache-storage.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/cache-storage/services/cache-storage.service.ts
@@ -4,6 +4,8 @@ import { Inject, Injectable } from '@nestjs/common';
import { type Milliseconds } from 'cache-manager';
import { type RedisCache } from 'cache-manager-redis-yet';
+import { isDefined } from 'twenty-shared/utils';
+
import {
CacheStorageException,
CacheStorageExceptionCode,
@@ -125,6 +127,37 @@ export class CacheStorageService {
}
}
+ async msetAndMdel<T = unknown>({
+ entries,
+ keysToDelete,
+ }: {
+ entries: Array<{ key: string; value: T; ttl?: Milliseconds }>;
+ keysToDelete: string[];
+ }): Promise<void> {
+ if (!this.isRedisCache(this.cache)) {
+ throw new CacheStorageException(
+ 'msetAndMdel is only supported with Redis cache',
+ CacheStorageExceptionCode.REDIS_CACHE_REQUIRED,
+ );
+ }
+
+ const transaction = this.cache.store.client.multi();
+
+ for (const { key, value, ttl } of entries) {
+ transaction.set(
+ this.getKey(key),
+ JSON.stringify(value),
+ isDefined(ttl) && ttl > 0 ? { PX: ttl } : {},
+ );
+ }
+
+ if (keysToDelete.length > 0) {
+ transaction.del(keysToDelete.map((key) => this.getKey(key)));
+ }
+
+ await transaction.exec();
+ }
+
async setAdd(key: string, value: string[], ttl?: Milliseconds) {
if (value.length === 0) {
return;
diff --git a/packages/twenty-server/src/engine/workspace-cache/constants/publish-workspace-cache-script.constant.ts b/packages/twenty-server/src/engine/workspace-cache/constants/publish-workspace-cache-script.constant.ts
new file mode 100644
index 00000000000..2f889485bbd
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-cache/constants/publish-workspace-cache-script.constant.ts
@@ -0,0 +1,34 @@
+import { type CacheScript } from 'src/engine/core-modules/cache-storage/types/cache-script.type';
+
+export const PUBLISH_WORKSPACE_CACHE_SCRIPT: CacheScript = {
+ name: 'workspace-cache:publish',
+ source: `
+local ttl = tonumber(ARGV[1])
+local function set(key, value)
+ if ttl > 0 then
+ redis.call('SET', key, value, 'PX', ttl)
+ else
+ redis.call('SET', key, value)
+ end
+end
+local published = {}
+local argumentIndex = 2
+for index = 1, #KEYS, 2 do
+ local expectedHash = ARGV[argumentIndex]
+ local hashToPublish = ARGV[argumentIndex + 1]
+ local data = ARGV[argumentIndex + 2]
+ local currentHash = redis.call('GET', KEYS[index]) or ''
+ if currentHash == expectedHash then
+ set(KEYS[index], hashToPublish)
+ if data ~= '' then
+ set(KEYS[index + 1], data)
+ end
+ table.insert(published, 1)
+ else
+ table.insert(published, 0)
+ end
+ argumentIndex = argumentIndex + 3
+end
+return published
+`,
+};
diff --git a/packages/twenty-server/src/engine/workspace-cache/services/workspace-cache.service.ts b/packages/twenty-server/src/engine/workspace-cache/services/workspace-cache.service.ts
index d85096d77a0..7244194139d 100644
--- a/packages/twenty-server/src/engine/workspace-cache/services/workspace-cache.service.ts
+++ b/packages/twenty-server/src/engine/workspace-cache/services/workspace-cache.service.ts
@@ -16,6 +16,7 @@ import { isDefined, isValidUuid } from 'twenty-shared/utils';
import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
import { WorkspaceDerivedCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-derived-cache-provider.service';
+import { PUBLISH_WORKSPACE_CACHE_SCRIPT } from 'src/engine/workspace-cache/constants/publish-workspace-cache-script.constant';
import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
@@ -84,18 +85,20 @@ type CacheEntriesResult = {
hashes: Partial<Record<WorkspaceCacheKeyName, string>>;
};
+type KeyToRecompute = {
+ keyName: WorkspaceCacheKeyName;
+ expectedHash?: string;
+};
+
+type RecomputedCacheEntriesResult = CacheEntriesResult & {
+ hasUnpublishedEntries: boolean;
+};
+
type CacheOrDerivedCacheEntriesResult = {
data: Partial<WorkspaceCacheOrDerivedCacheDataMap>;
hashes: Partial<Record<WorkspaceCacheOrDerivedCacheKeyName, string>>;
};
-type RecomputeHashResolution =
- | { strategy: 'mint' }
- | {
- strategy: 'recover';
- adoptableHashes: Partial<Record<WorkspaceCacheKeyName, string>>;
- };
-
@Injectable()
export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
private readonly localCache = new Map<
@@ -328,15 +331,8 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
return freshEntries;
}
- const {
- validKeys,
- keysNeedingDataFromRedis,
- keysNeedingRecompute,
- adoptableHashes,
- } = await this.validateLocalHashAgainstRedisHash(
- workspaceId,
- staleKeys,
- );
+ const { validKeys, keysNeedingDataFromRedis, keysNeedingRecompute } =
+ await this.validateLocalHashAgainstRedisHash(workspaceId, staleKeys);
const validatedEntries = this.getFromLocalCache(workspaceId, validKeys);
const { redisEntries, missingInRedis } = await this.fetchDataFromRedis(
@@ -344,12 +340,14 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
keysNeedingDataFromRedis,
);
- const keysToRecompute = [...keysNeedingRecompute, ...missingInRedis];
- const recomputedEntries = await this.recomputeDataFromProvider(
+ const recomputedEntries = await this.recomputeDataFromProvider({
workspaceId,
- keysToRecompute,
- { strategy: 'recover', adoptableHashes },
- );
+ keysToRecompute: [...keysNeedingRecompute, ...missingInRedis],
+ });
+
+ if (recomputedEntries.hasUnpublishedEntries) {
+ await this.memoizer.clearKey(memoKey);
+ }
return {
data: {
@@ -431,14 +429,12 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
attributes: { 'cache.key_count': cacheKeyNames.length },
},
async () => {
- await this.memoizer.clearKeys(`${workspaceId}-`);
-
- await this.flush(workspaceId, cacheKeyNames);
- await this.recomputeDataFromProvider(workspaceId, cacheKeyNames, {
- strategy: 'mint',
- });
+ const keysToRecompute = await this.invalidate(
+ workspaceId,
+ cacheKeyNames,
+ );
- // Clear again to evict entries concurrent getOrRecompute calls cached during the flush window
+ await this.recomputeDataFromProvider({ workspaceId, keysToRecompute });
await this.memoizer.clearKeys(`${workspaceId}-`);
},
);
@@ -482,9 +478,36 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
!isWorkspaceDerivedCacheKeyName(cacheKeyName),
);
- await this.deleteFromRedis(workspaceId, storedCacheKeyNames);
+ await this.invalidate(workspaceId, storedCacheKeyNames);
+ }
+
+ private async invalidate(
+ workspaceId: string,
+ cacheKeyNames: WorkspaceCacheKeyName[],
+ ): Promise<KeyToRecompute[]> {
+ if (cacheKeyNames.length === 0) {
+ return [];
+ }
+
+ const invalidatedKeys = cacheKeyNames.map((keyName) => ({
+ keyName,
+ expectedHash: crypto.randomUUID(),
+ }));
+
+ await this.cacheStorage.msetAndMdel({
+ entries: invalidatedKeys.map(({ keyName, expectedHash }) => ({
+ key: `${this.buildCacheKey(workspaceId, keyName)}:hash`,
+ value: expectedHash,
+ ttl: this.twentyConfigService.get('CACHE_STORAGE_TTL') * 1000,
+ })),
+ keysToDelete: cacheKeyNames.map(
+ (keyName) => `${this.buildCacheKey(workspaceId, keyName)}:data`,
+ ),
+ });
+ this.deleteFromLocalCache(workspaceId, cacheKeyNames);
+ await this.memoizer.clearKeys(`${workspaceId}-`);
- this.deleteFromLocalCache(workspaceId, storedCacheKeyNames);
+ return invalidatedKeys;
}
public async evictWorkspaceFromLocalCache(
@@ -543,20 +566,17 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
): Promise<{
validKeys: WorkspaceCacheKeyName[];
keysNeedingDataFromRedis: WorkspaceCacheKeyName[];
- keysNeedingRecompute: WorkspaceCacheKeyName[];
- adoptableHashes: Partial<Record<WorkspaceCacheKeyName, string>>;
+ keysNeedingRecompute: KeyToRecompute[];
}> {
const validKeys: WorkspaceCacheKeyName[] = [];
const keysNeedingDataFromRedis: WorkspaceCacheKeyName[] = [];
- const keysNeedingRecompute: WorkspaceCacheKeyName[] = [];
- const adoptableHashes: Partial<Record<WorkspaceCacheKeyName, string>> = {};
+ const keysNeedingRecompute: KeyToRecompute[] = [];
if (cacheKeyNames.length === 0) {
return {
validKeys,
keysNeedingDataFromRedis,
keysNeedingRecompute,
- adoptableHashes,
};
}
@@ -579,11 +599,7 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
localEntry.lastHashCheckedAt = Date.now();
validKeys.push(keyName);
} else if (this.localDataOnlyKeys.has(keyName)) {
- keysNeedingRecompute.push(keyName);
-
- if (isDefined(redisHash)) {
- adoptableHashes[keyName] = redisHash;
- }
+ keysNeedingRecompute.push({ keyName, expectedHash: redisHash });
} else {
keysNeedingDataFromRedis.push(keyName);
}
@@ -593,7 +609,6 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
validKeys,
keysNeedingDataFromRedis,
keysNeedingRecompute,
- adoptableHashes,
};
}
@@ -602,10 +617,10 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
cacheKeyNames: WorkspaceCacheKeyName[],
): Promise<{
redisEntries: CacheEntriesResult;
- missingInRedis: WorkspaceCacheKeyName[];
+ missingInRedis: KeyToRecompute[];
}> {
const redisEntries: CacheEntriesResult = { data: {}, hashes: {} };
- const missingInRedis: WorkspaceCacheKeyName[] = [];
+ const missingInRedis: KeyToRecompute[] = [];
if (cacheKeyNames.length === 0) {
return { redisEntries, missingInRedis };
@@ -635,7 +650,7 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
`Failed to expand cached ${keyName} for workspace ${workspaceId}, recomputing`,
error,
);
- missingInRedis.push(keyName);
+ missingInRedis.push({ keyName, expectedHash: hash });
continue;
}
@@ -643,21 +658,27 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
redisEntries.hashes[keyName] = hash;
this.setInLocalCache(workspaceId, keyName, data, hash);
} else {
- missingInRedis.push(keyName);
+ missingInRedis.push({ keyName, expectedHash: hash });
}
}
return { redisEntries, missingInRedis };
}
- private async recomputeDataFromProvider(
- workspaceId: string,
- cacheKeyNames: WorkspaceCacheKeyName[],
- hashResolution: RecomputeHashResolution,
- ): Promise<CacheEntriesResult> {
- const result: CacheEntriesResult = { data: {}, hashes: {} };
+ private async recomputeDataFromProvider({
+ workspaceId,
+ keysToRecompute,
+ }: {
+ workspaceId: string;
+ keysToRecompute: KeyToRecompute[];
+ }): Promise<RecomputedCacheEntriesResult> {
+ const result: RecomputedCacheEntriesResult = {
+ data: {},
+ hashes: {},
+ hasUnpublishedEntries: false,
+ };
- if (cacheKeyNames.length === 0) {
+ if (keysToRecompute.length === 0) {
return result;
}
@@ -666,9 +687,14 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
workspaceId,
);
- await rowsBatchLoader.loadRows(this.collectRowsRequirements(cacheKeyNames));
+ await rowsBatchLoader.loadRows(
+ this.collectRowsRequirements(
+ keysToRecompute.map(({ keyName }) => keyName),
+ ),
+ );
- const computePromises = cacheKeyNames.map(async (keyName) => {
+ const computePromises = keysToRecompute.map(async (keyToRecompute) => {
+ const { keyName, expectedHash } = keyToRecompute;
const provider = this.getProviderOrThrow(keyName);
const isLocalDataOnly = this.localDataOnlyKeys.has(keyName);
const computeStartedAt = performance.now();
@@ -681,7 +707,6 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
onlyIfParent: true,
attributes: {
'cache.key_name': keyName,
- 'cache.recompute.strategy': hashResolution.strategy,
'cache.local_data_only': isLocalDataOnly,
},
},
@@ -692,17 +717,11 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
}),
);
- if (hashResolution.strategy === 'mint') {
- return { keyName, data, hash: crypto.randomUUID(), isAdopted: false };
- }
-
- const adoptableHash = hashResolution.adoptableHashes[keyName];
-
return {
keyName,
data,
- hash: adoptableHash ?? crypto.randomUUID(),
- isAdopted: isDefined(adoptableHash),
+ expectedHash,
+ hashToPublish: expectedHash ?? crypto.randomUUID(),
};
} finally {
this.cacheMetricsService.recordRecompute(
@@ -722,7 +741,7 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
acc.computed.push(settled.value);
} else {
acc.computeFailures.push({
- keyName: cacheKeyNames[index],
+ keyName: keysToRecompute[index].keyName,
reason: settled.reason,
});
}
@@ -732,58 +751,59 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
{ computed: [], computeFailures: [] },
);
- const redisEntries: Array<{
- key: string;
- value: StoredCacheDataType | string;
- }> = [];
- const bootstrapHashEntries: Array<{ key: string; value: string }> = [];
-
- for (const { keyName, data, hash, isAdopted } of computed) {
- Object.assign(result.data, { [keyName]: data });
- result.hashes[keyName] = hash;
-
- const baseKey = this.buildCacheKey(workspaceId, keyName);
- const isLocalDataOnly = this.localDataOnlyKeys.has(keyName);
- const isRecoveryBootstrap =
- hashResolution.strategy === 'recover' && !isAdopted && isLocalDataOnly;
-
- if (isRecoveryBootstrap) {
- bootstrapHashEntries.push({ key: `${baseKey}:hash`, value: hash });
- } else if (!isAdopted) {
- redisEntries.push({ key: `${baseKey}:hash`, value: hash });
- }
-
- if (!isLocalDataOnly) {
- redisEntries.push({
- key: `${baseKey}:data`,
- value: this.getProviderOrThrow(keyName).compactForStorage(data),
- });
- }
-
- this.setInLocalCache(workspaceId, keyName, data, hash);
- }
-
- if (redisEntries.length > 0) {
+ if (computed.length > 0) {
const redisWriteStartedAt = performance.now();
+ const cacheTtlMs =
+ this.twentyConfigService.get('CACHE_STORAGE_TTL') * 1000;
+ const publishArgumentsByEntry = computed.map(
+ ({ keyName, data, expectedHash, hashToPublish }) => {
+ const serializedExpectedHash = isDefined(expectedHash)
+ ? JSON.stringify(expectedHash)
+ : '';
+ const serializedHashToPublish = JSON.stringify(hashToPublish);
+ const serializedData = this.localDataOnlyKeys.has(keyName)
+ ? ''
+ : JSON.stringify(
+ this.getProviderOrThrow(keyName).compactForStorage(data),
+ );
+
+ return [
+ serializedExpectedHash,
+ serializedHashToPublish,
+ serializedData,
+ ];
+ },
+ );
+ let published: number[];
try {
- await this.cacheStorage.mset(redisEntries);
+ published = await this.cacheStorage.runScript<number[]>({
+ script: PUBLISH_WORKSPACE_CACHE_SCRIPT,
+ keys: this.buildCacheEntryKeys(
+ workspaceId,
+ computed.map(({ keyName }) => keyName),
+ ),
+ args: [String(cacheTtlMs), ...publishArgumentsByEntry.flat()],
+ });
} finally {
this.cacheMetricsService.recordRedisWrite(
(performance.now() - redisWriteStartedAt) / 1000,
);
}
- }
- if (bootstrapHashEntries.length > 0) {
- const bootstrapHashTtlMs =
- this.twentyConfigService.get('CACHE_STORAGE_TTL') * 1000;
+ for (const [
+ index,
+ { keyName, data, hashToPublish },
+ ] of computed.entries()) {
+ Object.assign(result.data, { [keyName]: data });
+ result.hashes[keyName] = hashToPublish;
- await Promise.all(
- bootstrapHashEntries.map(({ key, value }) =>
- this.cacheStorage.setIfAbsent(key, value, bootstrapHashTtlMs),
- ),
- );
+ if (published[index] === 1) {
+ this.setInLocalCache(workspaceId, keyName, data, hashToPublish);
+ } else {
+ result.hasUnpublishedEntries = true;
+ }
+ }
}
if (computeFailures.length > 0) {
@@ -840,17 +860,15 @@ export class WorkspaceCacheService implements OnModuleInit, OnModuleDestroy {
}
}
- private async deleteFromRedis(
+ private buildCacheEntryKeys(
workspaceId: string,
cacheKeyNames: WorkspaceCacheKeyName[],
- ): Promise<void> {
- const keysToDelete = cacheKeyNames.flatMap((keyName) => {
+ ): string[] {
+ return cacheKeyNames.flatMap((keyName) => {
const baseKey = this.buildCacheKey(workspaceId, keyName);
- return [`${baseKey}:data`, `${baseKey}:hash`];
+ return [`${baseKey}:hash`, `${baseKey}:data`];
});
-
- await this.cacheStorage.mdel(keysToDelete);
}
private setInLocalCache(
diff --git a/packages/twenty-server/test/integration/workspace-cache/workspace-cache-concurrency.integration-spec.ts b/packages/twenty-server/test/integration/workspace-cache/workspace-cache-concurrency.integration-spec.ts
new file mode 100644
index 00000000000..3cb87bf2591
--- /dev/null
+++ b/packages/twenty-server/test/integration/workspace-cache/workspace-cache-concurrency.integration-spec.ts
@@ -0,0 +1,293 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import {
+ type ApplicationWithVariable,
+ setupApplicationWithVariable,
+} from 'test/integration/metadata/suites/application/utils/setup-application-with-variable.util';
+import { updateOneApplicationVariable } from 'test/integration/metadata/suites/application/utils/update-one-application-variable.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+import { type CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
+import { plaintextStringSchema } from 'src/engine/core-modules/secret-encryption/branded-strings/plaintext-string.type';
+import { type SecretEncryptionService } from 'src/engine/core-modules/secret-encryption/secret-encryption.service';
+import { type WorkspaceFlatWorkspaceMemberMapCacheService } from 'src/engine/core-modules/user/services/workspace-flat-workspace-member-map-cache.service';
+import { type FlatApplicationVariableMaps } from 'src/engine/metadata-modules/flat-application-variable/types/flat-application-variable-maps.type';
+import { type WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+describe('Workspace cache concurrent publication', () => {
+ let application: ApplicationWithVariable;
+ let applicationVariableId: string;
+ let applicationVariableUniversalIdentifier: string;
+ let workspaceCacheService: WorkspaceCacheService;
+
+ const readCachedValue = async () => {
+ const { flatApplicationVariableMaps } =
+ await workspaceCacheService.getOrRecompute(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]);
+ const value =
+ flatApplicationVariableMaps.byUniversalIdentifier[
+ applicationVariableUniversalIdentifier
+ ]?.value;
+
+ return isDefined(value)
+ ? getAppProviderByClassName<SecretEncryptionService>(
+ 'SecretEncryptionService',
+ ).decryptVersionedOrThrow(value, {
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ })
+ : undefined;
+ };
+
+ const updateValue = (value: string) =>
+ updateOneApplicationVariable({
+ input: {
+ applicationId: application.id,
+ key: application.variableKey,
+ value,
+ },
+ expectToFail: false,
+ });
+
+ const pauseNextValueSnapshot = () => {
+ let resume = () => {};
+ let signalSnapshotLoaded = () => {};
+ const gate = new Promise<void>((resolve) => {
+ resume = resolve;
+ });
+ const snapshotLoaded = new Promise<void>((resolve) => {
+ signalSnapshotLoaded = resolve;
+ });
+ const provider = getAppProviderByClassName<
+ WorkspaceCacheProvider<FlatApplicationVariableMaps>
+ >('WorkspaceFlatApplicationVariableMapCacheService');
+ const compute = provider.computeForCache.bind(provider);
+
+ jest
+ .spyOn(provider, 'computeForCache')
+ .mockImplementationOnce(async (context) => {
+ const snapshot = await compute(context);
+ signalSnapshotLoaded();
+ await gate;
+ return snapshot;
+ });
+
+ return { snapshotLoaded, resume };
+ };
+
+ const overwriteStoredValue = async (value: string) => {
+ const encryptedValue = getAppProviderByClassName<SecretEncryptionService>(
+ 'SecretEncryptionService',
+ ).encryptVersioned(plaintextStringSchema.parse(value), {
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ });
+
+ await global.testDataSource.query(
+ 'UPDATE core."applicationVariable" SET value = $1 WHERE id = $2',
+ [encryptedValue, applicationVariableId],
+ );
+ };
+
+ beforeEach(async () => {
+ workspaceCacheService = getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ );
+ application = await setupApplicationWithVariable({
+ name: 'Concurrent Cache Application',
+ variableKey: 'API_KEY',
+ });
+ const [applicationVariable]: { id: string; universalIdentifier: string }[] =
+ await global.testDataSource.query(
+ 'SELECT id, "universalIdentifier" FROM core."applicationVariable" WHERE "applicationId" = $1 AND key = $2',
+ [application.id, application.variableKey],
+ );
+
+ applicationVariableId = applicationVariable.id;
+ applicationVariableUniversalIdentifier =
+ applicationVariable.universalIdentifier;
+ }, 120000);
+
+ afterEach(async () => {
+ jest.restoreAllMocks();
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier: application.universalIdentifier,
+ });
+ });
+
+ it.each(['refresh', 'cold read'])(
+ 'rejects an older %s snapshot after a newer write completes',
+ async (operation) => {
+ await updateValue('first');
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]);
+ const { snapshotLoaded, resume } = pauseNextValueSnapshot();
+ const pendingOperation =
+ operation === 'refresh'
+ ? workspaceCacheService.invalidateAndRecompute(
+ SEED_APPLE_WORKSPACE_ID,
+ ['flatApplicationVariableMaps'],
+ )
+ : readCachedValue();
+
+ try {
+ await snapshotLoaded;
+ await updateValue('second');
+ } finally {
+ resume();
+ }
+ await pendingOperation;
+ expect(await readCachedValue()).toBe('second');
+ await workspaceCacheService.evictWorkspaceFromLocalCache(
+ SEED_APPLE_WORKSPACE_ID,
+ );
+ expect(await readCachedValue()).toBe('second');
+ },
+ );
+
+ it.each(['flush', 'hash removal'])(
+ 'rejects an in-flight snapshot after %s without a replacement writer',
+ async (operation) => {
+ await updateValue('first');
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]);
+ const { snapshotLoaded, resume } = pauseNextValueSnapshot();
+ const pendingRead = readCachedValue();
+
+ try {
+ await snapshotLoaded;
+ await overwriteStoredValue('second');
+
+ if (operation === 'flush') {
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]);
+ } else {
+ await global.app
+ .get<CacheStorageService>(CacheStorageNamespace.EngineWorkspace)
+ .del(`flatApplicationVariableMaps:${SEED_APPLE_WORKSPACE_ID}:hash`);
+ }
+ } finally {
+ resume();
+ }
+ await pendingRead;
+ expect(await readCachedValue()).toBe('second');
+ await workspaceCacheService.evictWorkspaceFromLocalCache(
+ SEED_APPLE_WORKSPACE_ID,
+ );
+ expect(await readCachedValue()).toBe('second');
+ },
+ );
+
+ it('replaces orphaned data left without a hash', async () => {
+ await updateValue('first');
+ await global.app
+ .get<CacheStorageService>(CacheStorageNamespace.EngineWorkspace)
+ .del(`flatApplicationVariableMaps:${SEED_APPLE_WORKSPACE_ID}:hash`);
+ await overwriteStoredValue('second');
+ await workspaceCacheService.evictWorkspaceFromLocalCache(
+ SEED_APPLE_WORKSPACE_ID,
+ );
+
+ expect(await readCachedValue()).toBe('second');
+ await workspaceCacheService.evictWorkspaceFromLocalCache(
+ SEED_APPLE_WORKSPACE_ID,
+ );
+ expect(await readCachedValue()).toBe('second');
+ });
+
+ it('skips publication under sustained invalidation', async () => {
+ await updateValue('first');
+ const provider = getAppProviderByClassName<
+ WorkspaceCacheProvider<FlatApplicationVariableMaps>
+ >('WorkspaceFlatApplicationVariableMapCacheService');
+ const compute = provider.computeForCache.bind(provider);
+
+ jest
+ .spyOn(provider, 'computeForCache')
+ .mockImplementation(async (context) => {
+ const snapshot = await compute(context);
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]);
+ return snapshot;
+ });
+
+ await expect(
+ workspaceCacheService.invalidateAndRecompute(SEED_APPLE_WORKSPACE_ID, [
+ 'flatApplicationVariableMaps',
+ ]),
+ ).resolves.toBeUndefined();
+ expect(
+ await global.app
+ .get<CacheStorageService>(CacheStorageNamespace.EngineWorkspace)
+ .get(`flatApplicationVariableMaps:${SEED_APPLE_WORKSPACE_ID}:data`),
+ ).toBeUndefined();
+ });
+
+ it('does not install superseded local-only computations', async () => {
+ const provider =
+ getAppProviderByClassName<WorkspaceFlatWorkspaceMemberMapCacheService>(
+ 'WorkspaceFlatWorkspaceMemberMapCacheService',
+ );
+ const compute = provider.computeForCache.bind(provider);
+ let resume = () => {};
+ let signalComputed = () => {};
+ const gate = new Promise<void>((resolve) => {
+ resume = resolve;
+ });
+ const computed = new Promise<void>((resolve) => {
+ signalComputed = resolve;
+ });
+
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatWorkspaceMemberMaps',
+ ]);
+ jest
+ .spyOn(provider, 'computeForCache')
+ .mockImplementationOnce(async (context) => {
+ const data = await compute(context);
+ signalComputed();
+ await gate;
+ return data;
+ });
+ const pendingRead = workspaceCacheService.getOrRecomputeWithHashes(
+ SEED_APPLE_WORKSPACE_ID,
+ ['flatWorkspaceMemberMaps'],
+ );
+
+ try {
+ await computed;
+ await workspaceCacheService.flush(SEED_APPLE_WORKSPACE_ID, [
+ 'flatWorkspaceMemberMaps',
+ ]);
+ } finally {
+ resume();
+ }
+ const { hashes: supersededHashes } = await pendingRead;
+ const currentHashes = await workspaceCacheService.getCacheHashes(
+ SEED_APPLE_WORKSPACE_ID,
+ ['flatWorkspaceMemberMaps'],
+ );
+
+ expect(supersededHashes).not.toEqual(currentHashes);
+ expect(
+ (
+ await workspaceCacheService.getOrRecomputeWithHashes(
+ SEED_APPLE_WORKSPACE_ID,
+ ['flatWorkspaceMemberMaps'],
+ )
+ ).hashes,
+ ).toEqual(currentHashes);
+ expect(
+ await global.app
+ .get<CacheStorageService>(CacheStorageNamespace.EngineWorkspace)
+ .get(`flatWorkspaceMemberMaps:${SEED_APPLE_WORKSPACE_ID}:data`),
+ ).toBeUndefined();
+ });
+});