@mikro-orm/core 7.0.0-dev.300 → 7.0.0-dev.301

package/platforms/Platform.js

@@ -198,35 +198,58 @@ export class Platform {
         }
         switch (this.extractSimpleType(type)) {
             case 'character':
-            case 'char': return Type.getType(CharacterType);
+            case 'char':
+                return Type.getType(CharacterType);
             case 'string':
-            case 'varchar': return Type.getType(StringType);
-            case 'interval': return Type.getType(IntervalType);
-            case 'text': return Type.getType(TextType);
+            case 'varchar':
+                return Type.getType(StringType);
+            case 'interval':
+                return Type.getType(IntervalType);
+            case 'text':
+                return Type.getType(TextType);
             case 'int':
-            case 'number': return Type.getType(IntegerType);
-            case 'bigint': return Type.getType(BigIntType);
-            case 'smallint': return Type.getType(SmallIntType);
-            case 'tinyint': return Type.getType(TinyIntType);
-            case 'mediumint': return Type.getType(MediumIntType);
-            case 'float': return Type.getType(FloatType);
-            case 'double': return Type.getType(DoubleType);
-            case 'integer': return Type.getType(IntegerType);
+            case 'number':
+                return Type.getType(IntegerType);
+            case 'bigint':
+                return Type.getType(BigIntType);
+            case 'smallint':
+                return Type.getType(SmallIntType);
+            case 'tinyint':
+                return Type.getType(TinyIntType);
+            case 'mediumint':
+                return Type.getType(MediumIntType);
+            case 'float':
+                return Type.getType(FloatType);
+            case 'double':
+                return Type.getType(DoubleType);
+            case 'integer':
+                return Type.getType(IntegerType);
             case 'decimal':
-            case 'numeric': return Type.getType(DecimalType);
-            case 'boolean': return Type.getType(BooleanType);
+            case 'numeric':
+                return Type.getType(DecimalType);
+            case 'boolean':
+                return Type.getType(BooleanType);
             case 'blob':
-            case 'buffer': return Type.getType(BlobType);
-            case 'uint8array': return Type.getType(Uint8ArrayType);
-            case 'uuid': return Type.getType(UuidType);
-            case 'date': return Type.getType(DateType);
+            case 'buffer':
+                return Type.getType(BlobType);
+            case 'uint8array':
+                return Type.getType(Uint8ArrayType);
+            case 'uuid':
+                return Type.getType(UuidType);
+            case 'date':
+                return Type.getType(DateType);
             case 'datetime':
-            case 'timestamp': return Type.getType(DateTimeType);
-            case 'time': return Type.getType(TimeType);
+            case 'timestamp':
+                return Type.getType(DateTimeType);
+            case 'time':
+                return Type.getType(TimeType);
             case 'object':
-            case 'json': return Type.getType(JsonType);
-            case 'enum': return Type.getType(EnumType);
-            default: return Type.getType(UnknownType);
+            case 'json':
+                return Type.getType(JsonType);
+            case 'enum':
+                return Type.getType(EnumType);
+            default:
+                return Type.getType(UnknownType);
         }
     }
     supportsMultipleCascadePaths() {

package/serialization/EntitySerializer.js

@@ -9,7 +9,8 @@ function isVisible(meta, propName, options) {
     if (options.groups && prop?.groups) {
         return prop.groups.some(g => options.groups.includes(g));
     }
-    if (Array.isArray(options.populate) && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (Array.isArray(options.populate) &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
@@ -20,7 +21,8 @@ function isVisible(meta, propName, options) {
     return visible && !prefixed;
 }
 function isPopulated(propName, options) {
-    if (typeof options.populate !== 'boolean' && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (typeof options.populate !== 'boolean' &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (typeof options.populate === 'boolean') {
@@ -176,7 +178,9 @@ export class EntitySerializer {
     static extractChildOptions(options, prop) {
         return {
             ...options,
-            populate: Array.isArray(options.populate) ? Utils.extractChildElements(options.populate, prop, '*') : options.populate,
+            populate: Array.isArray(options.populate)
+                ? Utils.extractChildElements(options.populate, prop, '*')
+                : options.populate,
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
         };
     }

package/serialization/SerializationContext.js

@@ -104,7 +104,7 @@ export class SerializationContext {
             }
             fields = fields
                 .filter(field => field.startsWith(`${segment[1]}.`) || field === '*')
-                .map(field => field === '*' ? field : field.substring(segment[1].length + 1));
+                .map(field => (field === '*' ? field : field.substring(segment[1].length + 1)));
         }
         return fields.some(p => p === prop || p === '*');
     }

package/typings.d.ts

@@ -36,11 +36,11 @@ export type Compute<T> = {
     [K in keyof T]: T[K];
 } & {};
 type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | '__selectedType' | '__loadedType';
-export type CleanKeys<T, K extends keyof T, B extends boolean = false> = (T[K] & {}) extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? (T[K] & {}) extends Scalar ? never : K : K;
+export type CleanKeys<T, K extends keyof T, B extends boolean = false> = T[K] & {} extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? T[K] & {} extends Scalar ? never : K : K;
 export type FunctionKeys<T, K extends keyof T> = T[K] extends Function ? K : never;
 export type Cast<T, R> = T extends R ? T : R;
-export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never : never;
-export type IsAny<T> = 0 extends (1 & T) ? true : false;
+export type IsUnknown<T> = T extends unknown ? (unknown extends T ? true : never) : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
 export type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
 export type MaybePromise<T> = T | Promise<T>;
 /**
@@ -98,9 +98,9 @@ type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
 export type UnionKeys<T> = T extends any ? keyof T : never;
 export type UnionPropertyType<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
 type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : false;
-export type MergeUnion<T> = [T] extends [object] ? (T extends Scalar ? T : IsUnion<T> extends true ? {
+export type MergeUnion<T> = [T] extends [object] ? T extends Scalar ? T : IsUnion<T> extends true ? {
     [K in UnionKeys<T>]: UnionPropertyType<T, K>;
-} : T) : T;
+} : T : T;
 export type DeepPartial<T> = T & {
     [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends Readonly<infer U>[] ? Readonly<DeepPartial<U>>[] : DeepPartial<T[P]>;
 };
@@ -113,7 +113,7 @@ export declare const Config: unique symbol;
 export declare const EntityName: unique symbol;
 export type InferEntityName<T> = T extends {
     [EntityName]?: infer Name;
-} ? Name extends string ? Name : never : never;
+} ? (Name extends string ? Name : never) : never;
 export type Opt<T = unknown> = T & Opt.Brand;
 export declare namespace Opt {
     const __optional: unique symbol;
@@ -173,11 +173,11 @@ export type Primary<T> = IsAny<T> extends true ? any : T extends {
 /** @internal */
 export type PrimaryProperty<T> = T extends {
     [PrimaryKeyProp]?: infer PK;
-} ? (PK extends keyof T ? PK : (PK extends any[] ? PK[number] : never)) : T extends {
+} ? PK extends keyof T ? PK : PK extends any[] ? PK[number] : never : T extends {
     _id?: any;
-} ? (T extends {
+} ? T extends {
     id?: any;
-} ? 'id' | '_id' : '_id') : T extends {
+} ? 'id' | '_id' : '_id' : T extends {
     id?: any;
 } ? 'id' : T extends {
     uuid?: any;
@@ -237,7 +237,7 @@ type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never
 export type FilterObject<T> = {
     -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | null;
 };
-export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
+export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
 };
@@ -324,11 +324,11 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
 type EntityDataItem<T, C extends boolean> = C extends false ? UnwrapScalarRef<T> | EntityDataProp<T, C> | Raw | null : EntityDataProp<T, C> | Raw | null;
@@ -368,9 +368,9 @@ export type Rel<T> = T;
 /** Alias for `ScalarReference` (see {@apilink Ref}). */
 export type ScalarRef<T> = ScalarReference<T>;
 /** Alias for `Reference<T> & { id: number }` (see {@apilink Ref}). */
-export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : ({
+export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : {
     [K in PrimaryProperty<T> & keyof T]: T[K];
-} & Reference<T>);
+} & Reference<T>;
 /**
  * Ref type represents a `Reference` instance, and adds the primary keys to its prototype automatically, so you can do
  * `ref.id` instead of `ref.unwrap().id`. It resolves to either `ScalarRef` or `EntityRef`, based on the type argument.
@@ -384,7 +384,7 @@ type ExtractHiddenProps<T> = (T extends {
 type ExcludeHidden<T, K extends keyof T> = K extends ExtractHiddenProps<T> ? never : K;
 type ExtractConfig<T> = T extends {
     [Config]?: infer K;
-} ? (K & TypeConfig) : TypeConfig;
+} ? K & TypeConfig : TypeConfig;
 type PreferExplicitConfig<E, I> = IsNever<E, I, E>;
 type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, ExtractConfig<T>>['forceObject'] extends true ? {
     [K in PrimaryProperty<U> & keyof U]: U[K];
@@ -392,7 +392,7 @@ type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, Extra
 type DTOWrapper<T, C extends TypeConfig, Flat extends boolean> = Flat extends true ? EntityDTOFlat<T, C> : EntityDTO<T, C>;
 export type EntityDTOProp<E, T, C extends TypeConfig = never, Flat extends boolean = false> = T extends Scalar ? T : T extends ScalarReference<infer U> ? U : T extends {
     __serialized?: infer U;
-} ? (IsUnknown<U> extends false ? U : T) : T extends LoadedReferenceShape<infer U> ? DTOWrapper<U, C, Flat> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? DTOWrapper<U & object, C, Flat>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C, Flat>[] : T extends Relation<T> ? DTOWrapper<T, C, Flat> : T;
+} ? IsUnknown<U> extends false ? U : T : T extends LoadedReferenceShape<infer U> ? DTOWrapper<U, C, Flat> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? DTOWrapper<U & object, C, Flat>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C, Flat>[] : T extends Relation<T> ? DTOWrapper<T, C, Flat> : T;
 type UnwrapLoadedEntity<T> = T extends {
     [__loadedType]?: infer U;
 } ? NonNullable<U> : T;
@@ -422,7 +422,7 @@ export type EntityDTOFlat<T, C extends TypeConfig = never> = {
  */
 type SerializeTopHints<H extends string> = H extends `${infer Top}.${string}` ? Top : H;
 type SerializeSubHints<K extends string, H extends string> = H extends `${K}.${infer Rest}` ? Rest : never;
-type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = (K & string) extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
 export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never> = string extends H ? EntityDTOFlat<T, C> : {
     [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>)]: SerializePropValue<T, K, H, C> | Extract<T[K], null | undefined>;
 };
@@ -975,7 +975,7 @@ type ExtractStringKeys<T> = {
  * Simplified to just check `T extends object` since ExtractType handles the unwrapping.
  */
 type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
-type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type RelationKeys<T> = T extends object ? {
     [K in keyof T]-?: CleanKeys<T, K, true>;
@@ -985,12 +985,12 @@ export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
 type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
-type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? T extends true ? true : false : false;
-type StringLiteral<T> = T extends string ? string extends T ? never : T : never;
-type Prefix<T, K> = K extends `${infer S}.${string}` ? S : (K extends '*' ? keyof T : K);
+type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? (T extends true ? true : false) : false;
+type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
+type Prefix<T, K> = K extends `${infer S}.${string}` ? S : K extends '*' ? keyof T : K;
 type IsPrefixedExclude<T, K extends keyof T, E extends string> = K extends E ? never : K;
-export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? (T[K] & {} extends LoadableShape ? K : never) : IsNever<StringLiteral<L>> extends true ? never : '*' extends L ? K : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
-type Suffix<Key, Hint extends string, All = true | '*'> = Hint extends `${infer Pref}.${infer Suf}` ? (Pref extends Key ? Suf : never) : Hint extends All ? Hint : never;
+export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? T[K] & {} extends LoadableShape ? K : never : IsNever<StringLiteral<L>> extends true ? never : '*' extends L ? K : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
+type Suffix<Key, Hint extends string, All = true | '*'> = Hint extends `${infer Pref}.${infer Suf}` ? Pref extends Key ? Suf : never : Hint extends All ? Hint : never;
 export type IsSubset<T, U> = keyof U extends keyof T ? {} : string extends keyof U ? {} : {
     [K in keyof U as K extends keyof T ? never : CleanKeys<U, K>]: never;
 };

package/typings.js

@@ -31,11 +31,9 @@ export class EntityMetadata {
         Object.assign(this, meta);
         const name = meta.className ?? meta.name;
         if (!this.class && name) {
-            const Class = this.extends === BaseEntity
-                ? ({ [name]: class extends BaseEntity {
-                    } })[name]
-                : ({ [name]: class {
-                    } })[name];
+            const Class = this.extends === BaseEntity ? { [name]: class extends BaseEntity {
+                } }[name] : { [name]: class {
+                } }[name];
             this.class = Class;
         }
     }
@@ -108,9 +106,7 @@ export class EntityMetadata {
      */
     createSchemaColumnMappingObject() {
         // For TPT entities, only include properties that belong to this entity's table
-        const props = this.inheritanceType === 'tpt' && this.ownProps
-            ? this.ownProps
-            : Object.values(this.properties);
+        const props = this.inheritanceType === 'tpt' && this.ownProps ? this.ownProps : Object.values(this.properties);
         return props.reduce((o, prop) => {
             if (prop.fieldNames) {
                 o[prop.name] = prop.fieldNames[0];
@@ -208,7 +204,11 @@ export class EntityMetadata {
                         const hydrator = wrapped.hydrator;
                         const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                         const old = Reference.unwrapReference(wrapped.__data[prop.name]);
-                        if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                        if (old &&
+                            old !== entity &&
+                            prop.kind === ReferenceKind.MANY_TO_ONE &&
+                            prop.inversedBy &&
+                            old[prop.inversedBy]) {
                             old[prop.inversedBy].removeWithoutPropagation(this);
                         }
                         wrapped.__data[prop.name] = Reference.wrapReference(val, prop);

package/unit-of-work/ChangeSet.js

@@ -27,10 +27,10 @@ export class ChangeSet {
         else {
             this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
         }
-        if (!this.meta.compositePK
-            && this.meta.getPrimaryProp().targetMeta?.compositePK
-            && typeof this.primaryKey === 'object'
-            && this.primaryKey !== null) {
+        if (!this.meta.compositePK &&
+            this.meta.getPrimaryProp().targetMeta?.compositePK &&
+            typeof this.primaryKey === 'object' &&
+            this.primaryKey !== null) {
             this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
                 return this.primaryKey[childPK];
             });

package/unit-of-work/ChangeSetComputer.js

@@ -31,7 +31,8 @@ export class ChangeSetComputer {
         const map = new Map();
         // 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.CREATE) { // run update hooks only after we know there are other changes
+        if (type === ChangeSetType.CREATE) {
+            // run update hooks only after we know there are other changes
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
@@ -74,10 +75,10 @@ export class ChangeSetComputer {
      * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
      */
     processPropertyInitializers(entity, prop, type, map, nested) {
-        if (prop.onCreate
-            && type === ChangeSetType.CREATE
-            && (entity[prop.name] == null
-                || (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
+        if (prop.onCreate &&
+            type === ChangeSetType.CREATE &&
+            (entity[prop.name] == null ||
+                (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
             entity[prop.name] = prop.onCreate(entity, this.em);
         }
         if (prop.onUpdate && type === ChangeSetType.UPDATE) {
@@ -120,7 +121,8 @@ export class ChangeSetComputer {
             targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
             return;
         }
-        if (Utils.isCollection(target)) { // m:n or 1:m
+        if (Utils.isCollection(target)) {
+            // m:n or 1:m
             this.processToMany(prop, changeSet);
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {

package/unit-of-work/ChangeSetPersister.js

@@ -49,7 +49,10 @@ export class ChangeSetPersister {
         // For STI with conflicting fieldNames (renamedFrom properties), we can't batch mixed child types
         const hasSTIConflicts = meta.root.props.some(p => p.renamedFrom);
         const hasMixedTypes = hasSTIConflicts && changeSets.some(cs => cs.meta.class !== meta.class);
-        if (batched && changeSets.length > 1 && !hasMixedTypes && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+        if (batched &&
+            changeSets.length > 1 &&
+            !hasMixedTypes &&
+            this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -238,7 +241,9 @@ export class ChangeSetPersister {
         // some drivers might be returning bigint PKs as numbers when the number is small enough,
         // but we need to have it as string so comparison works in change set tracking, so instead
         // of using the raw value from db, we convert it back to the db value explicitly
-        value = prop.customType ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' }) : value;
+        value = prop.customType
+            ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' })
+            : value;
         changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
         if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
             wrapped.__identifier.setValue(value);
@@ -268,7 +273,8 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
+        if (meta.concurrencyCheckKeys.size === 0 &&
+            (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
             return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
@@ -278,7 +284,8 @@ export class ChangeSetPersister {
         return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
-        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
+        if (meta.concurrencyCheckKeys.size === 0 &&
+            (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
             return;
         }
         // skip entity references as they don't have version values loaded
@@ -344,9 +351,7 @@ export class ChangeSetPersister {
             });
             // reload generated columns
             if (!this.usesReturningStatement) {
-                meta.props
-                    .filter(prop => prop.generated && !prop.primary)
-                    .forEach(prop => reloadProps.push(prop));
+                meta.props.filter(prop => prop.generated && !prop.primary).forEach(prop => reloadProps.push(prop));
                 reloadProps.push(...returning);
             }
         }
@@ -407,7 +412,7 @@ export class ChangeSetPersister {
             return;
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
-            changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
+            changeSet.payload[prop.name] = value.map(val => (val instanceof EntityIdentifier ? val.getValue() : val));
             return;
         }
         if (prop.name in changeSet.payload) {

package/unit-of-work/CommitOrderCalculator.js

@@ -78,11 +78,13 @@ export class CommitOrderCalculator {
         for (const edge of node.dependencies.values()) {
             const target = this.nodes.get(edge.to);
             switch (target.state) {
-                case 2 /* NodeState.VISITED */: break; // Do nothing, since node was already visited
+                case 2 /* NodeState.VISITED */:
+                    break; // Do nothing, since node was already visited
                 case 1 /* NodeState.IN_PROGRESS */:
                     this.visitOpenNode(node, target, edge);
                     break;
-                case 0 /* NodeState.NOT_VISITED */: this.visit(target);
+                case 0 /* NodeState.NOT_VISITED */:
+                    this.visit(target);
             }
         }
         if (node.state !== 2 /* NodeState.VISITED */) {

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

@@ -72,7 +72,13 @@ export declare class UnitOfWork {
     getRemoveStack(): Set<AnyEntity>;
     getChangeSets(): ChangeSet<AnyEntity>[];
     getCollectionUpdates(): Collection<AnyEntity>[];
-    getExtraUpdates(): Set<[AnyEntity, string | string[], (AnyEntity | AnyEntity[] | Reference<any> | Collection<any>), ChangeSet<any> | undefined, ChangeSetType]>;
+    getExtraUpdates(): Set<[
+        AnyEntity,
+        string | string[],
+        AnyEntity | AnyEntity[] | Reference<any> | Collection<any>,
+        ChangeSet<any> | undefined,
+        ChangeSetType
+    ]>;
     shouldAutoFlush<T extends object>(meta: EntityMetadata<T>): boolean;
     clearActionsQueue(): void;
     computeChangeSet<T extends object>(entity: T, type?: ChangeSetType): void;

package/unit-of-work/UnitOfWork.js

@@ -76,7 +76,8 @@ export class UnitOfWork {
             if (!prop) {
                 continue;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
                 // Skip polymorphic relations - they use PolymorphicRef wrapper
                 if (!prop.polymorphic) {
                     data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
@@ -86,12 +87,16 @@ export class UnitOfWork {
                 for (const p of prop.targetMeta.props) {
                     /* v8 ignore next */
                     const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                    data[prefix + p.name] = data[prop.name][p.name];
+                    data[(prefix + p.name)] = data[prop.name][p.name];
                 }
                 data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
             }
             if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
-                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, {
+                    key,
+                    mode: 'hydration',
+                    force: true,
+                });
                 data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
             }
             if (forceUndefined) {
@@ -423,7 +428,10 @@ export class UnitOfWork {
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel &&
+                    (prop.mapToPk
+                        ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
+                        : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
@@ -512,7 +520,13 @@ export class UnitOfWork {
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([changeSet.entity, props.map(p => p.name), props.map(p => changeSet.entity[p.name]), changeSet, type]);
+        this.extraUpdates.add([
+            changeSet.entity,
+            props.map(p => p.name),
+            props.map(p => changeSet.entity[p.name]),
+            changeSet,
+            type,
+        ]);
         for (const p of props) {
             delete changeSet.entity[p.name];
             delete changeSet.payload[p.name];
@@ -633,7 +647,7 @@ export class UnitOfWork {
         // when changing a unique nullable property (or a 1:1 relation), we can't do it in a single
         // query as it would cause unique constraint violations
         const uniqueProps = changeSet.meta.uniqueProps.filter(prop => {
-            return (prop.nullable || changeSet.type !== ChangeSetType.CREATE);
+            return prop.nullable || changeSet.type !== ChangeSetType.CREATE;
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
         return changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload);
@@ -643,25 +657,33 @@ export class UnitOfWork {
         if (!wrapped.__meta.hasUniqueProps) {
             return [];
         }
-        const simpleUniqueHashes = wrapped.__meta.uniqueProps.map(prop => {
+        const simpleUniqueHashes = wrapped.__meta.uniqueProps
+            .map(prop => {
             if (entity[prop.name] != null) {
-                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                    ? entity[prop.name]
+                    : helper(entity[prop.name]).getSerializedPrimaryKey();
             }
             if (wrapped.__originalEntityData?.[prop.name] != null) {
                 return Utils.getPrimaryKeyHash(Utils.asArray(wrapped.__originalEntityData[prop.name]));
             }
             return undefined;
-        }).filter(i => i);
-        const compoundUniqueHashes = wrapped.__meta.uniques.map(unique => {
+        })
+            .filter(i => i);
+        const compoundUniqueHashes = wrapped.__meta.uniques
+            .map(unique => {
             const props = Utils.asArray(unique.properties);
             if (props.every(prop => entity[prop] != null)) {
                 return Utils.getPrimaryKeyHash(props.map(p => {
                     const prop = wrapped.__meta.properties[p];
-                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                        ? entity[prop.name]
+                        : helper(entity[prop.name]).getSerializedPrimaryKey();
                 }));
             }
             return undefined;
-        }).filter(i => i);
+        })
+            .filter(i => i);
         return simpleUniqueHashes.concat(compoundUniqueHashes);
     }
     initIdentifier(entity) {
@@ -693,7 +715,8 @@ export class UnitOfWork {
             return this.processToOneReference(kind, visited, processed, idx);
         }
         if (Utils.isCollection(kind)) {
-            kind.getItems(false)
+            kind
+                .getItems(false)
                 .filter(item => !item.__helper.__originalEntityData)
                 .forEach(item => {
                 // propagate schema from parent
@@ -717,7 +740,8 @@ export class UnitOfWork {
             parent[prop.name] = coll;
             return;
         }
-        collection.getItems(false)
+        collection
+            .getItems(false)
             .filter(item => !item.__helper.__originalEntityData)
             .forEach(item => this.findNewEntities(item, visited, 0, processed));
     }
@@ -809,7 +833,8 @@ export class UnitOfWork {
         return filtered.some(items => processed.has(items));
     }
     shouldCascade(prop, type) {
-        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) && prop.orphanRemoval) {
+        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) &&
+            prop.orphanRemoval) {
             return true;
         }
         // ignore user settings for merge, it is kept only for back compatibility, this should have never been configurable
@@ -845,7 +870,9 @@ export class UnitOfWork {
         const target = Reference.unwrapReference(reference);
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && target && !prop.mapToPk) {
             if (!Utils.isEntity(target)) {
-                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, { wrapped: !!prop.ref });
+                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, {
+                    wrapped: !!prop.ref,
+                });
             }
             else if (!helper(target).__initialized && !helper(target).__em) {
                 const pk = helper(target).getPrimaryKey();
@@ -907,9 +934,9 @@ export class UnitOfWork {
             return;
         }
         const props = changeSets[0].meta.root.relations.filter(prop => {
-            return (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
-                || prop.kind === ReferenceKind.MANY_TO_ONE
-                || (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
+            return ((prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) ||
+                prop.kind === ReferenceKind.MANY_TO_ONE ||
+                (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable()));
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
@@ -984,7 +1011,8 @@ export class UnitOfWork {
             wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
-                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                        changeSet.entity[prop.name] == null) {
                         changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
                     }
                 }
@@ -1013,7 +1041,7 @@ export class UnitOfWork {
                 continue;
             }
             if (Array.isArray(extraUpdate[1])) {
-                extraUpdate[1].forEach((p, i) => extraUpdate[0][p] = extraUpdate[2][i]);
+                extraUpdate[1].forEach((p, i) => (extraUpdate[0][p] = extraUpdate[2][i]));
             }
             else {
                 extraUpdate[0][extraUpdate[1]] = extraUpdate[2];
@@ -1075,7 +1103,8 @@ export class UnitOfWork {
         };
         const addToGroup = (cs) => {
             // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
-            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) && !Utils.hasObjectKeys(cs.payload)) {
+            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) &&
+                !Utils.hasObjectKeys(cs.payload)) {
                 return;
             }
             const group = groups[cs.type];