vibefast-cli 0.7.0 → 0.7.1

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

@@ -1,599 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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,
-      });
-    }
-  }
-}