@mikro-orm/core 7.0.0-dev.74 → 7.0.0-dev.76

package/EntityManager.d.ts

@@ -3,7 +3,6 @@ import { type Configuration } from './utils/Configuration.js';
 import { Cursor } from './utils/Cursor.js';
 import { EntityFactory } from './entity/EntityFactory.js';
 import { type AssignOptions } from './entity/EntityAssigner.js';
-import { EntityValidator } from './entity/EntityValidator.js';
 import { type EntityRepository } from './entity/EntityRepository.js';
 import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js';
 import { Reference } from './entity/Reference.js';
@@ -33,7 +32,6 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     readonly global = false;
     readonly name: string;
     private readonly loaders;
-    private readonly validator;
     private readonly repositoryMap;
     private readonly entityLoader;
     protected readonly comparator: EntityComparator;
@@ -72,10 +70,6 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Shortcut for `em.getRepository()`.
      */
     repo<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(entityName: EntityName<Entity>): GetRepository<Entity, Repository>;
-    /**
-     * Gets EntityValidator instance
-     */
-    getValidator(): EntityValidator;
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */

package/EntityManager.js

@@ -8,7 +8,7 @@ import { TransactionContext } from './utils/TransactionContext.js';
 import { isRaw, RawQueryFragment } from './utils/RawQueryFragment.js';
 import { EntityFactory } from './entity/EntityFactory.js';
 import { EntityAssigner } from './entity/EntityAssigner.js';
-import { EntityValidator } from './entity/EntityValidator.js';
+import { validateEmptyWhere, validateParams, validatePrimaryKey, validateProperty } from './entity/validators.js';
 import { EntityLoader } from './entity/EntityLoader.js';
 import { Reference } from './entity/Reference.js';
 import { helper } from './entity/wrap.js';
@@ -36,7 +36,6 @@ export class EntityManager {
     global = false;
     name;
     loaders = {};
-    validator;
     repositoryMap = {};
     entityLoader;
     comparator;
@@ -61,7 +60,6 @@ export class EntityManager {
         this.eventManager = eventManager;
         this.entityLoader = new EntityLoader(this);
         this.name = this.config.get('contextName');
-        this.validator = new EntityValidator(this.config.get('strict'));
         this.comparator = this.config.getComparator(this.metadata);
         this.resultCache = this.config.getResultCacheAdapter();
         this.disableTransactions = this.config.get('disableTransactions');
@@ -105,12 +103,6 @@ export class EntityManager {
     repo(entityName) {
         return this.getRepository(entityName);
     }
-    /**
-     * Gets EntityValidator instance
-     */
-    getValidator() {
-        return this.validator;
-    }
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */
@@ -127,7 +119,7 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
-        em.validator.validateParams(where);
+        validateParams(where);
         options.orderBy = options.orderBy || {};
         options.populate = await em.preparePopulate(entityName, options);
         const populate = options.populate;
@@ -203,7 +195,7 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         entityName = Utils.className(entityName);
         const where = await em.processWhere(entityName, options.where ?? {}, options, 'read');
-        em.validator.validateParams(where);
+        validateParams(where);
         options.orderBy = options.orderBy || {};
         options.populate = await em.preparePopulate(entityName, options);
         const meta = this.metadata.get(entityName);
@@ -625,13 +617,13 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         const meta = em.metadata.get(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
-        em.validator.validateEmptyWhere(where);
+        validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
         const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }
-        em.validator.validateParams(where);
+        validateParams(where);
         options.populate = await em.preparePopulate(entityName, options);
         const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
@@ -763,7 +755,7 @@ export class EntityManager {
         }
         where = getWhereCondition(meta, options.onConflictFields, data, where).where;
         data = QueryHelper.processObjectParams(data);
-        em.validator.validateParams(data, 'insert data');
+        validateParams(data, 'insert data');
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
             await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity: data, em, meta }, meta);
         }
@@ -915,7 +907,7 @@ export class EntityManager {
                 platform: this.getPlatform(),
             });
             row = QueryHelper.processObjectParams(row);
-            em.validator.validateParams(row, 'insert data');
+            validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
         }
@@ -1144,7 +1136,7 @@ export class EntityManager {
             return cs.getPrimaryKey();
         }
         data = QueryHelper.processObjectParams(data);
-        em.validator.validateParams(data, 'insert data');
+        validateParams(data, 'insert data');
         const res = await em.driver.nativeInsert(entityName, data, { ctx: em.transactionContext, ...options });
         return res.insertId;
     }
@@ -1184,7 +1176,7 @@ export class EntityManager {
             return css.map(cs => cs.getPrimaryKey());
         }
         data = data.map(row => QueryHelper.processObjectParams(row));
-        data.forEach(row => em.validator.validateParams(row, 'insert data'));
+        data.forEach(row => validateParams(row, 'insert data'));
         const res = await em.driver.nativeInsertMany(entityName, data, { ctx: em.transactionContext, ...options });
         if (res.insertedIds) {
             return res.insertedIds;
@@ -1200,8 +1192,8 @@ export class EntityManager {
         entityName = Utils.className(entityName);
         data = QueryHelper.processObjectParams(data);
         where = await em.processWhere(entityName, where, { ...options, convertCustomTypes: false }, 'update');
-        em.validator.validateParams(data, 'update data');
-        em.validator.validateParams(where, 'update condition');
+        validateParams(data, 'update data');
+        validateParams(where, 'update condition');
         const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, ...options });
         return res.affectedRows;
     }
@@ -1213,7 +1205,7 @@ export class EntityManager {
         em.prepareOptions(options);
         entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'delete');
-        em.validator.validateParams(where, 'delete condition');
+        validateParams(where, 'delete condition');
         const res = await em.driver.nativeDelete(entityName, where, { ctx: em.transactionContext, ...options });
         return res.affectedRows;
     }
@@ -1224,15 +1216,17 @@ export class EntityManager {
         entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const data = this.driver.mapResult(result, meta);
-        Object.keys(data).forEach(k => {
+        for (const k of Object.keys(data)) {
             const prop = meta.properties[k];
-            if (prop && prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.includes(prop.runtimeType) && !prop.customType && (prop.setter || !prop.getter)) {
-                data[k] = this.validator.validateProperty(prop, data[k], data);
+            if (prop?.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && !prop.customType && (prop.setter || !prop.getter)) {
+                validateProperty(prop, data[k], data);
             }
-        });
+        }
         return this.merge(entityName, data, {
             convertCustomTypes: true,
-            refresh: true, ...options,
+            refresh: true,
+            validate: false,
+            ...options,
         });
     }
     /**
@@ -1248,15 +1242,11 @@ export class EntityManager {
         options.validate ??= true;
         options.cascade ??= true;
         entityName = Utils.className(entityName);
-        if (options.validate) {
-            em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
-        }
+        validatePrimaryKey(data, em.metadata.get(entityName));
         let entity = em.unitOfWork.tryGetById(entityName, data, options.schema, false);
         if (entity && helper(entity).__managed && helper(entity).__initialized && !options.refresh) {
             return entity;
         }
-        const meta = em.metadata.find(entityName);
-        const childMeta = em.metadata.getByDiscriminatorColumn(meta, data);
         const dataIsEntity = Utils.isEntity(data);
         if (options.keepIdentity && entity && dataIsEntity && entity !== data) {
             helper(entity).__data = helper(data).__data;
@@ -1264,9 +1254,6 @@ export class EntityManager {
             return entity;
         }
         entity = dataIsEntity ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
-        if (options.validate) {
-            em.validator.validate(entity, data, childMeta ?? meta);
-        }
         const visited = options.cascade ? undefined : new Set([entity]);
         em.unitOfWork.merge(entity, visited);
         return entity;
@@ -1344,7 +1331,7 @@ export class EntityManager {
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
         options.populateFilter = await this.getJoinedFilters(meta, options);
-        em.validator.validateParams(where);
+        validateParams(where);
         delete options.orderBy;
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey);

package/entity/EntityAssigner.js

@@ -3,10 +3,9 @@ import { Collection } from './Collection.js';
 import { Utils } from '../utils/Utils.js';
 import { Reference } from './Reference.js';
 import { ReferenceKind, SCALAR_TYPES } from '../enums.js';
-import { EntityValidator } from './EntityValidator.js';
+import { validateProperty } from './validators.js';
 import { helper, wrap } from './wrap.js';
 import { EntityHelper } from './EntityHelper.js';
-const validator = new EntityValidator(false);
 export class EntityAssigner {
     static assign(entity, data, options = {}) {
         let opts = options;
@@ -94,8 +93,9 @@ export class EntityAssigner {
             }
             return EntityAssigner.assignReference(entity, value, prop, options.em, options);
         }
-        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
-            return entity[prop.name] = validator.validateProperty(prop, value, entity);
+        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
+            validateProperty(prop, value, entity);
+            return entity[prop.name] = value;
         }
         if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);

package/entity/index.d.ts

@@ -1,6 +1,5 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
-export * from './EntityValidator.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';
@@ -9,6 +8,7 @@ export * from './EntityLoader.js';
 export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
+export * from './validators.js';
 export * from './wrap.js';
 export * from './defineEntity.js';
 export * from './utils.js';

package/entity/index.js

@@ -1,6 +1,5 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
-export * from './EntityValidator.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';
@@ -9,6 +8,7 @@ export * from './EntityLoader.js';
 export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
+export * from './validators.js';
 export * from './wrap.js';
 export * from './defineEntity.js';
 export * from './utils.js';

package/entity/validators.d.ts

@@ -0,0 +1,11 @@
+import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings.js';
+/** @internal */
+export declare function validateProperty<T extends object>(prop: EntityProperty, givenValue: any, entity: T): void;
+/** @internal */
+export declare function validateEntity<T extends object>(entity: T, meta: EntityMetadata<T>): void;
+/** @internal */
+export declare function validateParams(params: any, type?: string, field?: string): void;
+/** @internal */
+export declare function validatePrimaryKey<T>(entity: EntityData<T>, meta: EntityMetadata<T>): void;
+/** @internal */
+export declare function validateEmptyWhere<T>(where: FilterQuery<T>): void;

package/entity/validators.js

@@ -0,0 +1,61 @@
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { SCALAR_TYPES } from '../enums.js';
+/** @internal */
+export function validateProperty(prop, givenValue, entity) {
+    if (givenValue == null || isRaw(givenValue)) {
+        return;
+    }
+    const expectedType = prop.runtimeType;
+    const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
+    const givenType = Utils.getObjectType(givenValue);
+    if (prop.enum && prop.items) {
+        /* v8 ignore next 3 */
+        if (!prop.items.some(it => it === givenValue)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+    else {
+        if (givenType !== expectedType && SCALAR_TYPES.has(expectedType)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+}
+function getValue(o, prop) {
+    if (prop.embedded && prop.embedded[0] in o) {
+        return o[prop.embedded[0]]?.[prop.embedded[1]];
+    }
+    return o[prop.name];
+}
+/** @internal */
+export function validateEntity(entity, meta) {
+    for (const prop of meta.validateProps) {
+        validateProperty(prop, getValue(entity, prop), entity);
+    }
+}
+/** @internal */
+export function validateParams(params, type = 'search condition', field) {
+    if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
+        return;
+    }
+    if (Array.isArray(params)) {
+        return params.forEach(item => validateParams(item, type, field));
+    }
+    if (Utils.isPlainObject(params)) {
+        Object.keys(params).forEach(k => validateParams(params[k], type, k));
+    }
+}
+/** @internal */
+export function validatePrimaryKey(entity, meta) {
+    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
+    if (!entity || !pkExists) {
+        throw ValidationError.fromMergeWithoutPK(meta);
+    }
+}
+/** @internal */
+export function validateEmptyWhere(where) {
+    if (Utils.isEmpty(where)) {
+        throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
+    }
+}

package/enums.d.ts

@@ -89,7 +89,7 @@ export declare enum QueryFlag {
     IDENTITY_INSERT = "IDENTITY_INSERT",// mssql only
     OUTPUT_TABLE = "OUTPUT_TABLE"
 }
-export declare const SCALAR_TYPES: string[];
+export declare const SCALAR_TYPES: Set<string>;
 export declare enum ReferenceKind {
     SCALAR = "scalar",
     ONE_TO_ONE = "1:1",

package/enums.js

@@ -99,7 +99,7 @@ export var QueryFlag;
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
     QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
 })(QueryFlag || (QueryFlag = {}));
-export const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp'];
+export const SCALAR_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
 export var ReferenceKind;
 (function (ReferenceKind) {
     ReferenceKind["SCALAR"] = "scalar";

package/errors.d.ts

@@ -8,7 +8,6 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     getEntity(): AnyEntity | undefined;
     static fromWrongPropertyType(entity: AnyEntity, property: string, expectedType: string, givenType: string, givenValue: string): ValidationError;
     static fromWrongRepositoryType(entityName: string, repoType: string, method: string): ValidationError;
-    static fromCollectionNotInitialized(entity: AnyEntity, prop: EntityProperty): ValidationError;
     static fromMergeWithoutPK(meta: EntityMetadata): ValidationError;
     static transactionRequired(): ValidationError;
     static entityNotManaged(entity: AnyEntity): ValidationError;

package/errors.js

@@ -23,11 +23,6 @@ export class ValidationError extends Error {
         const msg = `Trying to use EntityRepository.${method}() with '${entityName}' entity while the repository is of type '${repoType}'`;
         return new ValidationError(msg);
     }
-    static fromCollectionNotInitialized(entity, prop) {
-        const entityName = entity.constructor.name;
-        const msg = `${entityName}.${prop.name} is not initialized, define it as '${prop.name} = new Collection<${prop.type}>(this);'`;
-        return new ValidationError(msg);
-    }
     static fromMergeWithoutPK(meta) {
         return new ValidationError(`You cannot merge entity '${meta.className}' without identifier!`);
     }

package/metadata/MetadataDiscovery.js

@@ -162,7 +162,7 @@ export class MetadataDiscovery {
         const processed = [];
         for (const entity of targets) {
             if (typeof entity === 'string') {
-                const { discoverEntities } = await import('@mikro-orm/core/file-discovery' + '');
+                const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
                 processed.push(...await discoverEntities(entity, { baseDir }));
             }
             else {

package/metadata/MetadataStorage.d.ts

@@ -1,4 +1,4 @@
-import { EntityMetadata, type Dictionary, type EntityData, type EntityName } from '../typings.js';
+import { EntityMetadata, type Dictionary, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
     static readonly PATH_SYMBOL: unique symbol;
@@ -10,7 +10,6 @@ export declare class MetadataStorage {
     static isKnownEntity(name: string): boolean;
     static clear(): void;
     getAll(): Dictionary<EntityMetadata>;
-    getByDiscriminatorColumn<T>(meta: EntityMetadata<T>, data: EntityData<T>): EntityMetadata<T> | undefined;
     get<T = any>(entityName: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
     find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
     has(entity: string): boolean;

package/metadata/MetadataStorage.js

@@ -33,14 +33,6 @@ export class MetadataStorage {
     getAll() {
         return this.metadata;
     }
-    getByDiscriminatorColumn(meta, data) {
-        const value = data[meta.root.discriminatorColumn];
-        if (!value) {
-            return undefined;
-        }
-        const type = meta.root.discriminatorMap[value];
-        return this.metadata[type];
-    }
     get(entityName, init = false, validate = true) {
         entityName = Utils.className(entityName);
         if (validate && !init && !this.has(entityName)) {

package/not-supported.d.ts

@@ -0,0 +1 @@
+export declare function discoverEntities(): void;

package/not-supported.js

@@ -0,0 +1,3 @@
+export function discoverEntities() {
+    throw new Error('File discovery is not supported in this environment.');
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.74",
+  "version": "7.0.0-dev.76",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
     ".": "./index.js",
-    "./file-discovery": "./metadata/discover-entities.js"
+    "./file-discovery": {
+      "node": "./metadata/discover-entities.js",
+      "browser": "./not-supported.js"
+    }
   },
   "repository": {
     "type": "git",

package/typings.d.ts

@@ -472,6 +472,7 @@ export interface EntityMetadata<T = any> {
     comparableProps: EntityProperty<T>[];
     trackingProps: EntityProperty<T>[];
     hydrateProps: EntityProperty<T>[];
+    validateProps: EntityProperty<T>[];
     uniqueProps: EntityProperty<T>[];
     getterProps: EntityProperty<T>[];
     indexes: {

package/typings.js

@@ -83,6 +83,12 @@ export class EntityMetadata {
         this.uniqueProps = this.props.filter(prop => prop.unique);
         this.getterProps = this.props.filter(prop => prop.getter);
         this.comparableProps = this.props.filter(prop => EntityComparator.isComparable(prop, this));
+        this.validateProps = this.props.filter(prop => {
+            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
+                return false;
+            }
+            return prop.kind === ReferenceKind.SCALAR && ['string', 'number', 'boolean', 'Date'].includes(prop.type);
+        });
         this.hydrateProps = this.props.filter(prop => {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;

package/unit-of-work/ChangeSetComputer.d.ts

@@ -2,19 +2,17 @@ import { type Configuration } from '../utils/Configuration.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { AnyEntity } from '../typings.js';
 import { ChangeSet } from './ChangeSet.js';
-import { type EntityValidator } from '../entity/EntityValidator.js';
 import { type Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
-    private readonly validator;
     private readonly collectionUpdates;
     private readonly metadata;
     private readonly platform;
     private readonly config;
     private readonly em;
     private readonly comparator;
-    constructor(validator: EntityValidator, collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
+    constructor(collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**
      * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.

package/unit-of-work/ChangeSetComputer.js

@@ -1,17 +1,16 @@
 import { Utils } from '../utils/Utils.js';
 import { ChangeSet, ChangeSetType } from './ChangeSet.js';
 import { helper } from '../entity/wrap.js';
+import { validateEntity } from '../entity/validators.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetComputer {
-    validator;
     collectionUpdates;
     metadata;
     platform;
     config;
     em;
     comparator;
-    constructor(validator, collectionUpdates, metadata, platform, config, em) {
-        this.validator = validator;
+    constructor(collectionUpdates, metadata, platform, config, em) {
         this.collectionUpdates = collectionUpdates;
         this.metadata = metadata;
         this.platform = platform;
@@ -42,15 +41,13 @@ export class ChangeSetComputer {
         }
         const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;
-        if (this.config.get('validate')) {
-            this.validator.validate(changeSet.entity, changeSet.payload, meta);
-        }
         for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
             this.processProperty(changeSet, prop);
         }
         if (changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload)) {
             return null;
         }
+        validateEntity(changeSet.entity, meta);
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
         if (type === ChangeSetType.UPDATE) {

package/unit-of-work/ChangeSetPersister.d.ts

@@ -1,7 +1,6 @@
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings.js';
 import { type EntityFactory } from '../entity/EntityFactory.js';
-import { type EntityValidator } from '../entity/EntityValidator.js';
 import { type ChangeSet } from './ChangeSet.js';
 import { type Configuration } from '../utils/Configuration.js';
 import type { DriverMethodOptions, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
@@ -11,17 +10,17 @@ export declare class ChangeSetPersister {
     private readonly metadata;
     private readonly hydrator;
     private readonly factory;
-    private readonly validator;
     private readonly config;
     private readonly em;
     private readonly platform;
     private readonly comparator;
     private readonly usesReturningStatement;
-    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration, em: EntityManager);
+    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, config: Configuration, em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     private runForEachSchema;
+    private validateRequired;
     private processProperties;
     private persistNewEntity;
     private persistNewEntities;

package/unit-of-work/ChangeSetPersister.js

@@ -3,25 +3,23 @@ import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from '../utils/Utils.js';
-import { OptimisticLockError } from '../errors.js';
+import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetPersister {
     driver;
     metadata;
     hydrator;
     factory;
-    validator;
     config;
     em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config, em) {
+    constructor(driver, metadata, hydrator, factory, config, em) {
         this.driver = driver;
         this.metadata = metadata;
         this.hydrator = hydrator;
         this.factory = factory;
-        this.validator = validator;
         this.config = config;
         this.em = em;
         this.platform = this.driver.getPlatform();
@@ -81,13 +79,32 @@ export class ChangeSetPersister {
             await this[method](group, ...args, options, true);
         }
     }
+    validateRequired(entity) {
+        const wrapped = helper(entity);
+        for (const prop of wrapped.__meta.props) {
+            if (!prop.nullable &&
+                !prop.autoincrement &&
+                !prop.default &&
+                !prop.defaultRaw &&
+                !prop.onCreate &&
+                !prop.generated &&
+                !prop.embedded &&
+                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                prop.name !== wrapped.__meta.root.discriminatorColumn &&
+                prop.type !== 'ObjectId' &&
+                prop.persist !== false &&
+                entity[prop.name] == null) {
+                throw ValidationError.propertyRequired(entity, prop);
+            }
+        }
+    }
     processProperties(changeSet) {
         const meta = this.metadata.find(changeSet.name);
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
         if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
-            this.validator.validateRequired(changeSet.entity);
+            this.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {

package/unit-of-work/UnitOfWork.js

@@ -42,8 +42,8 @@ export class UnitOfWork {
         this.identityMap = new IdentityMap(this.platform.getDefaultSchemaName());
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
-        this.changeSetComputer = new ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config, this.em);
+        this.changeSetComputer = new ChangeSetComputer(this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
+        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.config, this.em);
     }
     merge(entity, visited) {
         const wrapped = helper(entity);

package/utils/Configuration.d.ts

@@ -738,20 +738,6 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @see https://mikro-orm.io/docs/read-connections
      */
     replicas?: ConnectionOptions[];
-    /**
-     * Enable strict mode which disables automatic data type conversion.
-     * In strict mode, the ORM throws errors instead of fixing wrong data types.
-     * @default false
-     * @see https://mikro-orm.io/docs/property-validation
-     */
-    strict?: boolean;
-    /**
-     * Enable runtime property validation before persisting.
-     * Has performance implications and is usually not needed.
-     * @default false
-     * @see https://mikro-orm.io/docs/property-validation
-     */
-    validate?: boolean;
     /**
      * Validate that required properties are set on new entities before insert.
      * @default true

package/utils/clone.js

@@ -3,7 +3,6 @@
  * clone `EventEmitter`s to get around https://github.com/mikro-orm/mikro-orm/issues/2748
  * @internal
  */
-import { EventEmitter } from 'node:events';
 import { RawQueryFragment } from './RawQueryFragment.js';
 /**
  * Get the property descriptor of a property on an object or its prototype chain.
@@ -34,7 +33,7 @@ export function clone(parent, respectCustomCloneMethod = true) {
         if (raw && respectCustomCloneMethod) {
             return raw.clone();
         }
-        if (typeof parent !== 'object' || parent instanceof EventEmitter) {
+        if (typeof parent !== 'object') {
             return parent;
         }
         if (respectCustomCloneMethod && 'clone' in parent && typeof parent.clone === 'function') {

package/entity/EntityValidator.d.ts

@@ -1,19 +0,0 @@
-import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings.js';
-export declare class EntityValidator {
-    private strict;
-    KNOWN_TYPES: Set<string>;
-    constructor(strict: boolean);
-    validate<T extends object>(entity: T, payload: any, meta: EntityMetadata<T>): void;
-    validateRequired<T extends object>(entity: T): void;
-    validateProperty<T extends object>(prop: EntityProperty, givenValue: any, entity: T): any;
-    validateParams(params: any, type?: string, field?: string): void;
-    validatePrimaryKey<T>(entity: EntityData<T>, meta: EntityMetadata<T>): void;
-    validateEmptyWhere<T>(where: FilterQuery<T>): void;
-    private getValue;
-    private setValue;
-    private validateCollection;
-    private fixTypes;
-    private fixDateType;
-    private fixNumberType;
-    private fixBooleanType;
-}

package/entity/EntityValidator.js

@@ -1,150 +0,0 @@
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-import { ValidationError } from '../errors.js';
-import { helper } from './wrap.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
-export class EntityValidator {
-    strict;
-    KNOWN_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
-    constructor(strict) {
-        this.strict = strict;
-    }
-    validate(entity, payload, meta) {
-        meta.props.forEach(prop => {
-            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
-                return;
-            }
-            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
-                this.validateCollection(entity, prop);
-            }
-            const SCALAR_TYPES = ['string', 'number', 'boolean', 'Date'];
-            if (prop.kind !== ReferenceKind.SCALAR || !SCALAR_TYPES.includes(prop.type)) {
-                return;
-            }
-            const newValue = this.validateProperty(prop, this.getValue(payload, prop), entity);
-            if (this.getValue(payload, prop) === newValue) {
-                return;
-            }
-            this.setValue(payload, prop, newValue);
-            if (entity[prop.name]) {
-                entity[prop.name] = payload[prop.name];
-            }
-        });
-    }
-    validateRequired(entity) {
-        const wrapped = helper(entity);
-        for (const prop of wrapped.__meta.props) {
-            if (!prop.nullable &&
-                !prop.autoincrement &&
-                !prop.default &&
-                !prop.defaultRaw &&
-                !prop.onCreate &&
-                !prop.generated &&
-                !prop.embedded &&
-                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
-                prop.name !== wrapped.__meta.root.discriminatorColumn &&
-                prop.type !== 'ObjectId' &&
-                prop.persist !== false &&
-                entity[prop.name] == null) {
-                throw ValidationError.propertyRequired(entity, prop);
-            }
-        }
-    }
-    validateProperty(prop, givenValue, entity) {
-        if (givenValue == null || givenValue instanceof RawQueryFragment) {
-            return givenValue;
-        }
-        const expectedType = prop.runtimeType;
-        const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
-        let givenType = Utils.getObjectType(givenValue);
-        let ret = givenValue;
-        if (!this.strict) {
-            ret = this.fixTypes(expectedType, givenType, givenValue);
-            givenType = Utils.getObjectType(ret);
-        }
-        if (prop.enum && prop.items) {
-            /* v8 ignore next 3 */
-            if (!prop.items.some(it => it === givenValue)) {
-                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
-            }
-        }
-        else {
-            if (givenType !== expectedType && this.KNOWN_TYPES.has(expectedType)) {
-                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
-            }
-        }
-        return ret;
-    }
-    validateParams(params, type = 'search condition', field) {
-        if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
-            return;
-        }
-        if (Array.isArray(params)) {
-            return params.forEach(item => this.validateParams(item, type, field));
-        }
-        if (Utils.isPlainObject(params)) {
-            Object.keys(params).forEach(k => {
-                this.validateParams(params[k], type, k);
-            });
-        }
-    }
-    validatePrimaryKey(entity, meta) {
-        const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
-        if (!entity || !pkExists) {
-            throw ValidationError.fromMergeWithoutPK(meta);
-        }
-    }
-    validateEmptyWhere(where) {
-        if (Utils.isEmpty(where)) {
-            throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
-        }
-    }
-    getValue(o, prop) {
-        if (prop.embedded && prop.embedded[0] in o) {
-            return o[prop.embedded[0]]?.[prop.embedded[1]];
-        }
-        return o[prop.name];
-    }
-    setValue(o, prop, v) {
-        /* v8 ignore next 3 */
-        if (prop.embedded && prop.embedded[0] in o) {
-            return o[prop.embedded[0]][prop.embedded[1]] = v;
-        }
-        o[prop.name] = v;
-    }
-    validateCollection(entity, prop) {
-        if (prop.hydrate !== false && helper(entity).__initialized && !entity[prop.name]) {
-            throw ValidationError.fromCollectionNotInitialized(entity, prop);
-        }
-    }
-    fixTypes(expectedType, givenType, givenValue) {
-        if (expectedType === 'Date' && ['string', 'number'].includes(givenType)) {
-            givenValue = this.fixDateType(givenValue);
-        }
-        if (expectedType === 'number' && givenType === 'string') {
-            givenValue = this.fixNumberType(givenValue);
-        }
-        if (expectedType === 'boolean' && givenType === 'number') {
-            givenValue = this.fixBooleanType(givenValue);
-        }
-        return givenValue;
-    }
-    fixDateType(givenValue) {
-        let date;
-        if (typeof givenValue === 'string' && givenValue.match(/^-?\d+(\.\d+)?$/)) {
-            date = new Date(+givenValue);
-        }
-        else {
-            date = new Date(givenValue);
-        }
-        return date.toString() !== 'Invalid Date' ? date : givenValue;
-    }
-    fixNumberType(givenValue) {
-        const num = +givenValue;
-        return '' + num === givenValue ? num : givenValue;
-    }
-    fixBooleanType(givenValue) {
-        const bool = !!givenValue;
-        return +bool === givenValue ? bool : givenValue;
-    }
-}