@forgerock/storage 1.2.0 → 1.3.0

package/src/lib/storage.effects.test.ts

@@ -1,13 +1,12 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 /*
  * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
  *
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createStorage, type StorageConfig } from './storage.effects.js';
-import type { CustomStorageObject } from '@forgerock/sdk-types';
+import type { CustomStorageObject, GenericError } from '@forgerock/sdk-types';
 
 const localStorageMock = (() => {
   let store: Record<string, string> = {};
@@ -19,7 +18,7 @@ const localStorageMock = (() => {
       }
       return Promise.resolve(value);
     }),
-    setItem: vi.fn((key: string, value: any) => {
+    setItem: vi.fn((key: string, value: unknown) => {
       const valueIsString = typeof value === 'string';
       store[key] = valueIsString ? value : JSON.stringify(value);
       return Promise.resolve();
@@ -76,16 +75,47 @@ const sessionStorageMock = (() => {
 
 Object.defineProperty(global, 'sessionStorage', { value: sessionStorageMock });
 
+let customStore: Record<string, string> = {};
 const mockCustomStore: CustomStorageObject = {
-  get: vi.fn((key: string) => Promise.resolve<string | null>(null)),
-  set: vi.fn((key: string, value: unknown) => Promise.resolve()),
-  remove: vi.fn((key: string) => Promise.resolve()),
+  get: vi.fn(async (key: string): Promise<string | GenericError> => {
+    const keys = Object.keys(customStore);
+    if (!keys.includes(key)) {
+      return {
+        error: 'Retrieving_error',
+        message: 'Key not found',
+        type: 'unknown_error',
+      };
+    }
+    return customStore[key];
+  }),
+  set: vi.fn(async (key: string, valueToSet: unknown): Promise<void | GenericError> => {
+    if (valueToSet === `"bad-value"` || typeof valueToSet !== 'string') {
+      return {
+        error: 'Storing_error',
+        message: 'Value is bad',
+        type: 'unknown_error',
+      };
+    }
+    customStore[key] = valueToSet;
+  }),
+  remove: vi.fn(async (key: string): Promise<void | GenericError> => {
+    const keys = Object.keys(customStore);
+    if (!keys.includes(key)) {
+      return {
+        error: 'Removing_error',
+        message: 'Key not found',
+        type: 'unknown_error',
+      };
+    }
+    delete customStore[key];
+  }),
 };
 
 describe('storage Effect', () => {
   const storageName = 'MyStorage';
   const baseConfig: Omit<StorageConfig, 'tokenStore'> = {
-    storeType: 'localStorage',
+    type: 'localStorage',
+    name: storageName,
     prefix: 'testPrefix',
   };
   const expectedKey = `${baseConfig.prefix}-${storageName}`;
@@ -96,21 +126,20 @@ describe('storage Effect', () => {
     sessionStorageMock.clear();
     vi.clearAllMocks();
 
-    (mockCustomStore.get as Mock).mockResolvedValue(null);
-    (mockCustomStore.set as Mock).mockResolvedValue(undefined);
-    (mockCustomStore.remove as Mock).mockResolvedValue(undefined);
+    customStore = {};
   });
 
   describe('with localStorage', () => {
     const config: StorageConfig = {
       ...baseConfig,
-      storeType: 'localStorage',
+      name: storageName,
+      type: 'localStorage',
     };
 
-    const storageInstance = createStorage(config, storageName);
+    const storageInstance = createStorage(config);
 
     it('should call localStorage.getItem with the correct key and return value', async () => {
-      localStorageMock.setItem(expectedKey, JSON.stringify(testValue));
+      await localStorageMock.setItem(expectedKey, JSON.stringify(testValue));
       const result = await storageInstance.get();
       expect(localStorageMock.getItem).toHaveBeenCalledTimes(1);
       expect(localStorageMock.getItem).toHaveBeenCalledWith(expectedKey);
@@ -127,7 +156,8 @@ describe('storage Effect', () => {
     });
 
     it('should call localStorage.setItem with the correct key and value', async () => {
-      await storageInstance.set(testValue);
+      const result = await storageInstance.set(testValue);
+      expect(result).toBeNull();
       expect(localStorageMock.setItem).toHaveBeenCalledTimes(1);
       expect(localStorageMock.setItem).toHaveBeenCalledWith(expectedKey, JSON.stringify(testValue));
       expect(await localStorageMock.getItem(expectedKey)).toBe(JSON.stringify(testValue));
@@ -146,8 +176,9 @@ describe('storage Effect', () => {
     });
 
     it('should call localStorage.removeItem with the correct key', async () => {
-      localStorageMock.setItem(expectedKey, testValue);
-      await storageInstance.remove();
+      await localStorageMock.setItem(expectedKey, testValue);
+      const result = await storageInstance.remove();
+      expect(result).toBeNull();
       expect(localStorageMock.removeItem).toHaveBeenCalledTimes(1);
       expect(localStorageMock.removeItem).toHaveBeenCalledWith(expectedKey);
       expect(await localStorageMock.getItem(expectedKey)).toBeNull();
@@ -156,28 +187,28 @@ describe('storage Effect', () => {
 
     it('should parse objects/arrays when calling localStorage.getItem', async () => {
       const testObject = { a: 1, b: 'test' };
-      storageInstance.set(testObject);
+      await storageInstance.set(testObject);
 
       const result = await storageInstance.get();
-      console.log(result);
 
       expect(localStorageMock.getItem).toHaveBeenCalledTimes(1);
       expect(localStorageMock.getItem).toHaveBeenCalledWith(expectedKey);
-      // expect(result).toEqual(testObject);
-      // expect(mockCustomStore.remove).not.toHaveBeenCalled();
+      expect(result).toEqual(testObject);
+      expect(mockCustomStore.remove).not.toHaveBeenCalled();
     });
   });
 
   describe('with sessionStorage', () => {
+    const storageName = 'MyStorage';
     const config: StorageConfig = {
       ...baseConfig,
-      storeType: 'sessionStorage',
+      name: storageName,
+      type: 'sessionStorage',
     };
-    const storageName = 'MyStorage';
-    const storageInstance = createStorage(config, storageName);
+    const storageInstance = createStorage(config);
 
     it('should call sessionStorage.getItem with the correct key and return value', async () => {
-      sessionStorageMock.setItem(expectedKey, JSON.stringify(testValue));
+      await sessionStorageMock.setItem(expectedKey, JSON.stringify(testValue));
       const result = await storageInstance.get();
       expect(sessionStorageMock.getItem).toHaveBeenCalledTimes(1);
       expect(sessionStorageMock.getItem).toHaveBeenCalledWith(expectedKey);
@@ -196,16 +227,14 @@ describe('storage Effect', () => {
       const obj = { tokens: 123 };
       await storageInstance.set(obj);
       const result = await storageInstance.get();
-      if (!result) {
-        // we should not hit this expect
-        expect(false).toBe(true);
-      }
+
       expect(result).toStrictEqual(obj);
       expect(sessionStorageMock.getItem).toHaveBeenCalledTimes(1);
       expect(sessionStorageMock.getItem).toHaveBeenCalledWith(expectedKey);
     });
     it('should call sessionStorage.setItem with the correct key and value', async () => {
-      await storageInstance.set(testValue);
+      const result = await storageInstance.set(testValue);
+      expect(result).toBeNull();
       expect(sessionStorageMock.setItem).toHaveBeenCalledTimes(1);
       expect(sessionStorageMock.setItem).toHaveBeenCalledWith(
         expectedKey,
@@ -215,9 +244,10 @@ describe('storage Effect', () => {
       expect(localStorageMock.setItem).not.toHaveBeenCalled();
       expect(mockCustomStore.set).not.toHaveBeenCalled();
     });
-    it('should call sessionStorage.setItem with the correct key and value', async () => {
+    it('should call sessionStorage.setItem with the correct key and value and stringify objects', async () => {
       const obj = { tokens: 123 };
-      await storageInstance.set(obj);
+      const result = await storageInstance.set(obj);
+      expect(result).toBeNull();
       expect(sessionStorageMock.setItem).toHaveBeenCalledTimes(1);
       expect(sessionStorageMock.setItem).toHaveBeenCalledWith(expectedKey, JSON.stringify(obj));
       expect(await sessionStorageMock.getItem(expectedKey)).toBe(JSON.stringify(obj));
@@ -225,7 +255,8 @@ describe('storage Effect', () => {
       expect(mockCustomStore.set).not.toHaveBeenCalled();
     });
     it('should call sessionStorage.removeItem with the correct key', async () => {
-      await storageInstance.remove();
+      const result = await storageInstance.remove();
+      expect(result).toBeNull();
       expect(sessionStorageMock.removeItem).toHaveBeenCalledTimes(1);
       expect(sessionStorageMock.removeItem).toHaveBeenCalledWith(expectedKey);
       expect(await sessionStorageMock.getItem(expectedKey)).toBeNull();
@@ -234,16 +265,16 @@ describe('storage Effect', () => {
     });
   });
 
-  describe('with custom TokenStoreObject', () => {
+  describe('with custom storage', () => {
     const config: StorageConfig = {
       ...baseConfig,
-      storeType: 'localStorage',
+      type: 'custom',
+      custom: mockCustomStore,
     };
-    const myStorage = 'MyStorage';
-    const storageInstance = createStorage(config, myStorage, mockCustomStore);
+    const storageInstance = createStorage(config);
 
     it('should call customStore.get with the correct key and return its value', async () => {
-      (mockCustomStore.get as Mock).mockResolvedValueOnce(JSON.stringify(testValue));
+      await storageInstance.set(testValue);
       const result = await storageInstance.get();
       expect(mockCustomStore.get).toHaveBeenCalledTimes(1);
       expect(mockCustomStore.get).toHaveBeenCalledWith(expectedKey);
@@ -252,32 +283,37 @@ describe('storage Effect', () => {
       expect(sessionStorageMock.getItem).not.toHaveBeenCalled();
     });
 
-    it('should return null if customStore.get returns null', async () => {
-      (mockCustomStore.get as Mock).mockResolvedValueOnce(null);
+    it('should parse objects/arrays returned from customStore.get', async () => {
+      const testObject = { token: 'abc', user: 'xyz' };
+      await storageInstance.set(testObject);
+
       const result = await storageInstance.get();
+
       expect(mockCustomStore.get).toHaveBeenCalledTimes(1);
       expect(mockCustomStore.get).toHaveBeenCalledWith(expectedKey);
+      expect(result).toEqual(testObject); // Verify it was parsed
     });
 
-    it('should parse JSON strings returned from customStore.get', async () => {
-      const testObject = { token: 'abc', user: 'xyz' };
-      const jsonString = JSON.stringify(testObject);
-      (mockCustomStore.get as Mock).mockResolvedValueOnce(jsonString); // Mock returns JSON string
-
+    it('should return an error if customStore.get errors', async () => {
       const result = await storageInstance.get();
-
+      expect(result).toStrictEqual({
+        error: 'Retrieving_error',
+        message: 'Key not found',
+        type: 'unknown_error',
+      });
       expect(mockCustomStore.get).toHaveBeenCalledTimes(1);
       expect(mockCustomStore.get).toHaveBeenCalledWith(expectedKey);
-      expect(result).toEqual(testObject); // Verify it was parsed
     });
 
     it('should call customStore.set with the correct key and value', async () => {
-      await storageInstance.set(testValue);
+      const result = await storageInstance.set(testValue);
+      expect(result).toBeNull();
       expect(mockCustomStore.set).toHaveBeenCalledTimes(1);
       expect(mockCustomStore.set).toHaveBeenCalledWith(expectedKey, JSON.stringify(testValue));
       expect(localStorageMock.setItem).not.toHaveBeenCalled();
       expect(sessionStorageMock.setItem).not.toHaveBeenCalled();
     });
+
     it('should call customStore.set with the correct key and value and stringify objects', async () => {
       await storageInstance.set({ test: { tokens: '123' } });
       expect(mockCustomStore.set).toHaveBeenCalledTimes(1);
@@ -288,19 +324,43 @@ describe('storage Effect', () => {
       expect(localStorageMock.setItem).not.toHaveBeenCalled();
       expect(sessionStorageMock.setItem).not.toHaveBeenCalled();
     });
+
+    it('should return an error if customStore.set errors', async () => {
+      const result = await storageInstance.set('bad-value');
+      expect(result).toStrictEqual({
+        error: 'Storing_error',
+        message: 'Value is bad',
+        type: 'unknown_error',
+      });
+      expect(mockCustomStore.set).toHaveBeenCalledTimes(1);
+      expect(mockCustomStore.set).toHaveBeenCalledWith(expectedKey, JSON.stringify('bad-value'));
+    });
+
     it('should call customStore.remove with the correct key', async () => {
-      await storageInstance.remove();
+      await storageInstance.set(testValue);
+      const result = await storageInstance.remove();
+      expect(result).toBeNull();
       expect(mockCustomStore.remove).toHaveBeenCalledTimes(1);
       expect(mockCustomStore.remove).toHaveBeenCalledWith(expectedKey);
       expect(localStorageMock.removeItem).not.toHaveBeenCalled();
       expect(sessionStorageMock.removeItem).not.toHaveBeenCalled();
     });
+
+    it('should return an error if customStore.remove errors', async () => {
+      const result = await storageInstance.remove();
+      expect(result).toStrictEqual({
+        error: 'Removing_error',
+        message: 'Key not found',
+        type: 'unknown_error',
+      });
+      expect(mockCustomStore.remove).toHaveBeenCalledTimes(1);
+      expect(mockCustomStore.remove).toHaveBeenCalledWith(expectedKey);
+    });
   });
 
   it('should return a function that returns the storage interface', () => {
-    const config: StorageConfig = { ...baseConfig, storeType: 'localStorage' };
-    const myStorage = 'MyStorage';
-    const storageInterface = createStorage(config, myStorage);
+    const config: StorageConfig = { ...baseConfig, type: 'localStorage' };
+    const storageInterface = createStorage(config);
     expect(storageInterface).toHaveProperty('get');
     expect(storageInterface).toHaveProperty('set');
     expect(storageInterface).toHaveProperty('remove');

package/src/lib/storage.effects.ts

@@ -4,128 +4,126 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-import { CustomStorageObject } from '@forgerock/sdk-types';
+import { CustomStorageObject, GenericError } from '@forgerock/sdk-types';
 
-export interface StorageConfig {
-  storeType: CustomStorageObject | 'localStorage' | 'sessionStorage';
+export interface StorageClient<Value> {
+  get: () => Promise<Value | GenericError | null>;
+  set: (value: Value) => Promise<GenericError | null>;
+  remove: () => Promise<GenericError | null>;
+}
+
+export type StorageConfig = BrowserStorageConfig | CustomStorageConfig;
+
+export interface BrowserStorageConfig {
+  type: 'localStorage' | 'sessionStorage';
   prefix?: string;
+  name: string;
 }
 
-export interface GenericError {
-  code?: string | number;
-  message: string;
-  type:
-    | 'argument_error'
-    | 'davinci_error'
-    | 'internal_error'
-    | 'network_error'
-    | 'state_error'
-    | 'unknown_error';
+export interface CustomStorageConfig {
+  type: 'custom';
+  prefix?: string;
+  name: string;
+  custom: CustomStorageObject;
 }
 
-export function createStorage<Value>(
-  config: StorageConfig,
-  storageName: string,
-  customStore?: CustomStorageObject,
-) {
-  const { storeType, prefix = 'pic' } = config;
+function createStorageError(
+  storeType: 'localStorage' | 'sessionStorage' | 'custom',
+  action: 'Storing' | 'Retrieving' | 'Removing' | 'Parsing',
+): GenericError {
+  let storageName;
+  switch (storeType) {
+    case 'localStorage':
+      storageName = 'local';
+      break;
+    case 'sessionStorage':
+      storageName = 'session';
+      break;
+    case 'custom':
+      storageName = 'custom';
+      break;
+    default:
+      break;
+  }
+
+  return {
+    error: `${action}_error`,
+    message: `Error ${action.toLowerCase()} value from ${storageName} storage`,
+    type: action === 'Parsing' ? 'parse_error' : 'unknown_error',
+  };
+}
+
+export function createStorage<Value>(config: StorageConfig): StorageClient<Value> {
+  const { type: storeType, prefix = 'pic', name } = config;
+  const key = `${prefix}-${name}`;
+  const storageTypes = {
+    sessionStorage,
+    localStorage,
+  };
+
+  if (storeType === 'custom' && !('custom' in config)) {
+    throw new Error('Custom storage configuration must include a custom storage object');
+  }
 
-  const key = `${prefix}-${storageName}`;
   return {
     get: async function storageGet(): Promise<Value | GenericError | null> {
-      if (customStore) {
-        const value = await customStore.get(key);
-        if (value === null) {
+      if (storeType === 'custom') {
+        const value = await config.custom.get(key);
+        if (value === null || (typeof value === 'object' && 'error' in value)) {
           return value;
         }
+
         try {
           const parsed = JSON.parse(value);
           return parsed as Value;
         } catch {
-          return {
-            code: 'Parse_Error',
-            message: 'Eror parsing value from provided storage',
-            type: 'unknown_error',
-          };
+          return createStorageError(storeType, 'Parsing');
         }
       }
-      if (storeType === 'sessionStorage') {
-        const value = await sessionStorage.getItem(key);
+
+      let value: string | null;
+      try {
+        value = await storageTypes[storeType].getItem(key);
         if (value === null) {
           return value;
         }
-        try {
-          const parsed = JSON.parse(value);
-          return parsed as Value;
-        } catch {
-          return {
-            code: 'Parse_Error',
-            message: 'Eror parsing value from session storage',
-            type: 'unknown_error',
-          };
-        }
+      } catch {
+        return createStorageError(storeType, 'Retrieving');
       }
-      const value = await localStorage.getItem(key);
 
-      if (value === null) {
-        return value;
-      }
       try {
         const parsed = JSON.parse(value);
         return parsed as Value;
       } catch {
-        return {
-          code: 'Parse_Error',
-          message: 'Eror parsing value from local storage',
-          type: 'unknown_error',
-        };
+        return createStorageError(storeType, 'Parsing');
       }
     },
-    set: async function storageSet(value: Value) {
+    set: async function storageSet(value: Value): Promise<GenericError | null> {
       const valueToStore = JSON.stringify(value);
-      if (customStore) {
-        try {
-          await customStore.set(key, valueToStore);
-          return Promise.resolve();
-        } catch {
-          return {
-            code: 'Storing_Error',
-            message: 'Eror storing value in custom storage',
-            type: 'unknown_error',
-          };
-        }
-      }
-      if (storeType === 'sessionStorage') {
-        try {
-          await sessionStorage.setItem(key, valueToStore);
-          return Promise.resolve();
-        } catch {
-          return {
-            code: 'Storing_Error',
-            message: 'Eror storing value in session storage',
-            type: 'unknown_error',
-          };
-        }
+      if (storeType === 'custom') {
+        const value = await config.custom.set(key, valueToStore);
+        return Promise.resolve(value ?? null);
       }
+
       try {
-        await localStorage.setItem(key, valueToStore);
-        return Promise.resolve();
+        await storageTypes[storeType].setItem(key, valueToStore);
+        return Promise.resolve(null);
       } catch {
-        return {
-          code: 'Storing_Error',
-          message: 'Eror storing value in local storage',
-          type: 'unknown_error',
-        };
+        return createStorageError(storeType, 'Storing');
       }
     },
-    remove: async function storageSet() {
-      if (customStore) {
-        return await customStore.remove(key);
+    remove: async function storageRemove(): Promise<GenericError | null> {
+      if (storeType === 'custom') {
+        const value = await config.custom.remove(key);
+        return Promise.resolve(value ?? null);
       }
-      if (storeType === 'sessionStorage') {
-        return await sessionStorage.removeItem(key);
+
+      try {
+        await storageTypes[storeType].removeItem(key);
+        return Promise.resolve(null);
+      } catch {
+        return createStorageError(storeType, 'Removing');
       }
-      return await localStorage.removeItem(key);
     },
-  };
+  } as StorageClient<Value>;
 }