@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/entity/EntityRepository.d.ts

@@ -0,0 +1,161 @@
+import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager';
+import type { AssignOptions } from './EntityAssigner';
+import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement } from '../typings';
+import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, UpdateOptions } from '../drivers/IDatabaseDriver';
+import type { EntityLoaderOptions } from './EntityLoader';
+import type { Cursor } from '../utils/Cursor';
+export declare class EntityRepository<Entity extends object> {
+    protected readonly em: EntityManager;
+    protected readonly entityName: EntityName<Entity>;
+    constructor(em: EntityManager, entityName: EntityName<Entity>);
+    /**
+     * Finds first entity matching your `where` query.
+     */
+    findOne<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    /**
+     * Finds first entity matching your `where` query. If nothing is found, it will throw an error.
+     * You can override the factory for creating this method via `options.failHandler` locally
+     * or via `Configuration.findOneOrFailHandler` globally.
+     */
+    findOneOrFail<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const author = await em.getRepository(Author).upsert({ email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.getRepository(Author).upsert({ email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    upsert(entityOrData?: EntityData<Entity> | Entity, options?: NativeInsertUpdateOptions<Entity>): Promise<Entity>;
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const authors = await em.getRepository(Author).upsertMany([{ email: 'foo@bar.com', age: 33 }, ...]);
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com'), (666, 'lol@lol.lol') on conflict ("email") do update set "age" = excluded."age"
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.getRepository(Author).upsertMany([
+     *   { email: 'foo@bar.com', age: 33 },
+     *   { email: 'lol@lol.lol', age: 666 },
+     * ]);
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    upsertMany(entitiesOrData?: EntityData<Entity>[] | Entity[], options?: NativeInsertUpdateOptions<Entity>): Promise<Entity[]>;
+    /**
+     * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
+     */
+    find<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    /**
+     * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
+     * where first element is the array of entities, and the second is the count.
+     */
+    findAndCount<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
+    /**
+     * @inheritDoc EntityManager.findByCursor
+     */
+    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes>): Promise<Cursor<Entity, Hint, Fields, Excludes>>;
+    /**
+     * Finds all entities of given type. You can pass additional options via the `options` parameter.
+     */
+    findAll<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindAllOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    /**
+     * @inheritDoc EntityManager.insert
+     */
+    insert(data: Entity | RequiredEntityData<Entity>, options?: NativeInsertUpdateOptions<Entity>): Promise<Primary<Entity>>;
+    /**
+     * @inheritDoc EntityManager.insert
+     */
+    insertMany(data: Entity[] | RequiredEntityData<Entity>[], options?: NativeInsertUpdateOptions<Entity>): Promise<Primary<Entity>[]>;
+    /**
+     * Fires native update query. Calling this has no side effects on the context (identity map).
+     */
+    nativeUpdate(where: FilterQuery<Entity>, data: EntityData<Entity>, options?: UpdateOptions<Entity>): Promise<number>;
+    /**
+     * Fires native delete query. Calling this has no side effects on the context (identity map).
+     */
+    nativeDelete(where: FilterQuery<Entity>, options?: DeleteOptions<Entity>): Promise<number>;
+    /**
+     * Maps raw database result to an entity and merges it to this EntityManager.
+     */
+    map(result: EntityDictionary<Entity>, options?: {
+        schema?: string;
+    }): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped'> & {
+        wrapped: true;
+    }): Ref<Entity>;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference(id: Primary<Entity> | Primary<Entity>[]): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped'> & {
+        wrapped: false;
+    }): Entity;
+    /**
+     * Checks whether given property can be populated on the entity.
+     */
+    canPopulate(property: string): boolean;
+    /**
+     * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
+     */
+    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = '*', Excludes extends string = never>(entities: Ent, populate: AutoPath<Entity, Hint, '*'>[] | false, options?: EntityLoaderOptions<Entity, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
+    /**
+     * Creates new instance of given entity and populates it with given data.
+     * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
+     * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
+     * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
+     * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<Entity>)` and
+     * `em.create()` will pass the data into it (unless we have a property named `data` too).
+     */
+    create(data: RequiredEntityData<Entity>, options?: CreateOptions): Entity;
+    /**
+     * Shortcut for `wrap(entity).assign(data, { em })`
+     */
+    assign<Ent extends EntityType<Entity>, Naked extends FromEntityType<Ent> = FromEntityType<Ent>, Data extends EntityData<Naked> | Partial<EntityDTO<Naked>> = EntityData<Naked> | Partial<EntityDTO<Naked>>>(entity: Ent | Partial<Ent>, data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions): MergeSelected<Ent, Naked, keyof Data & string>;
+    /**
+     * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
+     * via second parameter. By default it will return already loaded entities without modifying them.
+     */
+    merge(data: Entity | EntityData<Entity>, options?: MergeOptions): Entity;
+    /**
+     * Returns total number of entities matching your `where` query.
+     */
+    count<Hint extends string = never>(where?: FilterQuery<Entity>, options?: CountOptions<Entity, Hint>): Promise<number>;
+    getEntityName(): string;
+    /**
+     * Returns the underlying EntityManager instance
+     */
+    getEntityManager(): EntityManager;
+    protected validateRepositoryType(entities: Entity[] | Entity, method: string): void;
+}

package/entity/EntityRepository.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRepository = void 0;
+const errors_1 = require("../errors");
+const Utils_1 = require("../utils/Utils");
+class EntityRepository {
+    em;
+    entityName;
+    constructor(em, entityName) {
+        this.em = em;
+        this.entityName = entityName;
+    }
+    /**
+     * Finds first entity matching your `where` query.
+     */
+    async findOne(where, options) {
+        return this.getEntityManager().findOne(this.entityName, where, options);
+    }
+    /**
+     * Finds first entity matching your `where` query. If nothing is found, it will throw an error.
+     * You can override the factory for creating this method via `options.failHandler` locally
+     * or via `Configuration.findOneOrFailHandler` globally.
+     */
+    async findOneOrFail(where, options) {
+        return this.getEntityManager().findOneOrFail(this.entityName, where, options);
+    }
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const author = await em.getRepository(Author).upsert({ email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.getRepository(Author).upsert({ email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    async upsert(entityOrData, options) {
+        return this.getEntityManager().upsert(this.entityName, entityOrData, options);
+    }
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const authors = await em.getRepository(Author).upsertMany([{ email: 'foo@bar.com', age: 33 }, ...]);
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com'), (666, 'lol@lol.lol') on conflict ("email") do update set "age" = excluded."age"
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.getRepository(Author).upsertMany([
+     *   { email: 'foo@bar.com', age: 33 },
+     *   { email: 'lol@lol.lol', age: 666 },
+     * ]);
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    async upsertMany(entitiesOrData, options) {
+        return this.getEntityManager().upsertMany(this.entityName, entitiesOrData, options);
+    }
+    /**
+     * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
+     */
+    async find(where, options) {
+        return this.getEntityManager().find(this.entityName, where, options);
+    }
+    /**
+     * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
+     * where first element is the array of entities, and the second is the count.
+     */
+    async findAndCount(where, options) {
+        return this.getEntityManager().findAndCount(this.entityName, where, options);
+    }
+    /**
+     * @inheritDoc EntityManager.findByCursor
+     */
+    async findByCursor(where, options) {
+        return this.getEntityManager().findByCursor(this.entityName, where, options);
+    }
+    /**
+     * Finds all entities of given type. You can pass additional options via the `options` parameter.
+     */
+    async findAll(options) {
+        return this.getEntityManager().findAll(this.entityName, options);
+    }
+    /**
+     * @inheritDoc EntityManager.insert
+     */
+    async insert(data, options) {
+        return this.getEntityManager().insert(this.entityName, data, options);
+    }
+    /**
+     * @inheritDoc EntityManager.insert
+     */
+    async insertMany(data, options) {
+        return this.getEntityManager().insertMany(this.entityName, data, options);
+    }
+    /**
+     * Fires native update query. Calling this has no side effects on the context (identity map).
+     */
+    async nativeUpdate(where, data, options) {
+        return this.getEntityManager().nativeUpdate(this.entityName, where, data, options);
+    }
+    /**
+     * Fires native delete query. Calling this has no side effects on the context (identity map).
+     */
+    async nativeDelete(where, options) {
+        return this.getEntityManager().nativeDelete(this.entityName, where, options);
+    }
+    /**
+     * Maps raw database result to an entity and merges it to this EntityManager.
+     */
+    map(result, options) {
+        return this.getEntityManager().map(this.entityName, result, options);
+    }
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference(id, options) {
+        return this.getEntityManager().getReference(this.entityName, id, options);
+    }
+    /**
+     * Checks whether given property can be populated on the entity.
+     */
+    canPopulate(property) {
+        return this.getEntityManager().canPopulate(this.entityName, property);
+    }
+    /**
+     * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
+     */
+    async populate(entities, populate, options) {
+        this.validateRepositoryType(entities, 'populate');
+        // @ts-ignore hard to type
+        return this.getEntityManager().populate(entities, populate, options);
+    }
+    /**
+     * Creates new instance of given entity and populates it with given data.
+     * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
+     * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
+     * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
+     * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<Entity>)` and
+     * `em.create()` will pass the data into it (unless we have a property named `data` too).
+     */
+    create(data, options) {
+        return this.getEntityManager().create(this.entityName, data, options);
+    }
+    /**
+     * Shortcut for `wrap(entity).assign(data, { em })`
+     */
+    assign(entity, data, options) {
+        this.validateRepositoryType(entity, 'assign');
+        return this.getEntityManager().assign(entity, data, options);
+    }
+    /**
+     * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
+     * via second parameter. By default it will return already loaded entities without modifying them.
+     */
+    merge(data, options) {
+        return this.getEntityManager().merge(this.entityName, data, options);
+    }
+    /**
+     * Returns total number of entities matching your `where` query.
+     */
+    async count(where = {}, options = {}) {
+        return this.getEntityManager().count(this.entityName, where, options);
+    }
+    getEntityName() {
+        return Utils_1.Utils.className(this.entityName);
+    }
+    /**
+     * Returns the underlying EntityManager instance
+     */
+    getEntityManager() {
+        return this.em;
+    }
+    validateRepositoryType(entities, method) {
+        entities = Utils_1.Utils.asArray(entities);
+        if (entities.length === 0) {
+            return;
+        }
+        const entityName = entities[0].constructor.name;
+        const repoType = Utils_1.Utils.className(this.entityName);
+        if (entityName && repoType !== entityName) {
+            throw errors_1.ValidationError.fromWrongRepositoryType(entityName, repoType, method);
+        }
+    }
+}
+exports.EntityRepository = EntityRepository;

package/entity/EntityValidator.d.ts

@@ -0,0 +1,19 @@
+import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings';
+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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityValidator = void 0;
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+const errors_1 = require("../errors");
+const wrap_1 = require("./wrap");
+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) {
+                return;
+            }
+            if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                this.validateCollection(entity, prop);
+            }
+            const SCALAR_TYPES = ['string', 'number', 'boolean', 'Date'];
+            if (prop.kind !== enums_1.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);
+            /* istanbul ignore else */
+            if (entity[prop.name]) {
+                entity[prop.name] = payload[prop.name];
+            }
+        });
+    }
+    validateRequired(entity) {
+        const wrapped = (0, wrap_1.helper)(entity);
+        for (const prop of wrapped.__meta.props) {
+            if (!prop.nullable &&
+                !prop.autoincrement &&
+                !prop.default &&
+                !prop.defaultRaw &&
+                !prop.onCreate &&
+                !prop.generated &&
+                !prop.embedded &&
+                ![enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                prop.name !== wrapped.__meta.root.discriminatorColumn &&
+                prop.type.toLowerCase() !== 'objectid' &&
+                prop.persist !== false &&
+                entity[prop.name] == null) {
+                throw errors_1.ValidationError.propertyRequired(entity, prop);
+            }
+        }
+    }
+    validateProperty(prop, givenValue, entity) {
+        if (givenValue === null || givenValue === undefined) {
+            return givenValue;
+        }
+        const expectedType = prop.runtimeType;
+        let givenType = Utils_1.Utils.getObjectType(givenValue);
+        let ret = givenValue;
+        if (!this.strict) {
+            ret = this.fixTypes(expectedType, givenType, givenValue);
+            givenType = Utils_1.Utils.getObjectType(ret);
+        }
+        if (prop.enum && prop.items) {
+            if (!prop.items.some(it => it === givenValue)) {
+                throw errors_1.ValidationError.fromWrongPropertyType(entity, prop.name, expectedType, givenType, givenValue);
+            }
+        }
+        else {
+            if (givenType !== expectedType && this.KNOWN_TYPES.has(expectedType)) {
+                throw errors_1.ValidationError.fromWrongPropertyType(entity, prop.name, expectedType, givenType, givenValue);
+            }
+        }
+        return ret;
+    }
+    validateParams(params, type = 'search condition', field) {
+        if (Utils_1.Utils.isPrimaryKey(params) || Utils_1.Utils.isEntity(params)) {
+            return;
+        }
+        if (Array.isArray(params)) {
+            return params.forEach(item => this.validateParams(item, type, field));
+        }
+        if (Utils_1.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) || entity[meta.serializedPrimaryKey] != null;
+        if (!entity || !pkExists) {
+            throw errors_1.ValidationError.fromMergeWithoutPK(meta);
+        }
+    }
+    validateEmptyWhere(where) {
+        if (Utils_1.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) {
+        /* istanbul ignore next */
+        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 && (0, wrap_1.helper)(entity).__initialized && !entity[prop.name]) {
+            throw errors_1.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 (Utils_1.Utils.isString(givenValue) && 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;
+    }
+}
+exports.EntityValidator = EntityValidator;

package/entity/Reference.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { AddEager, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings';
+import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver';
+export declare class Reference<T extends object> {
+    private entity;
+    constructor(entity: T);
+    static create<T extends object>(entity: T | Ref<T>): Ref<T>;
+    static createFromPK<T extends object>(entityType: EntityClass<T>, pk: Primary<T>, options?: {
+        schema?: string;
+    }): Ref<T>;
+    static createNakedFromPK<T extends object>(entityType: EntityClass<T>, pk: Primary<T>, options?: {
+        schema?: string;
+    }): T;
+    /**
+     * Checks whether the argument is instance of `Reference` wrapper.
+     */
+    static isReference<T extends object>(data: any): data is Reference<T>;
+    /**
+     * Wraps the entity in a `Reference` wrapper if the property is defined as `ref`.
+     */
+    static wrapReference<T extends object, O extends object>(entity: T | Reference<T>, prop: EntityProperty<O, T>): Reference<T> | T;
+    /**
+     * Returns wrapped entity.
+     */
+    static unwrapReference<T extends object>(ref: T | Reference<T> | ScalarReference<T> | Ref<T>): T;
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded). Returns the entity.
+     * If the entity is not found in the database (e.g. it was deleted in the meantime, or currently active filters disallow loading of it)
+     * the method returns `null`. Use `loadOrFail()` if you want an error to be thrown in such a case.
+     */
+    load<TT extends T, P extends string = never, F extends string = '*', E extends string = never>(options?: LoadReferenceOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E> | null>;
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    loadOrFail<TT extends T, P extends string = never, F extends string = '*', E extends string = never>(options?: LoadReferenceOrFailOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E>>;
+    private set;
+    unwrap(): T;
+    getEntity(): T;
+    getProperty<K extends keyof T>(prop: K): T[K];
+    loadProperty<TT extends T, P extends string = never, K extends keyof TT = keyof TT>(prop: K, options?: LoadReferenceOrFailOptions<TT, P>): Promise<Loaded<TT, P>[K]>;
+    isInitialized(): boolean;
+    populated(populated?: boolean): void;
+    toJSON(...args: any[]): Dictionary;
+    /** @ignore */
+    [inspect.custom](depth: number): string;
+}
+export declare class ScalarReference<Value> {
+    private value?;
+    private initialized;
+    private entity?;
+    private property?;
+    constructor(value?: Value | undefined, initialized?: boolean);
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns either the whole entity, or the requested property.
+     */
+    load(options?: Omit<LoadReferenceOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value | undefined>;
+    set(value: Value): void;
+    bind<Entity extends object>(entity: Entity, property: EntityKey<Entity>): void;
+    unwrap(): Value | undefined;
+    isInitialized(): boolean;
+    /** @ignore */
+    [inspect.custom](): string;
+}
+export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
+    dataloader?: boolean;
+}
+export interface LoadReferenceOrFailOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOrFailOptions<T, P, F, E> {
+    dataloader?: boolean;
+}
+/**
+ * shortcut for `wrap(entity).toReference()`
+ */
+export declare function ref<T extends object>(entity: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+/**
+ * shortcut for `Reference.createFromPK(entityType, pk)`
+ */
+export declare function ref<T extends object, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk?: T | PKV): Ref<T>;
+/**
+ * shortcut for `wrap(entity).toReference()`
+ */
+export declare function ref<T>(value: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+/**
+ * shortcut for `Reference.createNakedFromPK(entityType, pk)`
+ */
+export declare function rel<T, PK extends Primary<T>>(entityType: EntityClass<T>, pk: T | PK): T;
+export { Reference as Ref };