Merge branch 'main' into SDKS-8407_baseline

Author: EmilianoSanchez

CHANGES.txt

@@ -2,7 +2,9 @@
  - BREAKING CHANGES:
    - Removed `/mySegments` endpoint from SplitAPI module, as it is replaced by `/memberships` endpoint.
 
-1.16.1 (July 10, 2024)
+1.17.0 (September 6, 2024)
+ - Added `sync.requestOptions.getHeaderOverrides` configuration option to enhance SDK HTTP request Headers for Authorization Frameworks.
+ - Added `isTimedout` and `lastUpdate` properties to IStatusInterface to keep track of the timestamp of the last SDK event, used on React and Redux SDKs.
  - Updated some transitive dependencies for vulnerability fixes.
 
 1.16.0 (June 13, 2024)

package-lock.json

@@ -16,14 +16,16 @@ const settingsWithTimeout = {
   }
 } as unknown as ISettings;
 
-const statusFlagsCount = 5;
+const statusFlagsCount = 7;
 
 function assertInitialStatus(readinessManager: IReadinessManager) {
   expect(readinessManager.isReady()).toBe(false);
   expect(readinessManager.isReadyFromCache()).toBe(false);
+  expect(readinessManager.isTimedout()).toBe(false);
   expect(readinessManager.hasTimedout()).toBe(false);
   expect(readinessManager.isDestroyed()).toBe(false);
   expect(readinessManager.isOperational()).toBe(false);
+  expect(readinessManager.lastUpdate()).toBe(0);
 }
 
 test('READINESS MANAGER / Share splits but segments (without timeout enabled)', (done) => {
@@ -165,6 +167,7 @@ describe('READINESS MANAGER / Timeout ready event', () => {
     timeoutCounter = 0;
 
     readinessManager.gate.on(SDK_READY_TIMED_OUT, () => {
+      expect(readinessManager.isTimedout()).toBe(true);
       expect(readinessManager.hasTimedout()).toBe(true);
       if (!readinessManager.isReady()) timeoutCounter++;
     });
@@ -178,6 +181,8 @@ describe('READINESS MANAGER / Timeout ready event', () => {
   test('should be fired once', (done) => {
     readinessManager.gate.on(SDK_READY, () => {
       expect(readinessManager.isReady()).toBe(true);
+      expect(readinessManager.isTimedout()).toBe(false);
+      expect(readinessManager.hasTimedout()).toBe(true);
       expect(timeoutCounter).toBe(1);
       done();
     });
@@ -233,14 +238,24 @@ test('READINESS MANAGER / Destroy after it was ready but before timedout', () =>
     counter++;
   });
 
+  let lastUpdate = readinessManager.lastUpdate();
+  expect(lastUpdate).toBe(0);
+
   readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
   readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // ready state
 
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+  lastUpdate = readinessManager.lastUpdate();
+
   readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // fires an update
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+  lastUpdate = readinessManager.lastUpdate();
 
   expect(readinessManager.isDestroyed()).toBe(false);
   readinessManager.destroy(); // Destroy the gate, removing all the listeners and clearing the ready timeout.
   expect(readinessManager.isDestroyed()).toBe(true);
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+
   readinessManager.destroy(); // no-op
   readinessManager.destroy(); // no-op
 

src/readiness/__tests__/readinessManager.spec.ts

@@ -51,6 +51,10 @@ describe('SDK Readiness Manager - Event emitter', () => {
     });
 
     expect(typeof sdkStatus.ready).toBe('function'); // The sdkStatus exposes a .ready() function.
+    expect(typeof sdkStatus.__getStatus).toBe('function'); // The sdkStatus exposes a .__getStatus() function.
+    expect(sdkStatus.__getStatus()).toEqual({
+      isReady: false, isReadyFromCache: false, isTimedout: false, hasTimedout: false, isDestroyed: false, isOperational: false, lastUpdate: 0
+    });
 
     expect(typeof sdkStatus.Event).toBe('object'); // It also exposes the Event map,
     expect(sdkStatus.Event.SDK_READY).toBe(SDK_READY); // which contains the constants for the events, for backwards compatibility.

src/readiness/__tests__/sdkReadinessManager.spec.ts

@@ -41,6 +41,13 @@ export function readinessManagerFactory(
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
+  let lastUpdate = 0;
+  function syncLastUpdate() {
+    const dateNow = Date.now();
+    // ensure lastUpdate is always increasing per event, is case Date.now() is mocked or its value is the same
+    lastUpdate = dateNow > lastUpdate ? dateNow : lastUpdate + 1;
+  }
+
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
   if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
@@ -52,6 +59,7 @@ export function readinessManagerFactory(
   function timeout() {
     if (hasTimedout) return;
     hasTimedout = true;
+    syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
@@ -72,6 +80,7 @@ export function readinessManagerFactory(
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
     if (!isReady) {
       try {
+        syncLastUpdate();
         gate.emit(SDK_READY_FROM_CACHE);
       } catch (e) {
         // throws user callback exceptions in next tick
@@ -83,6 +92,7 @@ export function readinessManagerFactory(
   function checkIsReadyOrUpdate(diff: any) {
     if (isReady) {
       try {
+        syncLastUpdate();
         gate.emit(SDK_UPDATE, diff);
       } catch (e) {
         // throws user callback exceptions in next tick
@@ -93,6 +103,7 @@ export function readinessManagerFactory(
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
+          syncLastUpdate();
           gate.emit(SDK_READY);
         } catch (e) {
           // throws user callback exceptions in next tick
@@ -123,6 +134,7 @@ export function readinessManagerFactory(
 
     destroy() {
       isDestroyed = true;
+      syncLastUpdate();
 
       segments.removeAllListeners();
       gate.removeAllListeners();
@@ -133,10 +145,12 @@ export function readinessManagerFactory(
     },
 
     isReady() { return isReady; },
-    hasTimedout() { return hasTimedout; },
     isReadyFromCache() { return isReadyFromCache; },
+    isTimedout() { return hasTimedout && !isReady; },
+    hasTimedout() { return hasTimedout; },
     isDestroyed() { return isDestroyed; },
-    isOperational() { return (isReady || isReadyFromCache) && !isDestroyed; }
+    isOperational() { return (isReady || isReadyFromCache) && !isDestroyed; },
+    lastUpdate() { return lastUpdate; }
   };
 
 }

src/readiness/readinessManager.ts

@@ -121,14 +121,15 @@ export function sdkReadinessManagerFactory(
           return readyPromise;
         },
 
-        // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
         __getStatus() {
           return {
             isReady: readinessManager.isReady(),
             isReadyFromCache: readinessManager.isReadyFromCache(),
-            isOperational: readinessManager.isOperational(),
+            isTimedout: readinessManager.isTimedout(),
             hasTimedout: readinessManager.hasTimedout(),
             isDestroyed: readinessManager.isDestroyed(),
+            isOperational: readinessManager.isOperational(),
+            lastUpdate: readinessManager.lastUpdate(),
           };
         },
       }

src/readiness/sdkReadinessManager.ts

@@ -50,9 +50,11 @@ export interface IReadinessManager {
   /** Readiness status */
   isReady(): boolean,
   isReadyFromCache(): boolean,
+  isTimedout(): boolean,
   hasTimedout(): boolean,
   isDestroyed(): boolean,
   isOperational(): boolean,
+  lastUpdate(): number,
 
   timeout(): void,
   setDestroyed(): void,

src/readiness/types.ts

@@ -0,0 +1,50 @@
+import { ISettings } from '../../types';
+import { decorateHeaders } from '../decorateHeaders';
+
+const HEADERS = {
+  Authorization: 'Bearer SDK-KEY',
+  SplitSDKVersion: 'JS' // Overriding is forbidden
+};
+
+describe('decorateHeaders', () => {
+
+  test('should not decorate headers if getHeaderOverrides is not provided', () => {
+    const headers = { ...HEADERS };
+    const settings = { sync: {} };
+
+    expect(decorateHeaders(settings as unknown as ISettings, headers)).toEqual(HEADERS);
+  });
+
+  test('should decorate headers with header overrides, ignoring forbidden headers', () => {
+    const headers = { ...HEADERS };
+    const settings = {
+      sync: {
+        requestOptions: {
+          getHeaderOverrides: (context: { headers: Record<string, string> }) => {
+            context.headers['Authorization'] = 'ignored';
+            return { 'Authorization': 'updated', 'OTHER_HEADER': 'other_value', 'SplitSdkVersion': 'FORBIDDEN', 'splitsdkversion': 'FORBIDDEN TOO' };
+          }
+        }
+      }
+    };
+
+    expect(decorateHeaders(settings as unknown as ISettings, headers)).toEqual({ 'Authorization': 'updated', 'OTHER_HEADER': 'other_value', 'SplitSDKVersion': 'JS' });
+  });
+
+  test('should handle errors when decorating headers', () => {
+    const headers = { ...HEADERS };
+    const settings = {
+      sync: {
+        requestOptions: {
+          getHeaderOverrides: () => {
+            throw new Error('Unexpected error');
+          }
+        }
+      },
+      log: { error: jest.fn() }
+    };
+
+    expect(decorateHeaders(settings as unknown as ISettings, headers)).toEqual(HEADERS);
+    expect(settings.log.error).toHaveBeenCalledWith('Problem adding custom headers to request decorator: Error: Unexpected error');
+  });
+});

src/services/__tests__/decorateHeaders.spec.ts

@@ -0,0 +1,33 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+import { _Set } from '../utils/lang/sets';
+import { ISettings } from '../types';
+
+const FORBIDDEN_HEADERS = new _Set([
+  'splitsdkclientkey',
+  'splitsdkversion',
+  'splitsdkmachineip',
+  'splitsdkmachinename',
+  'splitsdkimpressionsmode',
+  'host',
+  'referrer',
+  'content-type',
+  'content-length',
+  'content-encoding',
+  'accept',
+  'keep-alive',
+  'x-fastly-debug'
+]);
+
+export function decorateHeaders(settings: ISettings, headers: Record<string, string>) {
+  if (settings.sync.requestOptions?.getHeaderOverrides) {
+    try {
+      const headerOverrides = settings.sync.requestOptions.getHeaderOverrides({ headers: objectAssign({}, headers) });
+      Object.keys(headerOverrides)
+        .filter(key => !FORBIDDEN_HEADERS.has(key.toLowerCase()))
+        .forEach(key => headers[key] = headerOverrides[key]);
+    } catch (e) {
+      settings.log.error('Problem adding custom headers to request decorator: ' + e);
+    }
+  }
+  return headers;
+}

src/services/decorateHeaders.ts

@@ -3,6 +3,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
 import { ISettings } from '../types';
 import { IPlatform } from '../sdkFactory/types';
+import { decorateHeaders } from './decorateHeaders';
 
 const messageNoFetch = 'Global fetch API is not available.';
 
@@ -21,20 +22,20 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
   // if fetch is not available, log Error
   if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
 
-  const headers: Record<string, string> = {
+  const commonHeaders: Record<string, string> = {
     'Accept': 'application/json',
     'Content-Type': 'application/json',
     'Authorization': `Bearer ${authorizationKey}`,
     'SplitSDKVersion': version
   };
 
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
+  if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
+  if (hostname) commonHeaders['SplitSDKMachineName'] = hostname;
 
   return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
     const request = objectAssign({
-      headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
+      headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
       method: reqOpts.method || 'GET',
       body: reqOpts.body
     }, options);