Introduce ConfigFetched hook

Author: adams85

src/AutoPollConfigService.ts

@@ -1,6 +1,6 @@
 import type { AutoPollOptions } from "./ConfigCatClientOptions";
 import type { LoggerWrapper } from "./ConfigCatLogger";
-import type { IConfigFetcher } from "./ConfigFetcher";
+import type { FetchResult, IConfigFetcher } from "./ConfigFetcher";
 import type { IConfigService, RefreshResult } from "./ConfigServiceBase";
 import { ClientCacheState, ConfigServiceBase } from "./ConfigServiceBase";
 import type { ProjectConfig } from "./ProjectConfig";
@@ -115,9 +115,9 @@ export class AutoPollConfigService extends ConfigServiceBase<AutoPollOptions> im
     }
   }
 
-  protected onConfigFetched(newConfig: ProjectConfig): void {
+  protected onConfigFetched(fetchResult: FetchResult, isInitiatedByUser: boolean): void {
     this.signalInitialization();
-    super.onConfigFetched(newConfig);
+    super.onConfigFetched(fetchResult, isInitiatedByUser);
   }
 
   protected goOnline(): void {
@@ -169,7 +169,7 @@ export class AutoPollConfigService extends ConfigServiceBase<AutoPollOptions> im
       // client.dispose();
       // ```
       if (initialCacheSyncUp ? !this.isOfflineExactly : !this.isOffline) {
-        await this.refreshConfigCoreAsync(latestConfig);
+        await this.refreshConfigCoreAsync(latestConfig, false);
         return; // postpone signalling initialization until `onConfigFetched`
       }
     }

src/ConfigServiceBase.ts

@@ -108,7 +108,7 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
   async refreshConfigAsync(): Promise<[RefreshResult, ProjectConfig]> {
     const latestConfig = await this.syncUpWithCache();
     if (!this.isOffline) {
-      const [fetchResult, config] = await this.refreshConfigCoreAsync(latestConfig);
+      const [fetchResult, config] = await this.refreshConfigCoreAsync(latestConfig, true);
       return [RefreshResult.from(fetchResult), config];
     } else if (this.options.cache instanceof ExternalConfigCache) {
       return [RefreshResult.success(), latestConfig];
@@ -118,7 +118,7 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
     }
   }
 
-  protected async refreshConfigCoreAsync(latestConfig: ProjectConfig): Promise<[FetchResult, ProjectConfig]> {
+  protected async refreshConfigCoreAsync(latestConfig: ProjectConfig, isInitiatedByUser: boolean): Promise<[FetchResult, ProjectConfig]> {
     const fetchResult = await this.fetchAsync(latestConfig);
 
     let configChanged = false;
@@ -131,7 +131,7 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
       latestConfig = fetchResult.config;
     }
 
-    this.onConfigFetched(fetchResult.config);
+    this.onConfigFetched(fetchResult, isInitiatedByUser);
 
     if (configChanged) {
       this.onConfigChanged(fetchResult.config);
@@ -140,8 +140,9 @@ export abstract class ConfigServiceBase<TOptions extends OptionsBase> {
     return [fetchResult, latestConfig];
   }
 
-  protected onConfigFetched(newConfig: ProjectConfig): void {
+  protected onConfigFetched(fetchResult: FetchResult, isInitiatedByUser: boolean): void {
     this.options.logger.debug("config fetched");
+    this.options.hooks.emit("configFetched", RefreshResult.from(fetchResult), isInitiatedByUser);
   }
 
   protected onConfigChanged(newConfig: ProjectConfig): void {

src/Hooks.ts

@@ -1,4 +1,4 @@
-import type { ClientCacheState } from "./ConfigServiceBase";
+import type { ClientCacheState, RefreshResult } from "./ConfigServiceBase";
 import type { IEventEmitter, IEventProvider } from "./EventEmitter";
 import { NullEventEmitter } from "./EventEmitter";
 import type { IConfig } from "./ProjectConfig";
@@ -19,6 +19,10 @@ export type HookEvents = {
   clientReady: [cacheState: ClientCacheState];
   /** Occurs after the value of a feature flag of setting has been evaluated. */
   flagEvaluated: [evaluationDetails: IEvaluationDetails];
+  /**
+   * Occurs after attempting to refresh the locally cached config by fetching the latest version from the remote server.
+   */
+  configFetched: [result: RefreshResult, isInitiatedByUser: boolean];
   /**
    * Occurs after the locally cached config has been updated to a newer version, either as a result of synchronization
    * with the external cache, or as a result of fetching a newer version from the remote server.

src/LazyLoadConfigService.ts

@@ -32,7 +32,7 @@ export class LazyLoadConfigService extends ConfigServiceBase<LazyLoadOptions> im
     if (cachedConfig.isExpired(this.cacheTimeToLiveMs)) {
       if (!this.isOffline) {
         logExpired(this.options.logger, ", calling refreshConfigCoreAsync()");
-        [, cachedConfig] = await this.refreshConfigCoreAsync(cachedConfig);
+        [, cachedConfig] = await this.refreshConfigCoreAsync(cachedConfig, false);
       } else {
         logExpired(this.options.logger);
       }

test/ConfigCatClientTests.ts

@@ -1355,17 +1355,20 @@ describe("ConfigCatClient", () => {
   for (const addListenersViaOptions of [false, true]) {
     it(`ConfigCatClient should emit events, which listeners added ${addListenersViaOptions ? "via options" : "directly on the client"} should get notified of`, async () => {
       let clientReadyEventCount = 0;
+      const configFetchedEvents: [RefreshResult, boolean][] = [];
       const configChangedEvents: IConfig[] = [];
       const flagEvaluatedEvents: IEvaluationDetails[] = [];
       const errorEvents: [string, any][] = [];
 
       const handleClientReady = () => clientReadyEventCount++;
+      const handleConfigFetched = (result: RefreshResult, isInitiatedByUser: boolean) => configFetchedEvents.push([result, isInitiatedByUser]);
       const handleConfigChanged = (pc: IConfig) => configChangedEvents.push(pc);
       const handleFlagEvaluated = (ed: IEvaluationDetails) => flagEvaluatedEvents.push(ed);
       const handleClientError = (msg: string, err: any) => errorEvents.push([msg, err]);
 
       function setupHooks(hooks: IProvidesHooks) {
         hooks.on("clientReady", handleClientReady);
+        hooks.on("configFetched", handleConfigFetched);
         hooks.on("configChanged", handleConfigChanged);
         hooks.on("flagEvaluated", handleFlagEvaluated);
         hooks.on("clientError", handleClientError);
@@ -1391,6 +1394,7 @@ describe("ConfigCatClient", () => {
 
       assert.equal(state, ClientCacheState.NoFlagData);
       assert.equal(clientReadyEventCount, 1);
+      assert.equal(configFetchedEvents.length, 0);
       assert.equal(configChangedEvents.length, 0);
       assert.equal(flagEvaluatedEvents.length, 0);
       assert.equal(errorEvents.length, 0);
@@ -1410,6 +1414,7 @@ describe("ConfigCatClient", () => {
 
       await client.forceRefreshAsync();
 
+      assert.equal(configFetchedEvents.length, 0);
       assert.equal(configChangedEvents.length, 0);
       assert.equal(errorEvents.length, 1);
       const [actualErrorMessage, actualErrorException] = errorEvents[0];
@@ -1422,6 +1427,10 @@ describe("ConfigCatClient", () => {
       await client.forceRefreshAsync();
       const cachedPc = await configCache.get("");
 
+      assert.equal(configFetchedEvents.length, 1);
+      const [refreshResult, isInitiatedByUser] = configFetchedEvents[0];
+      assert.isTrue(isInitiatedByUser);
+      assert.isTrue(refreshResult.isSuccess);
       assert.equal(configChangedEvents.length, 1);
       assert.strictEqual(configChangedEvents[0], cachedPc.config);
 
@@ -1438,6 +1447,7 @@ describe("ConfigCatClient", () => {
       // 5. Client gets disposed
       client.dispose();
 
+      assert.equal(configFetchedEvents.length, 1);
       assert.equal(clientReadyEventCount, 1);
       assert.equal(configChangedEvents.length, 1);
       assert.equal(evaluationDetails.length, flagEvaluatedEvents.length);

test/DataGovernanceTests.ts

@@ -293,7 +293,7 @@ export class FakeConfigServiceBase extends ConfigServiceBase<FakeOptions> {
   getConfig(): Promise<ProjectConfig> { return Promise.resolve(ProjectConfig.empty); }
 
   refreshLogicAsync(): Promise<[FetchResult, ProjectConfig]> {
-    return this.refreshConfigCoreAsync(ProjectConfig.empty);
+    return this.refreshConfigCoreAsync(ProjectConfig.empty, false);
   }
 
   prepareResponse(baseUrl: string, jsonBaseUrl: string, jsonRedirect: number, jsonFeatureFlags: any): void {