@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -4,13 +4,18 @@
  * @module Utils/AppIdResolver
  * @since 1.0.0
  * 
- * Comprehensive tests for app ID resolution utility functions covering all critical functionality.
+ * Comprehensive tests for app ID resolution utility functions covering:
+ * - Single and multiple app ID resolution
+ * - Caching behavior and TTL
+ * - Error handling and edge cases
+ * - Performance and integration scenarios
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
 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', () => {
@@ -71,14 +76,15 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBe('app-123');
+      expect(result.ok).toBe(true);
+      expect(result.data).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);
-    });
+    }, TEST_TIMEOUT);
 
-    it('returns null when app not found', async () => {
+    it('returns err when app not found', async () => {
       mockQueryBuilder.single.mockResolvedValue({
         data: null,
         error: { message: 'No rows found' }
@@ -86,8 +92,9 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'NONEXISTENT_APP');
 
-      expect(result).toBeNull();
-    });
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('No rows found');
+    }, TEST_TIMEOUT);
 
     it('handles database errors gracefully', async () => {
       mockQueryBuilder.single.mockResolvedValue({
@@ -97,7 +104,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Database error');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Failed to resolve app ID for app name:',
@@ -111,7 +119,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Network error');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Error resolving app ID for app name:',
@@ -124,18 +133,41 @@ describe('App ID Resolver', () => {
       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();
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBeNull();
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBeNull();
     });
 
     it('handles empty app name', async () => {
       const result = await getAppId(mockSupabase as any, '');
 
-      expect(result).toBeNull();
-    });
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
+    }, TEST_TIMEOUT);
   });
 
   describe('getAppIds', () => {
+    it('handles single app name array', async () => {
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [{ id: 'app-123', name: 'MY_APP' }],
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP']);
+
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({ 'MY_APP': 'app-123' });
+    }, TEST_TIMEOUT);
+
     it('resolves multiple app IDs', async () => {
       // Mock the chained call sequence for getAppIds
       const mockChain = {
@@ -156,7 +188,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP', 'MISSING_APP']);
 
-      expect(result).toEqual({
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({
         'MY_APP': 'app-123',
         'ANOTHER_APP': 'app-456',
         'MISSING_APP': null
@@ -183,16 +216,18 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
 
-      expect(result).toEqual({
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({
         'MY_APP': 'app-123',
         'ANOTHER_APP': 'app-456'
       });
     });
 
-    it('returns empty object for empty app names array', async () => {
+    it('returns ok with empty object for empty app names array', async () => {
       const result = await getAppIds(mockSupabase as any, []);
 
-      expect(result).toEqual({});
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({});
     });
 
     it('handles database errors gracefully', async () => {
@@ -211,7 +246,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
 
-      expect(result).toEqual({});
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Database error');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Failed to resolve app IDs for app names:',
@@ -233,7 +269,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'ANOTHER_APP']);
 
-      expect(result).toEqual({});
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Network error');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Error resolving app IDs for app names:',
@@ -246,9 +283,56 @@ describe('App ID Resolver', () => {
       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({});
-    });
+      expect(result1.ok).toBe(false);
+      expect(result2.ok).toBe(false);
+    }, TEST_TIMEOUT);
+
+    it('handles duplicate app names in array', async () => {
+      const mockChain = {
+        select: vi.fn().mockReturnThis(),
+        or: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [{ id: 'app-123', name: 'MY_APP' }],
+          error: null
+        })
+      };
+      
+      mockQueryBuilder.select.mockReturnValue(mockChain);
+      mockQueryBuilder.or.mockReturnValue(mockChain);
+      mockQueryBuilder.eq.mockReturnValue(mockChain);
+
+      const result = await getAppIds(mockSupabase as any, ['MY_APP', 'MY_APP', 'MY_APP']);
+
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({
+        'MY_APP': 'app-123'
+      });
+      expect(result.data!['MY_APP']).toBe('app-123');
+    }, TEST_TIMEOUT);
+
+    it('handles app names with different cases correctly', async () => {
+      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.ok).toBe(true);
+      expect(result.data!['MY_APP']).toBe('app-123');
+      expect(result.data!['another_app']).toBe('app-456');
+    }, TEST_TIMEOUT);
   });
 
   describe('CachedAppIdResolver', () => {
@@ -267,10 +351,12 @@ describe('App ID Resolver', () => {
       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
-    });
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBe('app-123');
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
+    }, TEST_TIMEOUT);
 
     it('expires cached results after TTL', async () => {
       resolver = new CachedAppIdResolver();
@@ -281,14 +367,15 @@ describe('App ID Resolver', () => {
       });
 
       const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result1).toBe('app-123');
+      expect(result1.ok).toBe(true);
+      expect(result1.data).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
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
     });
 
     it('handles cache misses gracefully', async () => {
@@ -299,8 +386,9 @@ describe('App ID Resolver', () => {
 
       const result = await resolver.getAppId(mockSupabase as any, 'NONEXISTENT_APP');
 
-      expect(result).toBeNull();
-    });
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('No rows found');
+    }, TEST_TIMEOUT);
 
     it('handles database errors gracefully', async () => {
       mockQueryBuilder.single.mockResolvedValue({
@@ -310,14 +398,29 @@ describe('App ID Resolver', () => {
 
       const result = await resolver.getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Database error');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Failed to resolve app ID for app name:',
         'MY_APP',
         { message: 'Database error' }
       );
-    });
+    }, TEST_TIMEOUT);
+
+    it('does not cache errors', async () => {
+      mockQueryBuilder.single
+        .mockResolvedValueOnce({ data: null, error: { message: 'Database error' } })
+        .mockResolvedValueOnce({ data: { id: 'app-123' }, error: null });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result1.ok).toBe(false);
+
+      resolver.clearCacheForApp('MY_APP');
+      const result2 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-123');
+    }, TEST_TIMEOUT);
 
     it('clears cache correctly', async () => {
       mockQueryBuilder.single.mockResolvedValue({
@@ -330,26 +433,115 @@ describe('App ID Resolver', () => {
 
       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
+      expect(result.ok).toBe(true);
+      expect(result.data).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
     });
 
-    it('respects max cache size', async () => {
-      resolver = new CachedAppIdResolver(60000, 2); // 2 max cache entries
+    it('handles multiple apps with different cache states', async () => {
+      mockQueryBuilder.single
+        .mockResolvedValueOnce({ data: { id: 'app-1' }, error: null })
+        .mockResolvedValueOnce({ data: { id: 'app-2' }, error: null })
+        .mockResolvedValueOnce({ data: { id: 'app-3' }, error: null });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'APP1');
+      const result2 = await resolver.getAppId(mockSupabase as any, 'APP2');
+      const result3 = await resolver.getAppId(mockSupabase as any, 'APP3');
+
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBe('app-1');
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-2');
+      expect(result3.ok).toBe(true);
+      expect(result3.data).toBe('app-3');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3);
+
+      const cached1 = await resolver.getAppId(mockSupabase as any, 'APP1');
+      const cached2 = await resolver.getAppId(mockSupabase as any, 'APP2');
+      const cached3 = await resolver.getAppId(mockSupabase as any, 'APP3');
+
+      expect(cached1.ok).toBe(true);
+      expect(cached1.data).toBe('app-1');
+      expect(cached2.ok).toBe(true);
+      expect(cached2.data).toBe('app-2');
+      expect(cached3.ok).toBe(true);
+      expect(cached3.data).toBe('app-3');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3);
+    }, TEST_TIMEOUT);
+
+    it('handles cache expiration with TTL', async () => {
+      const shortTTLResolver = new CachedAppIdResolver();
+      (shortTTLResolver as any).ttl = 100;
 
       mockQueryBuilder.single.mockResolvedValue({
         data: { id: 'app-123' },
         error: null
       });
 
-      // Fill cache beyond max size
+      const result1 = await shortTTLResolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
+
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      const result2 = await shortTTLResolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-123');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
+    }, TEST_TIMEOUT);
+
+    it('clears cache for specific app while keeping others', async () => {
+      mockQueryBuilder.single
+        .mockResolvedValueOnce({ data: { id: 'app-1' }, error: null })
+        .mockResolvedValueOnce({ data: { id: 'app-2' }, error: null })
+        .mockResolvedValueOnce({ data: { id: 'app-1' }, error: null });
+
+      await resolver.getAppId(mockSupabase as any, 'APP1');
+      await resolver.getAppId(mockSupabase as any, 'APP2');
+
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
+
+      resolver.clearCacheForApp('APP1');
+
       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);
-    });
+    }, TEST_TIMEOUT);
+
+    it('handles clearing cache for non-existent app', () => {
+      expect(() => resolver.clearCacheForApp('NONEXISTENT')).not.toThrow();
+    }, TEST_TIMEOUT);
+
+    it('does not cache error results', async () => {
+      mockQueryBuilder.single.mockResolvedValue({
+        data: null,
+        error: { message: 'Not found' }
+      });
+
+      const result1 = await resolver.getAppId(mockSupabase as any, 'MISSING_APP');
+      expect(result1.ok).toBe(false);
+      expect(result1.error.message).toBe('Not found');
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
+
+      const result2 = await resolver.getAppId(mockSupabase as any, 'MISSING_APP');
+      expect(result2.ok).toBe(false);
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
+    }, TEST_TIMEOUT);
+
+    it('handles singleton instance correctly', async () => {
+      const { cachedAppIdResolver } = await import('./appIdResolver');
+      
+      mockQueryBuilder.single.mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      });
+
+      const result = await cachedAppIdResolver.getAppId(mockSupabase as any, 'MY_APP');
+      expect(result.ok).toBe(true);
+      expect(result.data).toBe('app-123');
+    }, TEST_TIMEOUT);
   });
 
   describe('Integration Tests', () => {
@@ -368,7 +560,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockClient as any, 'MY_APP');
 
-      expect(result).toBe('app-123');
+      expect(result.ok).toBe(true);
+      expect(result.data).toBe('app-123');
       expect(mockClient.from).toHaveBeenCalledWith('rbac_apps');
     });
 
@@ -399,7 +592,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, appNames);
 
-      expect(result).toEqual({
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({
         'MY_APP': 'app-123',
         'my-app': 'app-456',
         'my_app': null,
@@ -415,7 +609,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Request timeout');
       const logger = getMockLogger();
       expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
         'Error resolving app ID for app name:',
@@ -432,8 +627,9 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
-    });
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
+    }, TEST_TIMEOUT);
 
     it('handles null data responses', async () => {
       mockQueryBuilder.single.mockResolvedValue({
@@ -443,8 +639,9 @@ describe('App ID Resolver', () => {
 
       const result = await getAppId(mockSupabase as any, 'MY_APP');
 
-      expect(result).toBeNull();
-    });
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
+    }, TEST_TIMEOUT);
   });
 
   describe('Performance', () => {
@@ -468,8 +665,9 @@ describe('App ID Resolver', () => {
       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
+      expect(result.ok).toBe(true);
+      expect(Object.keys(result.data!)).toHaveLength(100);
+      expect(endTime - startTime).toBeLessThan(1000);
     });
 
     it('caches results efficiently', async () => {
@@ -482,16 +680,13 @@ describe('App ID Resolver', () => {
 
       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
-    });
+      expect(endTime - startTime).toBeLessThan(100);
+    }, TEST_TIMEOUT);
   });
 });

package/src/utils/app/appIdResolver.ts

@@ -9,21 +9,30 @@
 
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../../types/database';
+import { ok, err, type ApiResult, type ApiError } from '../../types/api-result';
 import { createLogger } from '../core/logger';
 
 const log = createLogger('AppIdResolver');
 
+function toApiError(error: unknown): ApiError {
+  const message = error instanceof Error ? error.message : 'Unknown error';
+  const code = error instanceof Error && (error as Error & { code?: string }).code
+    ? (error as Error & { code: string }).code
+    : 'APP_ID_RESOLVER_ERROR';
+  return { code, message };
+}
+
 /**
  * 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
+ * @returns Promise resolving to ApiResult with app ID or null if not found
  */
 export async function getAppId(
   supabase: SupabaseClient<Database>,
   appName: string
-): Promise<string | null> {
+): Promise<ApiResult<string | null>> {
   try {
     const { data, error } = await supabase
       .from('rbac_apps')
@@ -34,13 +43,13 @@ export async function getAppId(
 
     if (error) {
       log.error('Failed to resolve app ID for app name:', appName, error);
-      return null;
+      return err({ code: 'APP_ID_RESOLVE_ERROR', message: error.message });
     }
 
-    return (data as { id: string } | null)?.id || null;
-  } catch (error) {
-    log.error('Error resolving app ID for app name:', appName, error);
-    return null;
+    return ok((data as { id: string } | null)?.id ?? null);
+  } catch (e) {
+    log.error('Error resolving app ID for app name:', appName, e);
+    return err(toApiError(e));
   }
 }
 
@@ -49,12 +58,12 @@ export async function getAppId(
  * 
  * @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
+ * @returns Promise resolving to ApiResult with map of app names to app IDs
  */
 export async function getAppIds(
   supabase: SupabaseClient<Database>,
   appNames: string[]
-): Promise<Record<string, string | null>> {
+): Promise<ApiResult<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
@@ -68,7 +77,7 @@ export async function getAppIds(
 
     if (error) {
       log.error('Failed to resolve app IDs for app names:', appNames, error);
-      return {};
+      return err({ code: 'APP_IDS_RESOLVE_ERROR', message: error.message });
     }
 
     const result: Record<string, string | null> = {};
@@ -89,10 +98,10 @@ export async function getAppIds(
       }
     });
 
-    return result;
-  } catch (error) {
-    log.error('Error resolving app IDs for app names:', appNames, error);
-    return {};
+    return ok(result);
+  } catch (e) {
+    log.error('Error resolving app IDs for app names:', appNames, e);
+    return err(toApiError(e));
   }
 }
 
@@ -106,18 +115,20 @@ export class CachedAppIdResolver {
   async getAppId(
     supabase: SupabaseClient<Database>,
     appName: string
-  ): Promise<string | null> {
+  ): Promise<ApiResult<string | null>> {
     const now = Date.now();
     const cached = this.cache.get(appName);
 
     if (cached && cached.expires > now) {
-      return cached.id;
+      return ok(cached.id);
     }
 
-    const id = await getAppId(supabase, appName);
-    this.cache.set(appName, { id, expires: now + this.ttl });
-
-    return id;
+    const result = await getAppId(supabase, appName);
+    if (!result.ok) {
+      return result;
+    }
+    this.cache.set(appName, { id: result.data, expires: now + this.ttl });
+    return ok(result.data);
   }
 
   clearCache(): void {