@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/utils/context/organisationContext.test.ts

@@ -37,22 +37,26 @@ describe('Organisation Context', () => {
     describe('setOrganisationContext', () => {
     it('sets organisation context successfully (no-op)', async () => {
       // setOrganisationContext is now a no-op (deprecated)
-      // It should complete without calling rpc
-      await setOrganisationContext(mockSupabase, 'org-123');
-
-      // Should not call rpc since it's a no-op
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeUndefined();
       expect(mockSupabase.rpc).not.toHaveBeenCalled();
     }, TEST_TIMEOUT);
 
     it('handles missing supabase client gracefully', async () => {
-      await expect(setOrganisationContext(null as any, 'org-123')).resolves.not.toThrow();
-      await expect(setOrganisationContext(undefined as any, 'org-123')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(null as any, 'org-123');
+      const r2 = await setOrganisationContext(undefined as any, 'org-123');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles missing organisation ID gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, null as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, undefined as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, null as any);
+      const r2 = await setOrganisationContext(mockSupabase, undefined as any);
+      const r3 = await setOrganisationContext(mockSupabase, '');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
     });
 
     it('handles database function errors gracefully', async () => {
@@ -61,25 +65,28 @@ describe('Organisation Context', () => {
         error: { message: 'Function not found' }
       });
 
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true); // no-op does not call rpc
     });
 
     it('handles RPC exceptions gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
 
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true); // no-op does not call rpc
     });
 
     it('handles invalid organisation ID format', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'invalid-id')).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, 'invalid-id');
+      const r2 = await setOrganisationContext(mockSupabase, '123');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles very long organisation ID', async () => {
       const longOrgId = 'a'.repeat(1000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, longOrgId);
+      expect(result.ok).toBe(true);
     });
   });
 
@@ -90,8 +97,9 @@ describe('Organisation Context', () => {
         error: null
       });
 
-      await clearOrganisationContext(mockSupabase);
-
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeUndefined();
       expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
         p_event_type: 'organisation_switched',
         p_metadata: { action: 'clear_context' }
@@ -99,8 +107,10 @@ describe('Organisation Context', () => {
     });
 
     it('handles missing supabase client gracefully', async () => {
-      await expect(clearOrganisationContext(null as any)).resolves.not.toThrow();
-      await expect(clearOrganisationContext(undefined as any)).resolves.not.toThrow();
+      const r1 = await clearOrganisationContext(null as any);
+      const r2 = await clearOrganisationContext(undefined as any);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles database function errors gracefully', async () => {
@@ -109,61 +119,64 @@ describe('Organisation Context', () => {
         error: { message: 'Function not found' }
       });
 
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Function not found');
     });
 
     it('handles RPC exceptions gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
 
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Network error');
     });
   });
 
   describe('getOrganisationContext', () => {
     it('gets organisation context successfully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('returns null when no context is set', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles missing supabase client gracefully', async () => {
       const result1 = await getOrganisationContext(null as any);
       const result2 = await getOrganisationContext(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 database function errors gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles RPC exceptions gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles invalid data format gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles empty string data', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
   });
 
@@ -177,39 +190,34 @@ describe('Organisation Context', () => {
       };
 
       const result = await getOrganisationContext(mockClient as any);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles complete workflow', async () => {
-      // setOrganisationContext is now a no-op, so it won't call rpc
-      await setOrganisationContext(mockSupabase, 'org-123');
+      const setResult = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(setResult.ok).toBe(true);
 
-      // getOrganisationContext always returns null (deprecated)
-      const result = await getOrganisationContext(mockSupabase);
-      expect(result).toBeNull();
+      const getResult = await getOrganisationContext(mockSupabase);
+      expect(getResult.ok).toBe(true);
+      expect(getResult.data).toBeNull();
 
-      // clearOrganisationContext still calls rpc
       mockSupabase.rpc.mockResolvedValueOnce({
         data: null,
         error: null
       });
 
-      await clearOrganisationContext(mockSupabase);
-
-      // Only clearOrganisationContext should call rpc (once)
+      const clearResult = await clearOrganisationContext(mockSupabase);
+      expect(clearResult.ok).toBe(true);
       expect(mockSupabase.rpc).toHaveBeenCalledTimes(1);
     });
 
     it('handles multiple organisation switches', async () => {
       const organisations = ['org-123', 'org-456', 'org-789'];
-
-      // setOrganisationContext is now a no-op, so it won't call rpc
       for (const orgId of organisations) {
-        await setOrganisationContext(mockSupabase, orgId);
+        const result = await setOrganisationContext(mockSupabase, orgId);
+        expect(result.ok).toBe(true);
       }
-
-      // setOrganisationContext is deprecated and doesn't call rpc anymore
       expect(mockSupabase.rpc).not.toHaveBeenCalled();
     }, TEST_TIMEOUT);
   });
@@ -218,96 +226,102 @@ describe('Organisation Context', () => {
     it('handles network timeouts gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Request timeout'));
 
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
-      await expect(getOrganisationContext(mockSupabase)).resolves.toBeNull();
+      const setResult = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(setResult.ok).toBe(true);
+      const clearResult = await clearOrganisationContext(mockSupabase);
+      expect(clearResult.ok).toBe(false);
+      expect(clearResult.error.message).toContain('Request timeout');
+      const getResult = await getOrganisationContext(mockSupabase);
+      expect(getResult.ok).toBe(true);
+      expect(getResult.data).toBeNull();
     });
 
     it('handles malformed responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles null responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles undefined responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
   });
 
   describe('Performance', () => {
     it('handles rapid context changes efficiently', async () => {
       const startTime = Date.now();
-
-      // Rapidly switch contexts
       for (let i = 0; i < 100; i++) {
-        mockSupabase.rpc.mockResolvedValue({
-          data: null,
-          error: null
-        });
-
-        await setOrganisationContext(mockSupabase, `org-${i}`);
+        const result = await setOrganisationContext(mockSupabase, `org-${i}`);
+        expect(result.ok).toBe(true);
       }
-
       const endTime = Date.now();
-
-      expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
+      expect(endTime - startTime).toBeLessThan(1000);
     });
 
     it('handles concurrent operations gracefully', async () => {
-      const operations = [
+      mockSupabase.rpc.mockResolvedValue({ data: null, error: null });
+      const [r1, r2, r3, r4] = await Promise.all([
         setOrganisationContext(mockSupabase, 'org-1'),
         setOrganisationContext(mockSupabase, 'org-2'),
         clearOrganisationContext(mockSupabase),
         getOrganisationContext(mockSupabase)
-      ];
-
-      await expect(Promise.all(operations)).resolves.not.toThrow();
+      ]);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
+      expect(r4.ok).toBe(true);
     });
   });
 
   describe('Edge Cases', () => {
     it('handles special characters in organisation ID', async () => {
-      const specialOrgId = 'org-123@domain.com';
-      await expect(setOrganisationContext(mockSupabase, specialOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123@domain.com');
+      expect(result.ok).toBe(true);
     });
 
     it('handles unicode characters in organisation ID', async () => {
-      const unicodeOrgId = 'org-用户-123';
-      await expect(setOrganisationContext(mockSupabase, unicodeOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-用户-123');
+      expect(result.ok).toBe(true);
     });
 
     it('handles very long organisation ID', async () => {
-      const longOrgId = 'a'.repeat(10000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'a'.repeat(10000));
+      expect(result.ok).toBe(true);
     });
 
     it('handles numeric organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, '123');
+      expect(result.ok).toBe(true);
     });
 
     it('handles boolean organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'true' as any)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'true' as any);
+      expect(result.ok).toBe(true);
     });
   });
 
   describe('Type Safety', () => {
     it('maintains type safety with TypeScript', async () => {
       const result = await getOrganisationContext(mockSupabase);
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles mixed input types gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, 123 as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, true as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, {} as any)).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, 123 as any);
+      const r2 = await setOrganisationContext(mockSupabase, true as any);
+      const r3 = await setOrganisationContext(mockSupabase, {} as any);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
     });
   });
 });

package/src/utils/context/organisationContext.ts

@@ -9,10 +9,19 @@
  */
 
 import type { SupabaseClient } from '@supabase/supabase-js';
+import { ok, err, type ApiResult, type ApiError } from '../../types/api-result';
 import { createLogger } from '../core/logger';
 
 const log = createLogger('organisationContext');
 
+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
+    : 'ORGANISATION_CONTEXT_ERROR';
+  return { code, message };
+}
+
 /**
  * Set organisation context in the database session
  * 
@@ -25,30 +34,29 @@ const log = createLogger('organisationContext');
  * 
  * @param supabase - Supabase client instance (unused)
  * @param organisationId - The organisation ID (unused)
- * @returns Promise that resolves immediately
+ * @returns Promise that resolves to ApiResult<void>
  */
 export async function setOrganisationContext(
   _supabase: SupabaseClient,
   _organisationId: string
-): Promise<void> {
+): Promise<ApiResult<void>> {
   // No-op: Organisation context is now handled via secure client and explicit parameters
   // This function is kept for backward compatibility
   log.debug('setOrganisationContext called but is a no-op - context handled via secure client');
-  return Promise.resolve();
+  return ok(undefined);
 }
 
 /**
  * Clear organisation context from the database session
  * 
  * @param supabase - Supabase client instance
- * @returns Promise that resolves when context is cleared
+ * @returns Promise that resolves to ApiResult<void>
  */
 export async function clearOrganisationContext(
   supabase: SupabaseClient
-): Promise<void> {
+): Promise<ApiResult<void>> {
   if (!supabase) {
-    // TODO: Replace with proper logging service integration
-    return;
+    return ok(undefined);
   }
 
   try {
@@ -56,16 +64,13 @@ export async function clearOrganisationContext(
       p_event_type: 'organisation_switched',
       p_metadata: { action: 'clear_context' }
     });
-    
+
     if (error) {
-      // Silent fail - function not available
-      // TODO: Replace with proper logging service integration
-    } else {
-      // TODO: Replace with proper logging service integration
+      return err({ code: 'CLEAR_CONTEXT_ERROR', message: error.message });
     }
-  } catch (_error) {
-    // Silent fail - error occurred
-    // TODO: Replace with proper logging service integration
+    return ok(undefined);
+  } catch (e) {
+    return err(toApiError(e));
   }
 }
 
@@ -73,37 +78,21 @@ export async function clearOrganisationContext(
  * Get current organisation context from the database session
  * 
  * @param supabase - Supabase client instance
- * @returns Promise that resolves to the current organisation ID or null
+ * @returns Promise that resolves to ApiResult<string | null>
  */
 export async function getOrganisationContext(
   supabase: SupabaseClient
-): Promise<string | null> {
+): Promise<ApiResult<string | null>> {
   if (!supabase) {
-    // TODO: Replace with proper logging service integration
-    return null;
+    return ok(null);
   }
 
   try {
     // For now, return null since we're not using database context
     // This will be replaced with proper context management
-    const data = null;
-    const error = null;
-    
-    if (error) {
-      // TODO: Replace with proper logging service integration
-      return null;
-    }
-    
-    // Validate that data is a string (allow empty strings)
-    if (typeof data === 'string') {
-      return data;
-    }
-    
-    // Return null for invalid data formats
-    return null;
-  } catch (_error) {
-    // TODO: Replace with proper logging service integration
-    return null;
+    return ok(null);
+  } catch (e) {
+    return err(toApiError(e));
   }
 }
 
@@ -114,12 +103,12 @@ export async function getOrganisationContext(
  * Organisation context is now handled via secure client and explicit parameters.
  * 
  * @param supabase - Supabase client instance (unused)
- * @returns Promise that resolves to false
+ * @returns Promise that resolves to ApiResult<boolean>
  */
 export async function isOrganisationContextAvailable(
   _supabase: SupabaseClient
-): Promise<boolean> {
+): Promise<ApiResult<boolean>> {
   // Always return false - organisation context functions have been removed
   // Context is now handled via secure client and explicit parameters
-  return false;
+  return ok(false);
 } 

package/src/utils/core/cn.test.ts

@@ -0,0 +1,66 @@
+/**
+ * @file Unit Tests for cn Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Core
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { cn } from './cn';
+
+describe('cn utility', () => {
+  describe('Class merging', () => {
+    it('merges class names correctly', () => {
+      expect(cn('foo', 'bar')).toBe('foo bar');
+      expect(cn('foo', 'bar', 'baz')).toBe('foo bar baz');
+    });
+
+    it('handles conditional classes', () => {
+      expect(cn('foo', true && 'bar', false && 'baz')).toBe('foo bar');
+      expect(cn('foo', false && 'bar', true && 'baz')).toBe('foo baz');
+    });
+
+    it('handles arrays of classes', () => {
+      expect(cn(['foo', 'bar'], 'baz')).toBe('foo bar baz');
+      expect(cn('foo', ['bar', 'baz'])).toBe('foo bar baz');
+    });
+
+    it('handles objects with boolean values', () => {
+      expect(cn({ foo: true, bar: false, baz: true })).toBe('foo baz');
+      expect(cn({ foo: false, bar: true })).toBe('bar');
+    });
+
+    it('handles undefined and null values', () => {
+      expect(cn('foo', undefined, 'bar', null, 'baz')).toBe('foo bar baz');
+      expect(cn(undefined, null)).toBe('');
+    });
+
+    it('handles empty strings', () => {
+      expect(cn('foo', '', 'bar')).toBe('foo bar');
+      expect(cn('', '')).toBe('');
+    });
+
+    it('merges Tailwind classes correctly', () => {
+      const result1 = cn('px-2 py-1', 'px-4');
+      expect(result1).toContain('px-4');
+      expect(result1).toContain('py-1');
+      expect(result1).not.toContain('px-2');
+      
+      expect(cn('bg-acc-500', 'bg-main-500')).toBe('bg-main-500');
+    });
+
+    it('handles complex combinations', () => {
+      expect(cn('foo', { bar: true, baz: false }, ['qux', 'quux'], 'corge')).toBe('foo bar qux quux corge');
+    });
+
+    it('handles no arguments', () => {
+      expect(cn()).toBe('');
+    });
+
+    it('handles single argument', () => {
+      expect(cn('foo')).toBe('foo');
+      expect(cn({ foo: true })).toBe('foo');
+      expect(cn(['foo', 'bar'])).toBe('foo bar');
+    });
+  });
+});