@jmruthers/pace-core 0.6.10 → 0.6.11

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

@@ -76,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' }
@@ -91,7 +92,8 @@ 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 () => {
@@ -102,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:',
@@ -116,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:',
@@ -129,14 +133,17 @@ 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);
   });
 
@@ -157,7 +164,8 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP']);
 
-      expect(result).toEqual({ 'MY_APP': 'app-123' });
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({ 'MY_APP': 'app-123' });
     }, TEST_TIMEOUT);
 
     it('resolves multiple app IDs', async () => {
@@ -180,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
@@ -207,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 () => {
@@ -235,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:',
@@ -257,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:',
@@ -270,8 +283,8 @@ 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 () => {
@@ -290,11 +303,11 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'MY_APP', 'MY_APP']);
 
-      expect(result).toEqual({
+      expect(result.ok).toBe(true);
+      expect(result.data).toEqual({
         'MY_APP': 'app-123'
       });
-      // All three entries should map to the same ID
-      expect(result['MY_APP']).toBe('app-123');
+      expect(result.data!['MY_APP']).toBe('app-123');
     }, TEST_TIMEOUT);
 
     it('handles app names with different cases correctly', async () => {
@@ -316,8 +329,9 @@ describe('App ID Resolver', () => {
 
       const result = await getAppIds(mockSupabase as any, ['MY_APP', 'another_app']);
 
-      expect(result['MY_APP']).toBe('app-123');
-      expect(result['another_app']).toBe('app-456');
+      expect(result.ok).toBe(true);
+      expect(result.data!['MY_APP']).toBe('app-123');
+      expect(result.data!['another_app']).toBe('app-456');
     }, TEST_TIMEOUT);
   });
 
@@ -337,9 +351,11 @@ 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 () => {
@@ -351,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 () => {
@@ -369,7 +386,8 @@ 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 () => {
@@ -380,7 +398,8 @@ 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:',
@@ -395,12 +414,12 @@ describe('App ID Resolver', () => {
         .mockResolvedValueOnce({ data: { id: 'app-123' }, error: null });
 
       const result1 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result1).toBeNull();
+      expect(result1.ok).toBe(false);
 
-      // Clear cache and try again - should succeed this time
       resolver.clearCacheForApp('MY_APP');
       const result2 = await resolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result2).toBe('app-123');
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBe('app-123');
     }, TEST_TIMEOUT);
 
     it('clears cache correctly', async () => {
@@ -414,8 +433,9 @@ 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('handles multiple apps with different cache states', async () => {
@@ -428,27 +448,30 @@ describe('App ID Resolver', () => {
       const result2 = await resolver.getAppId(mockSupabase as any, 'APP2');
       const result3 = await resolver.getAppId(mockSupabase as any, 'APP3');
 
-      expect(result1).toBe('app-1');
-      expect(result2).toBe('app-2');
-      expect(result3).toBe('app-3');
+      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);
 
-      // Second calls should use cache
       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).toBe('app-1');
-      expect(cached2).toBe('app-2');
-      expect(cached3).toBe('app-3');
-      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3); // No additional calls
+      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 () => {
-      // Create resolver with short TTL for testing
       const shortTTLResolver = new CachedAppIdResolver();
-      // Access private ttl property via type assertion for testing
-      (shortTTLResolver as any).ttl = 100; // 100ms TTL
+      (shortTTLResolver as any).ttl = 100;
 
       mockQueryBuilder.single.mockResolvedValue({
         data: { id: 'app-123' },
@@ -456,22 +479,23 @@ describe('App ID Resolver', () => {
       });
 
       const result1 = await shortTTLResolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result1).toBe('app-123');
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBe('app-123');
       expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
 
-      // Wait for TTL to expire
       await new Promise(resolve => setTimeout(resolve, 150));
 
       const result2 = await shortTTLResolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result2).toBe('app-123');
-      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2); // Should call again after TTL
+      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 }); // Re-fetch after clear
+        .mockResolvedValueOnce({ data: { id: 'app-1' }, error: null });
 
       await resolver.getAppId(mockSupabase as any, 'APP1');
       await resolver.getAppId(mockSupabase as any, 'APP2');
@@ -480,31 +504,30 @@ describe('App ID Resolver', () => {
 
       resolver.clearCacheForApp('APP1');
 
-      // APP1 should be re-fetched, APP2 should still be cached
       await resolver.getAppId(mockSupabase as any, 'APP1');
       await resolver.getAppId(mockSupabase as any, 'APP2');
 
-      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3); // Only APP1 re-fetched
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(3);
     }, TEST_TIMEOUT);
 
     it('handles clearing cache for non-existent app', () => {
       expect(() => resolver.clearCacheForApp('NONEXISTENT')).not.toThrow();
     }, TEST_TIMEOUT);
 
-    it('handles null results in cache', async () => {
+    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).toBeNull();
+      expect(result1.ok).toBe(false);
+      expect(result1.error.message).toBe('Not found');
       expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1);
 
-      // Should use cached null result
       const result2 = await resolver.getAppId(mockSupabase as any, 'MISSING_APP');
-      expect(result2).toBeNull();
-      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(1); // Still cached
+      expect(result2.ok).toBe(false);
+      expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
     }, TEST_TIMEOUT);
 
     it('handles singleton instance correctly', async () => {
@@ -516,7 +539,8 @@ describe('App ID Resolver', () => {
       });
 
       const result = await cachedAppIdResolver.getAppId(mockSupabase as any, 'MY_APP');
-      expect(result).toBe('app-123');
+      expect(result.ok).toBe(true);
+      expect(result.data).toBe('app-123');
     }, TEST_TIMEOUT);
   });
 
@@ -536,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');
     });
 
@@ -567,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,
@@ -583,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:',
@@ -600,7 +627,8 @@ 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 () => {
@@ -611,7 +639,8 @@ 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);
   });
 
@@ -636,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 () => {
@@ -650,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 {

package/src/utils/{__tests__/appConfig.unit.test.ts → appConfig.unit.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { setAppConfig, getAppConfig, getCurrentAppName, getCurrentAppId } from '../app/appConfig';
+import { setAppConfig, getAppConfig, getCurrentAppName, getCurrentAppId } from './app/appConfig';
 
 describe('App Configuration Utilities', () => {
   beforeEach(() => {

package/src/utils/{__tests__/audit.unit.test.ts → audit.unit.test.ts}

@@ -4,7 +4,7 @@ import {
   logAuthEvent,
   logPermissionEvent,
   logSecurityEvent
-} from '../audit/audit';
+} from './audit/audit';
 
 describe('Audit Logger Utility', () => {
   beforeEach(() => {

package/src/utils/{__tests__/auth-utils.unit.test.ts → auth-utils.unit.test.ts}

@@ -5,47 +5,46 @@ import {
   resetPassword,
   updatePassword,
   auditLogger
-} from '../security/auth-utils';
+} from './security/auth-utils';
 
 describe('Auth Utils', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
   });
 
-  it('signInWithEmail logs and returns error', async () => {
+  it('signInWithEmail returns ApiResult error', async () => {
     const result = await signInWithEmail({ email: 'test@example.com', password: 'pw' });
-    expect(result).toHaveProperty('error');
-    expect(result.error).toBeInstanceOf(Error);
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatchObject({ code: expect.any(String), message: expect.any(String) });
   });
 
-  it('signUpWithEmail logs and returns error', async () => {
+  it('signUpWithEmail returns ApiResult error', async () => {
     const result = await signUpWithEmail({ email: 'new@example.com', password: 'pw' });
-    expect(result).toHaveProperty('error');
-    expect(result.error).toBeInstanceOf(Error);
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatchObject({ code: expect.any(String), message: expect.any(String) });
   });
 
-  it('resetPassword logs and returns error', async () => {
+  it('resetPassword returns ApiResult error', async () => {
     const result = await resetPassword('reset@example.com');
-    expect(result).toHaveProperty('error');
-    expect(result.error).toBeInstanceOf(Error);
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatchObject({ code: expect.any(String), message: expect.any(String) });
   });
 
-  it('updatePassword calls supabaseClient.auth.updateUser and returns error if thrown', async () => {
+  it('updatePassword calls supabaseClient.auth.updateUser and returns ok', async () => {
     const updateUser = vi.fn().mockResolvedValue({ error: undefined });
     const supabaseClient = { auth: { updateUser } } as any;
     const result = await updatePassword(supabaseClient, 'newpw');
     expect(updateUser).toHaveBeenCalledWith({ password: 'newpw' });
-    expect(result).toEqual({ error: undefined });
+    expect(result.ok).toBe(true);
+    expect(result.data).toBeUndefined();
   });
 
-  it('updatePassword returns error if thrown', async () => {
+  it('updatePassword returns ApiResult error if thrown', async () => {
     const updateUser = vi.fn().mockRejectedValue(new Error('fail'));
     const supabaseClient = { auth: { updateUser } } as any;
     const result = await updatePassword(supabaseClient, 'pw');
-    expect(result.error).toBeInstanceOf(Error);
-    if (result.error) {
-      expect(result.error.message).toBe('fail');
-    }
+    expect(result.ok).toBe(false);
+    expect(result.error.message).toBe('fail');
   });
 
   it('auditLogger.log logs event', () => {