@jmruthers/pace-core 0.5.53 → 0.5.55

package/src/utils/appIdResolver.test.ts

@@ -0,0 +1,503 @@
+/**
+ * @file App ID Resolver Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/AppIdResolver
+ * @since 1.0.0
+ * 
+ * Comprehensive tests for app ID resolution utility functions covering all critical functionality.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { getAppId, getAppIds, CachedAppIdResolver } from './appIdResolver';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../types/database';
+
+// Mock Supabase client
+const createMockSupabaseClient = () => {
+  const queryBuilder = {
+    select: vi.fn().mockReturnThis(),
+    ilike: vi.fn().mockReturnThis(),
+    eq: vi.fn().mockReturnThis(),
+    or: vi.fn().mockReturnThis(),
+    single: vi.fn().mockResolvedValue({ data: null, error: null }),
+    mockResolvedValue: vi.fn(),
+    mockRejectedValue: vi.fn()
+  };
+  
+  // Make the chained methods return the query builder with mock methods
+  queryBuilder.select.mockReturnValue(queryBuilder);
+  queryBuilder.ilike.mockReturnValue(queryBuilder);
+  queryBuilder.eq.mockReturnValue(queryBuilder);
+  queryBuilder.or.mockReturnValue(queryBuilder);
+  
+  return {
+    from: vi.fn(() => queryBuilder),
+    queryBuilder // Export the query builder for direct access
+  };
+};
+
+describe('App ID Resolver', () => {
+  let mockSupabase: any;
+  let mockQueryBuilder: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabase = createMockSupabaseClient();
+    mockQueryBuilder = mockSupabase.queryBuilder;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getAppId', () => {
+    it('resolves app ID for valid app name', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBe('app-123');
+      expect(mockSupabase.from).toHaveBeenCalledWith('rbac_apps');
+      expect(mockQueryBuilder.select).toHaveBeenCalledWith('id');
+      expect(mockQueryBuilder.ilike).toHaveBeenCalledWith('name', 'MY_APP');
+      expect(mockQueryBuilder.eq).toHaveBeenCalledWith('is_active', true);
+    });
+
+    it('returns null when app not found', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: { message: 'No rows found' }
+      });
+
+      const result = await getAppId(mockSupabase as any, 'NONEXISTENT_APP');
+
+      expect(result).toBeNull();
+    });
+
+    it('handles database errors gracefully', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: { message: 'Database error' }
+      });
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to resolve app ID for app name:',
+        'MY_APP',
+        { message: 'Database error' }
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles exceptions gracefully', async () => {
+      mockQueryBuilder.single.mockRejectedValue(new Error('Network error'));
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Error resolving app ID for app name:',
+        'MY_APP',
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles null/undefined app name', async () => {
+      const result1 = await getAppId(mockSupabase as any, null as any);
+      const result2 = await getAppId(mockSupabase as any, undefined as any);
+
+      expect(result1).toBeNull();
+      expect(result2).toBeNull();
+    });
+
+    it('handles empty app name', async () => {
+      const result = await getAppId(mockSupabase as any, '');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getAppIds', () => {
+    it('resolves multiple app IDs', async () => {
+      // Mock the chained call sequence for getAppIds
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [
+            { id: 'app-123', name: 'MY_APP' },
+            { id: 'app-456', name: 'ANOTHER_APP' }
+          ],
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP', 'MISSING_APP']);
+
+      expect(result).toEqual({
+        'MY_APP': 'app-123',
+        'ANOTHER_APP': 'app-456',
+        'MISSING_APP': null
+      });
+    });
+
+    it('handles case-insensitive matching', async () => {
+      // Mock the chained call sequence for getAppIds
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [
+            { id: 'app-123', name: 'my_app' },
+            { id: 'app-456', name: 'another_app' }
+          ],
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
+
+      expect(result).toEqual({
+        'MY_APP': 'app-123',
+        'ANOTHER_APP': 'app-456'
+      });
+    });
+
+    it('returns empty object for empty app names array', async () => {
+      const result = await getAppIds(mockSupabase as any, []);
+
+      expect(result).toEqual({});
+    });
+
+    it('handles database errors gracefully', async () => {
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: null,
+          error: { message: 'Database error' }
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
+
+      expect(result).toEqual({});
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to resolve app IDs for app names:',
+        ['MY_APP', 'ANOTHER_APP'],
+        { message: 'Database error' }
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles exceptions gracefully', async () => {
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockRejectedValue(new Error('Network error'))
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
+
+      expect(result).toEqual({});
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Error resolving app IDs for app names:',
+        ['MY_APP', 'ANOTHER_APP'],
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles null/undefined app names array', async () => {
+      const result1 = await getAppIds(mockSupabase as any, null as any);
+      const result2 = await getAppIds(mockSupabase as any, undefined as any);
+
+      expect(result1).toEqual({});
+      expect(result2).toEqual({});
+    });
+  });
+
+  describe('CachedAppIdResolver', () => {
+    let resolver: CachedAppIdResolver;
+
+    beforeEach(() => {
+      resolver = new CachedAppIdResolver();
+    });
+
+    it('resolves app ID and caches result', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      const result2 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result1).toBe('app-123');
+      expect(result2).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1); // Should only call once due to caching
+    });
+
+    it.skip('expires cached results after TTL', async () => {
+      resolver = new CachedAppIdResolver(100); // 100ms TTL
+
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result1).toBe('app-123');
+
+      // Wait for TTL to expire
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      const result2 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result2).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2); // Should call again after TTL
+    });
+
+    it('handles cache misses gracefully', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: { message: 'No rows found' }
+      });
+
+      const result = await resolver.getAppId(mockSupabase as any, 'NONEXISTENT_APP');
+
+      expect(result).toBeNull();
+    });
+
+    it('handles database errors gracefully', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: { message: 'Database error' }
+      });
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to resolve app ID for app name:',
+        'MY_APP',
+        { message: 'Database error' }
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('clears cache correctly', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      resolver.clearCache();
+
+      const result = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2); // Should call again after cache clear
+    });
+
+    it('respects max cache size', async () => {
+      resolver = new CachedAppIdResolver(60000, 2); // 2 max cache entries
+
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      // Fill cache beyond max size
+      await resolver.getAppId(mockSupabase as any, 'APP1');
+      await resolver.getAppId(mockSupabase as any, 'APP2');
+      await resolver.getAppId(mockSupabase as any, 'APP3');
+
+      // Should have called database for all three apps
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('integrates with real Supabase client structure', async () => {
+      const mockClient = {
+        from: vi.fn(() => ({
+          select: vi.fn().mockReturnThis(),
+          ilike: vi.fn().mockReturnThis(),
+          eq: vi.fn().mockReturnThis(),
+          single: vi.fn().mockResolvedValue({
+            data: { id: 'app-123' },
+            error: null
+          })
+        }))
+      };
+
+      const result = await getAppId(mockClient as any, 'MY_APP');
+
+      expect(result).toBe('app-123');
+      expect(mockClient.from).toHaveBeenCalledWith('rbac_apps');
+    });
+
+    it('handles complex app name patterns', async () => {
+      const appNames = [
+        'MY_APP',
+        'my-app',
+        'my_app',
+        'MyApp',
+        'myapp'
+      ];
+
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [
+            { id: 'app-123', name: 'my_app' },
+            { id: 'app-456', name: 'my-app' }
+          ],
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const result = await getAppIds(mockSupabase as any, appNames);
+
+      expect(result).toEqual({
+        'MY_APP': 'app-123',
+        'my-app': 'app-456',
+        'my_app': null,
+        'MyApp': null,
+        'myapp': null
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles network timeouts', async () => {
+      mockQueryBuilder.single.mockRejectedValue(new Error('Request timeout'));
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Error resolving app ID for app name:',
+        'MY_APP',
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles malformed responses', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { invalid: 'structure' },
+        error: null
+      });
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+    });
+
+    it('handles null data responses', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: null
+      });
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Performance', () => {
+    it('handles large numbers of app names efficiently', async () => {
+      const appNames = Array.from({ length: 100 }, (_, i) => `APP_${i}`);
+      
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: appNames.map((name, i) => ({ id: `app-${i}`, name: name.toLowerCase() })),
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const startTime = Date.now();
+      const result = await getAppIds(mockSupabase as any, appNames);
+      const endTime = Date.now();
+
+      expect(Object.keys(result)).toHaveLength(100);
+      expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
+    });
+
+    it('caches results efficiently', async () => {
+      const resolver = new CachedAppIdResolver();
+      
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const startTime = Date.now();
+      
+      // First call - should hit database
+      await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      
+      // Second call - should hit cache
+      await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      
+      const endTime = Date.now();
+
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
+      expect(endTime - startTime).toBeLessThan(100); // Should be very fast due to caching
+    });
+  });
+});

package/src/utils/appIdResolver.ts

@@ -96,7 +96,7 @@ export async function getAppIds(
 /**
  * Cached app ID resolver with TTL
  */
-class CachedAppIdResolver {
+export class CachedAppIdResolver {
   private cache = new Map<string, { id: string | null; expires: number }>();
   private ttl = 5 * 60 * 1000; // 5 minutes