feat: Add ABT support for remote config

Author: Athira M

packages/remote-config/src/abt/experiment.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Storage } from '../storage/storage';
+import { FirebaseExperimentDescription } from '../public_types';
+
+export class Experiment {
+  constructor(private readonly storage: Storage) {}
+
+  async updateActiveExperiments(
+    latestExperiments: FirebaseExperimentDescription[]
+  ): Promise<void> {
+    const currentActiveExperiments = await this.storage.getActiveExperiments() || new Set<string>();
+    const experimentInfoMap = this.createExperimentInfoMap(latestExperiments);
+    this.addActiveExperiments(currentActiveExperiments, experimentInfoMap);
+    this.removeInactiveExperiments(currentActiveExperiments, experimentInfoMap);
+    return this.storage.setActiveExperiments(new Set(experimentInfoMap.keys()));
+  }
+
+  private createExperimentInfoMap(
+    latestExperiments: FirebaseExperimentDescription[]
+  ): Map<string, FirebaseExperimentDescription> {
+    const experimentInfoMap = new Map<string, FirebaseExperimentDescription>();
+    for (const experiment of latestExperiments) {
+      experimentInfoMap.set(experiment.experimentId, experiment);
+    }
+    return experimentInfoMap;
+  }
+
+  private addActiveExperiments(
+    currentActiveExperiments: Set<string>,
+    experimentInfoMap: Map<string, FirebaseExperimentDescription>): void {
+    for (const [experimentId, experimentInfo] of experimentInfoMap.entries()) {
+      if (!currentActiveExperiments.has(experimentId)) {
+        this.addExperimentToAnalytics(experimentId, experimentInfo.variantId);
+      }
+    }
+  }
+
+  private removeInactiveExperiments(
+    currentActiveExperiments: Set<string>,
+    experimentInfoMap: Map<string, FirebaseExperimentDescription>
+  ): void {
+    for (const experimentId of currentActiveExperiments) {
+      if (!experimentInfoMap.has(experimentId)) {
+        this.removeExperimentFromAnalytics(experimentId);
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private addExperimentToAnalytics(experimentId: string, variantId: string): void {
+    // TODO
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private removeExperimentFromAnalytics(experimentId: string): void {
+    // TODO
+  }
+}

packages/remote-config/src/api.ts

@@ -34,6 +34,7 @@ import { ERROR_FACTORY, ErrorCode, hasErrorCode } from './errors';
 import { RemoteConfig as RemoteConfigImpl } from './remote_config';
 import { Value as ValueImpl } from './value';
 import { LogLevel as FirebaseLogLevel } from '@firebase/logger';
+import { Experiment } from './abt/experiment';
 
 /**
  *
@@ -105,8 +106,10 @@ export async function activate(remoteConfig: RemoteConfig): Promise<boolean> {
     // config.
     return false;
   }
+  const experiment = new Experiment(rc._storage);
   await Promise.all([
     rc._storageCache.setActiveConfig(lastSuccessfulFetchResponse.config),
+    experiment.updateActiveExperiments(lastSuccessfulFetchResponse.experiments),
     rc._storage.setActiveConfigEtag(lastSuccessfulFetchResponse.eTag)
   ]);
   return true;

packages/remote-config/src/storage/storage.ts

@@ -64,6 +64,7 @@ export interface ThrottleMetadata {
 type ProjectNamespaceKeyFieldValue =
   | 'active_config'
   | 'active_config_etag'
+  | 'active_experiments'
   | 'last_fetch_status'
   | 'last_successful_fetch_timestamp_millis'
   | 'last_successful_fetch_response'
@@ -156,6 +157,14 @@ export abstract class Storage {
     return this.set<string>('active_config_etag', etag);
   }
 
+  getActiveExperiments(): Promise<Set<string> | undefined> {
+    return this.get<Set<string>>('active_experiments');
+  }
+
+  setActiveExperiments(experiments:Set<string>): Promise<void> {
+    return this.set<Set<string>>('active_experiments', experiments);
+  }
+
   getThrottleMetadata(): Promise<ThrottleMetadata | undefined> {
     return this.get<ThrottleMetadata>('throttle_metadata');
   }

packages/remote-config/test/abt/experiment.test.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import '../setup';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Experiment } from '../../src/abt/experiment';
+import { FirebaseExperimentDescription } from '../../src/public_types';
+import { Storage } from '../../src/storage/storage';
+
+describe('Experiment', () => {
+  const storage = {} as Storage;
+  const experiment = new Experiment(storage);
+
+  describe('updateActiveExperiments', () => {
+    beforeEach(() => {
+      storage.getActiveExperiments = sinon.stub();
+      storage.setActiveExperiments = sinon.stub();
+    });
+
+    it('adds mew experiments to storage', async () => {
+      const latestExperiments: FirebaseExperimentDescription[] = [
+        {
+          experimentId: '_exp_3',
+          variantId: '1',
+          experimentStartTime: '0',
+          triggerTimeoutMillis: '0',
+          timeToLiveMillis: '0'
+        },
+        {
+          experimentId: '_exp_1',
+          variantId: '2',
+          experimentStartTime: '0',
+          triggerTimeoutMillis: '0',
+          timeToLiveMillis: '0'
+        },
+        {
+          experimentId: '_exp_2',
+          variantId: '1',
+          experimentStartTime: '0',
+          triggerTimeoutMillis: '0',
+          timeToLiveMillis: '0'
+        },
+      ];
+      const expectedStoredExperiments = new Set(['_exp_3', '_exp_1', '_exp_2']);
+      storage.getActiveExperiments = sinon.stub().returns(new Set(['_exp_1', '_exp_2']));
+
+
+      await experiment.updateActiveExperiments(latestExperiments);
+
+      expect(storage.setActiveExperiments).to.have.been.calledWith(expectedStoredExperiments);
+    });
+
+    it('removes missing experiment in fetch response from storage', async () => {
+      const latestExperiments: FirebaseExperimentDescription[] = [
+        {
+          experimentId: '_exp_1',
+          variantId: '2',
+          experimentStartTime: '0',
+          triggerTimeoutMillis: '0',
+          timeToLiveMillis: '0'
+        }
+      ];
+      const expectedStoredExperiments = new Set(['_exp_1']);
+      storage.getActiveExperiments = sinon.stub().returns(new Set(['_exp_1', '_exp_2']));
+
+
+      await experiment.updateActiveExperiments(latestExperiments);
+
+      expect(storage.setActiveExperiments).to.have.been.calledWith(expectedStoredExperiments);
+    });
+  });
+});

packages/remote-config/test/remote_config.test.ts

@@ -46,6 +46,7 @@ import {
 import * as api from '../src/api';
 import { fetchAndActivate } from '../src';
 import { restore } from 'sinon';
+import { Experiment } from '../src/abt/experiment';
 
 describe('RemoteConfig', () => {
   const ACTIVE_CONFIG = {
@@ -388,12 +389,16 @@ describe('RemoteConfig', () => {
       "timeToLiveMillis" : "15552000000"   
     }];
 
+    let sandbox: sinon.SinonSandbox;
+    let updateActiveExperimentsStub: sinon.SinonStub;
     let getLastSuccessfulFetchResponseStub: sinon.SinonStub;
     let getActiveConfigEtagStub: sinon.SinonStub;
     let setActiveConfigEtagStub: sinon.SinonStub;
     let setActiveConfigStub: sinon.SinonStub;
 
     beforeEach(() => {
+      sandbox = sinon.createSandbox(); 
+      updateActiveExperimentsStub = sandbox.stub(Experiment.prototype, 'updateActiveExperiments');
       getLastSuccessfulFetchResponseStub = sinon.stub();
       getActiveConfigEtagStub = sinon.stub();
       setActiveConfigEtagStub = sinon.stub();
@@ -406,6 +411,10 @@ describe('RemoteConfig', () => {
       storageCache.setActiveConfig = setActiveConfigStub;
     });
 
+    afterEach(() => {
+      sandbox.restore();
+    });
+
     it('does not activate if last successful fetch response is undefined', async () => {
       getLastSuccessfulFetchResponseStub.returns(Promise.resolve());
       getActiveConfigEtagStub.returns(Promise.resolve(ETAG));
@@ -415,6 +424,7 @@ describe('RemoteConfig', () => {
       expect(activateResponse).to.be.false;
       expect(storage.setActiveConfigEtag).to.not.have.been.called;
       expect(storageCache.setActiveConfig).to.not.have.been.called;
+      expect(updateActiveExperimentsStub).to.not.have.been.called;
     });
 
     it('does not activate if fetched and active etags are the same', async () => {
@@ -428,6 +438,7 @@ describe('RemoteConfig', () => {
       expect(activateResponse).to.be.false;
       expect(storage.setActiveConfigEtag).to.not.have.been.called;
       expect(storageCache.setActiveConfig).to.not.have.been.called;
+      expect(updateActiveExperimentsStub).to.not.have.been.called;
     });
 
     it('activates if fetched and active etags are different', async () => {
@@ -454,6 +465,7 @@ describe('RemoteConfig', () => {
       expect(activateResponse).to.be.true;
       expect(storage.setActiveConfigEtag).to.have.been.calledWith(NEW_ETAG);
       expect(storageCache.setActiveConfig).to.have.been.calledWith(CONFIG);
+      expect(updateActiveExperimentsStub).to.have.been.calledWith(EXPERIMENTS);
     });
   });