@jmruthers/pace-core 0.6.9 → 0.6.10

package/src/utils/__tests__/request-deduplication.test.ts

@@ -0,0 +1,349 @@
+/**
+ * @file Request Deduplication Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/__tests__
+ * @since 2.0.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  generateRequestKey,
+  getOrCreateRequest,
+  clearInFlightRequests,
+  getInFlightRequestStats,
+  deduplicatedQuery,
+} from '../request-deduplication';
+
+describe('Request Deduplication', () => {
+  beforeEach(() => {
+    clearInFlightRequests();
+    vi.clearAllMocks();
+  });
+
+  describe('generateRequestKey', () => {
+    it('generates key from method and table', () => {
+      const key = generateRequestKey('GET', 'users');
+      expect(key).toBe('GET:users::*');
+    });
+
+    it('generates key with filters', () => {
+      const key = generateRequestKey('GET', 'users', { user_id: '123' });
+      expect(key).toBe('GET:users:{"user_id":"123"}:*');
+    });
+
+    it('generates key with select columns', () => {
+      const key = generateRequestKey('GET', 'users', undefined, 'id, name');
+      expect(key).toBe('GET:users::id, name');
+    });
+
+    it('generates key with filters and select', () => {
+      const key = generateRequestKey('GET', 'users', { user_id: '123' }, 'id, name');
+      expect(key).toBe('GET:users:{"user_id":"123"}:id, name');
+    });
+
+    it('generates consistent keys for same parameters', () => {
+      const key1 = generateRequestKey('GET', 'users', { user_id: '123' }, 'id, name');
+      const key2 = generateRequestKey('GET', 'users', { user_id: '123' }, 'id, name');
+      expect(key1).toBe(key2);
+    });
+
+    it('generates different keys for different filters', () => {
+      const key1 = generateRequestKey('GET', 'users', { user_id: '123' });
+      const key2 = generateRequestKey('GET', 'users', { user_id: '456' });
+      expect(key1).not.toBe(key2);
+    });
+
+    it('generates different keys for different methods', () => {
+      const key1 = generateRequestKey('GET', 'users');
+      const key2 = generateRequestKey('POST', 'users');
+      expect(key1).not.toBe(key2);
+    });
+
+    it('handles complex filter objects', () => {
+      const filters = {
+        user_id: '123',
+        status: 'active',
+        tags: ['tag1', 'tag2'],
+      };
+      const key = generateRequestKey('GET', 'users', filters);
+      expect(key).toContain('GET:users:');
+      expect(key).toContain('user_id');
+      expect(key).toContain('status');
+    });
+
+    it('handles empty filters object', () => {
+      const key = generateRequestKey('GET', 'users', {});
+      expect(key).toBe('GET:users:{}:*');
+    });
+
+    it('uses default select when not provided', () => {
+      const key = generateRequestKey('GET', 'users');
+      expect(key).toContain(':*');
+    });
+  });
+
+  describe('getOrCreateRequest', () => {
+    it('creates new request when key does not exist', async () => {
+      const requestFn = vi.fn().mockResolvedValue('result');
+      const result = await getOrCreateRequest('test-key', requestFn);
+
+      expect(result).toBe('result');
+      expect(requestFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('reuses existing request when key exists', async () => {
+      const requestFn = vi.fn().mockResolvedValue('result');
+      
+      const promise1 = getOrCreateRequest('test-key', requestFn);
+      const promise2 = getOrCreateRequest('test-key', requestFn);
+
+      const [result1, result2] = await Promise.all([promise1, promise2]);
+
+      expect(result1).toBe('result');
+      expect(result2).toBe('result');
+      expect(requestFn).toHaveBeenCalledTimes(1); // Only called once due to deduplication
+    });
+
+    it('removes request from cache after successful completion', async () => {
+      const requestFn = vi.fn().mockResolvedValue('result');
+      
+      await getOrCreateRequest('test-key', requestFn);
+      
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+      expect(stats.keys).not.toContain('test-key');
+    });
+
+    it('removes request from cache after error', async () => {
+      const requestFn = vi.fn().mockRejectedValue(new Error('Request failed'));
+      
+      await expect(getOrCreateRequest('test-key', requestFn)).rejects.toThrow('Request failed');
+      
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+      expect(stats.keys).not.toContain('test-key');
+    });
+
+    it('propagates errors correctly', async () => {
+      const error = new Error('Request failed');
+      const requestFn = vi.fn().mockRejectedValue(error);
+      
+      await expect(getOrCreateRequest('test-key', requestFn)).rejects.toThrow('Request failed');
+    });
+
+    it('handles concurrent requests with same key', async () => {
+      let callCount = 0;
+      const requestFn = vi.fn().mockImplementation(async () => {
+        callCount++;
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return `result-${callCount}`;
+      });
+
+      const promises = [
+        getOrCreateRequest('test-key', requestFn),
+        getOrCreateRequest('test-key', requestFn),
+        getOrCreateRequest('test-key', requestFn),
+      ];
+
+      const results = await Promise.all(promises);
+
+      // All should get the same result (first one)
+      expect(results[0]).toBe('result-1');
+      expect(results[1]).toBe('result-1');
+      expect(results[2]).toBe('result-1');
+      expect(requestFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles different keys independently', async () => {
+      const requestFn1 = vi.fn().mockResolvedValue('result1');
+      const requestFn2 = vi.fn().mockResolvedValue('result2');
+
+      const [result1, result2] = await Promise.all([
+        getOrCreateRequest('key1', requestFn1),
+        getOrCreateRequest('key2', requestFn2),
+      ]);
+
+      expect(result1).toBe('result1');
+      expect(result2).toBe('result2');
+      expect(requestFn1).toHaveBeenCalledTimes(1);
+      expect(requestFn2).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles async request functions', async () => {
+      const requestFn = vi.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 50));
+        return 'async-result';
+      });
+
+      const result = await getOrCreateRequest('test-key', requestFn);
+      expect(result).toBe('async-result');
+    });
+  });
+
+  describe('clearInFlightRequests', () => {
+    it('clears all in-flight requests', async () => {
+      const requestFn = vi.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return 'result';
+      });
+
+      // Start a request but don't wait for it
+      getOrCreateRequest('test-key', requestFn);
+
+      // Verify request is in-flight
+      let stats = getInFlightRequestStats();
+      expect(stats.count).toBe(1);
+
+      // Clear all requests
+      clearInFlightRequests();
+
+      // Verify cache is empty
+      stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+      expect(stats.keys).toEqual([]);
+    });
+
+    it('can be called multiple times safely', () => {
+      clearInFlightRequests();
+      clearInFlightRequests();
+      clearInFlightRequests();
+
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+    });
+
+    it('clears requests even when they are in progress', async () => {
+      const requestFn = vi.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return 'result';
+      });
+
+      getOrCreateRequest('test-key', requestFn);
+
+      clearInFlightRequests();
+
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+    });
+  });
+
+  describe('getInFlightRequestStats', () => {
+    it('returns empty stats when no requests in flight', () => {
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+      expect(stats.keys).toEqual([]);
+    });
+
+    it('returns correct count for in-flight requests', async () => {
+      const requestFn = vi.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return 'result';
+      });
+
+      getOrCreateRequest('key1', requestFn);
+      getOrCreateRequest('key2', requestFn);
+
+      const stats = getInFlightRequestStats();
+      expect(stats.count).toBe(2);
+      expect(stats.keys).toContain('key1');
+      expect(stats.keys).toContain('key2');
+    });
+
+    it('returns all request keys', async () => {
+      const requestFn = vi.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return 'result';
+      });
+
+      getOrCreateRequest('key1', requestFn);
+      getOrCreateRequest('key2', requestFn);
+      getOrCreateRequest('key3', requestFn);
+
+      const stats = getInFlightRequestStats();
+      expect(stats.keys).toHaveLength(3);
+      expect(stats.keys.sort()).toEqual(['key1', 'key2', 'key3'].sort());
+    });
+
+    it('updates stats as requests complete', async () => {
+      const requestFn = vi.fn().mockResolvedValue('result');
+
+      getOrCreateRequest('key1', requestFn);
+      getOrCreateRequest('key2', requestFn);
+
+      let stats = getInFlightRequestStats();
+      expect(stats.count).toBe(2);
+
+      await Promise.all([
+        getOrCreateRequest('key1', requestFn),
+        getOrCreateRequest('key2', requestFn),
+      ]);
+
+      stats = getInFlightRequestStats();
+      expect(stats.count).toBe(0);
+    });
+  });
+
+  describe('deduplicatedQuery', () => {
+    it('generates key and calls getOrCreateRequest', async () => {
+      const mockSupabase = {} as any;
+      const filters = { user_id: '123' };
+      const select = 'id, name';
+      const requestFn = vi.fn().mockResolvedValue('result');
+
+      const result = await deduplicatedQuery(mockSupabase, 'users', filters, select, requestFn);
+
+      expect(result).toBe('result');
+      expect(requestFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('uses correct key format for deduplication', async () => {
+      const mockSupabase = {} as any;
+      const filters = { user_id: '123' };
+      const select = 'id, name';
+      const requestFn = vi.fn().mockResolvedValue('result');
+
+      // Call twice with same parameters
+      const promise1 = deduplicatedQuery(mockSupabase, 'users', filters, select, requestFn);
+      const promise2 = deduplicatedQuery(mockSupabase, 'users', filters, select, requestFn);
+
+      await Promise.all([promise1, promise2]);
+
+      // Should only call requestFn once due to deduplication
+      expect(requestFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles different filters as separate requests', async () => {
+      const mockSupabase = {} as any;
+      const requestFn = vi.fn().mockResolvedValue('result');
+
+      await Promise.all([
+        deduplicatedQuery(mockSupabase, 'users', { user_id: '123' }, '*', requestFn),
+        deduplicatedQuery(mockSupabase, 'users', { user_id: '456' }, '*', requestFn),
+      ]);
+
+      expect(requestFn).toHaveBeenCalledTimes(2);
+    });
+
+    it('handles different tables as separate requests', async () => {
+      const mockSupabase = {} as any;
+      const requestFn = vi.fn().mockResolvedValue('result');
+
+      await Promise.all([
+        deduplicatedQuery(mockSupabase, 'users', {}, '*', requestFn),
+        deduplicatedQuery(mockSupabase, 'events', {}, '*', requestFn),
+      ]);
+
+      expect(requestFn).toHaveBeenCalledTimes(2);
+    });
+
+    it('propagates errors from request function', async () => {
+      const mockSupabase = {} as any;
+      const error = new Error('Query failed');
+      const requestFn = vi.fn().mockRejectedValue(error);
+
+      await expect(
+        deduplicatedQuery(mockSupabase, 'users', {}, '*', requestFn)
+      ).rejects.toThrow('Query failed');
+    });
+  });
+});

package/src/utils/__tests__/secureDataAccess.unit.test.ts

@@ -7,7 +7,6 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createSecureDataAccess } from '../security/secureDataAccess';
-import type { SupabaseClient } from '@supabase/supabase-js';
 import { testDataGenerators } from '../../__tests__/helpers/test-utils';
 
 // Create a proper mock for Supabase query chain

package/src/utils/__tests__/timezone.test.ts

@@ -18,7 +18,7 @@ import {
   fromZonedTime,
   roundToNearestMinutes,
   getTimeZoneDifference
-} from '../timezone';
+} from '../timezone/timezone';
 
 describe('Timezone Utilities', () => {
   describe('formatInTimeZone', () => {

package/src/utils/__tests__/validation.unit.test.ts

@@ -10,7 +10,7 @@ import {
   matchesPattern,
   deepMerge,
   isObject
-} from '../validation';
+} from '../validation/validation';
 
 describe('validation utilities', () => {
   describe('isValidEmail', () => {
@@ -137,7 +137,6 @@ describe('validation utilities', () => {
     it('invalidates dates with invalid day', () => {
       // Note: JavaScript Date is permissive, but some invalid dates will be detected
       // Dates like '2023-01-32' may roll over to next month, so we check actual behavior
-      const invalidDay = new Date('2023-01-32');
       // If the date rolls over, it's technically valid from Date's perspective
       // So we test with truly invalid formats instead
       expect(isValidDate('not-a-date-format')).toBe(false);

package/src/utils/__tests__/validationUtils.unit.test.ts

@@ -13,7 +13,7 @@ import {
 // Mock sanitization functions
 vi.mock('../validation/sanitization', () => ({
   sanitizeUserInput: vi.fn((input: string) => `sanitized_${input}`),
-  sanitizeFormData: vi.fn((data: unknown, schema: z.ZodSchema, rules?: Record<string, any>) => {
+  sanitizeFormData: vi.fn((data: unknown, schema: z.ZodSchema, _rules?: Record<string, any>) => {
     // Try to parse with the schema to determine success
     try {
       const result = schema.parse(data);

package/src/utils/app/appConfig.test.ts

@@ -0,0 +1,235 @@
+/**
+ * @file App Config Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/AppConfig
+ * @since 0.1.0
+ *
+ * Comprehensive tests for app configuration utility functions covering:
+ * - Configuration setting and retrieval
+ * - Fallback behavior
+ * - Default values
+ * - Edge cases
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  setAppConfig,
+  getAppConfig,
+  getCurrentAppName,
+  getCurrentAppId
+} from './appConfig';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+describe('App Config', () => {
+  beforeEach(() => {
+    // Clear app config before each test
+    // We need to access the internal state to reset it
+    // Since the module uses a closure, we'll set a new config to clear it
+    setAppConfig({ appName: 'PACE', appId: 'PACE' });
+    // Then clear it by setting to a known state
+    vi.clearAllMocks();
+  });
+
+  describe('setAppConfig', () => {
+    it('sets the app configuration', () => {
+      const config = { appName: 'TEST_APP', appId: 'test-app-id' };
+      setAppConfig(config);
+
+      const result = getAppConfig();
+      expect(result).toEqual(config);
+    }, TEST_TIMEOUT);
+
+    it('overwrites previous configuration', () => {
+      setAppConfig({ appName: 'APP1', appId: 'app1-id' });
+      setAppConfig({ appName: 'APP2', appId: 'app2-id' });
+
+      const result = getAppConfig();
+      expect(result).toEqual({ appName: 'APP2', appId: 'app2-id' });
+    }, TEST_TIMEOUT);
+
+    it('handles configuration with same appName and appId', () => {
+      const config = { appName: 'SAME', appId: 'SAME' };
+      setAppConfig(config);
+
+      const result = getAppConfig();
+      expect(result).toEqual(config);
+    }, TEST_TIMEOUT);
+
+    it('handles configuration with different appName and appId', () => {
+      const config = { appName: 'MyApp', appId: 'my-app-id-123' };
+      setAppConfig(config);
+
+      const result = getAppConfig();
+      expect(result).toEqual(config);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('getAppConfig', () => {
+    it('returns the current app configuration when set', () => {
+      const config = { appName: 'TEST_APP', appId: 'test-app-id' };
+      setAppConfig(config);
+
+      const result = getAppConfig();
+      expect(result).toEqual(config);
+    }, TEST_TIMEOUT);
+
+    it('returns fallback configuration when not set', () => {
+      // Clear config by setting a known state, then test fallback
+      // The fallback uses import.meta.env.REACT_APP_NAME or 'PACE'
+      const result = getAppConfig();
+      
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty('appName');
+      expect(result).toHaveProperty('appId');
+      expect(typeof result.appName).toBe('string');
+      expect(typeof result.appId).toBe('string');
+    }, TEST_TIMEOUT);
+
+    it('uses REACT_APP_NAME from environment when available', () => {
+      // Note: import.meta.env is read-only in Vite, so we can't easily test this
+      // But we can verify the structure is correct
+      const result = getAppConfig();
+      
+      expect(result.appName).toBeTruthy();
+      expect(result.appId).toBeTruthy();
+    }, TEST_TIMEOUT);
+
+    it('uses PACE as default when REACT_APP_NAME is not available', () => {
+      // The function falls back to 'PACE' if REACT_APP_NAME is not set
+      // Since we can't easily control import.meta.env, we verify the structure
+      const result = getAppConfig();
+      
+      // Should have appName and appId
+      expect(result.appName).toBeDefined();
+      expect(result.appId).toBeDefined();
+      // appId should match appName in fallback case
+      expect(result.appId).toBe(result.appName);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('getCurrentAppName', () => {
+    it('returns the app name from configuration', () => {
+      setAppConfig({ appName: 'MY_APP', appId: 'my-app-id' });
+
+      const result = getCurrentAppName();
+      expect(result).toBe('MY_APP');
+    }, TEST_TIMEOUT);
+
+    it('returns fallback app name when configuration is not set', () => {
+      // Clear config and test fallback
+      const result = getCurrentAppName();
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    }, TEST_TIMEOUT);
+
+    it('returns updated app name after configuration change', () => {
+      setAppConfig({ appName: 'APP1', appId: 'app1-id' });
+      expect(getCurrentAppName()).toBe('APP1');
+
+      setAppConfig({ appName: 'APP2', appId: 'app2-id' });
+      expect(getCurrentAppName()).toBe('APP2');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('getCurrentAppId', () => {
+    it('returns the app ID from configuration', () => {
+      setAppConfig({ appName: 'MY_APP', appId: 'my-app-id' });
+
+      const result = getCurrentAppId();
+      expect(result).toBe('my-app-id');
+    }, TEST_TIMEOUT);
+
+    it('returns fallback app ID when configuration is not set', () => {
+      // Clear config and test fallback
+      const result = getCurrentAppId();
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    }, TEST_TIMEOUT);
+
+    it('returns updated app ID after configuration change', () => {
+      setAppConfig({ appName: 'APP1', appId: 'app1-id' });
+      expect(getCurrentAppId()).toBe('app1-id');
+
+      setAppConfig({ appName: 'APP2', appId: 'app2-id' });
+      expect(getCurrentAppId()).toBe('app2-id');
+    }, TEST_TIMEOUT);
+
+    it('can have different appName and appId', () => {
+      setAppConfig({ appName: 'MyApp', appId: 'different-id' });
+
+      expect(getCurrentAppName()).toBe('MyApp');
+      expect(getCurrentAppId()).toBe('different-id');
+      expect(getCurrentAppName()).not.toBe(getCurrentAppId());
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Integration', () => {
+    it('maintains consistent state across multiple calls', () => {
+      const config = { appName: 'CONSISTENT', appId: 'consistent-id' };
+      setAppConfig(config);
+
+      expect(getAppConfig()).toEqual(config);
+      expect(getCurrentAppName()).toBe('CONSISTENT');
+      expect(getCurrentAppId()).toBe('consistent-id');
+      
+      // Multiple calls should return same values
+      expect(getAppConfig()).toEqual(config);
+      expect(getCurrentAppName()).toBe('CONSISTENT');
+      expect(getCurrentAppId()).toBe('consistent-id');
+    }, TEST_TIMEOUT);
+
+    it('handles rapid configuration changes', () => {
+      const configs = [
+        { appName: 'APP1', appId: 'app1' },
+        { appName: 'APP2', appId: 'app2' },
+        { appName: 'APP3', appId: 'app3' }
+      ];
+
+      configs.forEach((config, _index) => {
+        setAppConfig(config);
+        expect(getCurrentAppName()).toBe(config.appName);
+        expect(getCurrentAppId()).toBe(config.appId);
+      });
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Edge Cases', () => {
+    it('handles empty string app name', () => {
+      setAppConfig({ appName: '', appId: 'id' });
+      
+      expect(getCurrentAppName()).toBe('');
+      expect(getCurrentAppId()).toBe('id');
+    }, TEST_TIMEOUT);
+
+    it('handles empty string app ID', () => {
+      setAppConfig({ appName: 'APP', appId: '' });
+      
+      expect(getCurrentAppName()).toBe('APP');
+      expect(getCurrentAppId()).toBe('');
+    }, TEST_TIMEOUT);
+
+    it('handles very long app names and IDs', () => {
+      const longName = 'A'.repeat(1000);
+      const longId = 'B'.repeat(1000);
+      
+      setAppConfig({ appName: longName, appId: longId });
+      
+      expect(getCurrentAppName()).toBe(longName);
+      expect(getCurrentAppId()).toBe(longId);
+    }, TEST_TIMEOUT);
+
+    it('handles special characters in app name and ID', () => {
+      const config = { appName: 'APP-123_test@domain', appId: 'app-123_test@domain' };
+      setAppConfig(config);
+      
+      expect(getCurrentAppName()).toBe('APP-123_test@domain');
+      expect(getCurrentAppId()).toBe('app-123_test@domain');
+    }, TEST_TIMEOUT);
+  });
+});