@jmruthers/pace-core 0.5.67 → 0.5.69

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

@@ -0,0 +1,527 @@
+/**
+ * @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,
+  AccessLevel,
+  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');
+    });
+  });
+});

package/src/utils/__tests__/bundleAnalysis.unit.test.ts

@@ -18,11 +18,7 @@ describe('bundleAnalysis', () => {
     };
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('bundleAnalyzer.analyzeBundle', () => {
+    describe('bundleAnalyzer.analyzeBundle', () => {
     it('should return null in production mode', async () => {
       const originalEnv = process.env.NODE_ENV;
       process.env.NODE_ENV = 'production';