@jmruthers/pace-core 0.2.7 → 0.5.1

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

@@ -1,537 +0,0 @@
-/**
- * @file Unified Types Unit Tests
- * @package @jmruthers/pace-core
- * @module Types/Unified
- * @since 0.4.0
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  AuthErrorCode,
-  PermissionErrorCode,
-  AccessLevel,
-  UserId,
-  SessionToken,
-  PermissionString,
-  RequestId,
-  createUserId,
-  createSessionToken,
-  createPermissionString,
-  createRequestId,
-  isUserId,
-  isSessionToken,
-  isPermissionString,
-  isRequestId,
-  User,
-  Session,
-  DataRecord,
-  DataTableAction,
-  DataTableColumn,
-  Event,
-  EventContextType,
-  UserPermissions,
-  PermissionMap,
-  PermissionContext,
-  AuthError,
-  PermissionError,
-  ThemeColors,
-  EventTheme
-} from '../unified';
-
-describe('Unified Types', () => {
-  describe('AuthErrorCode Enum', () => {
-    it('should have all expected error codes', () => {
-      expect(AuthErrorCode.UNKNOWN_ERROR).toBe('UNKNOWN_ERROR');
-      expect(AuthErrorCode.INVALID_CREDENTIALS).toBe('INVALID_CREDENTIALS');
-      expect(AuthErrorCode.USER_NOT_FOUND).toBe('USER_NOT_FOUND');
-      expect(AuthErrorCode.EMAIL_NOT_CONFIRMED).toBe('EMAIL_NOT_CONFIRMED');
-      expect(AuthErrorCode.PASSWORD_TOO_WEAK).toBe('PASSWORD_TOO_WEAK');
-      expect(AuthErrorCode.WEAK_PASSWORD).toBe('WEAK_PASSWORD');
-      expect(AuthErrorCode.RATE_LIMITED).toBe('RATE_LIMITED');
-      expect(AuthErrorCode.RATE_LIMIT_EXCEEDED).toBe('RATE_LIMIT_EXCEEDED');
-      expect(AuthErrorCode.SESSION_EXPIRED).toBe('SESSION_EXPIRED');
-      expect(AuthErrorCode.PERMISSION_DENIED).toBe('PERMISSION_DENIED');
-      expect(AuthErrorCode.NETWORK_ERROR).toBe('NETWORK_ERROR');
-    });
-
-    it('should have unique values', () => {
-      const values = Object.values(AuthErrorCode);
-      const uniqueValues = new Set(values);
-      expect(uniqueValues.size).toBe(values.length);
-    });
-  });
-
-  describe('PermissionErrorCode Enum', () => {
-    it('should have all expected error codes', () => {
-      expect(PermissionErrorCode.INSUFFICIENT_PERMISSIONS).toBe('INSUFFICIENT_PERMISSIONS');
-      expect(PermissionErrorCode.INVALID_PERMISSION).toBe('INVALID_PERMISSION');
-      expect(PermissionErrorCode.PERMISSION_CHECK_FAILED).toBe('PERMISSION_CHECK_FAILED');
-      expect(PermissionErrorCode.ACCESS_DENIED).toBe('ACCESS_DENIED');
-    });
-
-    it('should have unique values', () => {
-      const values = Object.values(PermissionErrorCode);
-      const uniqueValues = new Set(values);
-      expect(uniqueValues.size).toBe(values.length);
-    });
-  });
-
-  describe('AccessLevel Enum', () => {
-    it('should have all expected access levels', () => {
-      expect(AccessLevel.NONE).toBe('none');
-      expect(AccessLevel.VIEWER).toBe('viewer');
-      expect(AccessLevel.PARTICIPANT).toBe('participant');
-      expect(AccessLevel.EDITOR).toBe('editor');
-      expect(AccessLevel.PLANNER).toBe('planner');
-      expect(AccessLevel.ADMIN).toBe('admin');
-      expect(AccessLevel.SUPER_ADMIN).toBe('super_admin');
-      expect(AccessLevel.SUPER).toBe('super');
-    });
-
-    it('should have unique values', () => {
-      const values = Object.values(AccessLevel);
-      const uniqueValues = new Set(values);
-      expect(uniqueValues.size).toBe(values.length);
-    });
-  });
-
-  describe('Branded Type Creators', () => {
-    describe('createUserId', () => {
-      it('should create a valid UserId', () => {
-        const userId = createUserId('user-123');
-        expect(typeof userId).toBe('string');
-        expect(userId).toBe('user-123');
-      });
-
-      it('should work with empty string', () => {
-        const userId = createUserId('');
-        expect(typeof userId).toBe('string');
-        expect(userId).toBe('');
-      });
-    });
-
-    describe('createSessionToken', () => {
-      it('should create a valid SessionToken', () => {
-        const token = createSessionToken('token-123');
-        expect(typeof token).toBe('string');
-        expect(token).toBe('token-123');
-      });
-
-      it('should work with empty string', () => {
-        const token = createSessionToken('');
-        expect(typeof token).toBe('string');
-        expect(token).toBe('');
-      });
-    });
-
-    describe('createPermissionString', () => {
-      it('should create a valid PermissionString', () => {
-        const permission = createPermissionString('resource:action');
-        expect(typeof permission).toBe('string');
-        expect(permission).toBe('resource:action');
-      });
-
-      it('should work with complex permission strings', () => {
-        const permission = createPermissionString('events:create:organisation:123');
-        expect(typeof permission).toBe('string');
-        expect(permission).toBe('events:create:organisation:123');
-      });
-    });
-
-    describe('createRequestId', () => {
-      it('should create a valid RequestId', () => {
-        const requestId = createRequestId('req-123');
-        expect(typeof requestId).toBe('string');
-        expect(requestId).toBe('req-123');
-      });
-
-      it('should work with empty string', () => {
-        const requestId = createRequestId('');
-        expect(typeof requestId).toBe('string');
-        expect(requestId).toBe('');
-      });
-    });
-  });
-
-  describe('Branded Type Guards', () => {
-    describe('isUserId', () => {
-      it('should return true for valid user IDs', () => {
-        expect(isUserId('user-123')).toBe(true);
-        expect(isUserId('user_with_underscores')).toBe(true);
-        expect(isUserId('user-with-dashes')).toBe(true);
-      });
-
-      it('should return false for invalid user IDs', () => {
-        expect(isUserId(null)).toBe(false);
-        expect(isUserId(undefined)).toBe(false);
-        expect(isUserId(123)).toBe(false);
-        expect(isUserId({})).toBe(false);
-        expect(isUserId([])).toBe(false);
-      });
-    });
-
-    describe('isSessionToken', () => {
-      it('should return true for valid session tokens', () => {
-        expect(isSessionToken('token-123')).toBe(true);
-        expect(isSessionToken('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9')).toBe(true);
-      });
-
-      it('should return false for invalid session tokens', () => {
-        expect(isSessionToken(null)).toBe(false);
-        expect(isSessionToken(undefined)).toBe(false);
-        expect(isSessionToken(123)).toBe(false);
-        expect(isSessionToken({})).toBe(false);
-        expect(isSessionToken([])).toBe(false);
-      });
-    });
-
-    describe('isPermissionString', () => {
-      it('should return true for valid permission strings', () => {
-        expect(isPermissionString('resource:action')).toBe(true);
-        expect(isPermissionString('events:create')).toBe(true);
-      });
-
-      it('should return false for invalid permission strings', () => {
-        expect(isPermissionString('')).toBe(false);
-        expect(isPermissionString('resource')).toBe(false);
-        expect(isPermissionString('resource:action:extra')).toBe(false);
-        expect(isPermissionString(null)).toBe(false);
-        expect(isPermissionString(undefined)).toBe(false);
-        expect(isPermissionString(123)).toBe(false);
-        expect(isPermissionString({})).toBe(false);
-        expect(isPermissionString([])).toBe(false);
-      });
-    });
-
-    describe('isRequestId', () => {
-      it('should return true for valid request IDs', () => {
-        expect(isRequestId('req-123')).toBe(true);
-        expect(isRequestId('request_with_underscores')).toBe(true);
-        expect(isRequestId('request-with-dashes')).toBe(true);
-      });
-
-      it('should return false for invalid request IDs', () => {
-        expect(isRequestId(null)).toBe(false);
-        expect(isRequestId(undefined)).toBe(false);
-        expect(isRequestId(123)).toBe(false);
-        expect(isRequestId({})).toBe(false);
-        expect(isRequestId([])).toBe(false);
-      });
-    });
-  });
-
-  describe('Interface Type Compatibility', () => {
-    describe('User Interface', () => {
-      it('should accept valid user objects', () => {
-        const user: User = {
-          id: 'user-123',
-          email: 'test@example.com',
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z',
-          email_confirmed_at: '2023-01-01T00:00:00Z',
-          last_sign_in_at: '2023-01-01T00:00:00Z',
-          user_metadata: { name: 'Test User' },
-          app_metadata: { role: 'admin' }
-        };
-        expect(user.id).toBe('user-123');
-        expect(user.email).toBe('test@example.com');
-      });
-
-      it('should work with minimal user objects', () => {
-        const user: User = {
-          id: 'user-123',
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z'
-        };
-        expect(user.id).toBe('user-123');
-      });
-    });
-
-    describe('Session Interface', () => {
-      it('should accept valid session objects', () => {
-        const session: Session = {
-          access_token: 'token-123',
-          refresh_token: 'refresh-123',
-          expires_in: 3600,
-          expires_at: 1234567890,
-          token_type: 'bearer',
-          user: {
-            id: 'user-123',
-            created_at: '2023-01-01T00:00:00Z',
-            updated_at: '2023-01-01T00:00:00Z'
-          },
-          provider_token: 'provider-123',
-          provider_refresh_token: 'provider-refresh-123'
-        };
-        expect(session.access_token).toBe('token-123');
-        expect(session.user.id).toBe('user-123');
-      });
-
-      it('should work with minimal session objects', () => {
-        const session: Session = {
-          access_token: 'token-123',
-          expires_in: 3600,
-          expires_at: 1234567890,
-          token_type: 'bearer',
-          user: {
-            id: 'user-123',
-            created_at: '2023-01-01T00:00:00Z',
-            updated_at: '2023-01-01T00:00:00Z'
-          }
-        };
-        expect(session.access_token).toBe('token-123');
-      });
-    });
-
-    describe('DataRecord Interface', () => {
-      it('should accept valid data records', () => {
-        const record: DataRecord = {
-          id: 'record-123',
-          name: 'Test Record',
-          value: 42,
-          active: true
-        };
-        expect(record.id).toBe('record-123');
-        expect(record.name).toBe('Test Record');
-      });
-
-      it('should work with numeric IDs', () => {
-        const record: DataRecord = {
-          id: 123,
-          name: 'Test Record'
-        };
-        expect(record.id).toBe(123);
-      });
-    });
-
-    describe('DataTableAction Interface', () => {
-      it('should accept valid action objects', () => {
-        const action: DataTableAction = {
-          label: 'Edit',
-          onClick: (row) => console.log(row),
-          testId: 'edit-button',
-          disabled: false,
-          variant: 'primary'
-        };
-        expect(action.label).toBe('Edit');
-        expect(action.testId).toBe('edit-button');
-      });
-
-      it('should work with function-based disabled state', () => {
-        const action: DataTableAction = {
-          label: 'Delete',
-          onClick: (row) => console.log(row),
-          disabled: (row) => row.deleted,
-          variant: 'destructive'
-        };
-        expect(action.label).toBe('Delete');
-        expect(typeof action.disabled).toBe('function');
-      });
-    });
-
-    describe('DataTableColumn Interface', () => {
-      it('should accept valid column objects', () => {
-        const column: DataTableColumn = {
-          id: 'name',
-          key: 'name',
-          label: 'Name',
-          sortable: true,
-          filterable: true,
-          accessorKey: 'name',
-          enableSorting: true,
-          enableColumnFilter: true,
-          enableGrouping: true,
-          enableHiding: true
-        };
-        expect(column.id).toBe('name');
-        expect(column.label).toBe('Name');
-      });
-
-      it('should work with function-based accessors', () => {
-        const column: DataTableColumn = {
-          key: 'fullName',
-          label: 'Full Name',
-          accessorFn: (row) => `${row.firstName} ${row.lastName}`,
-          cell: (value, row) => `span: ${value}`
-        };
-        expect(column.key).toBe('fullName');
-        expect(typeof column.accessorFn).toBe('function');
-        expect(typeof column.cell).toBe('function');
-      });
-    });
-
-    describe('Event Interface', () => {
-      it('should accept valid event objects', () => {
-        const event: Event = {
-          id: 'event-123',
-          event_id: 'event-123',
-          event_name: 'Test Event',
-          event_code: 'TEST2024',
-          organisation_id: 'org-123',
-          event_date: '2024-01-01',
-          event_days: 3,
-          event_venue: 'Test Venue',
-          event_participants: 100,
-          is_visible: true,
-          event_logo: 'logo.png',
-          event_colours: { primary: '#ff0000' },
-          event_col_d1: '#ff0000',
-          event_col_d2: '#00ff00',
-          event_col_m1: '#0000ff',
-          event_col_m2: '#ffff00',
-          event_col_l1: '#ff00ff',
-          event_col_l2: '#00ffff',
-          event_news: 'Event news',
-          event_billing: 'Billing info',
-          event_catering_email: 'catering@test.com',
-          event_email: 'event@test.com',
-          event_footer: 'Event footer',
-          event_rounddown: 0.5,
-          event_youthmultiplier: 0.8,
-          event_typicalunit: 1.0,
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z',
-          created_by: 'user-123',
-          updated_by: 'user-123'
-        };
-        expect(event.id).toBe('event-123');
-        expect(event.event_name).toBe('Test Event');
-        expect(event.organisation_id).toBe('org-123');
-      });
-
-      it('should work with minimal event objects', () => {
-        const event: Event = {
-          id: 'event-123',
-          event_id: 'event-123',
-          event_name: 'Test Event',
-          organisation_id: 'org-123',
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z'
-        };
-        expect(event.id).toBe('event-123');
-        expect(event.event_name).toBe('Test Event');
-      });
-    });
-
-    describe('EventContextType Interface', () => {
-      it('should accept valid context objects', () => {
-        const context: EventContextType = {
-          selectedEvent: null,
-          currentEvent: null,
-          events: [],
-          isLoading: false,
-          error: null,
-          selectEvent: (event) => {},
-          setCurrentEvent: (event) => {},
-          clearSelection: () => {},
-          refreshEvents: async () => {},
-          createEvent: async (event) => ({ id: 'new-event' } as Event),
-          updateEvent: async (id, updates) => ({ id } as Event),
-          deleteEvent: async (id) => {}
-        };
-        expect(context.selectedEvent).toBe(null);
-        expect(context.isLoading).toBe(false);
-        expect(typeof context.selectEvent).toBe('function');
-      });
-    });
-
-    describe('UserPermissions Interface', () => {
-      it('should accept valid user permissions', () => {
-        const permissions: UserPermissions = {
-          user_id: createUserId('user-123'),
-          accessLevel: AccessLevel.ADMIN,
-          permissions: { 'events:create': true, 'users:read': true },
-          roles: ['admin', 'leader']
-        };
-        expect(permissions.user_id).toBe('user-123');
-        expect(permissions.accessLevel).toBe(AccessLevel.ADMIN);
-        expect(permissions.roles).toEqual(['admin', 'leader']);
-      });
-    });
-
-    describe('PermissionContext Interface', () => {
-      it('should accept valid permission context', () => {
-        const context: PermissionContext = {
-          eventId: 'event-123',
-          appName: 'test-app',
-          userId: 'user-123'
-        };
-        expect(context.eventId).toBe('event-123');
-        expect(context.appName).toBe('test-app');
-        expect(context.userId).toBe('user-123');
-      });
-
-      it('should work with partial context', () => {
-        const context: PermissionContext = {
-          eventId: 'event-123'
-        };
-        expect(context.eventId).toBe('event-123');
-        expect(context.appName).toBeUndefined();
-        expect(context.userId).toBeUndefined();
-      });
-    });
-
-    describe('ThemeColors Interface', () => {
-      it('should accept valid theme colors', () => {
-        const colors: ThemeColors = {
-          primary: '#ff0000',
-          secondary: '#00ff00',
-          hover: '#ffff00',
-          active: '#ff00ff',
-          bgSoft: '#f0f0f0'
-        };
-        expect(colors.primary).toBe('#ff0000');
-        expect(colors.secondary).toBe('#00ff00');
-      });
-
-      it('should work with minimal theme colors', () => {
-        const colors: ThemeColors = {
-          primary: '#ff0000',
-          secondary: '#00ff00'
-        };
-        expect(colors.primary).toBe('#ff0000');
-        expect(colors.secondary).toBe('#00ff00');
-      });
-    });
-
-    describe('EventTheme Interface', () => {
-      it('should accept valid event theme', () => {
-        const theme: EventTheme = {
-          mid: {
-            primary: '#ffff00',
-            secondary: '#ff00ff'
-          },
-          light: {
-            primary: '#00ffff',
-            secondary: '#ffffff'
-          }
-        };
-        expect(theme.mid.primary).toBe('#ffff00');
-        expect(theme.light.primary).toBe('#00ffff');
-      });
-    });
-  });
-
-  describe('Type Compatibility with Branded Types', () => {
-    it('should work with UserId in UserPermissions', () => {
-      const userId = createUserId('user-123');
-      const permissions: UserPermissions = {
-        user_id: userId,
-        accessLevel: AccessLevel.VIEWER,
-        permissions: {},
-        roles: []
-      };
-      expect(permissions.user_id).toBe('user-123');
-    });
-
-    it('should work with PermissionString in PermissionMap', () => {
-      const permission = createPermissionString('events:create');
-      const permissionMap: PermissionMap = {
-        [permission]: true,
-        'users:read': false
-      };
-      expect(permissionMap[permission]).toBe(true);
-      expect(permissionMap['users:read']).toBe(false);
-    });
-  });
-});