@jmruthers/pace-core 0.2.4

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

@@ -0,0 +1,489 @@
+/**
+ * @file Database Types Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Types/Database
+ * @since 0.4.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Database } from '../database';
+
+describe('Database Types', () => {
+  describe('Database Interface', () => {
+    it('should have the correct structure', () => {
+      const db: Database = {
+        public: {
+          Tables: {
+            rbac_apps: {
+              Row: {
+                id: 'app-123',
+                name: 'test-app',
+                display_name: 'Test Application',
+                description: 'A test application',
+                requires_event: true,
+                is_active: true,
+                created_at: '2023-01-01T00:00:00Z',
+                updated_at: '2023-01-01T00:00:00Z',
+                created_by: 'user-123',
+                updated_by: 'user-123'
+              },
+              Insert: {
+                name: 'test-app',
+                display_name: 'Test Application',
+                description: 'A test application',
+                requires_event: true,
+                is_active: true
+              },
+              Update: {
+                name: 'updated-app',
+                display_name: 'Updated Application',
+                description: 'An updated application',
+                requires_event: false,
+                is_active: false
+              }
+            }
+          },
+          Views: {},
+          Functions: {}
+        }
+      };
+
+      expect(db.public.Tables.rbac_apps).toBeDefined();
+      expect(db.public.Tables.rbac_apps.Row).toBeDefined();
+      expect(db.public.Tables.rbac_apps.Insert).toBeDefined();
+      expect(db.public.Tables.rbac_apps.Update).toBeDefined();
+    });
+  });
+
+  describe('RBAC Apps Table', () => {
+    describe('Row Type', () => {
+      it('should accept valid row objects', () => {
+        const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+          id: 'app-123',
+          name: 'test-app',
+          display_name: 'Test Application',
+          description: 'A test application',
+          requires_event: true,
+          is_active: true,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+          created_by: 'user-123',
+          updated_by: 'user-123'
+        };
+
+        expect(row.id).toBe('app-123');
+        expect(row.name).toBe('test-app');
+        expect(row.display_name).toBe('Test Application');
+        expect(row.requires_event).toBe(true);
+        expect(row.is_active).toBe(true);
+      });
+
+      it('should work with null description and created_by/updated_by', () => {
+        const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+          id: 'app-123',
+          name: 'test-app',
+          display_name: 'Test Application',
+          description: null,
+          requires_event: false,
+          is_active: true,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+          created_by: null,
+          updated_by: null
+        };
+
+        expect(row.description).toBeNull();
+        expect(row.created_by).toBeNull();
+        expect(row.updated_by).toBeNull();
+      });
+    });
+
+    describe('Insert Type', () => {
+      it('should accept valid insert objects', () => {
+        const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+          name: 'test-app',
+          display_name: 'Test Application',
+          description: 'A test application',
+          requires_event: true,
+          is_active: true
+        };
+
+        expect(insert.name).toBe('test-app');
+        expect(insert.display_name).toBe('Test Application');
+        expect(insert.requires_event).toBe(true);
+        expect(insert.is_active).toBe(true);
+      });
+
+      it('should work with optional fields', () => {
+        const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+          name: 'test-app',
+          display_name: 'Test Application'
+        };
+
+        expect(insert.name).toBe('test-app');
+        expect(insert.display_name).toBe('Test Application');
+        expect(insert.description).toBeUndefined();
+        expect(insert.requires_event).toBeUndefined();
+        expect(insert.is_active).toBeUndefined();
+      });
+
+      it('should not include id, created_at, updated_at, created_by, updated_by', () => {
+        const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+          name: 'test-app',
+          display_name: 'Test Application'
+        };
+
+        // These properties should not exist on Insert type
+        expect((insert as any).id).toBeUndefined();
+        expect((insert as any).created_at).toBeUndefined();
+        expect((insert as any).updated_at).toBeUndefined();
+        expect((insert as any).created_by).toBeUndefined();
+        expect((insert as any).updated_by).toBeUndefined();
+      });
+    });
+
+    describe('Update Type', () => {
+      it('should accept valid update objects', () => {
+        const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+          name: 'updated-app',
+          display_name: 'Updated Application',
+          description: 'An updated application',
+          requires_event: false,
+          is_active: false
+        };
+
+        expect(update.name).toBe('updated-app');
+        expect(update.display_name).toBe('Updated Application');
+        expect(update.requires_event).toBe(false);
+        expect(update.is_active).toBe(false);
+      });
+
+      it('should work with partial updates', () => {
+        const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+          name: 'updated-app'
+        };
+
+        expect(update.name).toBe('updated-app');
+        expect(update.display_name).toBeUndefined();
+        expect(update.description).toBeUndefined();
+        expect(update.requires_event).toBeUndefined();
+        expect(update.is_active).toBeUndefined();
+      });
+
+      it('should not include id, created_at, updated_at, created_by, updated_by', () => {
+        const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+          name: 'updated-app'
+        };
+
+        // These properties should not exist on Update type
+        expect((update as any).id).toBeUndefined();
+        expect((update as any).created_at).toBeUndefined();
+        expect((update as any).updated_at).toBeUndefined();
+        expect((update as any).created_by).toBeUndefined();
+        expect((update as any).updated_by).toBeUndefined();
+      });
+    });
+  });
+
+  describe('Type Compatibility', () => {
+    it('should ensure Row type is compatible with full data', () => {
+      const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+        id: 'app-123',
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application',
+        requires_event: true,
+        is_active: true,
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:00:00Z',
+        created_by: 'user-123',
+        updated_by: 'user-123'
+      };
+
+      // Should be able to access all properties
+      expect(row.id).toBe('app-123');
+      expect(row.name).toBe('test-app');
+      expect(row.display_name).toBe('Test Application');
+      expect(row.description).toBe('A test application');
+      expect(row.requires_event).toBe(true);
+      expect(row.is_active).toBe(true);
+      expect(row.created_at).toBe('2023-01-01T00:00:00Z');
+      expect(row.updated_at).toBe('2023-01-01T00:00:00Z');
+      expect(row.created_by).toBe('user-123');
+      expect(row.updated_by).toBe('user-123');
+    });
+
+    it('should ensure Insert type excludes auto-generated fields', () => {
+      const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application',
+        requires_event: true,
+        is_active: true
+      };
+
+      // Should not have auto-generated fields
+      expect((insert as any).id).toBeUndefined();
+      expect((insert as any).created_at).toBeUndefined();
+      expect((insert as any).updated_at).toBeUndefined();
+      expect((insert as any).created_by).toBeUndefined();
+      expect((insert as any).updated_by).toBeUndefined();
+
+      // Should have the required fields
+      expect(insert.name).toBe('test-app');
+      expect(insert.display_name).toBe('Test Application');
+    });
+
+    it('should ensure Update type allows partial updates', () => {
+      const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+        name: 'updated-app',
+        is_active: false
+      };
+
+      // Should allow partial updates
+      expect(update.name).toBe('updated-app');
+      expect(update.is_active).toBe(false);
+      expect(update.display_name).toBeUndefined();
+      expect(update.description).toBeUndefined();
+      expect(update.requires_event).toBeUndefined();
+
+      // Should not have auto-generated fields
+      expect((update as any).id).toBeUndefined();
+      expect((update as any).created_at).toBeUndefined();
+      expect((update as any).updated_at).toBeUndefined();
+      expect((update as any).created_by).toBeUndefined();
+      expect((update as any).updated_by).toBeUndefined();
+    });
+  });
+
+  describe('Database Schema Structure', () => {
+    it('should have the correct public schema structure', () => {
+      const db: Database = {
+        public: {
+          Tables: {
+            rbac_apps: {
+              Row: {} as Database['public']['Tables']['rbac_apps']['Row'],
+              Insert: {} as Database['public']['Tables']['rbac_apps']['Insert'],
+              Update: {} as Database['public']['Tables']['rbac_apps']['Update']
+            }
+          },
+          Views: {},
+          Functions: {}
+        }
+      };
+
+      expect(db.public).toBeDefined();
+      expect(db.public.Tables).toBeDefined();
+      expect(db.public.Views).toBeDefined();
+      expect(db.public.Functions).toBeDefined();
+      expect(db.public.Tables.rbac_apps).toBeDefined();
+    });
+
+    it('should support multiple tables', () => {
+      // This test ensures the database type can be extended with additional tables
+      const db: Database = {
+        public: {
+          Tables: {
+            rbac_apps: {
+              Row: {} as Database['public']['Tables']['rbac_apps']['Row'],
+              Insert: {} as Database['public']['Tables']['rbac_apps']['Insert'],
+              Update: {} as Database['public']['Tables']['rbac_apps']['Update']
+            }
+            // Additional tables can be added here
+          },
+          Views: {},
+          Functions: {}
+        }
+      };
+
+      expect(db.public.Tables).toBeDefined();
+      expect(db.public.Tables.rbac_apps).toBeDefined();
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should prevent invalid field types in Row', () => {
+      // This test ensures TypeScript would catch type errors
+      const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+        id: 'app-123',
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application',
+        requires_event: true,
+        is_active: true,
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:00:00Z',
+        created_by: 'user-123',
+        updated_by: 'user-123'
+      };
+
+      // All fields should have the correct types
+      expect(typeof row.id).toBe('string');
+      expect(typeof row.name).toBe('string');
+      expect(typeof row.display_name).toBe('string');
+      expect(typeof row.description).toBe('string');
+      expect(typeof row.requires_event).toBe('boolean');
+      expect(typeof row.is_active).toBe('boolean');
+      expect(typeof row.created_at).toBe('string');
+      expect(typeof row.updated_at).toBe('string');
+      expect(typeof row.created_by).toBe('string');
+      expect(typeof row.updated_by).toBe('string');
+    });
+
+    it('should ensure Insert type has correct optional fields', () => {
+      const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+        name: 'test-app',
+        display_name: 'Test Application'
+      };
+
+      // Required fields should be present
+      expect(insert.name).toBe('test-app');
+      expect(insert.display_name).toBe('Test Application');
+
+      // Optional fields should be undefined
+      expect(insert.description).toBeUndefined();
+      expect(insert.requires_event).toBeUndefined();
+      expect(insert.is_active).toBeUndefined();
+    });
+
+    it('should ensure Update type allows all fields to be optional', () => {
+      const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+        name: 'updated-app'
+      };
+
+      // Should allow partial updates
+      expect(update.name).toBe('updated-app');
+      expect(update.display_name).toBeUndefined();
+      expect(update.description).toBeUndefined();
+      expect(update.requires_event).toBeUndefined();
+      expect(update.is_active).toBeUndefined();
+    });
+  });
+
+  describe('Null Handling', () => {
+    it('should handle null values correctly in Row type', () => {
+      const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+        id: 'app-123',
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: null,
+        requires_event: true,
+        is_active: true,
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:00:00Z',
+        created_by: null,
+        updated_by: null
+      };
+
+      expect(row.description).toBeNull();
+      expect(row.created_by).toBeNull();
+      expect(row.updated_by).toBeNull();
+    });
+
+    it('should not allow null values in Insert type for required fields', () => {
+      const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: null // This should be allowed
+      };
+
+      expect(insert.name).toBe('test-app');
+      expect(insert.display_name).toBe('Test Application');
+      expect(insert.description).toBeNull();
+    });
+  });
+
+  describe('Boolean Fields', () => {
+    it('should handle boolean fields correctly', () => {
+      const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+        id: 'app-123',
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application',
+        requires_event: true,
+        is_active: false,
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:00:00Z',
+        created_by: 'user-123',
+        updated_by: 'user-123'
+      };
+
+      expect(row.requires_event).toBe(true);
+      expect(row.is_active).toBe(false);
+      expect(typeof row.requires_event).toBe('boolean');
+      expect(typeof row.is_active).toBe('boolean');
+    });
+
+    it('should allow boolean fields in Insert type', () => {
+      const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+        name: 'test-app',
+        display_name: 'Test Application',
+        requires_event: true,
+        is_active: false
+      };
+
+      expect(insert.requires_event).toBe(true);
+      expect(insert.is_active).toBe(false);
+    });
+
+    it('should allow boolean fields in Update type', () => {
+      const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+        requires_event: false,
+        is_active: true
+      };
+
+      expect(update.requires_event).toBe(false);
+      expect(update.is_active).toBe(true);
+    });
+  });
+
+  describe('String Fields', () => {
+    it('should handle string fields correctly', () => {
+      const row: Database['public']['Tables']['rbac_apps']['Row'] = {
+        id: 'app-123',
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application',
+        requires_event: true,
+        is_active: true,
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:00:00Z',
+        created_by: 'user-123',
+        updated_by: 'user-123'
+      };
+
+      expect(typeof row.id).toBe('string');
+      expect(typeof row.name).toBe('string');
+      expect(typeof row.display_name).toBe('string');
+      expect(typeof row.description).toBe('string');
+      expect(typeof row.created_at).toBe('string');
+      expect(typeof row.updated_at).toBe('string');
+      expect(typeof row.created_by).toBe('string');
+      expect(typeof row.updated_by).toBe('string');
+    });
+
+    it('should allow string fields in Insert type', () => {
+      const insert: Database['public']['Tables']['rbac_apps']['Insert'] = {
+        name: 'test-app',
+        display_name: 'Test Application',
+        description: 'A test application'
+      };
+
+      expect(typeof insert.name).toBe('string');
+      expect(typeof insert.display_name).toBe('string');
+      expect(typeof insert.description).toBe('string');
+    });
+
+    it('should allow string fields in Update type', () => {
+      const update: Database['public']['Tables']['rbac_apps']['Update'] = {
+        name: 'updated-app',
+        display_name: 'Updated Application',
+        description: 'An updated application'
+      };
+
+      expect(typeof update.name).toBe('string');
+      expect(typeof update.display_name).toBe('string');
+      expect(typeof update.description).toBe('string');
+    });
+  });
+}); 

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

@@ -0,0 +1,146 @@
+/**
+ * @file Type Guards Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Types/Guards
+ * @since 0.4.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { isAuthErrorCode, isUser, isSession } from '../guards';
+import { AuthErrorCode } from '../unified';
+
+describe('Type Guards', () => {
+  describe('isAuthErrorCode', () => {
+    it('should return true for valid auth error codes', () => {
+      expect(isAuthErrorCode('INVALID_CREDENTIALS')).toBe(true);
+      expect(isAuthErrorCode('USER_NOT_FOUND')).toBe(true);
+      expect(isAuthErrorCode('EMAIL_NOT_CONFIRMED')).toBe(true);
+      expect(isAuthErrorCode('PASSWORD_TOO_WEAK')).toBe(true);
+      expect(isAuthErrorCode('WEAK_PASSWORD')).toBe(true);
+      expect(isAuthErrorCode('RATE_LIMITED')).toBe(true);
+      expect(isAuthErrorCode('RATE_LIMIT_EXCEEDED')).toBe(true);
+      expect(isAuthErrorCode('SESSION_EXPIRED')).toBe(true);
+      expect(isAuthErrorCode('PERMISSION_DENIED')).toBe(true);
+      expect(isAuthErrorCode('NETWORK_ERROR')).toBe(true);
+      expect(isAuthErrorCode('UNKNOWN_ERROR')).toBe(true);
+    });
+
+    it('should return false for invalid auth error codes', () => {
+      expect(isAuthErrorCode('INVALID_CODE')).toBe(false);
+      expect(isAuthErrorCode('')).toBe(false);
+      expect(isAuthErrorCode('random_string')).toBe(false);
+      expect(isAuthErrorCode('INVALID_EMAIL_EXTRA')).toBe(false);
+      expect(isAuthErrorCode('invalid_email')).toBe(false);
+    });
+
+    it('should return false for non-string values', () => {
+      expect(isAuthErrorCode(null as any)).toBe(false);
+      expect(isAuthErrorCode(undefined as any)).toBe(false);
+      expect(isAuthErrorCode(123 as any)).toBe(false);
+      expect(isAuthErrorCode({} as any)).toBe(false);
+      expect(isAuthErrorCode([] as any)).toBe(false);
+    });
+
+    it('should work with all AuthErrorCode enum values', () => {
+      Object.values(AuthErrorCode).forEach(code => {
+        expect(isAuthErrorCode(code)).toBe(true);
+      });
+    });
+  });
+
+  describe('isUser', () => {
+    it('should return true for valid user objects', () => {
+      const validUser = {
+        id: 'user-123',
+        created_at: '2023-01-01T00:00:00Z'
+      };
+      expect(isUser(validUser)).toBe(true);
+    });
+
+    it('should return false for objects missing required properties', () => {
+      expect(isUser({ id: 'user-123' })).toBe(false);
+      expect(isUser({ created_at: '2023-01-01T00:00:00Z' })).toBe(false);
+      expect(isUser({})).toBe(false);
+    });
+
+    it('should return false for objects with wrong property types', () => {
+      expect(isUser({ id: 123, created_at: '2023-01-01T00:00:00Z' })).toBe(false);
+      expect(isUser({ id: 'user-123', created_at: 123 })).toBe(false);
+      expect(isUser({ id: null, created_at: '2023-01-01T00:00:00Z' })).toBe(false);
+    });
+
+    it('should return false for null and undefined', () => {
+      expect(isUser(null)).toBe(false);
+      expect(isUser(undefined)).toBe(false);
+    });
+
+    it('should return false for non-objects', () => {
+      expect(isUser('string')).toBe(false);
+      expect(isUser(123)).toBe(false);
+      expect(isUser([])).toBe(false);
+      expect(isUser(true)).toBe(false);
+    });
+
+    it('should return true for user objects with additional properties', () => {
+      const userWithExtras = {
+        id: 'user-123',
+        created_at: '2023-01-01T00:00:00Z',
+        email: 'test@example.com',
+        name: 'Test User'
+      };
+      expect(isUser(userWithExtras)).toBe(true);
+    });
+  });
+
+  describe('isSession', () => {
+    it('should return true for valid session objects', () => {
+      const validSession = {
+        access_token: 'token-123',
+        user: { id: 'user-123' }
+      };
+      expect(isSession(validSession)).toBe(true);
+    });
+
+    it('should return false for objects missing required properties', () => {
+      expect(isSession({ access_token: 'token-123' })).toBe(false);
+      expect(isSession({ user: { id: 'user-123' } })).toBe(false);
+      expect(isSession({})).toBe(false);
+    });
+
+    it('should return false for objects with wrong property types', () => {
+      expect(isSession({ access_token: 123, user: { id: 'user-123' } })).toBe(false);
+      expect(isSession({ access_token: 'token-123', user: 'not-an-object' })).toBe(false);
+      expect(isSession({ access_token: null, user: { id: 'user-123' } })).toBe(false);
+    });
+
+    it('should return false for null and undefined', () => {
+      expect(isSession(null)).toBe(false);
+      expect(isSession(undefined)).toBe(false);
+    });
+
+    it('should return false for non-objects', () => {
+      expect(isSession('string')).toBe(false);
+      expect(isSession(123)).toBe(false);
+      expect(isSession([])).toBe(false);
+      expect(isSession(true)).toBe(false);
+    });
+
+    it('should return true for session objects with additional properties', () => {
+      const sessionWithExtras = {
+        access_token: 'token-123',
+        user: { id: 'user-123' },
+        refresh_token: 'refresh-123',
+        expires_at: 1234567890
+      };
+      expect(isSession(sessionWithExtras)).toBe(true);
+    });
+
+    it('should return true even if user object is empty', () => {
+      const sessionWithEmptyUser = {
+        access_token: 'token-123',
+        user: {}
+      };
+      expect(isSession(sessionWithEmptyUser)).toBe(true);
+    });
+  });
+});