@jmruthers/pace-core 0.2.4

package/src/types/__tests__/supabase.unit.test.ts

@@ -0,0 +1,658 @@
+/**
+ * @file Supabase Types Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Types/Supabase
+ * @since 0.4.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  TypedSupabaseClient,
+  SupabaseConfig,
+  SupabaseAuthConfig,
+  SupabaseStorageConfig,
+  SupabaseRealtimeConfig,
+  SupabaseError,
+  SupabaseResponse,
+  SupabaseQueryBuilder,
+  SupabaseFilterBuilder,
+  SupabaseAuthResponse,
+  SupabaseUserResponse,
+  SupabaseSessionResponse,
+  SupabaseSubscription,
+  SupabaseChannel,
+  SupabasePresenceState,
+  SupabaseRealtimePayload,
+  SupabaseStorageResponse,
+  SupabaseBucketResponse,
+  SupabaseFileResponse,
+  SupabaseFunctionResponse
+} from '../supabase';
+
+describe('Supabase Types', () => {
+  describe('TypedSupabaseClient', () => {
+    it('should be a type alias for SupabaseClient', () => {
+      // This test verifies the type alias is correctly defined
+      const client: TypedSupabaseClient = {} as TypedSupabaseClient;
+      expect(typeof client).toBe('object');
+    });
+  });
+
+  describe('SupabaseConfig Interface', () => {
+    it('should accept valid Supabase config objects', () => {
+      const config: SupabaseConfig = {
+        url: 'https://example.supabase.co',
+        anonKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+        serviceRoleKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+        auth: {
+          autoRefreshToken: true,
+          persistSession: true,
+          detectSessionInUrl: true
+        },
+        storage: {
+          maxFileSize: 52428800,
+          allowedMimeTypes: ['image/jpeg', 'image/png']
+        },
+        realtime: {
+          params: {
+            eventsPerSecond: 10
+          }
+        }
+      };
+
+      expect(config.url).toBe('https://example.supabase.co');
+      expect(config.anonKey).toBe('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
+      expect(config.auth.autoRefreshToken).toBe(true);
+      expect(config.storage.maxFileSize).toBe(52428800);
+    });
+
+    it('should work with minimal config objects', () => {
+      const config: SupabaseConfig = {
+        url: 'https://example.supabase.co',
+        anonKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+      };
+
+      expect(config.url).toBe('https://example.supabase.co');
+      expect(config.serviceRoleKey).toBeUndefined();
+      expect(config.auth).toBeUndefined();
+      expect(config.storage).toBeUndefined();
+      expect(config.realtime).toBeUndefined();
+    });
+  });
+
+  describe('SupabaseAuthConfig Interface', () => {
+    it('should accept valid auth config objects', () => {
+      const authConfig: SupabaseAuthConfig = {
+        autoRefreshToken: true,
+        persistSession: true,
+        detectSessionInUrl: true,
+        flowType: 'pkce',
+        debug: false,
+        storage: {
+          getItem: (key: string) => Promise.resolve(null),
+          setItem: (key: string, value: string) => Promise.resolve(),
+          removeItem: (key: string) => Promise.resolve()
+        }
+      };
+
+      expect(authConfig.autoRefreshToken).toBe(true);
+      expect(authConfig.persistSession).toBe(true);
+      expect(authConfig.detectSessionInUrl).toBe(true);
+      expect(authConfig.flowType).toBe('pkce');
+      expect(authConfig.debug).toBe(false);
+      expect(typeof authConfig.storage.getItem).toBe('function');
+    });
+
+    it('should work with minimal auth config objects', () => {
+      const authConfig: SupabaseAuthConfig = {
+        autoRefreshToken: false,
+        persistSession: false,
+        detectSessionInUrl: false
+      };
+
+      expect(authConfig.flowType).toBeUndefined();
+      expect(authConfig.debug).toBeUndefined();
+      expect(authConfig.storage).toBeUndefined();
+    });
+  });
+
+  describe('SupabaseStorageConfig Interface', () => {
+    it('should accept valid storage config objects', () => {
+      const storageConfig: SupabaseStorageConfig = {
+        maxFileSize: 52428800,
+        allowedMimeTypes: ['image/jpeg', 'image/png', 'application/pdf'],
+        transform: {
+          width: 800,
+          height: 600,
+          quality: 80
+        }
+      };
+
+      expect(storageConfig.maxFileSize).toBe(52428800);
+      expect(storageConfig.allowedMimeTypes).toEqual(['image/jpeg', 'image/png', 'application/pdf']);
+      expect(storageConfig.transform?.width).toBe(800);
+      expect(storageConfig.transform?.height).toBe(600);
+      expect(storageConfig.transform?.quality).toBe(80);
+    });
+
+    it('should work with minimal storage config objects', () => {
+      const storageConfig: SupabaseStorageConfig = {
+        maxFileSize: 10485760,
+        allowedMimeTypes: []
+      };
+
+      expect(storageConfig.transform).toBeUndefined();
+    });
+  });
+
+  describe('SupabaseRealtimeConfig Interface', () => {
+    it('should accept valid realtime config objects', () => {
+      const realtimeConfig: SupabaseRealtimeConfig = {
+        params: {
+          eventsPerSecond: 10
+        },
+        heartbeatIntervalMs: 30000,
+        reconnectAfterMs: 1000
+      };
+
+      expect(realtimeConfig.params.eventsPerSecond).toBe(10);
+      expect(realtimeConfig.heartbeatIntervalMs).toBe(30000);
+      expect(realtimeConfig.reconnectAfterMs).toBe(1000);
+    });
+
+    it('should work with minimal realtime config objects', () => {
+      const realtimeConfig: SupabaseRealtimeConfig = {
+        params: {}
+      };
+
+      expect(realtimeConfig.heartbeatIntervalMs).toBeUndefined();
+      expect(realtimeConfig.reconnectAfterMs).toBeUndefined();
+    });
+  });
+
+  describe('SupabaseError Interface', () => {
+    it('should accept valid error objects', () => {
+      const error: SupabaseError = {
+        message: 'Invalid credentials',
+        status: 401,
+        name: 'AuthError',
+        details: 'Email or password is incorrect',
+        hint: 'Please check your credentials and try again'
+      };
+
+      expect(error.message).toBe('Invalid credentials');
+      expect(error.status).toBe(401);
+      expect(error.name).toBe('AuthError');
+      expect(error.details).toBe('Email or password is incorrect');
+      expect(error.hint).toBe('Please check your credentials and try again');
+    });
+
+    it('should work with minimal error objects', () => {
+      const error: SupabaseError = {
+        message: 'Network error',
+        status: 500
+      };
+
+      expect(error.name).toBeUndefined();
+      expect(error.details).toBeUndefined();
+      expect(error.hint).toBeUndefined();
+    });
+  });
+
+  describe('SupabaseResponse Interface', () => {
+    it('should accept valid response objects', () => {
+      const response: SupabaseResponse<{ id: string; name: string }> = {
+        data: { id: 'user-123', name: 'John Doe' },
+        error: null,
+        count: 1,
+        status: 200,
+        statusText: 'OK'
+      };
+
+      expect(response.data).toEqual({ id: 'user-123', name: 'John Doe' });
+      expect(response.error).toBeNull();
+      expect(response.count).toBe(1);
+      expect(response.status).toBe(200);
+      expect(response.statusText).toBe('OK');
+    });
+
+    it('should work with error responses', () => {
+      const response: SupabaseResponse<null> = {
+        data: null,
+        error: {
+          message: 'Not found',
+          status: 404,
+          name: 'NotFoundError'
+        },
+        count: null,
+        status: 404,
+        statusText: 'Not Found'
+      };
+
+      expect(response.data).toBeNull();
+      expect(response.error?.message).toBe('Not found');
+      expect(response.count).toBeNull();
+    });
+  });
+
+  describe('SupabaseQueryBuilder Interface', () => {
+    it('should accept valid query builder objects', () => {
+      const queryBuilder: SupabaseQueryBuilder<{ id: string; name: string }> = {
+        select: (columns: string) => queryBuilder,
+        insert: (values: any) => queryBuilder,
+        update: (values: any) => queryBuilder,
+        delete: () => queryBuilder,
+        eq: (column: string, value: any) => queryBuilder,
+        neq: (column: string, value: any) => queryBuilder,
+        gt: (column: string, value: any) => queryBuilder,
+        gte: (column: string, value: any) => queryBuilder,
+        lt: (column: string, value: any) => queryBuilder,
+        lte: (column: string, value: any) => queryBuilder,
+        like: (column: string, pattern: string) => queryBuilder,
+        ilike: (column: string, pattern: string) => queryBuilder,
+        in: (column: string, values: any[]) => queryBuilder,
+        is: (column: string, value: any) => queryBuilder,
+        or: (filters: string, values: any[]) => queryBuilder,
+        order: (column: string, options?: { ascending?: boolean; nullsFirst?: boolean }) => queryBuilder,
+        limit: (count: number) => queryBuilder,
+        range: (from: number, to: number) => queryBuilder,
+        single: () => Promise.resolve({ data: null, error: null }),
+        maybeSingle: () => Promise.resolve({ data: null, error: null }),
+        then: (onfulfilled: any, onrejected?: any) => Promise.resolve({ data: null, error: null })
+      };
+
+      expect(typeof queryBuilder.select).toBe('function');
+      expect(typeof queryBuilder.insert).toBe('function');
+      expect(typeof queryBuilder.update).toBe('function');
+      expect(typeof queryBuilder.delete).toBe('function');
+      expect(typeof queryBuilder.eq).toBe('function');
+      expect(typeof queryBuilder.single).toBe('function');
+    });
+  });
+
+  describe('SupabaseFilterBuilder Interface', () => {
+    it('should accept valid filter builder objects', () => {
+      const filterBuilder: SupabaseFilterBuilder<{ id: string; name: string }> = {
+        eq: (column: string, value: any) => filterBuilder,
+        neq: (column: string, value: any) => filterBuilder,
+        gt: (column: string, value: any) => filterBuilder,
+        gte: (column: string, value: any) => filterBuilder,
+        lt: (column: string, value: any) => filterBuilder,
+        lte: (column: string, value: any) => filterBuilder,
+        like: (column: string, pattern: string) => filterBuilder,
+        ilike: (column: string, pattern: string) => filterBuilder,
+        in: (column: string, values: any[]) => filterBuilder,
+        is: (column: string, value: any) => filterBuilder,
+        or: (filters: string, values: any[]) => filterBuilder
+      };
+
+      expect(typeof filterBuilder.eq).toBe('function');
+      expect(typeof filterBuilder.neq).toBe('function');
+      expect(typeof filterBuilder.gt).toBe('function');
+      expect(typeof filterBuilder.like).toBe('function');
+      expect(typeof filterBuilder.in).toBe('function');
+    });
+  });
+
+  describe('SupabaseAuthResponse Interface', () => {
+    it('should accept valid auth response objects', () => {
+      const authResponse: SupabaseAuthResponse = {
+        data: {
+          user: {
+            id: 'user-123',
+            email: 'user@example.com',
+            created_at: '2023-01-01T00:00:00Z',
+            updated_at: '2023-01-01T00:00:00Z'
+          },
+          session: {
+            access_token: 'token-123',
+            refresh_token: 'refresh-123',
+            expires_in: 3600,
+            expires_at: 1234567890,
+            token_type: 'bearer',
+            user: {
+              id: 'user-123',
+              email: 'user@example.com',
+              created_at: '2023-01-01T00:00:00Z',
+              updated_at: '2023-01-01T00:00:00Z'
+            }
+          }
+        },
+        error: null
+      };
+
+      expect(authResponse.data.user.id).toBe('user-123');
+      expect(authResponse.data.session.access_token).toBe('token-123');
+      expect(authResponse.error).toBeNull();
+    });
+
+    it('should work with error responses', () => {
+      const authResponse: SupabaseAuthResponse = {
+        data: { user: null, session: null },
+        error: {
+          message: 'Invalid credentials',
+          status: 401,
+          name: 'AuthError'
+        }
+      };
+
+      expect(authResponse.data.user).toBeNull();
+      expect(authResponse.data.session).toBeNull();
+      expect(authResponse.error?.message).toBe('Invalid credentials');
+    });
+  });
+
+  describe('SupabaseUserResponse Interface', () => {
+    it('should accept valid user response objects', () => {
+      const userResponse: SupabaseUserResponse = {
+        data: {
+          user: {
+            id: 'user-123',
+            email: 'user@example.com',
+            created_at: '2023-01-01T00:00:00Z',
+            updated_at: '2023-01-01T00:00:00Z'
+          }
+        },
+        error: null
+      };
+
+      expect(userResponse.data.user.id).toBe('user-123');
+      expect(userResponse.data.user.email).toBe('user@example.com');
+      expect(userResponse.error).toBeNull();
+    });
+
+    it('should work with error responses', () => {
+      const userResponse: SupabaseUserResponse = {
+        data: { user: null },
+        error: {
+          message: 'User not found',
+          status: 404,
+          name: 'NotFoundError'
+        }
+      };
+
+      expect(userResponse.data.user).toBeNull();
+      expect(userResponse.error?.message).toBe('User not found');
+    });
+  });
+
+  describe('SupabaseSessionResponse Interface', () => {
+    it('should accept valid session response objects', () => {
+      const sessionResponse: SupabaseSessionResponse = {
+        data: {
+          session: {
+            access_token: 'token-123',
+            refresh_token: 'refresh-123',
+            expires_in: 3600,
+            expires_at: 1234567890,
+            token_type: 'bearer',
+            user: {
+              id: 'user-123',
+              email: 'user@example.com',
+              created_at: '2023-01-01T00:00:00Z',
+              updated_at: '2023-01-01T00:00:00Z'
+            }
+          }
+        },
+        error: null
+      };
+
+      expect(sessionResponse.data.session.access_token).toBe('token-123');
+      expect(sessionResponse.data.session.user.id).toBe('user-123');
+      expect(sessionResponse.error).toBeNull();
+    });
+
+    it('should work with error responses', () => {
+      const sessionResponse: SupabaseSessionResponse = {
+        data: { session: null },
+        error: {
+          message: 'Session expired',
+          status: 401,
+          name: 'AuthError'
+        }
+      };
+
+      expect(sessionResponse.data.session).toBeNull();
+      expect(sessionResponse.error?.message).toBe('Session expired');
+    });
+  });
+
+  describe('SupabaseSubscription Interface', () => {
+    it('should accept valid subscription objects', () => {
+      const subscription: SupabaseSubscription = {
+        channel: {} as SupabaseChannel,
+        payload: {
+          new: { id: 'record-123', name: 'Test Record' },
+          old: null,
+          eventType: 'INSERT'
+        },
+        status: 'SUBSCRIBED',
+        subscribe: (callback: (payload: any) => void) => subscription,
+        unsubscribe: () => subscription
+      };
+
+      expect(subscription.payload.eventType).toBe('INSERT');
+      expect(subscription.status).toBe('SUBSCRIBED');
+      expect(typeof subscription.subscribe).toBe('function');
+      expect(typeof subscription.unsubscribe).toBe('function');
+    });
+  });
+
+  describe('SupabaseChannel Interface', () => {
+    it('should accept valid channel objects', () => {
+      const channel: SupabaseChannel = {
+        topic: 'public:users',
+        params: { event: 'INSERT' },
+        join: () => channel,
+        leave: () => channel,
+        subscribe: (callback: (payload: any) => void) => channel,
+        unsubscribe: () => channel,
+        send: (type: string, payload: any) => channel,
+        on: (event: string, callback: (payload: any) => void) => channel,
+        off: (event: string, callback?: (payload: any) => void) => channel
+      };
+
+      expect(channel.topic).toBe('public:users');
+      expect(typeof channel.join).toBe('function');
+      expect(typeof channel.leave).toBe('function');
+      expect(typeof channel.subscribe).toBe('function');
+    });
+  });
+
+  describe('SupabasePresenceState Interface', () => {
+    it('should accept valid presence state objects', () => {
+      const presenceState: SupabasePresenceState = {
+        'user-123': {
+          user_id: 'user-123',
+          online_at: '2023-01-01T00:00:00Z',
+          metadata: {
+            name: 'John Doe',
+            avatar: 'https://example.com/avatar.jpg'
+          }
+        }
+      };
+
+      expect(presenceState['user-123'].user_id).toBe('user-123');
+      expect(presenceState['user-123'].online_at).toBe('2023-01-01T00:00:00Z');
+      expect(presenceState['user-123'].metadata.name).toBe('John Doe');
+    });
+  });
+
+  describe('SupabaseRealtimePayload Interface', () => {
+    it('should accept valid realtime payload objects', () => {
+      const payload: SupabaseRealtimePayload<{ id: string; name: string }> = {
+        new: { id: 'record-123', name: 'New Record' },
+        old: { id: 'record-123', name: 'Old Record' },
+        eventType: 'UPDATE',
+        schema: 'public',
+        table: 'users',
+        commit_timestamp: '2023-01-01T00:00:00Z',
+        errors: null
+      };
+
+      expect(payload.new?.id).toBe('record-123');
+      expect(payload.old?.name).toBe('Old Record');
+      expect(payload.eventType).toBe('UPDATE');
+      expect(payload.schema).toBe('public');
+      expect(payload.table).toBe('users');
+    });
+
+    it('should work with insert events', () => {
+      const payload: SupabaseRealtimePayload<{ id: string; name: string }> = {
+        new: { id: 'record-123', name: 'New Record' },
+        old: null,
+        eventType: 'INSERT',
+        schema: 'public',
+        table: 'users',
+        commit_timestamp: '2023-01-01T00:00:00Z',
+        errors: null
+      };
+
+      expect(payload.old).toBeNull();
+      expect(payload.eventType).toBe('INSERT');
+    });
+  });
+
+  describe('SupabaseStorageResponse Interface', () => {
+    it('should accept valid storage response objects', () => {
+      const storageResponse: SupabaseStorageResponse = {
+        data: {
+          path: '/avatars/user-123.jpg',
+          id: 'file-123',
+          size: 1024,
+          mimeType: 'image/jpeg',
+          lastAccessedAt: '2023-01-01T00:00:00Z',
+          updatedAt: '2023-01-01T00:00:00Z',
+          createdAt: '2023-01-01T00:00:00Z'
+        },
+        error: null
+      };
+
+      expect(storageResponse.data.path).toBe('/avatars/user-123.jpg');
+      expect(storageResponse.data.size).toBe(1024);
+      expect(storageResponse.data.mimeType).toBe('image/jpeg');
+      expect(storageResponse.error).toBeNull();
+    });
+  });
+
+  describe('SupabaseBucketResponse Interface', () => {
+    it('should accept valid bucket response objects', () => {
+      const bucketResponse: SupabaseBucketResponse = {
+        data: {
+          id: 'bucket-123',
+          name: 'avatars',
+          owner: 'user-123',
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+          public: false,
+          file_size_limit: 52428800,
+          allowed_mime_types: ['image/jpeg', 'image/png']
+        },
+        error: null
+      };
+
+      expect(bucketResponse.data.id).toBe('bucket-123');
+      expect(bucketResponse.data.name).toBe('avatars');
+      expect(bucketResponse.data.public).toBe(false);
+      expect(bucketResponse.error).toBeNull();
+    });
+  });
+
+  describe('SupabaseFileResponse Interface', () => {
+    it('should accept valid file response objects', () => {
+      const fileResponse: SupabaseFileResponse = {
+        data: {
+          name: 'avatar.jpg',
+          bucket_id: 'bucket-123',
+          owner: 'user-123',
+          id: 'file-123',
+          updated_at: '2023-01-01T00:00:00Z',
+          created_at: '2023-01-01T00:00:00Z',
+          last_accessed_at: '2023-01-01T00:00:00Z',
+          metadata: {
+            size: 1024,
+            mimetype: 'image/jpeg'
+          }
+        },
+        error: null
+      };
+
+      expect(fileResponse.data.name).toBe('avatar.jpg');
+      expect(fileResponse.data.bucket_id).toBe('bucket-123');
+      expect(fileResponse.data.metadata.size).toBe(1024);
+      expect(fileResponse.error).toBeNull();
+    });
+  });
+
+  describe('SupabaseFunctionResponse Interface', () => {
+    it('should accept valid function response objects', () => {
+      const functionResponse: SupabaseFunctionResponse<{ result: string }> = {
+        data: { result: 'success' },
+        error: null
+      };
+
+      expect(functionResponse.data.result).toBe('success');
+      expect(functionResponse.error).toBeNull();
+    });
+
+    it('should work with error responses', () => {
+      const functionResponse: SupabaseFunctionResponse<null> = {
+        data: null,
+        error: {
+          message: 'Function execution failed',
+          status: 500,
+          name: 'FunctionError'
+        }
+      };
+
+      expect(functionResponse.data).toBeNull();
+      expect(functionResponse.error?.message).toBe('Function execution failed');
+    });
+  });
+
+  describe('Type Compatibility', () => {
+    it('should ensure response types work with generic data', () => {
+      const userData = { id: 'user-123', name: 'John Doe' };
+      const response: SupabaseResponse<typeof userData> = {
+        data: userData,
+        error: null,
+        count: 1,
+        status: 200,
+        statusText: 'OK'
+      };
+
+      expect(response.data.id).toBe('user-123');
+      expect(response.data.name).toBe('John Doe');
+    });
+
+          it('should ensure query builder types work with table schemas', () => {
+        const userSchema = { id: 'string', name: 'string', email: 'string' };
+        const queryBuilder: SupabaseQueryBuilder<{ id: string; name: string; email: string }> = {
+        select: (columns: string) => queryBuilder,
+        insert: (values: any) => queryBuilder,
+        update: (values: any) => queryBuilder,
+        delete: () => queryBuilder,
+        eq: (column: string, value: any) => queryBuilder,
+        neq: (column: string, value: any) => queryBuilder,
+        gt: (column: string, value: any) => queryBuilder,
+        gte: (column: string, value: any) => queryBuilder,
+        lt: (column: string, value: any) => queryBuilder,
+        lte: (column: string, value: any) => queryBuilder,
+        like: (column: string, pattern: string) => queryBuilder,
+        ilike: (column: string, pattern: string) => queryBuilder,
+        in: (column: string, values: any[]) => queryBuilder,
+        is: (column: string, value: any) => queryBuilder,
+        or: (filters: string, values: any[]) => queryBuilder,
+        order: (column: string, options?: { ascending?: boolean; nullsFirst?: boolean }) => queryBuilder,
+        limit: (count: number) => queryBuilder,
+        range: (from: number, to: number) => queryBuilder,
+        single: () => Promise.resolve({ data: null, error: null }),
+        maybeSingle: () => Promise.resolve({ data: null, error: null }),
+        then: (onfulfilled: any, onrejected?: any) => Promise.resolve({ data: null, error: null })
+      };
+
+      expect(typeof queryBuilder.select).toBe('function');
+      expect(typeof queryBuilder.eq).toBe('function');
+    });
+  });
+});