@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/types/__tests__/type-validation.test.ts

@@ -1,526 +0,0 @@
-/**
- * @file Type Validation Tests
- * @package @jmruthers/pace-core
- * @module Types/__tests__
- * @since 1.0.0
- */
-
-import { describe, it, expect } from 'vitest';
-import type {
-  User,
-  Session,
-  Event,
-  Organisation,
-  PermissionString,
-  UserPermissions,
-  ValidationError,
-  ValidationResult,
-  QueryResult,
-  TableName,
-  RPCFunctionName
-} from '../index';
-
-describe('[types] Core Type Definitions', () => {
-  describe('User interface', () => {
-    it('validates User type structure', () => {
-      const user: User = {
-        id: 'test-user-id',
-        email: 'test@example.com',
-        app_metadata: {}
-      };
-
-      expect(user).toHaveProperty('id');
-      expect(user).toHaveProperty('email');
-      expect(user).toHaveProperty('app_metadata');
-      expect(typeof user.id).toBe('string');
-      expect(typeof user.email).toBe('string');
-      expect(typeof user.app_metadata).toBe('object');
-    });
-
-    it('validates User with optional properties', () => {
-      const user: User = {
-        id: 'test-user-id',
-        email: 'test@example.com'
-      };
-
-      expect(user).toHaveProperty('id');
-      expect(user).toHaveProperty('email');
-      expect(user.app_metadata).toBeUndefined();
-    });
-  });
-
-  describe('Session interface', () => {
-    it('validates Session type structure', () => {
-      const session: Session = {
-        access_token: 'test-access-token',
-        refresh_token: 'test-refresh-token',
-        expires_in: 3600,
-        token_type: 'bearer',
-        user: {
-          id: 'test-user-id',
-          email: 'test@example.com'
-        }
-      };
-
-      expect(session).toHaveProperty('access_token');
-      expect(session).toHaveProperty('refresh_token');
-      expect(session).toHaveProperty('expires_in');
-      expect(session).toHaveProperty('token_type');
-      expect(session).toHaveProperty('user');
-      expect(typeof session.access_token).toBe('string');
-      expect(typeof session.refresh_token).toBe('string');
-      expect(typeof session.expires_in).toBe('number');
-      expect(typeof session.token_type).toBe('string');
-      expect(typeof session.user).toBe('object');
-    });
-  });
-
-  describe('Event interface', () => {
-    it('validates Event type structure', () => {
-      const event: Event = {
-        event_id: 'test-event-id',
-        event_name: 'Test Event',
-        event_venue: 'Test Venue',
-        organisation_id: 'test-org-id',
-        event_start_date: '2024-01-01',
-        event_end_date: '2024-01-02',
-        event_description: 'Test event description',
-        event_status: 'active',
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z'
-      };
-
-      expect(event).toHaveProperty('event_id');
-      expect(event).toHaveProperty('event_name');
-      expect(event).toHaveProperty('event_venue');
-      expect(event).toHaveProperty('organisation_id');
-      expect(event).toHaveProperty('event_start_date');
-      expect(event).toHaveProperty('event_end_date');
-      expect(event).toHaveProperty('event_description');
-      expect(event).toHaveProperty('event_status');
-      expect(event).toHaveProperty('created_at');
-      expect(event).toHaveProperty('updated_at');
-      expect(typeof event.event_id).toBe('string');
-      expect(typeof event.event_name).toBe('string');
-      expect(typeof event.organisation_id).toBe('string');
-    });
-  });
-
-  describe('Organisation interface', () => {
-    it('validates Organisation type structure', () => {
-      const organisation: Organisation = {
-        id: 'test-org-id',
-        name: 'Test Organisation',
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z'
-      };
-
-      expect(organisation).toHaveProperty('id');
-      expect(organisation).toHaveProperty('name');
-      expect(organisation).toHaveProperty('created_at');
-      expect(organisation).toHaveProperty('updated_at');
-      expect(typeof organisation.id).toBe('string');
-      expect(typeof organisation.name).toBe('string');
-    });
-  });
-
-  describe('AccessLevel enum', () => {
-    it('validates AccessLevel values', () => {
-      const levels: AccessLevel[] = ['read', 'create', 'update', 'delete', 'manage'];
-      
-      expect(levels).toContain('read');
-      expect(levels).toContain('create');
-      expect(levels).toContain('update');
-      expect(levels).toContain('delete');
-      expect(levels).toContain('manage');
-    });
-
-    it('validates AccessLevel type usage', () => {
-      const level: AccessLevel = 'read';
-      expect(typeof level).toBe('string');
-      expect(['read', 'create', 'update', 'delete', 'manage']).toContain(level);
-    });
-  });
-
-  describe('PermissionString type', () => {
-    it('validates PermissionString format', () => {
-      const permissions: PermissionString[] = [
-        'read:users',
-        'create:events',
-        'update:organisations',
-        'delete:meals',
-        'manage:all'
-      ];
-
-      permissions.forEach(permission => {
-        expect(typeof permission).toBe('string');
-        expect(permission).toMatch(/^[a-z]+:[a-z_]+$/);
-      });
-    });
-  });
-
-  describe('UserPermissions interface', () => {
-    it('validates UserPermissions type structure', () => {
-      const userPermissions: UserPermissions = {
-        permissions: ['read:users', 'create:events'],
-        roles: ['admin', 'user']
-      };
-
-      expect(userPermissions).toHaveProperty('permissions');
-      expect(userPermissions).toHaveProperty('roles');
-      expect(Array.isArray(userPermissions.permissions)).toBe(true);
-      expect(Array.isArray(userPermissions.roles)).toBe(true);
-    });
-  });
-});
-
-describe('[types] Validation Types', () => {
-  describe('ValidationError interface', () => {
-    it('validates ValidationError type structure', () => {
-      const validationError: ValidationError = {
-        field: 'email',
-        message: 'Invalid email format',
-        code: 'INVALID_EMAIL'
-      };
-
-      expect(validationError).toHaveProperty('field');
-      expect(validationError).toHaveProperty('message');
-      expect(validationError).toHaveProperty('code');
-      expect(typeof validationError.field).toBe('string');
-      expect(typeof validationError.message).toBe('string');
-      expect(typeof validationError.code).toBe('string');
-    });
-  });
-
-  describe('ValidationResult interface', () => {
-    it('validates ValidationResult type structure', () => {
-      const successResult: ValidationResult<{ id: string }> = {
-        success: true,
-        data: { id: 'test-id' }
-      };
-
-      const errorResult: ValidationResult<{ id: string }> = {
-        success: false,
-        data: undefined
-      };
-
-      expect(successResult).toHaveProperty('success');
-      expect(successResult).toHaveProperty('data');
-      expect(typeof successResult.success).toBe('boolean');
-      expect(successResult.success).toBe(true);
-      expect(successResult.data).toEqual({ id: 'test-id' });
-
-      expect(errorResult.success).toBe(false);
-      expect(errorResult.data).toBeUndefined();
-    });
-  });
-});
-
-describe('[types] Supabase Types', () => {
-  describe('QueryResult interface', () => {
-    it('validates QueryResult type structure', () => {
-      const successResult: QueryResult<{ id: string }> = {
-        data: { id: 'test-id' },
-        error: null
-      };
-
-      const errorResult: QueryResult<{ id: string }> = {
-        data: null,
-        error: new Error('Test error')
-      };
-
-      expect(successResult).toHaveProperty('data');
-      expect(successResult).toHaveProperty('error');
-      expect(successResult.data).toEqual({ id: 'test-id' });
-      expect(successResult.error).toBeNull();
-
-      expect(errorResult.data).toBeNull();
-      expect(errorResult.error).toBeInstanceOf(Error);
-    });
-  });
-
-  describe('TableName type', () => {
-    it('validates TableName values', () => {
-      const tableNames: TableName[] = [
-        'users',
-        'rbac_global_roles',
-        'rbac_organisation_roles',
-        'rbac_event_app_roles',
-        'rbac_page_permissions',
-        'rbac_user_sessions',
-        'rbac_user_profiles',
-        'rbac_user_login_history',
-        'event',
-        'organisations',
-        'rbac_apps'
-      ];
-
-      tableNames.forEach(tableName => {
-        expect(typeof tableName).toBe('string');
-        expect(tableName).toMatch(/^[a-z_]+$/);
-      });
-    });
-  });
-
-  describe('RPCFunctionName type', () => {
-    it('validates RPCFunctionName values', () => {
-      const rpcFunctions: RPCFunctionName[] = [
-        'check_rbac_permission',
-        'check_rbac_permission_with_context',
-        'get_user_permissions',
-        'get_user_roles',
-        'create_rbac_rls_policy',
-        'update_rbac_rls_policy',
-        'delete_rbac_rls_policy',
-        'update_all_rbac_policies',
-        'register_rbac_table',
-        'unregister_rbac_table',
-        'get_rbac_audit_log',
-        'get_rbac_health_check',
-        'test_rbac_permission',
-        'get_rbac_policy_configs',
-        'update_rbac_policy_config',
-        'get_rbac_user_sessions',
-        'create_rbac_user_session',
-        'update_rbac_user_session',
-        'delete_rbac_user_session',
-        'get_rbac_user_login_history'
-      ];
-
-      rpcFunctions.forEach(rpcFunction => {
-        expect(typeof rpcFunction).toBe('string');
-        expect(rpcFunction).toMatch(/^[a-z_]+$/);
-      });
-    });
-  });
-});
-
-describe('[types] Type Usage Patterns', () => {
-  describe('Component Props with Types', () => {
-    it('validates component props using types', () => {
-      interface ButtonProps {
-        children: string;
-        onClick: () => void;
-        disabled?: boolean;
-        variant?: 'primary' | 'secondary';
-      }
-
-      const buttonProps: ButtonProps = {
-        children: 'Click me',
-        onClick: () => {},
-        disabled: false,
-        variant: 'primary'
-      };
-
-      expect(buttonProps).toHaveProperty('children');
-      expect(buttonProps).toHaveProperty('onClick');
-      expect(buttonProps).toHaveProperty('disabled');
-      expect(buttonProps).toHaveProperty('variant');
-      expect(typeof buttonProps.children).toBe('string');
-      expect(typeof buttonProps.onClick).toBe('function');
-      expect(typeof buttonProps.disabled).toBe('boolean');
-      expect(typeof buttonProps.variant).toBe('string');
-    });
-  });
-
-  describe('Hook Return Types', () => {
-    it('validates hook return types', () => {
-      interface UseAuthReturn {
-        user: User | null;
-        session: Session | null;
-        loading: boolean;
-        error: Error | null;
-        signIn: (email: string, password: string) => Promise<void>;
-        signOut: () => Promise<void>;
-      }
-
-      const authHook: UseAuthReturn = {
-        user: null,
-        session: null,
-        loading: false,
-        error: null,
-        signIn: async () => {},
-        signOut: async () => {}
-      };
-
-      expect(authHook).toHaveProperty('user');
-      expect(authHook).toHaveProperty('session');
-      expect(authHook).toHaveProperty('loading');
-      expect(authHook).toHaveProperty('error');
-      expect(authHook).toHaveProperty('signIn');
-      expect(authHook).toHaveProperty('signOut');
-      expect(typeof authHook.loading).toBe('boolean');
-      expect(typeof authHook.signIn).toBe('function');
-      expect(typeof authHook.signOut).toBe('function');
-    });
-  });
-
-  describe('API Response Types', () => {
-    it('validates API response types', () => {
-      interface ApiResponse<T> {
-        data: T | null;
-        error: string | null;
-        status: number;
-        message?: string;
-      }
-
-      const successResponse: ApiResponse<{ id: string }> = {
-        data: { id: 'test-id' },
-        error: null,
-        status: 200,
-        message: 'Success'
-      };
-
-      const errorResponse: ApiResponse<{ id: string }> = {
-        data: null,
-        error: 'Not found',
-        status: 404
-      };
-
-      expect(successResponse).toHaveProperty('data');
-      expect(successResponse).toHaveProperty('error');
-      expect(successResponse).toHaveProperty('status');
-      expect(successResponse).toHaveProperty('message');
-      expect(successResponse.data).toEqual({ id: 'test-id' });
-      expect(successResponse.error).toBeNull();
-      expect(successResponse.status).toBe(200);
-
-      expect(errorResponse.data).toBeNull();
-      expect(errorResponse.error).toBe('Not found');
-      expect(errorResponse.status).toBe(404);
-    });
-  });
-
-  describe('Form Data Types', () => {
-    it('validates form data types', () => {
-      interface LoginFormData {
-        email: string;
-        password: string;
-        rememberMe?: boolean;
-      }
-
-      const formData: LoginFormData = {
-        email: 'test@example.com',
-        password: 'password123',
-        rememberMe: true
-      };
-
-      expect(formData).toHaveProperty('email');
-      expect(formData).toHaveProperty('password');
-      expect(formData).toHaveProperty('rememberMe');
-      expect(typeof formData.email).toBe('string');
-      expect(typeof formData.password).toBe('string');
-      expect(typeof formData.rememberMe).toBe('boolean');
-    });
-  });
-
-  describe('Event Handler Types', () => {
-    it('validates event handler types', () => {
-      interface EventHandlers {
-        onClick: (event: MouseEvent) => void;
-        onChange: (event: ChangeEvent<HTMLInputElement>) => void;
-        onSubmit: (event: FormEvent<HTMLFormElement>) => void;
-      }
-
-      const handlers: EventHandlers = {
-        onClick: (event) => {},
-        onChange: (event) => {},
-        onSubmit: (event) => {}
-      };
-
-      expect(handlers).toHaveProperty('onClick');
-      expect(handlers).toHaveProperty('onChange');
-      expect(handlers).toHaveProperty('onSubmit');
-      expect(typeof handlers.onClick).toBe('function');
-      expect(typeof handlers.onChange).toBe('function');
-      expect(typeof handlers.onSubmit).toBe('function');
-    });
-  });
-});
-
-describe('[types] Type Guards', () => {
-  describe('Type guard functions', () => {
-    it('validates type guard for User', () => {
-      function isUser(obj: any): obj is User {
-        return obj && typeof obj.id === 'string' && typeof obj.email === 'string';
-      }
-
-      const validUser = { id: 'test-id', email: 'test@example.com' };
-      const invalidUser = { id: 'test-id', name: 'Test' };
-
-      expect(isUser(validUser)).toBe(true);
-      expect(isUser(invalidUser)).toBe(false);
-    });
-
-    it('validates type guard for Event', () => {
-      function isEvent(obj: any): obj is Event {
-        return obj && 
-               typeof obj.event_id === 'string' && 
-               typeof obj.event_name === 'string' &&
-               typeof obj.organisation_id === 'string';
-      }
-
-      const validEvent = {
-        event_id: 'test-event-id',
-        event_name: 'Test Event',
-        organisation_id: 'test-org-id'
-      };
-      const invalidEvent = { id: 'test-id', name: 'Test' };
-
-      expect(isEvent(validEvent)).toBe(true);
-      expect(isEvent(invalidEvent)).toBe(false);
-    });
-  });
-});
-
-describe('[types] Generic Types', () => {
-  describe('Generic utility types', () => {
-    it('validates generic response type', () => {
-      interface ApiResponse<T> {
-        data: T;
-        success: boolean;
-        message?: string;
-      }
-
-      const stringResponse: ApiResponse<string> = {
-        data: 'test',
-        success: true,
-        message: 'Success'
-      };
-
-      const numberResponse: ApiResponse<number> = {
-        data: 42,
-        success: true
-      };
-
-      expect(stringResponse.data).toBe('test');
-      expect(typeof stringResponse.data).toBe('string');
-      expect(numberResponse.data).toBe(42);
-      expect(typeof numberResponse.data).toBe('number');
-    });
-
-    it('validates generic option type', () => {
-      interface Option<T> {
-        value: T;
-        label: string;
-        disabled?: boolean;
-      }
-
-      const stringOption: Option<string> = {
-        value: 'option1',
-        label: 'Option 1',
-        disabled: false
-      };
-
-      const numberOption: Option<number> = {
-        value: 1,
-        label: 'First Option'
-      };
-
-      expect(stringOption.value).toBe('option1');
-      expect(typeof stringOption.value).toBe('string');
-      expect(numberOption.value).toBe(1);
-      expect(typeof numberOption.value).toBe('number');
-    });
-  });
-});