@jmruthers/pace-core 0.5.135 → 0.5.137

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

@@ -0,0 +1,497 @@
+/**
+ * @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 the Logger module
+vi.mock('../core/logger', () => {
+  const mockLoggerInstance = {
+    error: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+  };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../core/logger';
+const getMockLogger = () => createLogger('test');
+
+// 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;
+    const logger = getMockLogger();
+    vi.mocked(logger.error).mockClear();
+  });
+
+    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 result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Failed to resolve app ID for app name:',
+        'MY_APP',
+        { message: 'Database error' }
+      );
+    });
+
+    it('handles exceptions gracefully', async () => {
+      mockQueryBuilder.single.mockRejectedValue(new Error('Network error'));
+
+      const result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Error resolving app ID for app name:',
+        'MY_APP',
+        expect.any(Error)
+      );
+    });
+
+    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 result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
+
+      expect(result).toEqual({});
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Failed to resolve app IDs for app names:',
+        ['MY_APP', 'ANOTHER_APP'],
+        { message: 'Database error' }
+      );
+    });
+
+    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 result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
+
+      expect(result).toEqual({});
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Error resolving app IDs for app names:',
+        ['MY_APP', 'ANOTHER_APP'],
+        expect.any(Error)
+      );
+    });
+
+    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('expires cached results after TTL', async () => {
+      resolver = new CachedAppIdResolver();
+
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result1).toBe('app-123');
+
+      // Clear cache to simulate TTL expiration
+      resolver.clearCacheForApp('MY_APP');
+
+      const result2 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result2).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2); // Should call again after cache clear
+    });
+
+    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 result = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Failed to resolve app ID for app name:',
+        'MY_APP',
+        { message: 'Database error' }
+      );
+    });
+
+    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 result = await getAppId(mockSupabase as any, 'MY_APP');
+
+      expect(result).toBeNull();
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Error resolving app ID for app name:',
+        'MY_APP',
+        expect.any(Error)
+      );
+    });
+
+    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/app/appIdResolver.ts

@@ -0,0 +1,133 @@
+/**
+ * App ID Resolution Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/AppIdResolver
+ * @since 1.0.0
+ * 
+ * This module provides utilities to resolve app names to app IDs for database operations.
+ */
+
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+import { createLogger } from '../core/logger';
+
+const log = createLogger('AppIdResolver');
+
+/**
+ * Resolves an app name to its corresponding app ID
+ * 
+ * @param supabase - Supabase client instance
+ * @param appName - The app name to resolve
+ * @returns Promise resolving to the app ID or null if not found
+ */
+export async function getAppId(
+  supabase: SupabaseClient<Database>,
+  appName: string
+): Promise<string | null> {
+  try {
+    const { data, error } = await supabase
+      .from('rbac_apps')
+      .select('id')
+      .ilike('name', appName)
+      .eq('is_active', true)
+      .single();
+
+    if (error) {
+      log.error('Failed to resolve app ID for app name:', appName, error);
+      return null;
+    }
+
+    return (data as { id: string } | null)?.id || null;
+  } catch (error) {
+    log.error('Error resolving app ID for app name:', appName, error);
+    return null;
+  }
+}
+
+/**
+ * Resolves multiple app names to their corresponding app IDs
+ * 
+ * @param supabase - Supabase client instance
+ * @param appNames - Array of app names to resolve
+ * @returns Promise resolving to a map of app names to app IDs
+ */
+export async function getAppIds(
+  supabase: SupabaseClient<Database>,
+  appNames: string[]
+): Promise<Record<string, string | null>> {
+  try {
+    // For case-insensitive matching with multiple values, we need to use OR conditions
+    // since PostgreSQL doesn't support case-insensitive IN with ILIKE
+    const orConditions = appNames.map(name => `name.ilike.${name}`).join(',');
+    
+    const { data, error } = await supabase
+      .from('rbac_apps')
+      .select('id, name')
+      .or(orConditions)
+      .eq('is_active', true);
+
+    if (error) {
+      log.error('Failed to resolve app IDs for app names:', appNames, error);
+      return {};
+    }
+
+    const result: Record<string, string | null> = {};
+    
+    // Initialize all app names with null
+    appNames.forEach(name => {
+      result[name] = null;
+    });
+
+    // Set resolved app IDs - match case-insensitively
+    (data as { id: string; name: string }[] | null)?.forEach(app => {
+      // Find the original app name that matches (case-insensitive)
+      const originalName = appNames.find(name => 
+        name.toLowerCase() === app.name.toLowerCase()
+      );
+      if (originalName) {
+        result[originalName] = app.id;
+      }
+    });
+
+    return result;
+  } catch (error) {
+    log.error('Error resolving app IDs for app names:', appNames, error);
+    return {};
+  }
+}
+
+/**
+ * Cached app ID resolver with TTL
+ */
+export class CachedAppIdResolver {
+  private cache = new Map<string, { id: string | null; expires: number }>();
+  private ttl = 5 * 60 * 1000; // 5 minutes
+
+  async getAppId(
+    supabase: SupabaseClient<Database>,
+    appName: string
+  ): Promise<string | null> {
+    const now = Date.now();
+    const cached = this.cache.get(appName);
+
+    if (cached && cached.expires > now) {
+      return cached.id;
+    }
+
+    const id = await getAppId(supabase, appName);
+    this.cache.set(appName, { id, expires: now + this.ttl });
+
+    return id;
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  clearCacheForApp(appName: string): void {
+    this.cache.delete(appName);
+  }
+}
+
+// Export singleton instance
+export const cachedAppIdResolver = new CachedAppIdResolver();