core tests

adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.test.ts

@@ -1,6 +1,6 @@
-import { AdminUser } from '../../domain/entities/AdminUser';
+import { AdminUser } from '@core/admin/domain/entities/AdminUser';
-import { UserRole } from '../../domain/value-objects/UserRole';
+import { UserRole } from '@core/admin/domain/value-objects/UserRole';
-import { UserStatus } from '../../domain/value-objects/UserStatus';
+import { UserStatus } from '@core/admin/domain/value-objects/UserStatus';
 import { InMemoryAdminUserRepository } from './InMemoryAdminUserRepository';
 
 describe('InMemoryAdminUserRepository', () => {
@@ -787,4 +787,4 @@ describe('InMemoryAdminUserRepository', () => {
       });
     });
   });
-});
+});

adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.ts

@@ -1,7 +1,7 @@
-import { AdminUser } from '../../domain/entities/AdminUser';
+import { AdminUser } from '@core/admin/domain/entities/AdminUser';
-import { AdminUserRepository, StoredAdminUser, UserFilter, UserListQuery, UserListResult } from '../../domain/repositories/AdminUserRepository';
+import { AdminUserRepository, StoredAdminUser, UserFilter, UserListQuery, UserListResult } from '@core/admin/domain/repositories/AdminUserRepository';
-import { Email } from '../../domain/value-objects/Email';
+import { Email } from '@core/admin/domain/value-objects/Email';
-import { UserId } from '../../domain/value-objects/UserId';
+import { UserId } from '@core/admin/domain/value-objects/UserId';
 
 /**
  * In-memory implementation of AdminUserRepository for testing and development
@@ -254,4 +254,4 @@ export class InMemoryAdminUserRepository implements AdminUserRepository {
 
     return AdminUser.rehydrate(props);
   }
-}
+}

adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.ts

@@ -10,4 +10,4 @@ export class TypeOrmAdminSchemaError extends Error {
     super(`[TypeOrmAdminSchemaError] ${details.entityName}.${details.fieldName}: ${details.reason} - ${details.message}`);
     this.name = 'TypeOrmAdminSchemaError';
   }
-}
+}

adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.ts

@@ -92,4 +92,4 @@ export class AdminUserOrmMapper {
   toStored(entity: AdminUserOrmEntity): AdminUser {
     return this.toDomain(entity);
   }
-}
+}

adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.test.ts

@@ -1016,4 +1016,4 @@ describe('TypeOrmAdminUserRepository', () => {
       expect(count).toBe(1);
     });
   });
-});
+});

adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.ts

@@ -185,4 +185,4 @@ export class TypeOrmAdminUserRepository implements AdminUserRepository {
 
     return AdminUser.rehydrate(props);
   }
-}
+}

adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts

@@ -0,0 +1,365 @@
+import { describe, expect, it } from 'vitest';
+import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError';
+import {
+  assertNonEmptyString,
+  assertStringArray,
+  assertDate,
+  assertOptionalDate,
+  assertOptionalString,
+} from './TypeOrmAdminSchemaGuards';
+
+describe('TypeOrmAdminSchemaGuards', () => {
+  describe('TDD - Test First', () => {
+    describe('assertNonEmptyString', () => {
+      it('should pass for valid non-empty string', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = 'test@example.com';
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should throw error for empty string', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = '';
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string');
+      });
+
+      it('should throw error for string with only spaces', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = '   ';
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string');
+      });
+
+      it('should throw error for non-string value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = 123;
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string');
+      });
+
+      it('should throw error for null value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = null;
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string');
+      });
+
+      it('should throw error for undefined value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'email';
+        const value = undefined;
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string');
+      });
+    });
+
+    describe('assertStringArray', () => {
+      it('should pass for valid string array', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = ['admin', 'user'];
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for empty array', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = [];
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should throw error for non-array value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = 'admin';
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings');
+      });
+
+      it('should throw error for array with non-string items', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = ['admin', 123];
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings');
+      });
+
+      it('should throw error for null value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = null;
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings');
+      });
+
+      it('should throw error for undefined value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'roles';
+        const value = undefined;
+
+        // Act & Assert
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings');
+      });
+    });
+
+    describe('assertDate', () => {
+      it('should pass for valid Date', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = new Date();
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for specific date', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = new Date('2024-01-01');
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should throw error for invalid date', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = new Date('invalid');
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date');
+      });
+
+      it('should throw error for non-Date value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = '2024-01-01';
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date');
+      });
+
+      it('should throw error for null value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = null;
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date');
+      });
+
+      it('should throw error for undefined value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'createdAt';
+        const value = undefined;
+
+        // Act & Assert
+        expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date');
+      });
+    });
+
+    describe('assertOptionalDate', () => {
+      it('should pass for valid Date', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'lastLoginAt';
+        const value = new Date();
+
+        // Act & Assert
+        expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for null value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'lastLoginAt';
+        const value = null;
+
+        // Act & Assert
+        expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for undefined value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'lastLoginAt';
+        const value = undefined;
+
+        // Act & Assert
+        expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should throw error for invalid date', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'lastLoginAt';
+        const value = new Date('invalid');
+
+        // Act & Assert
+        expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow('Field lastLoginAt must be a valid Date');
+      });
+
+      it('should throw error for non-Date value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'lastLoginAt';
+        const value = '2024-01-01';
+
+        // Act & Assert
+        expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow('Field lastLoginAt must be a valid Date');
+      });
+    });
+
+    describe('assertOptionalString', () => {
+      it('should pass for valid string', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'primaryDriverId';
+        const value = 'driver-123';
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for null value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'primaryDriverId';
+        const value = null;
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should pass for undefined value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'primaryDriverId';
+        const value = undefined;
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow();
+      });
+
+      it('should throw error for non-string value', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'primaryDriverId';
+        const value = 123;
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalString(entityName, fieldName, value)).toThrow('Field primaryDriverId must be a string or undefined');
+      });
+
+      it('should throw error for empty string', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const fieldName = 'primaryDriverId';
+        const value = '';
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalString(entityName, fieldName, value)).toThrow('Field primaryDriverId must be a string or undefined');
+      });
+    });
+
+    describe('real-world scenarios', () => {
+      it('should validate complete admin user entity', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const id = 'user-123';
+        const email = 'admin@example.com';
+        const displayName = 'Admin User';
+        const roles = ['owner', 'admin'];
+        const status = 'active';
+        const createdAt = new Date();
+        const updatedAt = new Date();
+
+        // Act & Assert
+        expect(() => assertNonEmptyString(entityName, 'id', id)).not.toThrow();
+        expect(() => assertNonEmptyString(entityName, 'email', email)).not.toThrow();
+        expect(() => assertNonEmptyString(entityName, 'displayName', displayName)).not.toThrow();
+        expect(() => assertStringArray(entityName, 'roles', roles)).not.toThrow();
+        expect(() => assertNonEmptyString(entityName, 'status', status)).not.toThrow();
+        expect(() => assertDate(entityName, 'createdAt', createdAt)).not.toThrow();
+        expect(() => assertDate(entityName, 'updatedAt', updatedAt)).not.toThrow();
+      });
+
+      it('should validate admin user with optional fields', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const primaryDriverId = 'driver-456';
+        const lastLoginAt = new Date();
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, 'primaryDriverId', primaryDriverId)).not.toThrow();
+        expect(() => assertOptionalDate(entityName, 'lastLoginAt', lastLoginAt)).not.toThrow();
+      });
+
+      it('should validate admin user without optional fields', () => {
+        // Arrange
+        const entityName = 'AdminUser';
+        const primaryDriverId = undefined;
+        const lastLoginAt = null;
+
+        // Act & Assert
+        expect(() => assertOptionalString(entityName, 'primaryDriverId', primaryDriverId)).not.toThrow();
+        expect(() => assertOptionalDate(entityName, 'lastLoginAt', lastLoginAt)).not.toThrow();
+      });
+    });
+  });
+});

adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.ts

@@ -52,4 +52,4 @@ export function assertOptionalString(entityName: string, fieldName: string, valu
       message: `Field ${fieldName} must be a string or undefined`,
     });
   }
-}
+}

core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts

@@ -1,253 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  assertNonEmptyString,
-  assertStringArray,
-  assertDate,
-  assertOptionalDate,
-  assertOptionalString,
-} from './TypeOrmAdminSchemaGuards';
-import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError';
-
-describe('TypeOrmAdminSchemaGuards', () => {
-  describe('TDD - Test First', () => {
-    describe('assertNonEmptyString', () => {
-      it('should not throw for valid non-empty string', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 'valid string')).not.toThrow();
-      });
-
-      it('should throw for empty string', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for string with only whitespace', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '   ')).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '   ')).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for null', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for undefined', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for number', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for object', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should throw for array', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a non-empty string');
-      });
-
-      it('should include entity name in error message', () => {
-        // Arrange & Act & Assert
-        expect(() => assertNonEmptyString('AdminUser', 'email', '')).toThrow('[TypeOrmAdminSchemaError] AdminUser.email: INVALID_STRING - Field email must be a non-empty string');
-      });
-    });
-
-    describe('assertStringArray', () => {
-      it('should not throw for valid string array', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 'b', 'c'])).not.toThrow();
-      });
-
-      it('should not throw for empty array', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', [])).not.toThrow();
-      });
-
-      it('should throw for non-array', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for null', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for undefined', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for array with non-string items', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for array with null items', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for array with undefined items', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should throw for array with object items', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow('Field fieldName must be an array of strings');
-      });
-
-      it('should include entity name in error message', () => {
-        // Arrange & Act & Assert
-        expect(() => assertStringArray('AdminUser', 'roles', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.roles: INVALID_STRING_ARRAY - Field roles must be an array of strings');
-      });
-    });
-
-    describe('assertDate', () => {
-      it('should not throw for valid Date', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', new Date())).not.toThrow();
-      });
-
-      it('should not throw for Date with valid timestamp', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', new Date('2024-01-01'))).not.toThrow();
-      });
-
-      it('should throw for null', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for undefined', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for string', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for number', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for object', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for invalid Date (NaN)', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should include entity name in error message', () => {
-        // Arrange & Act & Assert
-        expect(() => assertDate('AdminUser', 'createdAt', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.createdAt: INVALID_DATE - Field createdAt must be a valid Date');
-      });
-    });
-
-    describe('assertOptionalDate', () => {
-      it('should not throw for valid Date', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date())).not.toThrow();
-      });
-
-      it('should not throw for null', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', null)).not.toThrow();
-      });
-
-      it('should not throw for undefined', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', undefined)).not.toThrow();
-      });
-
-      it('should throw for invalid Date', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should throw for string', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date');
-      });
-
-      it('should include entity name in error message', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalDate('AdminUser', 'lastLoginAt', new Date('invalid'))).toThrow('[TypeOrmAdminSchemaError] AdminUser.lastLoginAt: INVALID_DATE - Field lastLoginAt must be a valid Date');
-      });
-    });
-
-    describe('assertOptionalString', () => {
-      it('should not throw for valid string', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', 'valid string')).not.toThrow();
-      });
-
-      it('should not throw for null', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', null)).not.toThrow();
-      });
-
-      it('should not throw for undefined', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', undefined)).not.toThrow();
-      });
-
-      it('should throw for number', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a string or undefined');
-      });
-
-      it('should throw for object', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a string or undefined');
-      });
-
-      it('should throw for array', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError);
-        expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a string or undefined');
-      });
-
-      it('should include entity name in error message', () => {
-        // Arrange & Act & Assert
-        expect(() => assertOptionalString('AdminUser', 'primaryDriverId', 123)).toThrow('[TypeOrmAdminSchemaError] AdminUser.primaryDriverId: INVALID_OPTIONAL_STRING - Field primaryDriverId must be a string or undefined');
-      });
-    });
-  });
-});