@statsig/js-client 0.0.1-beta.10

package/src/__tests__/InitStrategyBootstrap.test.ts

@@ -0,0 +1,67 @@
+import fetchMock from 'jest-fetch-mock';
+
+import {
+  DataAdapterCachePrefix,
+  getUserStorageKey,
+} from '@statsig/client-core';
+
+import StatsigClient from '../StatsigClient';
+import { MockLocalStorage } from './MockLocalStorage';
+import InitializeResponse from './initialize.json';
+
+describe('Init Strategy - Bootstrap', () => {
+  const sdkKey = 'client-key';
+  const user = { userID: 'a-user' };
+  const cacheKey = `${DataAdapterCachePrefix}.evaluations.${getUserStorageKey(sdkKey, user)}`;
+
+  let client: StatsigClient;
+  let storageMock: MockLocalStorage;
+
+  beforeAll(async () => {
+    storageMock = MockLocalStorage.enabledMockStorage();
+    storageMock.clear();
+
+    fetchMock.enableMocks();
+    fetchMock.mockResponse(JSON.stringify(InitializeResponse));
+
+    client = new StatsigClient(sdkKey, user);
+    client.dataAdapter.setData(JSON.stringify(InitializeResponse), user);
+
+    client.initializeSync();
+  });
+
+  afterAll(() => {
+    MockLocalStorage.disableMockStorage();
+  });
+
+  it('is ready after initialize', () => {
+    expect(client.loadingStatus).toBe('Ready');
+  });
+
+  it('reports source as "Bootstrap"', () => {
+    const gate = client.getFeatureGate('a_gate');
+    expect(gate.details.reason).toBe('Bootstrap:Recognized');
+  });
+
+  it('writes the updated values to cache', () => {
+    expect(storageMock.data[cacheKey]).toBeDefined();
+  });
+
+  describe('the next session', () => {
+    beforeAll(async () => {
+      fetchMock.mockClear();
+
+      client = new StatsigClient(sdkKey, user);
+      client.initializeSync();
+    });
+
+    it('is ready after initialize', () => {
+      expect(client.loadingStatus).toBe('Ready');
+    });
+
+    it('reports source as "Cache"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('Cache:Recognized');
+    });
+  });
+});

package/src/__tests__/InitStrategyDelayed.test.ts

@@ -0,0 +1,65 @@
+import fetchMock from 'jest-fetch-mock';
+
+import {
+  DataAdapterCachePrefix,
+  getUserStorageKey,
+} from '@statsig/client-core';
+
+import StatsigClient from '../StatsigClient';
+import { MockLocalStorage } from './MockLocalStorage';
+import InitializeResponse from './initialize.json';
+
+describe('Init Strategy - Delayed', () => {
+  const sdkKey = 'client-key';
+  const user = { userID: 'a-user' };
+  const cacheKey = `${DataAdapterCachePrefix}.evaluations.${getUserStorageKey(sdkKey, user)}`;
+
+  let client: StatsigClient;
+  let storageMock: MockLocalStorage;
+
+  beforeAll(async () => {
+    storageMock = MockLocalStorage.enabledMockStorage();
+    storageMock.clear();
+
+    fetchMock.enableMocks();
+    fetchMock.mockResponse(JSON.stringify(InitializeResponse));
+
+    client = new StatsigClient(sdkKey, user);
+    client.initializeSync();
+  });
+
+  afterAll(() => {
+    MockLocalStorage.disableMockStorage();
+  });
+
+  it('is ready after initialize', () => {
+    expect(client.loadingStatus).toBe('Ready');
+  });
+
+  it('reports source as "NoValues"', () => {
+    const gate = client.getFeatureGate('a_gate');
+    expect(gate.details.reason).toBe('NoValues');
+  });
+
+  it('writes the updated values to cache', () => {
+    expect(storageMock.data[cacheKey]).toBeDefined();
+  });
+
+  describe('the next session', () => {
+    beforeAll(async () => {
+      fetchMock.mockClear();
+
+      client = new StatsigClient(sdkKey, user);
+      client.initializeSync();
+    });
+
+    it('is ready after initialize', () => {
+      expect(client.loadingStatus).toBe('Ready');
+    });
+
+    it('reports source as "Cache"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('Cache:Recognized');
+    });
+  });
+});

package/src/__tests__/InitializeNetworkBadResponse.test.ts

@@ -0,0 +1,77 @@
+import fetchMock from 'jest-fetch-mock';
+
+import { DataAdapterCachePrefix, LogLevel } from '@statsig/client-core';
+
+import StatsigClient from '../StatsigClient';
+import { MockLocalStorage } from './MockLocalStorage';
+import InitializeResponse from './initialize.json';
+
+describe('Initialize Network Bad Response', () => {
+  const sdkKey = 'client-key';
+  const user = { userID: 'a-user' };
+
+  let client: StatsigClient;
+  let storageMock: MockLocalStorage;
+
+  async function initialize() {
+    client = new StatsigClient(sdkKey, user, {
+      logLevel: LogLevel.None,
+    });
+    await client.initializeAsync();
+  }
+
+  beforeAll(async () => {
+    storageMock = MockLocalStorage.enabledMockStorage();
+    storageMock.clear();
+
+    fetchMock.enableMocks();
+    fetchMock.mockResponse('<NOT JSON>');
+  });
+
+  afterAll(() => {
+    MockLocalStorage.disableMockStorage();
+  });
+
+  describe('No Cache', () => {
+    beforeAll(async () => {
+      fetchMock.mock.calls = [];
+
+      await initialize();
+    });
+
+    it('is ready after initialize', () => {
+      expect(client.loadingStatus).toBe('Ready');
+    });
+
+    it('reports source as "NoValues"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('NoValues');
+    });
+
+    it('writes nothing to storage', () => {
+      expect(storageMock.data).toMatchObject({});
+    });
+  });
+
+  describe('With Cache', () => {
+    beforeAll(async () => {
+      fetchMock.mock.calls = [];
+
+      storageMock.setItem(
+        `${DataAdapterCachePrefix}.evaluations.2442570830`,
+        JSON.stringify({
+          source: 'Network',
+          data: JSON.stringify(InitializeResponse),
+          receivedAt: Date.now(),
+        }),
+      );
+
+      await initialize();
+    });
+
+    it('reports source as "Cache"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('Cache:Recognized');
+    });
+  });
+});

package/src/__tests__/InitializeNetworkFailures.test.ts

@@ -0,0 +1,91 @@
+import fetchMock from 'jest-fetch-mock';
+
+import { DataAdapterCachePrefix, LogLevel } from '@statsig/client-core';
+
+import StatsigClient from '../StatsigClient';
+import { MockLocalStorage } from './MockLocalStorage';
+import InitializeResponse from './initialize.json';
+
+describe('Initialize Network Failure', () => {
+  const sdkKey = 'client-key';
+  const user = { userID: 'a-user' };
+
+  let client: StatsigClient;
+  let storageMock: MockLocalStorage;
+
+  async function runInitAsync() {
+    client = new StatsigClient(sdkKey, user, {
+      logLevel: LogLevel.None,
+    });
+    await client.initializeAsync();
+  }
+
+  beforeAll(async () => {
+    storageMock = MockLocalStorage.enabledMockStorage();
+    storageMock.clear();
+
+    fetchMock.enableMocks();
+    fetchMock.mockReject();
+  });
+
+  afterAll(() => {
+    MockLocalStorage.disableMockStorage();
+  });
+
+  describe('No Cache', () => {
+    beforeAll(async () => {
+      fetchMock.mock.calls = [];
+
+      await runInitAsync();
+    });
+
+    it('is ready after initialize', () => {
+      expect(client.loadingStatus).toBe('Ready');
+    });
+
+    it('reports source as "NoValues"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('NoValues');
+    });
+
+    it('tries to call /initialize 3 times', () => {
+      expect(fetchMock.mock.calls).toHaveLength(3);
+      expect(fetchMock.mock.calls[0][0]).toContain(
+        'https://api.statsig.com/v1/initialize',
+      );
+    });
+
+    it('writes nothing to storage', () => {
+      expect(storageMock.data).toMatchObject({});
+    });
+  });
+
+  describe('With Cache', () => {
+    beforeAll(async () => {
+      fetchMock.mock.calls = [];
+
+      storageMock.setItem(
+        `${DataAdapterCachePrefix}.evaluations.2442570830`,
+        JSON.stringify({
+          source: 'Network',
+          data: JSON.stringify(InitializeResponse),
+          receivedAt: Date.now(),
+        }),
+      );
+
+      await runInitAsync();
+    });
+
+    it('reports source as "Cache"', () => {
+      const gate = client.getFeatureGate('a_gate');
+      expect(gate.details.reason).toBe('Cache:Recognized');
+    });
+
+    it('tries to call /initialize 3 times', () => {
+      expect(fetchMock.mock.calls).toHaveLength(3);
+      expect(fetchMock.mock.calls[0][0]).toContain(
+        'https://api.statsig.com/v1/initialize',
+      );
+    });
+  });
+});

package/src/__tests__/MockLocalStorage.ts

@@ -0,0 +1,38 @@
+const actualLocalStorage = window.localStorage;
+
+// todo: move to test-helpers (break circular dep)
+export class MockLocalStorage {
+  data: Record<string, string> = {};
+
+  static enabledMockStorage(): MockLocalStorage {
+    const value = new MockLocalStorage();
+    Object.defineProperty(window, 'localStorage', {
+      value,
+    });
+    return value;
+  }
+
+  static disableMockStorage(): void {
+    Object.defineProperty(window, 'localStorage', {
+      value: actualLocalStorage,
+    });
+  }
+
+  // LocalStorage Functions
+
+  clear(): void {
+    this.data = {};
+  }
+
+  getItem(key: string): string | null {
+    return this.data[key] ? this.data[key] : null;
+  }
+
+  setItem(key: string, value: string): void {
+    this.data[key] = String(value);
+  }
+
+  removeItem(key: string): void {
+    delete this.data[key];
+  }
+}

package/src/__tests__/PrecomputedEvaluationsClient.test.ts

@@ -0,0 +1,27 @@
+import fetchMock from 'jest-fetch-mock';
+
+import StatsigClient from '../StatsigClient';
+
+describe('StatsigClient', () => {
+  let client: StatsigClient;
+
+  beforeAll(async () => {
+    fetchMock.enableMocks();
+    fetchMock.mockResponse('{}');
+
+    client = new StatsigClient('client-key', { userID: '' });
+    client.initializeSync();
+
+    client.getExperiment('');
+  });
+
+  it('calls /initialize', () => {
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'https://api.statsig.com/v1/initialize?k=client-key&st=javascript-client',
+      ),
+      expect.any(Object),
+    );
+  });
+});

package/src/__tests__/RacingUpdates.test.ts

@@ -0,0 +1,108 @@
+import fetchMock from 'jest-fetch-mock';
+import { CreateTestPromise, TestPromise } from 'statsig-test-helpers';
+
+import StatsigClient from '../StatsigClient';
+import { MockLocalStorage } from './MockLocalStorage';
+import InitializeResponse from './initialize.json';
+
+const FIRST_RESPONSE = () =>
+  new Response(getResponseWithConfigValue({ isFirst: true }), { headers: {} });
+
+const SECOND_RESPONSE = () =>
+  new Response(getResponseWithConfigValue({ isSecond: true }), { headers: {} });
+
+describe('Racing Updates', () => {
+  let firstReqPromise: TestPromise<Response>;
+  let secondReqPromise: TestPromise<Response>;
+  let client: StatsigClient;
+  let storageMock: MockLocalStorage;
+
+  afterAll(() => {
+    jest.clearAllMocks();
+    MockLocalStorage.disableMockStorage();
+  });
+
+  beforeAll(async () => {
+    storageMock = MockLocalStorage.enabledMockStorage();
+    storageMock.clear();
+
+    firstReqPromise = CreateTestPromise<Response>();
+    secondReqPromise = CreateTestPromise<Response>();
+
+    fetchMock.enableMocks();
+    fetchMock.mockResponseOnce('{}');
+
+    client = new StatsigClient('client-key', {
+      userID: 'initial',
+    });
+
+    await client.initializeAsync();
+
+    let times = 0;
+    fetchMock.mockImplementation(async (_url, _payload) => {
+      if (times++ === 0) {
+        return firstReqPromise;
+      }
+      return secondReqPromise;
+    });
+
+    client.updateUserAsync({ userID: 'first-update' }).catch((e) => {
+      throw e;
+    });
+
+    client.updateUserAsync({ userID: 'second-update' }).catch((e) => {
+      throw e;
+    });
+  });
+
+  describe('when the second request finishes first', () => {
+    beforeAll(async () => {
+      secondReqPromise.resolve(SECOND_RESPONSE());
+      firstReqPromise.resolve(FIRST_RESPONSE());
+
+      await new Promise((r) => setTimeout(r, 1)); // Next Loop
+    });
+
+    it('correctly returns the second value', () => {
+      const config = client.getDynamicConfig('a_dynamic_config');
+      expect(config.value).toEqual({ isSecond: true });
+    });
+
+    it('writes both values to cache', () => {
+      const keys = Object.keys(storageMock.data);
+      expect(keys).toContain('statsig.cached.evaluations.2153812029');
+      expect(keys).toContain('statsig.cached.evaluations.1807619807');
+    });
+  });
+
+  describe('when the first request finishes first', () => {
+    beforeAll(async () => {
+      firstReqPromise.resolve(FIRST_RESPONSE());
+      secondReqPromise.resolve(SECOND_RESPONSE());
+
+      await new Promise((r) => setTimeout(r, 1)); // Next Loop
+    });
+
+    it('correctly returns the second value', () => {
+      const config = client.getDynamicConfig('a_dynamic_config');
+      expect(config.value).toEqual({ isSecond: true });
+    });
+
+    it('writes both values to cache', () => {
+      const keys = Object.keys(storageMock.data);
+      expect(keys).toContain('statsig.cached.evaluations.2153812029');
+      expect(keys).toContain('statsig.cached.evaluations.1807619807');
+    });
+  });
+});
+
+function getResponseWithConfigValue(value: Record<string, unknown>): string {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const result = JSON.parse(JSON.stringify(InitializeResponse)) as any;
+
+  result['dynamic_configs']['3495537376' /* DJB2('a_dynamic_config') */][
+    'value'
+  ] = value;
+
+  return JSON.stringify(result);
+}

package/src/__tests__/StatsigMetadata.test.ts

@@ -0,0 +1,30 @@
+import fetchMock from 'jest-fetch-mock';
+
+import { version } from '../../package.json';
+import StatsigClient from '../StatsigClient';
+
+describe('StatsigMetadata', () => {
+  let body: Record<string, unknown>;
+
+  beforeAll(async () => {
+    fetchMock.mockResponse('{}');
+
+    const client = new StatsigClient('', { userID: '' });
+    await client.initializeAsync();
+
+    const data = fetchMock.mock.calls?.[0]?.[1]?.body?.toString() ?? '{}';
+    body = JSON.parse(data) as Record<string, unknown>;
+  });
+
+  it('has the correct sdkType', () => {
+    expect(body['statsigMetadata']).toMatchObject({
+      sdkType: 'javascript-client',
+    });
+  });
+
+  it('has the correct sdkVersion', () => {
+    expect(body['statsigMetadata']).toMatchObject({
+      sdkVersion: version as string,
+    });
+  });
+});

package/src/__tests__/initialize.json

@@ -0,0 +1,117 @@
+{
+  "__note": "Sample Response using the SDK Demo project",
+  "feature_gates": {
+    "610600137": {
+      "name": "610600137",
+      "value": false,
+      "rule_id": "59nkHdlmIytrqNG9iT7gkd:50.00:2",
+      "id_type": "userID",
+      "secondary_exposures": []
+    },
+    "2867927529": {
+      "name": "2867927529",
+      "value": true,
+      "rule_id": "2QWhVkWdUEXR6Q3KYgV73O",
+      "id_type": "userID",
+      "secondary_exposures": []
+    },
+    "3339045027": {
+      "name": "3339045027",
+      "value": false,
+      "rule_id": "default",
+      "id_type": "userID",
+      "secondary_exposures": []
+    }
+  },
+  "dynamic_configs": {
+    "782154425": {
+      "name": "782154425",
+      "value": {
+        "a_string": "test",
+        "a_bool": true
+      },
+      "rule_id": "3cOnAc0cD6eI8mYw6Ofpgb",
+      "group": "3cOnAc0cD6eI8mYw6Ofpgb",
+      "group_name": "Test",
+      "is_device_based": false,
+      "id_type": "userID",
+      "is_experiment_active": true,
+      "is_user_in_experiment": true,
+      "secondary_exposures": []
+    },
+    "2493531029": {
+      "name": "2493531029",
+      "value": {
+        "a_string": "c"
+      },
+      "rule_id": "1J6QLlETnyrV1XE2um2XiS",
+      "group": "1J6QLlETnyrV1XE2um2XiS",
+      "group_name": "Control",
+      "is_device_based": false,
+      "id_type": "userID",
+      "is_experiment_active": true,
+      "is_user_in_experiment": true,
+      "secondary_exposures": []
+    },
+    "3495537376": {
+      "name": "3495537376",
+      "value": {
+        "red": "#FF0000",
+        "blue": "#00FF00",
+        "green": "#0000FF"
+      },
+      "rule_id": "default",
+      "group": "default",
+      "is_device_based": false,
+      "id_type": "userID",
+      "secondary_exposures": []
+    },
+    "3921852239": {
+      "name": "3921852239",
+      "value": {
+        "a_string": "Experiment Test Value"
+      },
+      "rule_id": "49CGlTB7z97PEdqJapQplA",
+      "group": "49CGlTB7z97PEdqJapQplA",
+      "group_name": "Test",
+      "is_device_based": false,
+      "id_type": "userID",
+      "is_experiment_active": true,
+      "is_user_in_experiment": true,
+      "is_in_layer": true,
+      "explicit_parameters": ["a_string"],
+      "secondary_exposures": []
+    }
+  },
+  "layer_configs": {
+    "3011030003": {
+      "name": "3011030003",
+      "value": {
+        "a_string": "Experiment Test Value"
+      },
+      "rule_id": "49CGlTB7z97PEdqJapQplA",
+      "group": "49CGlTB7z97PEdqJapQplA",
+      "group_name": "Test",
+      "allocated_experiment_name": "3921852239",
+      "is_device_based": false,
+      "is_experiment_active": true,
+      "explicit_parameters": ["a_string"],
+      "is_user_in_experiment": true,
+      "secondary_exposures": [],
+      "undelegated_secondary_exposures": []
+    }
+  },
+  "sdkParams": {},
+  "has_updates": true,
+  "generator": "scrapi-nest",
+  "time": 1705543730484,
+  "company_lcut": 1705543730484,
+  "evaluated_keys": {},
+  "hash_used": "djb2",
+  "derived_fields": {
+    "user_agent": "PostmanRuntime/7.36.3",
+    "ip": "4.38.114.186",
+    "country": "US"
+  },
+  "hashed_sdk_key_used": "1295945792"
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+import StatsigClient from './StatsigClient';
+import { StatsigEvaluationsDataAdapter } from './StatsigEvaluationsDataAdapter';
+import './StatsigMetadataAdditions';
+import type { StatsigOptions } from './StatsigOptions';
+
+export type {
+  StatsigEnvironment,
+  StatsigEvent,
+  StatsigUser,
+} from '@statsig/client-core';
+
+export { StatsigEvaluationsDataAdapter, StatsigClient, StatsigOptions };
+
+export type { EvaluationResponse } from './EvaluationData';
+
+__STATSIG__ = {
+  ...(__STATSIG__ ?? {}),
+  StatsigEvaluationsDataAdapter,
+  StatsigClient,
+};
+
+export default __STATSIG__;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {},
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"],
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "sourceMap": true
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}