fix(electron-sdk): localstorage indexing

joker23 · joker23 · commit 90a310e9a64b · 2026-04-13T14:24:42.000-05:00
diff --git a/packages/sdk/electron/__tests__/ElectronClient.mainProcess.test.ts b/packages/sdk/electron/__tests__/ElectronClient.mainProcess.test.ts
@@ -288,6 +288,101 @@ describe('given an initialized ElectronClient with enableIPC: false and polling'
   });
 });
 
+function makeMemoryStorage() {
+  const data = new Map<string, string>();
+  return {
+    get: jest.fn(async (key: string) => data.get(key) ?? null),
+    set: jest.fn(async (key: string, value: string) => {
+      data.set(key, value);
+    }),
+    clear: jest.fn(async (key: string) => {
+      data.delete(key);
+    }),
+    keys: () => Array.from(data.keys()),
+  };
+}
+
+describe('maxCachedContexts', () => {
+  it('evicts the oldest cached context when the limit is exceeded', async () => {
+    const storage = makeMemoryStorage();
+    const mockedFetch = mockFetch(JSON.stringify(remoteFlagsMockData), 200);
+    (ElectronPlatform as jest.Mock).mockReturnValue({
+      crypto: new ElectronCrypto(),
+      info: new ElectronInfo(),
+      requests: {
+        createEventSource: jest.fn(),
+        fetch: mockedFetch,
+        getEventSourceCapabilities: jest.fn(),
+      },
+      encoding: new ElectronEncoding(),
+      storage,
+    });
+
+    const client = createClient(clientSideId, DEFAULT_INITIAL_CONTEXT, {
+      initialConnectionMode: 'polling',
+      enableIPC: false,
+      diagnosticOptOut: true,
+      sendEvents: false,
+      maxCachedContexts: 1,
+    });
+    await client.start();
+
+    // After start, context A's flags are cached.
+    // Storage should contain: context index + context A data + context A freshness
+    const keysAfterStart = storage.keys();
+    const contextDataKeys = keysAfterStart.filter(
+      (k) => !k.includes('ContextIndex') && !k.includes('_freshness'),
+    );
+    expect(contextDataKeys).toHaveLength(1);
+
+    // Identify a second context — context A should be evicted (maxCachedContexts: 1)
+    await client.identify({ kind: 'user', key: 'context-b' });
+
+    const keysAfterIdentify = storage.keys();
+    const contextDataKeysAfter = keysAfterIdentify.filter(
+      (k) => !k.includes('ContextIndex') && !k.includes('_freshness'),
+    );
+    expect(contextDataKeysAfter).toHaveLength(1);
+
+    // The surviving key should be different from the first one (context B replaced context A)
+    expect(contextDataKeysAfter[0]).not.toEqual(contextDataKeys[0]);
+  });
+
+  it('does not cache flags when maxCachedContexts is 0', async () => {
+    const storage = makeMemoryStorage();
+    const mockedFetch = mockFetch(JSON.stringify(remoteFlagsMockData), 200);
+    (ElectronPlatform as jest.Mock).mockReturnValue({
+      crypto: new ElectronCrypto(),
+      info: new ElectronInfo(),
+      requests: {
+        createEventSource: jest.fn(),
+        fetch: mockedFetch,
+        getEventSourceCapabilities: jest.fn(),
+      },
+      encoding: new ElectronEncoding(),
+      storage,
+    });
+
+    const client = createClient(clientSideId, DEFAULT_INITIAL_CONTEXT, {
+      initialConnectionMode: 'polling',
+      enableIPC: false,
+      diagnosticOptOut: true,
+      sendEvents: false,
+      maxCachedContexts: 0,
+    });
+    await client.start();
+
+    // Flags should still evaluate correctly from the network response
+    expect(client.boolVariation('on-off-flag', false)).toBe(true);
+
+    // But no context data should be persisted to storage
+    const contextDataKeys = storage
+      .keys()
+      .filter((k) => !k.includes('ContextIndex') && !k.includes('_freshness'));
+    expect(contextDataKeys).toHaveLength(0);
+  });
+});
+
 describe('given an initialized ElectronClient with enableIPC: false and streaming', () => {
   const logger: LDLogger = {
     debug: jest.fn(),
diff --git a/packages/sdk/electron/__tests__/platform/ElectronStorage.test.ts b/packages/sdk/electron/__tests__/platform/ElectronStorage.test.ts
@@ -11,8 +11,7 @@ jest.mock('electron', () => ({
   },
 }));
 
-const namespace = 'test_namespace';
-const storageFile = `/user/data/ldcache-${namespace}`;
+const storageFile = '/user/data/ldcache';
 const tempFile = `${storageFile}.tmp`;
 
 const logger: LDLogger = {
@@ -30,7 +29,7 @@ it('handles failed initialization when clearing values', async () => {
   (fs.readFile as jest.Mock).mockRejectedValueOnce(new Error('file not found'));
   (fs.writeFile as jest.Mock).mockRejectedValueOnce(new Error('write failed'));
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.clear('key1');
 
   expect(logger.debug).not.toHaveBeenCalled();
@@ -47,7 +46,7 @@ it('can clear values', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.clear('key1');
 
   expect(await storage.get('key1')).toBeNull();
@@ -70,7 +69,7 @@ it('does nothing when clearing a non-existent key', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.clear('key3');
 
   expect(fs.writeFile).not.toHaveBeenCalled();
@@ -88,7 +87,7 @@ it('handles error when clearing values', async () => {
   );
   (fs.writeFile as jest.Mock).mockRejectedValueOnce(new Error('write failed'));
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.clear('key1');
 
   expect(await storage.get('key1')).toEqual('value1');
@@ -105,7 +104,7 @@ it('handles failed initialization when getting values', async () => {
   (fs.readFile as jest.Mock).mockRejectedValueOnce(new Error('file not found'));
   (fs.writeFile as jest.Mock).mockRejectedValueOnce(new Error('write failed'));
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   const value = await storage.get('key1');
 
   expect(value).toBeNull();
@@ -124,7 +123,7 @@ it('can get values', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   const value = await storage.get('key1');
 
   expect(value).toEqual('value1');
@@ -140,7 +139,7 @@ it('returns null when getting a non-existent key', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   const value = await storage.get('key3');
 
   expect(value).toBeNull();
@@ -155,7 +154,7 @@ it('handles failed initialization when setting values', async () => {
   (fs.readFile as jest.Mock).mockRejectedValueOnce(new Error('file not found'));
   (fs.writeFile as jest.Mock).mockRejectedValueOnce(new Error('write failed'));
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.set('key3', 'value3');
 
   expect(logger.debug).not.toHaveBeenCalled();
@@ -172,7 +171,7 @@ it('can set values', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.set('key3', 'value3');
 
   expect(await storage.get('key3')).toEqual('value3');
@@ -195,7 +194,7 @@ it('can set values with existing keys', async () => {
     JSON.stringify({ key1: 'value1', key2: 'value2' }),
   );
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.set('key1', 'new-value1');
 
   expect(await storage.get('key1')).toEqual('new-value1');
@@ -219,7 +218,7 @@ it('handles error when setting values', async () => {
   );
   (fs.writeFile as jest.Mock).mockRejectedValueOnce(new Error('write failed'));
 
-  const storage = new ElectronStorage(namespace, logger);
+  const storage = new ElectronStorage(logger);
   await storage.set('key3', 'value3');
 
   expect(await storage.get('key3')).toBeNull();
diff --git a/packages/sdk/electron/contract-tests/entity/src/ClientEntity.ts b/packages/sdk/electron/contract-tests/entity/src/ClientEntity.ts
@@ -1,4 +1,3 @@
-import { createHash } from 'crypto';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { app } from 'electron';
 import fs from 'node:fs';
@@ -257,15 +256,10 @@ export class ClientEntity {
 export async function createEntity(options: CreateInstanceParams) {
   const logger = makeLogger(options.tag);
 
-  // Need to keep track of this to know where electron is storing the caches.
-  // We can make this a bit more robust by either mocking out the storage path
-  // or allowing users to define a custom storage. That way we can isolate each
-  // client's cache.
   const clientSideId = options.configuration.credential || 'unknown-env-id';
   logger.info(`Creating client with configuration: ${JSON.stringify(options.configuration)}`);
 
-  const namespace = createHash('sha256').update(clientSideId).digest?.('base64url');
-  const storagePath = path.join(app.getPath('userData'), `ldcache-${namespace}`);
+  const storagePath = path.join(app.getPath('userData'), 'ldcache');
 
   const timeoutMs =
     options.configuration.startWaitTimeMs !== null &&
diff --git a/packages/sdk/electron/contract-tests/entity/src/main.ts b/packages/sdk/electron/contract-tests/entity/src/main.ts
@@ -15,9 +15,6 @@ if (process.argv.includes('--build')) {
 const capabilities = [
   'client-side',
   'mobile',
-  // This is a required feature since electron SDK uses a shared localstorage for all clients.
-  // Which would cause issues with flag evaluations when multiple clients are created.
-  'singleton',
   'service-endpoints',
   'tags',
   'user-type',
diff --git a/packages/sdk/electron/src/ElectronClient.ts b/packages/sdk/electron/src/ElectronClient.ts
@@ -95,7 +95,7 @@ export class ElectronClient extends LDClientImpl {
       credentialType: useClientSideId ? 'clientSideId' : 'mobileKey',
     };
 
-    const platform = new ElectronPlatform(logger, credential, options);
+    const platform = new ElectronPlatform(logger, options);
     const endpoints = useClientSideId ? browserFdv1Endpoints(credential) : mobileFdv1Endpoints();
 
     super(
diff --git a/packages/sdk/electron/src/platform/ElectronPlatform.ts b/packages/sdk/electron/src/platform/ElectronPlatform.ts
@@ -21,9 +21,8 @@ export default class ElectronPlatform implements platform.Platform {
 
   requests: platform.Requests;
 
-  constructor(logger: LDLogger, clientSideId: string, options: ElectronOptions) {
-    const namespace = this.crypto.createHash('sha256').update(clientSideId).digest?.('base64url');
-    this.storage = new ElectronStorage(namespace!, logger);
+  constructor(logger: LDLogger, options: ElectronOptions) {
+    this.storage = new ElectronStorage(logger);
     this.requests = new ElectronRequests(
       options.tlsParams,
       options.proxyOptions,
diff --git a/packages/sdk/electron/src/platform/ElectronStorage.ts b/packages/sdk/electron/src/platform/ElectronStorage.ts
@@ -10,11 +10,8 @@ export default class ElectronStorage implements Storage {
   private readonly _initialized: Promise<boolean>;
   private _cache: Map<string, string>;
 
-  constructor(
-    private readonly _namespace: string,
-    private readonly _logger?: LDLogger,
-  ) {
-    this._storageFile = path.join(electron.app.getPath('userData'), `ldcache-${this._namespace}`);
+  constructor(private readonly _logger?: LDLogger) {
+    this._storageFile = path.join(electron.app.getPath('userData'), 'ldcache');
     this._tempFile = `${this._storageFile}.tmp`;
     this._cache = new Map<string, string>();
     this._initialized = this._initialize();
