feat: prevent fetching toggles when they are up to date

README.md

@@ -133,6 +133,7 @@ The Unleash SDK takes the following options:
 | customHeaders     | no| `{}` | Additional headers to use when making HTTP requests to the Unleash proxy. In case of name collisions with the default headers, the `customHeaders` value will be used if it is not `null` or `undefined`. `customHeaders` values that are `null` or `undefined` will be ignored. |
 | impressionDataAll | no| `false` | Allows you to trigger "impression" events for **all** `getToggle` and `getVariant` invocations. This is particularly useful for "disabled" feature toggles that are not visible to frontend SDKs. |
 | environment | no | `default` | Sets the `environment` option of the [Unleash context](https://docs.getunleash.io/reference/unleash-context). This does **not** affect the SDK's [Unleash environment](https://docs.getunleash.io/reference/environments). |
+| togglesStorageTTL   | no | `0` | How long (Time To Live), in seconds, the toggles in storage are considered valid and should not be fetched again. If set to 0 will disable expiration checking and will be considered always expired.                 |
 
 ### Listen for updates via the EventEmitter
 

src/index.test.ts

@@ -7,6 +7,7 @@ import {
     IConfig,
     IMutableContext,
     IToggle,
+    InMemoryStorageProvider,
     UnleashClient,
 } from './index';
 import { getTypeSafeRequest, getTypeSafeRequestUrl } from './test';
@@ -553,6 +554,77 @@ test('Should publish ready when initial fetch completed', (done) => {
     });
 });
 
+describe('handling last update flag storage', () => {
+    let storageProvider: IStorageProvider;
+    let saveSpy: jest.SpyInstance;
+    class Store implements IStorageProvider {
+        public async save() {
+            return Promise.resolve();
+        }
+
+        public async get() {
+            return Promise.resolve([]);
+        }
+    }
+
+    beforeEach(() => {
+        storageProvider = new Store();
+        saveSpy = jest.spyOn(storageProvider, 'save');
+    });
+
+    test('Should store last update flag when fetch is successful', async () => {
+        const startTime = Date.now();
+        fetchMock.mockResponseOnce(JSON.stringify(data));
+
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider,
+        };
+
+        const client = new UnleashClient(config);
+        await client.start();
+        expect(saveSpy).toHaveBeenCalledWith('repoLastUpdateTimestamp', expect.any(Number));
+        expect(saveSpy.mock.lastCall?.at(1)).toBeGreaterThanOrEqual(startTime);
+    });
+
+    test('Should store last update flag when fetch is successful with 304 status', async () => {
+        const startTime = Date.now();
+        fetchMock.mockResponseOnce(JSON.stringify(data), { status: 304 });
+
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider,
+        };
+
+        const client = new UnleashClient(config);
+        await client.start();
+        expect(saveSpy).toHaveBeenCalledWith('repoLastUpdateTimestamp', expect.any(Number));
+        expect(saveSpy.mock.lastCall?.at(1)).toBeGreaterThanOrEqual(startTime);
+    });
+
+    test('Should not store last update flag when fetch is not successful', async () => {
+        fetchMock.mockResponseOnce('', { status: 500 });
+
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider,
+        };
+
+        const client = new UnleashClient(config);
+        await client.start();
+        expect(saveSpy).not.toHaveBeenCalledWith(
+            'lastUpdate',
+            expect.any(Number)
+        );
+    });
+});
+
 test('Should publish error when initial init fails', (done) => {
     const givenError = 'Error';
 
@@ -1483,15 +1555,16 @@ test('Should emit impression events on getVariant calls when impressionData is f
 });
 
 test('Should publish ready only when the first fetch was successful', async () => {
+    expect.assertions(3);
     fetchMock.mockResponse(JSON.stringify(data));
     const config: IConfig = {
         url: 'http://localhost/test',
         clientKey: '12',
         appName: 'web',
         refreshInterval: 1,
+        disableMetrics: true,
     };
     const client = new UnleashClient(config);
-    await client.start();
 
     let readyCount = 0;
 
@@ -1503,6 +1576,8 @@ test('Should publish ready only when the first fetch was successful', async () =
         expect(readyCount).toEqual(1);
     });
 
+    await client.start();
+
     jest.advanceTimersByTime(1001);
     jest.advanceTimersByTime(1001);
 
@@ -1715,3 +1790,114 @@ describe('READY event emission', () => {
         expect(client.emit).toHaveBeenCalledWith(EVENTS.READY);
     });
 });
+
+describe('handling togglesStorageTTL > 0', () => {
+    let storage: IStorageProvider;
+    let fakeNow: number;
+    beforeEach(async () => {
+        fakeNow = new Date('2024-01-01').getTime();
+        jest.useFakeTimers();
+        jest.setSystemTime(fakeNow);
+        storage = new InMemoryStorageProvider();
+
+        fetchMock.mockResponseOnce(JSON.stringify(data)).mockResponseOnce(
+            JSON.stringify({
+                toggles: [
+                    {
+                        name: 'simpleToggle',
+                        enabled: false,
+                        impressionData: true,
+                    },
+                ],
+            })
+        );
+
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider: storage,
+        };
+        // performing an initial fetch to populate the toggles and lastUpdate timestamp
+        const client = new UnleashClient(config);
+        await client.start();
+        client.stop();
+
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        fetchMock.mockClear();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    test('Should not perform an initial fetch when toggles are up to date', async () => {
+        jest.setSystemTime(fakeNow + 59000);
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider: storage,
+            togglesStorageTTL: 60,
+        };
+        const client = new UnleashClient(config);
+        await client.start();
+        const isEnabled = client.isEnabled('simpleToggle');
+        expect(isEnabled).toBe(true);
+        client.stop();
+        expect(fetchMock).toHaveBeenCalledTimes(0);
+    });
+
+    test('Should perform an initial fetch when toggles are expired', async () => {
+        jest.setSystemTime(fakeNow + 61000);
+
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider: storage,
+            togglesStorageTTL: 60,
+        };
+        const client = new UnleashClient(config);
+        await client.start();
+        const isEnabled = client.isEnabled('simpleToggle');
+        expect(isEnabled).toBe(false);
+        client.stop();
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+
+    test('Should send ready event when toggles are up to date', async () => {
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider: storage,
+            togglesStorageTTL: 60,
+        };
+        const client = new UnleashClient(config);
+
+        const readySpy = jest.fn();
+        client.on(EVENTS.READY, readySpy);
+        client.on(EVENTS.INIT, () => readySpy.mockClear());
+        await client.start();
+        expect(readySpy).toHaveBeenCalledTimes(1);
+    });
+
+    test('Should perform a fetch when context is updated, even if flags are up to date', async () => {
+        const config: IConfig = {
+            url: 'http://localhost/test',
+            clientKey: '12',
+            appName: 'web',
+            storageProvider: storage,
+            togglesStorageTTL: 60,
+        };
+        const client = new UnleashClient(config);
+        await client.start();
+        let isEnabled = client.isEnabled('simpleToggle');
+        expect(isEnabled).toBe(true);
+        await client.updateContext({ userId: '123' });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        isEnabled = client.isEnabled('simpleToggle');
+        expect(isEnabled).toBe(false);
+    });
+});

src/index.ts

@@ -53,6 +53,7 @@ interface IConfig extends IStaticContext {
     customHeaders?: Record<string, string>;
     impressionDataAll?: boolean;
     usePOSTrequests?: boolean;
+    togglesStorageTTL?: number;
 }
 
 interface IVariant {
@@ -93,6 +94,7 @@ const defaultVariant: IVariant = {
     feature_enabled: false,
 };
 const storeKey = 'repo';
+const lastUpdateKey = 'repoLastUpdateTimestamp';
 
 type SdkState = 'initializing' | 'healthy' | 'error';
 
@@ -146,6 +148,8 @@ export class UnleashClient extends TinyEmitter {
     private usePOSTrequests = false;
     private started = false;
     private sdkState: SdkState;
+    private togglesStorageTTL: number;
+    private lastRefreshTimestamp: number;
 
     constructor({
         storageProvider,
@@ -167,6 +171,7 @@ export class UnleashClient extends TinyEmitter {
         customHeaders = {},
         impressionDataAll = false,
         usePOSTrequests = false,
+        togglesStorageTTL = 0,
     }: IConfig) {
         super();
         // Validations
@@ -195,6 +200,9 @@ export class UnleashClient extends TinyEmitter {
         this.context = { appName, environment, ...context };
         this.usePOSTrequests = usePOSTrequests;
         this.sdkState = 'initializing';
+        this.togglesStorageTTL = togglesStorageTTL * 1000;
+        this.lastRefreshTimestamp = 0;
+
         this.ready = new Promise((resolve) => {
             this.init()
                 .then(resolve)
@@ -348,6 +356,7 @@ export class UnleashClient extends TinyEmitter {
         this.context = { sessionId, ...this.context };
 
         this.toggles = (await this.storage.get(storeKey)) || [];
+        this.lastRefreshTimestamp = await this.storage.get(lastUpdateKey);
 
         if (
             this.bootstrap &&
@@ -374,7 +383,7 @@ export class UnleashClient extends TinyEmitter {
         this.metrics.start();
         const interval = this.refreshInterval;
 
-        await this.fetchToggles();
+        await this.initialFetchToggles();
 
         if (interval > 0) {
             this.timerRef = setInterval(() => this.fetchToggles(), interval);
@@ -426,6 +435,31 @@ export class UnleashClient extends TinyEmitter {
         await this.storage.save(storeKey, toggles);
     }
 
+    private isUpToDate() {
+        if (this.togglesStorageTTL <= 0) {
+            return false;
+        }
+        const timestamp = Date.now();
+
+        return !!(
+            this.lastRefreshTimestamp &&
+            timestamp - this.lastRefreshTimestamp <= this.togglesStorageTTL
+        );
+    }
+
+    private async updateLastRefreshTimestamp() {
+        this.lastRefreshTimestamp = Date.now();
+        this.storage.save(lastUpdateKey, this.lastRefreshTimestamp);
+    }
+
+    private initialFetchToggles() {
+        if (this.isUpToDate()) {
+            this.emitReady();
+            return;
+        }
+        return this.fetchToggles();
+    }
+
     private async fetchToggles() {
         if (this.fetch) {
             if (this.abortController) {
@@ -460,20 +494,7 @@ export class UnleashClient extends TinyEmitter {
                     this.emit(EVENTS.RECOVERED);
                 }
 
-                if (response.ok && response.status !== 304) {
-                    this.etag = response.headers.get('ETag') || '';
-                    const data = await response.json();
-                    await this.storeToggles(data.toggles);
-
-                    if (this.sdkState !== 'healthy') {
-                        this.sdkState = 'healthy';
-                    }
-
-                    if (!this.readyEventEmitted) {
-                        this.emit(EVENTS.READY);
-                        this.readyEventEmitted = true;
-                    }
-                } else if (!response.ok && response.status !== 304) {
+                if (!response.ok && response.status !== 304) {
                     console.error(
                         'Unleash: Fetching feature toggles did not have an ok response'
                     );
@@ -483,6 +504,19 @@ export class UnleashClient extends TinyEmitter {
                         code: response.status,
                     });
                 }
+                else if (response.status !== 304) {
+                    this.etag = response.headers.get('ETag') || '';
+                    const data = await response.json();
+                    await this.storeToggles(data.toggles);
+
+                    if (this.sdkState !== 'healthy') {
+                        this.sdkState = 'healthy';
+                    }
+
+                    this.emitReady();
+                }
+
+                this.updateLastRefreshTimestamp();
             } catch (e) {
                 console.error('Unleash: unable to fetch feature toggles', e);
                 this.sdkState = 'error';
@@ -492,6 +526,13 @@ export class UnleashClient extends TinyEmitter {
             }
         }
     }
+
+    private emitReady() {
+        if (!this.readyEventEmitted) {
+            this.emit(EVENTS.READY);
+            this.readyEventEmitted = true;
+        }
+    }
 }
 
 // export storage providers from root module