Eliminate race condition between initial and user-initiated cache sync ups

Author: adams85

src/AutoPollConfigService.ts

@@ -82,7 +82,7 @@ export class AutoPollConfigService extends ConfigServiceBase<AutoPollOptions> im
 
     let cachedConfig: ProjectConfig;
     if (!this.initialized) {
-      cachedConfig = await this.options.cache.get(this.cacheKey);
+      cachedConfig = await this.syncUpWithCache();
       if (!cachedConfig.isExpired(this.pollIntervalMs)) {
         logSuccess(this.options.logger);
         return cachedConfig;
@@ -92,7 +92,7 @@ export class AutoPollConfigService extends ConfigServiceBase<AutoPollOptions> im
       await this.initializationPromise;
     }
 
-    cachedConfig = await this.options.cache.get(this.cacheKey);
+    cachedConfig = await this.syncUpWithCache();
     if (!cachedConfig.isExpired(this.pollIntervalMs)) {
       logSuccess(this.options.logger);
     } else {
@@ -160,7 +160,7 @@ export class AutoPollConfigService extends ConfigServiceBase<AutoPollOptions> im
   private async refreshWorkerLogic(initialCacheSyncUp: ProjectConfig | Promise<ProjectConfig> | null) {
     this.options.logger.debug("AutoPollConfigService.refreshWorkerLogic() called.");
 
-    const latestConfig = await (initialCacheSyncUp ?? this.options.cache.get(this.cacheKey));
+    const latestConfig = await (initialCacheSyncUp ?? this.syncUpWithCache());
     if (latestConfig.isExpired(this.pollExpirationMs)) {
       // Even if the service gets disposed immediately, we allow the first refresh for backward compatibility,
       // i.e. to not break usage patterns like this:

src/ConfigServiceBase.ts

@@ -4,6 +4,7 @@ import type { FetchErrorCauses, IConfigFetcher, IFetchResponse } from "./ConfigF
 import { FetchError, FetchResult, FetchStatus } from "./ConfigFetcher";
 import { RedirectMode } from "./ConfigJson";
 import { Config, ProjectConfig } from "./ProjectConfig";
+import { isPromiseLike } from "./Utils";
 
 /** Contains the result of an `IConfigCatClient.forceRefresh` or `IConfigCatClient.forceRefreshAsync` operation. */
 export class RefreshResult {
@@ -75,6 +76,7 @@ function nameOfConfigServiceStatus(value: ConfigServiceStatus): string {
 export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
   private status: ConfigServiceStatus;
 
+  private pendingCacheSyncUp: Promise<ProjectConfig> | null = null;
   private pendingFetch: Promise<FetchResult> | null = null;
 
   protected readonly cacheKey: string;
@@ -103,7 +105,7 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
   abstract getConfig(): Promise<ProjectConfig>;
 
   async refreshConfigAsync(): Promise<[RefreshResult, ProjectConfig]> {
-    const latestConfig = await this.options.cache.get(this.cacheKey);
+    const latestConfig = await this.syncUpWithCache();
     if (!this.isOffline) {
       const [fetchResult, config] = await this.refreshConfigCoreAsync(latestConfig);
       return [RefreshResult.from(fetchResult), config];
@@ -147,13 +149,8 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
   }
 
   private fetchAsync(lastConfig: ProjectConfig): Promise<FetchResult> {
-    return this.pendingFetch ??= (async () => {
-      try {
-        return await this.fetchLogicAsync(lastConfig);
-      } finally {
-        this.pendingFetch = null;
-      }
-    })();
+    return this.pendingFetch ??= this.fetchLogicAsync(lastConfig)
+      .finally(() => this.pendingFetch = null);
   }
 
   private async fetchLogicAsync(lastConfig: ProjectConfig): Promise<FetchResult> {
@@ -305,7 +302,20 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
   abstract getCacheState(cachedConfig: ProjectConfig): ClientCacheState;
 
   protected syncUpWithCache(): ProjectConfig | Promise<ProjectConfig> {
-    return this.options.cache.get(this.cacheKey);
+    if (this.pendingCacheSyncUp) {
+      return this.pendingCacheSyncUp;
+    }
+
+    const syncResult = this.options.cache.get(this.cacheKey);
+    if (!isPromiseLike(syncResult)) {
+      return syncResult;
+    }
+
+    const syncUpAndFinish = syncResult
+      .finally(() => this.pendingCacheSyncUp = null);
+
+    this.pendingCacheSyncUp = syncResult;
+    return syncUpAndFinish;
   }
 
   protected async waitForReadyAsync(initialCacheSyncUp: ProjectConfig | Promise<ProjectConfig>): Promise<ClientCacheState> {

src/LazyLoadConfigService.ts

@@ -27,7 +27,7 @@ export class LazyLoadConfigService extends ConfigServiceBase<LazyLoadOptions> im
       logger.debug(`LazyLoadConfigService.getConfig(): cache is empty or expired${appendix}.`);
     }
 
-    let cachedConfig = await this.options.cache.get(this.cacheKey);
+    let cachedConfig = await this.syncUpWithCache();
 
     if (cachedConfig.isExpired(this.cacheTimeToLiveMs)) {
       if (!this.isOffline) {

src/ManualPollConfigService.ts

@@ -26,7 +26,7 @@ export class ManualPollConfigService extends ConfigServiceBase<ManualPollOptions
 
   async getConfig(): Promise<ProjectConfig> {
     this.options.logger.debug("ManualPollService.getConfig() called.");
-    return await this.options.cache.get(this.cacheKey);
+    return await this.syncUpWithCache();
   }
 
   refreshConfigAsync(): Promise<[RefreshResult, ProjectConfig]> {