vibefast-cli 0.2.4 → 0.3.0

package/2/apps/native/src/core/cache/__tests__/cache-service.test.ts

@@ -0,0 +1,599 @@
+import { type MMKV } from 'react-native-mmkv';
+
+import { error as logError } from '@/core/logging';
+
+import { CacheService } from '../cache-service';
+
+// Mock MMKV
+jest.mock('react-native-mmkv');
+jest.mock('@/core/logging', () => ({
+  error: jest.fn(),
+}));
+
+const mockedLogError = logError as jest.MockedFunction<typeof logError>;
+
+describe('CacheService', () => {
+  let cacheService: CacheService;
+  let mockMMKV: jest.Mocked<MMKV>;
+
+  beforeEach(() => {
+    // Create a fresh MMKV mock for each test
+    mockMMKV = {
+      set: jest.fn(),
+      getString: jest.fn(),
+      delete: jest.fn(),
+      clearAll: jest.fn(),
+      keys: jest.fn(),
+      contains: jest.fn(),
+      recrypt: jest.fn(),
+      getNumber: jest.fn(),
+      getBoolean: jest.fn(),
+      getBuffer: jest.fn(),
+      getMap: jest.fn(),
+      setMultiple: jest.fn(),
+      addEntries: jest.fn(),
+    } as any;
+
+    cacheService = new CacheService({ mmkvInstance: mockMMKV });
+    mockedLogError.mockClear();
+  });
+
+  afterEach(() => {
+    mockedLogError.mockReset();
+  });
+
+  describe('constructor', () => {
+    it('should create CacheService with MMKV instance', () => {
+      expect(cacheService).toBeInstanceOf(CacheService);
+    });
+  });
+
+  describe('setItem', () => {
+    it('should set item successfully with string value', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('test-key', 'test-value');
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('test-key', '"test-value"');
+    });
+
+    it('should set item successfully with number value', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('number-key', 42);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('number-key', '42');
+    });
+
+    it('should set item successfully with boolean value', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('boolean-key', true);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('boolean-key', 'true');
+    });
+
+    it('should set item successfully with object value', async () => {
+      const testObject = { name: 'John', age: 30, active: true };
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('object-key', testObject);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        'object-key',
+        JSON.stringify(testObject),
+      );
+    });
+
+    it('should set item successfully with array value', async () => {
+      const testArray = [1, 2, 3, 'test', true];
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('array-key', testArray);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        'array-key',
+        JSON.stringify(testArray),
+      );
+    });
+
+    it('should set item successfully with null value', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('null-key', null);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('null-key', 'null');
+    });
+
+    it('should handle undefined value by converting to null', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('undefined-key', undefined);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('undefined-key', undefined);
+    });
+
+    it('should handle circular reference objects gracefully', async () => {
+      const circularObject: any = { name: 'test' };
+      circularObject.self = circularObject;
+
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('circular-key', circularObject);
+
+      // Should handle the error gracefully by logging structured metadata
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error setting item circular-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'circular-key',
+          error: expect.any(Error),
+        }),
+      );
+    });
+
+    it('should handle large objects', async () => {
+      const largeObject = {
+        data: Array.from({ length: 1000 }, (_, i) => ({
+          id: i,
+          name: `item-${i}`,
+          description: `This is item number ${i} with some additional text`,
+          tags: [`tag${i % 10}`, `category${i % 5}`],
+          metadata: {
+            created: new Date().toISOString(),
+            version: '1.0.0',
+            active: i % 2 === 0,
+          },
+        })),
+      };
+
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('large-key', largeObject);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        'large-key',
+        JSON.stringify(largeObject),
+      );
+    });
+
+    it('should handle special characters in key and value', async () => {
+      const specialValue = 'Special chars: äöü ñ 中文 🎉 emojis! @#$%^&*()';
+      const specialKey = 'special-key_äöü-ñ中文🎉';
+
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem(specialKey, specialValue);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        specialKey,
+        JSON.stringify(specialValue),
+      );
+    });
+
+    it('should handle MMKV set errors gracefully', async () => {
+      const error = new Error('MMKV storage error');
+      mockMMKV.set.mockImplementation(() => {
+        throw error;
+      });
+
+      await cacheService.setItem('error-key', 'error-value');
+
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error setting item error-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'error-key',
+          error,
+        }),
+      );
+    });
+
+    it('should handle JSON.stringify errors gracefully', async () => {
+      // Create an object that will cause JSON.stringify to throw
+      const problematicObject = {};
+      Object.defineProperty(problematicObject, 'problematic', {
+        get() {
+          throw new Error('Property access error');
+        },
+        enumerable: true,
+      });
+
+      await cacheService.setItem('problematic-key', problematicObject);
+
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error setting item problematic-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'problematic-key',
+          error: expect.any(Error),
+        }),
+      );
+    });
+
+    it('should handle empty string key', async () => {
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('', 'empty-key-value');
+
+      expect(mockMMKV.set).toHaveBeenCalledWith('', '"empty-key-value"');
+    });
+
+    it('should handle very long keys', async () => {
+      const longKey = 'a'.repeat(1000);
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem(longKey, 'long-key-value');
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(longKey, '"long-key-value"');
+    });
+  });
+
+  describe('getItem', () => {
+    it('should get item successfully with string value', async () => {
+      mockMMKV.getString.mockReturnValue('"test-value"');
+
+      const result = await cacheService.getItem<string>('test-key');
+
+      expect(result).toBe('test-value');
+      expect(mockMMKV.getString).toHaveBeenCalledWith('test-key');
+    });
+
+    it('should get item successfully with number value', async () => {
+      mockMMKV.getString.mockReturnValue('42');
+
+      const result = await cacheService.getItem<number>('number-key');
+
+      expect(result).toBe(42);
+    });
+
+    it('should get item successfully with boolean value', async () => {
+      mockMMKV.getString.mockReturnValue('true');
+
+      const result = await cacheService.getItem<boolean>('boolean-key');
+
+      expect(result).toBe(true);
+    });
+
+    it('should get item successfully with object value', async () => {
+      const testObject = { name: 'John', age: 30, active: true };
+      mockMMKV.getString.mockReturnValue(JSON.stringify(testObject));
+
+      const result =
+        await cacheService.getItem<typeof testObject>('object-key');
+
+      expect(result).toEqual(testObject);
+    });
+
+    it('should get item successfully with array value', async () => {
+      const testArray = [1, 2, 3, 'test', true];
+      mockMMKV.getString.mockReturnValue(JSON.stringify(testArray));
+
+      const result = await cacheService.getItem<typeof testArray>('array-key');
+
+      expect(result).toEqual(testArray);
+    });
+
+    it('should return null when key does not exist', async () => {
+      mockMMKV.getString.mockReturnValue(undefined);
+
+      const result = await cacheService.getItem<string>('non-existent-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when MMKV returns null', async () => {
+      mockMMKV.getString.mockReturnValue(null);
+
+      const result = await cacheService.getItem<string>('null-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when MMKV returns empty string', async () => {
+      mockMMKV.getString.mockReturnValue('');
+
+      const result = await cacheService.getItem<string>('empty-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle malformed JSON gracefully', async () => {
+      mockMMKV.getString.mockReturnValue('invalid-json{');
+
+      const result = await cacheService.getItem<string>('malformed-key');
+
+      expect(result).toBeNull();
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error getting item malformed-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'malformed-key',
+          error: expect.any(Error),
+        }),
+      );
+    });
+
+    it('should handle JSON parse errors gracefully', async () => {
+      mockMMKV.getString.mockReturnValue('{"invalid": json}');
+
+      const result = await cacheService.getItem<string>('parse-error-key');
+
+      expect(result).toBeNull();
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error getting item parse-error-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'parse-error-key',
+          error: expect.any(Error),
+        }),
+      );
+    });
+
+    it('should handle MMKV getString errors gracefully', async () => {
+      const error = new Error('MMKV read error');
+      mockMMKV.getString.mockImplementation(() => {
+        throw error;
+      });
+
+      const result = await cacheService.getItem<string>('error-key');
+
+      expect(result).toBeNull();
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error getting item error-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'error-key',
+          error,
+        }),
+      );
+    });
+
+    it('should handle complex nested objects', async () => {
+      const complexObject = {
+        user: {
+          id: '123',
+          profile: {
+            personal: {
+              name: 'John Doe',
+              email: 'john@example.com',
+            },
+            preferences: {
+              theme: 'dark',
+              notifications: {
+                email: true,
+                push: false,
+                categories: ['news', 'updates'],
+              },
+            },
+          },
+        },
+        sessions: [
+          {
+            id: 'sess1',
+            timestamp: '2023-01-01T00:00:00Z',
+            duration: 3600,
+            active: true,
+          },
+        ],
+      };
+
+      mockMMKV.getString.mockReturnValue(JSON.stringify(complexObject));
+
+      const result =
+        await cacheService.getItem<typeof complexObject>('complex-key');
+
+      expect(result).toEqual(complexObject);
+    });
+
+    it('should handle different number formats', async () => {
+      const testCases = [
+        { input: 42, expected: 42 },
+        { input: 3.14, expected: 3.14 },
+        { input: -100, expected: -100 },
+        { input: 0, expected: 0 },
+        // Infinity and NaN get converted to null in JSON
+        { input: Number.POSITIVE_INFINITY, expected: null },
+        { input: Number.NaN, expected: null },
+      ];
+
+      for (const testCase of testCases) {
+        mockMMKV.getString.mockReturnValue(JSON.stringify(testCase.input));
+        const result = await cacheService.getItem<number>('number-key');
+
+        if (testCase.expected === null) {
+          expect(result).toBeNull();
+        } else {
+          expect(result).toBe(testCase.expected);
+        }
+      }
+    });
+  });
+
+  describe('removeItem', () => {
+    it('should remove item successfully', async () => {
+      mockMMKV.delete.mockImplementation();
+
+      await cacheService.removeItem('test-key');
+
+      expect(mockMMKV.delete).toHaveBeenCalledWith('test-key');
+    });
+
+    it('should handle MMKV delete errors gracefully', async () => {
+      const error = new Error('MMKV delete error');
+      mockMMKV.delete.mockImplementation(() => {
+        throw error;
+      });
+
+      await cacheService.removeItem('error-key');
+
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error removing item error-key',
+        expect.objectContaining({
+          feature: 'cache',
+          key: 'error-key',
+          error,
+        }),
+      );
+    });
+
+    it('should handle removing non-existent key', async () => {
+      mockMMKV.delete.mockImplementation();
+
+      await cacheService.removeItem('non-existent-key');
+
+      expect(mockMMKV.delete).toHaveBeenCalledWith('non-existent-key');
+    });
+
+    it('should handle empty string key', async () => {
+      mockMMKV.delete.mockImplementation();
+
+      await cacheService.removeItem('');
+
+      expect(mockMMKV.delete).toHaveBeenCalledWith('');
+    });
+
+    it('should handle special characters in key', async () => {
+      const specialKey = 'special-key_äöü-ñ中文🎉';
+      mockMMKV.delete.mockImplementation();
+
+      await cacheService.removeItem(specialKey);
+
+      expect(mockMMKV.delete).toHaveBeenCalledWith(specialKey);
+    });
+  });
+
+  describe('clearAll', () => {
+    it('should clear all items successfully', async () => {
+      mockMMKV.clearAll.mockReturnValue(undefined);
+
+      await cacheService.clearAll();
+
+      expect(mockMMKV.clearAll).toHaveBeenCalled();
+    });
+
+    it('should handle MMKV clearAll errors gracefully', async () => {
+      const error = new Error('MMKV clearAll error');
+      mockMMKV.clearAll.mockImplementation(() => {
+        throw error;
+      });
+
+      await cacheService.clearAll();
+
+      expect(mockedLogError).toHaveBeenCalledWith(
+        '[CacheService] Error clearing all items',
+        expect.objectContaining({
+          feature: 'cache',
+          error,
+        }),
+      );
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should handle set and get operations together', async () => {
+      mockMMKV.set.mockImplementation();
+      mockMMKV.getString.mockReturnValue('"test-value"');
+
+      await cacheService.setItem('integration-key', 'test-value');
+      const result = await cacheService.getItem<string>('integration-key');
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        'integration-key',
+        '"test-value"',
+      );
+      expect(mockMMKV.getString).toHaveBeenCalledWith('integration-key');
+      expect(result).toBe('test-value');
+    });
+
+    it('should handle set, get, and remove operations together', async () => {
+      mockMMKV.set.mockImplementation();
+      mockMMKV.getString.mockReturnValue('"test-value"');
+      mockMMKV.delete.mockImplementation();
+
+      await cacheService.setItem('lifecycle-key', 'test-value');
+      const getValue = await cacheService.getItem<string>('lifecycle-key');
+      await cacheService.removeItem('lifecycle-key');
+
+      expect(getValue).toBe('test-value');
+      expect(mockMMKV.delete).toHaveBeenCalledWith('lifecycle-key');
+    });
+
+    it('should handle multiple data types in sequence', async () => {
+      const testCases = [
+        { key: 'string-key', value: 'test string' },
+        { key: 'number-key', value: 42 },
+        { key: 'boolean-key', value: true },
+        { key: 'object-key', value: { test: 'object' } },
+        { key: 'array-key', value: [1, 2, 3] },
+        { key: 'null-key', value: null },
+      ];
+
+      mockMMKV.set.mockImplementation();
+
+      for (const testCase of testCases) {
+        await cacheService.setItem(testCase.key, testCase.value);
+        expect(mockMMKV.set).toHaveBeenCalledWith(
+          testCase.key,
+          JSON.stringify(testCase.value),
+        );
+      }
+    });
+  });
+
+  describe('Edge Cases and Performance', () => {
+    it('should handle rapid successive operations', async () => {
+      mockMMKV.set.mockImplementation();
+      mockMMKV.getString.mockReturnValue('"rapid-value"');
+
+      const operations = Array.from({ length: 100 }, (_, i) =>
+        cacheService.setItem(`key-${i}`, `value-${i}`),
+      );
+
+      await Promise.all(operations);
+
+      expect(mockMMKV.set).toHaveBeenCalledTimes(100);
+    });
+
+    it('should handle deeply nested objects', async () => {
+      const createDeepObject = (depth: number): any => {
+        if (depth === 0) return 'deep value';
+        return { nested: createDeepObject(depth - 1) };
+      };
+
+      const deepObject = createDeepObject(50);
+      mockMMKV.set.mockImplementation();
+
+      await cacheService.setItem('deep-key', deepObject);
+
+      expect(mockMMKV.set).toHaveBeenCalledWith(
+        'deep-key',
+        JSON.stringify(deepObject),
+      );
+    });
+
+    it('should handle date objects', async () => {
+      const testDate = new Date('2023-12-25T10:30:00.000Z');
+      mockMMKV.set.mockImplementation();
+      mockMMKV.getString.mockReturnValue(JSON.stringify(testDate));
+
+      await cacheService.setItem('date-key', testDate);
+      const result = await cacheService.getItem<string>('date-key');
+
+      // Dates get converted to ISO strings in JSON
+      expect(result).toBe(testDate.toISOString());
+    });
+
+    it('should handle regular expressions', async () => {
+      const regex = /test\d+/gi;
+      mockMMKV.set.mockImplementation();
+      mockMMKV.getString.mockReturnValue(JSON.stringify(regex));
+
+      await cacheService.setItem('regex-key', regex);
+      const result = await cacheService.getItem<object>('regex-key');
+
+      // Regular expressions get converted to empty objects in JSON
+      expect(result).toEqual({});
+    });
+  });
+});

package/2/apps/native/src/core/cache/cache-service.ts

@@ -0,0 +1,89 @@
+import type { MMKV } from 'react-native-mmkv';
+
+import { error } from '@/core/logging';
+
+type CacheServiceOptions = {
+  mmkvInstance: MMKV;
+};
+
+export class CacheService {
+  private mmkvInstance: MMKV;
+
+  constructor({ mmkvInstance }: CacheServiceOptions) {
+    this.mmkvInstance = mmkvInstance;
+  }
+
+  /**
+   * Sets an item in the cache.
+   * @param key The key to set.
+   * @param value The value to set.
+   * @returns A promise that resolves when the item is set.
+   */
+  async setItem<T>(key: string, value: T): Promise<void> {
+    try {
+      const stringValue = JSON.stringify(value);
+      this.mmkvInstance.set(key, stringValue);
+    } catch (err) {
+      error(`[CacheService] Error setting item ${key}`, {
+        feature: 'cache',
+        key,
+        error: err,
+      });
+      // Depending on the desired behavior, we might want to re-throw or handle differently
+    }
+  }
+
+  /**
+   * Gets an item from the cache.
+   * @param key The key to get.
+   * @returns A promise that resolves with the item, or null if not found or an error occurs.
+   */
+  async getItem<T>(key: string): Promise<T | null> {
+    try {
+      const stringValue = this.mmkvInstance.getString(key);
+      if (stringValue === undefined || stringValue === null) {
+        return null;
+      }
+      return JSON.parse(stringValue) as T;
+    } catch (err) {
+      error(`[CacheService] Error getting item ${key}`, {
+        feature: 'cache',
+        key,
+        error: err,
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Removes an item from the cache.
+   * @param key The key to remove.
+   * @returns A promise that resolves when the item is removed.
+   */
+  async removeItem(key: string): Promise<void> {
+    try {
+      this.mmkvInstance.delete(key);
+    } catch (err) {
+      error(`[CacheService] Error removing item ${key}`, {
+        feature: 'cache',
+        key,
+        error: err,
+      });
+    }
+  }
+
+  /**
+   * Clears all items from the cache.
+   * @returns A promise that resolves when the cache is cleared.
+   */
+  async clearAll(): Promise<void> {
+    try {
+      this.mmkvInstance.clearAll();
+    } catch (err) {
+      error('[CacheService] Error clearing all items', {
+        feature: 'cache',
+        error: err,
+      });
+    }
+  }
+}