@mikro-orm/core 6.2.10-dev.9 → 6.2.10-dev.90

package/types/index.js

@@ -1,54 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.t = exports.types = exports.IntervalType = exports.UnknownType = exports.TextType = exports.UuidType = exports.StringType = exports.DecimalType = exports.BooleanType = exports.DoubleType = exports.FloatType = exports.MediumIntType = exports.TinyIntType = exports.SmallIntType = exports.IntegerType = exports.JsonType = exports.EnumType = exports.EnumArrayType = exports.ArrayType = exports.Uint8ArrayType = exports.BlobType = exports.BigIntType = exports.DateTimeType = exports.TimeType = exports.DateType = exports.Type = void 0;
-const Type_1 = require("./Type");
-Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return Type_1.Type; } });
-const DateType_1 = require("./DateType");
-Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return DateType_1.DateType; } });
-const TimeType_1 = require("./TimeType");
-Object.defineProperty(exports, "TimeType", { enumerable: true, get: function () { return TimeType_1.TimeType; } });
-const DateTimeType_1 = require("./DateTimeType");
-Object.defineProperty(exports, "DateTimeType", { enumerable: true, get: function () { return DateTimeType_1.DateTimeType; } });
+exports.t = exports.types = exports.CharacterType = exports.IntervalType = exports.UnknownType = exports.TextType = exports.UuidType = exports.StringType = exports.DecimalType = exports.BooleanType = exports.DoubleType = exports.FloatType = exports.MediumIntType = exports.TinyIntType = exports.SmallIntType = exports.IntegerType = exports.JsonType = exports.EnumType = exports.EnumArrayType = exports.ArrayType = exports.Uint8ArrayType = exports.BlobType = exports.BigIntType = exports.DateTimeType = exports.TimeType = exports.DateType = exports.Type = void 0;
+const ArrayType_1 = require("./ArrayType");
+Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return ArrayType_1.ArrayType; } });
 const BigIntType_1 = require("./BigIntType");
 Object.defineProperty(exports, "BigIntType", { enumerable: true, get: function () { return BigIntType_1.BigIntType; } });
 const BlobType_1 = require("./BlobType");
 Object.defineProperty(exports, "BlobType", { enumerable: true, get: function () { return BlobType_1.BlobType; } });
-const Uint8ArrayType_1 = require("./Uint8ArrayType");
-Object.defineProperty(exports, "Uint8ArrayType", { enumerable: true, get: function () { return Uint8ArrayType_1.Uint8ArrayType; } });
-const ArrayType_1 = require("./ArrayType");
-Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return ArrayType_1.ArrayType; } });
+const BooleanType_1 = require("./BooleanType");
+Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return BooleanType_1.BooleanType; } });
+const DateTimeType_1 = require("./DateTimeType");
+Object.defineProperty(exports, "DateTimeType", { enumerable: true, get: function () { return DateTimeType_1.DateTimeType; } });
+const DateType_1 = require("./DateType");
+Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return DateType_1.DateType; } });
+const DecimalType_1 = require("./DecimalType");
+Object.defineProperty(exports, "DecimalType", { enumerable: true, get: function () { return DecimalType_1.DecimalType; } });
+const DoubleType_1 = require("./DoubleType");
+Object.defineProperty(exports, "DoubleType", { enumerable: true, get: function () { return DoubleType_1.DoubleType; } });
 const EnumArrayType_1 = require("./EnumArrayType");
 Object.defineProperty(exports, "EnumArrayType", { enumerable: true, get: function () { return EnumArrayType_1.EnumArrayType; } });
 const EnumType_1 = require("./EnumType");
 Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return EnumType_1.EnumType; } });
-const JsonType_1 = require("./JsonType");
-Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return JsonType_1.JsonType; } });
+const CharacterType_1 = require("./CharacterType");
+Object.defineProperty(exports, "CharacterType", { enumerable: true, get: function () { return CharacterType_1.CharacterType; } });
+const FloatType_1 = require("./FloatType");
+Object.defineProperty(exports, "FloatType", { enumerable: true, get: function () { return FloatType_1.FloatType; } });
 const IntegerType_1 = require("./IntegerType");
 Object.defineProperty(exports, "IntegerType", { enumerable: true, get: function () { return IntegerType_1.IntegerType; } });
-const SmallIntType_1 = require("./SmallIntType");
-Object.defineProperty(exports, "SmallIntType", { enumerable: true, get: function () { return SmallIntType_1.SmallIntType; } });
-const TinyIntType_1 = require("./TinyIntType");
-Object.defineProperty(exports, "TinyIntType", { enumerable: true, get: function () { return TinyIntType_1.TinyIntType; } });
+const IntervalType_1 = require("./IntervalType");
+Object.defineProperty(exports, "IntervalType", { enumerable: true, get: function () { return IntervalType_1.IntervalType; } });
+const JsonType_1 = require("./JsonType");
+Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return JsonType_1.JsonType; } });
 const MediumIntType_1 = require("./MediumIntType");
 Object.defineProperty(exports, "MediumIntType", { enumerable: true, get: function () { return MediumIntType_1.MediumIntType; } });
-const FloatType_1 = require("./FloatType");
-Object.defineProperty(exports, "FloatType", { enumerable: true, get: function () { return FloatType_1.FloatType; } });
-const DoubleType_1 = require("./DoubleType");
-Object.defineProperty(exports, "DoubleType", { enumerable: true, get: function () { return DoubleType_1.DoubleType; } });
-const BooleanType_1 = require("./BooleanType");
-Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return BooleanType_1.BooleanType; } });
-const DecimalType_1 = require("./DecimalType");
-Object.defineProperty(exports, "DecimalType", { enumerable: true, get: function () { return DecimalType_1.DecimalType; } });
+const SmallIntType_1 = require("./SmallIntType");
+Object.defineProperty(exports, "SmallIntType", { enumerable: true, get: function () { return SmallIntType_1.SmallIntType; } });
 const StringType_1 = require("./StringType");
 Object.defineProperty(exports, "StringType", { enumerable: true, get: function () { return StringType_1.StringType; } });
-const UuidType_1 = require("./UuidType");
-Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return UuidType_1.UuidType; } });
 const TextType_1 = require("./TextType");
 Object.defineProperty(exports, "TextType", { enumerable: true, get: function () { return TextType_1.TextType; } });
-const IntervalType_1 = require("./IntervalType");
-Object.defineProperty(exports, "IntervalType", { enumerable: true, get: function () { return IntervalType_1.IntervalType; } });
+const TimeType_1 = require("./TimeType");
+Object.defineProperty(exports, "TimeType", { enumerable: true, get: function () { return TimeType_1.TimeType; } });
+const TinyIntType_1 = require("./TinyIntType");
+Object.defineProperty(exports, "TinyIntType", { enumerable: true, get: function () { return TinyIntType_1.TinyIntType; } });
+const Type_1 = require("./Type");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return Type_1.Type; } });
+const Uint8ArrayType_1 = require("./Uint8ArrayType");
+Object.defineProperty(exports, "Uint8ArrayType", { enumerable: true, get: function () { return Uint8ArrayType_1.Uint8ArrayType; } });
 const UnknownType_1 = require("./UnknownType");
 Object.defineProperty(exports, "UnknownType", { enumerable: true, get: function () { return UnknownType_1.UnknownType; } });
+const UuidType_1 = require("./UuidType");
+Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return UuidType_1.UuidType; } });
 exports.types = {
     date: DateType_1.DateType,
     time: TimeType_1.TimeType,
@@ -68,6 +70,7 @@ exports.types = {
     double: DoubleType_1.DoubleType,
     boolean: BooleanType_1.BooleanType,
     decimal: DecimalType_1.DecimalType,
+    character: CharacterType_1.CharacterType,
     string: StringType_1.StringType,
     uuid: UuidType_1.UuidType,
     text: TextType_1.TextType,

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from './connections';
-import { type PopulatePath, type DeferMode, type Cascade, type EventType, type LoadStrategy, type QueryOrderMap, ReferenceKind } from './enums';
+import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums';
 import { type AssignOptions, type Collection, type EntityFactory, type EntityIdentifier, type EntityLoaderOptions, type EntityRepository, Reference, type ScalarReference } from './entity';
 import type { SerializationContext, SerializeOptions } from './serialization';
 import type { EntitySchema, MetadataStorage } from './metadata';
@@ -13,9 +13,9 @@ export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
 };
-export type EntityKey<T = unknown, B extends boolean = false> = string & keyof {
-    [K in keyof T as CleanKeys<T, K, B>]?: unknown;
-};
+export type EntityKey<T = unknown, B extends boolean = false> = string & {
+    [K in keyof T]-?: CleanKeys<T, K, B> extends never ? never : K;
+}[keyof T];
 export type EntityValue<T> = T[EntityKey<T>];
 export type FilterKey<T> = keyof FilterQuery<T>;
 export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
@@ -126,7 +126,7 @@ export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : Filte
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
 };
-export type ObjectQuery<T> = OperatorMap<T> & ExpandObject<T>;
+export type ObjectQuery<T> = OperatorMap<T> & FilterObject<T>;
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
 export type QBFilterQuery<T = any> = ObjectQuery<T> | Dictionary;
 export interface IWrappedEntity<Entity extends object> {
@@ -223,7 +223,7 @@ type ExplicitlyOptionalProps<T> = (T extends {
 type NullableKeys<T, V = null> = {
     [K in keyof T]: V extends T[K] ? K : never;
 }[keyof T];
-type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | Defined<NullableKeys<T>>;
+type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | NonNullable<NullableKeys<T>>;
 type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
@@ -271,7 +271,7 @@ type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, Extra
 export type EntityDTOProp<E, T, C extends TypeConfig = never> = T extends Scalar ? T : T extends {
     __serialized?: infer U;
 } ? U : T extends LoadedReference<infer U> ? EntityDTO<U, C> : T extends Reference<infer U> ? PrimaryOrObject<E, U, C> : T extends ScalarReference<infer U> ? U : T extends LoadedCollection<infer U> ? EntityDTO<U, C>[] : T extends Collection<infer U> ? PrimaryOrObject<E, U, C>[] : T extends readonly (infer U)[] ? (T extends readonly any[] ? T : U[]) : T extends Relation<T> ? EntityDTO<T, C> : T;
-type DTOProbablyOptionalProps<T> = Defined<NullableKeys<T, undefined>>;
+type DTOProbablyOptionalProps<T> = NonNullable<NullableKeys<T, undefined>>;
 type DTOIsOptional<T, K extends keyof T> = T[K] extends LoadedCollection<any> ? false : K extends PrimaryProperty<T> ? false : K extends DTOProbablyOptionalProps<T> ? true : false;
 type DTORequiredKeys<T, K extends keyof T> = DTOIsOptional<T, K> extends false ? ExcludeHidden<T, K> & CleanKeys<T, K> : never;
 type DTOOptionalKeys<T, K extends keyof T> = DTOIsOptional<T, K> extends false ? never : ExcludeHidden<T, K> & CleanKeys<T, K>;
@@ -372,7 +372,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     extra?: string;
     userDefined?: boolean;
     optional?: boolean;
-    ignoreSchemaChanges?: ('type' | 'extra')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
     deferMode?: DeferMode;
 }
 export declare class EntityMetadata<T = any> {
@@ -519,6 +519,10 @@ export interface ISchemaGenerator {
     refreshDatabase(options?: RefreshDatabaseOptions): Promise<void>;
     clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
 }
+export type ImportsResolver = (alias: string, basePath: string, extension: '.js' | '', originFileName: string) => {
+    path: string;
+    name: string;
+} | undefined;
 export interface GenerateOptions {
     path?: string;
     save?: boolean;
@@ -533,10 +537,12 @@ export interface GenerateOptions {
     scalarTypeInDecorator?: boolean;
     scalarPropertiesForRelations?: 'always' | 'never' | 'smart';
     fileName?: (className: string) => string;
+    extraImport?: ImportsResolver;
     onlyPurePivotTables?: boolean;
     readOnlyPivotTables?: boolean;
     customBaseEntityName?: string;
     useCoreBaseEntity?: boolean;
+    coreImportsPrefix?: string;
     onInitialMetadata?: MetadataProcessor;
     onProcessedMetadata?: MetadataProcessor;
 }
@@ -668,7 +674,7 @@ type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type CollectionKeys<T> = T extends object ? {
     [K in keyof T]: T[K] extends Collection<any> ? IsAny<T[K]> extends true ? never : K & string : never;
 }[keyof T] & {} : never;
-export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<Defined<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (Defined<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<Defined<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q & string}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never : never;
+export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q & string}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never : never;
 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 Reference<infer U> ? NonNullable<U> : T extends Collection<infer U, any> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
@@ -679,7 +685,6 @@ type Prefix<T, K> = K extends `${infer S}.${string}` ? S : (K extends '*' ? keyo
 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 Loadable<any> ? K : never) : IsNever<StringLiteral<L>> extends true ? never : 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;
-type Defined<T> = T & {};
 export type IsSubset<T, U> = keyof U extends keyof T ? {} : Dictionary extends U ? {} : {
     [K in keyof U as K extends keyof T ? never : CleanKeys<U, K>]: never;
 };
@@ -695,7 +700,7 @@ type LoadedProp<T, L extends string = never, F extends string = '*', E extends s
 export type AddEager<T> = ExtractEagerProps<T> & string;
 export type ExpandHint<T, L extends string> = L | AddEager<T>;
 export type Selected<T, L extends string = never, F extends string = '*'> = {
-    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>>]: LoadedProp<Defined<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
+    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
 } & {
     [K in keyof T as FunctionKeys<T, K>]: T[K];
 } & {
@@ -711,9 +716,9 @@ export type FromEntityType<T> = T extends LoadedEntityType<infer U> ? U : T;
 type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [
     F
 ] extends ['*'] ? IsNever<E> extends true ? T & {
-    [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>>]: LoadedProp<Defined<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
+    [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : {
-    [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>, E>]: LoadedProp<Defined<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
+    [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>, E>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : Selected<T, L, F>;
 /**
  * Represents entity with its loaded relations (`populate` hint) and selected properties (`fields` hint).
@@ -721,13 +726,13 @@ type LoadedInternal<T, L extends string = never, F extends string = '*', E exten
 export type Loaded<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedInternal<T, L, F, E> & {
     [__loadedType]?: T;
 };
-export interface LoadedReference<T> extends Reference<Defined<T>> {
-    $: Defined<T>;
-    get(): Defined<T>;
+export interface LoadedReference<T> extends Reference<NonNullable<T>> {
+    $: NonNullable<T>;
+    get(): NonNullable<T>;
 }
-export interface LoadedScalarReference<T> extends ScalarReference<Defined<T>> {
-    $: Defined<T>;
-    get(): Defined<T>;
+export interface LoadedScalarReference<T> extends ScalarReference<T> {
+    $: T;
+    get(): T;
 }
 export interface LoadedCollection<T extends object> extends Collection<T> {
     $: Collection<T>;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { EntityData, EntityMetadata, EntityDictionary, Primary } from '../typings';
 export declare class ChangeSet<T extends object> {

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

@@ -47,5 +47,5 @@ export declare class ChangeSetPersister {
      * No need to handle composite keys here as they need to be set upfront.
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
-    mapReturnedValues<T extends object>(entity: T, payload: EntityDictionary<T>, row: Dictionary | undefined, meta: EntityMetadata<T>): void;
+    mapReturnedValues<T extends object>(entity: T | null | undefined, payload: EntityDictionary<T>, row: Dictionary | undefined, meta: EntityMetadata<T>, upsert?: boolean): void;
 }

package/unit-of-work/ChangeSetPersister.js

@@ -351,10 +351,12 @@ class ChangeSetPersister {
      * No need to handle composite keys here as they need to be set upfront.
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
-    mapReturnedValues(entity, payload, row, meta) {
-        if (this.usesReturningStatement && row && utils_1.Utils.hasObjectKeys(row)) {
+    mapReturnedValues(entity, payload, row, meta, upsert = false) {
+        if ((this.usesReturningStatement || upsert) && row && utils_1.Utils.hasObjectKeys(row)) {
             const mapped = this.comparator.mapResult(meta.className, row);
-            this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
+            if (entity) {
+                this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
+            }
             Object.assign(payload, mapped); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
     }

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

@@ -52,7 +52,7 @@ 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]>;
+    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

@@ -423,15 +423,24 @@ class UnitOfWork {
             return;
         }
         let conflicts = false;
+        let type = ChangeSet_1.ChangeSetType.UPDATE;
+        if (!props.some(prop => prop.name in changeSet.payload)) {
+            return;
+        }
         for (const cs of this.changeSets.values()) {
-            if (cs.rootName === changeSet.rootName && cs.type === changeSet.type) {
-                conflicts = true;
+            for (const prop of props) {
+                if (prop.name in cs.payload && cs.rootName === changeSet.rootName && cs.type === changeSet.type) {
+                    conflicts = true;
+                    if (changeSet.payload[prop.name] == null) {
+                        type = ChangeSet_1.ChangeSetType.UPDATE_EARLY;
+                    }
+                }
             }
         }
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([changeSet.entity, props.map(p => p.name), props.map(p => changeSet.entity[p.name]), changeSet]);
+        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];
@@ -483,13 +492,13 @@ class UnitOfWork {
      * Returns `true` when the change set should be skipped as it will be empty after the extra update.
      */
     checkUniqueProps(changeSet) {
-        if (this.platform.allowsUniqueBatchUpdates() || changeSet.type !== ChangeSet_1.ChangeSetType.UPDATE) {
+        if (changeSet.type !== ChangeSet_1.ChangeSetType.UPDATE) {
             return false;
         }
-        // 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
+        // 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 !== ChangeSet_1.ChangeSetType.CREATE)
-                && changeSet.payload[prop.name] != null;
+            return (prop.nullable || changeSet.type !== ChangeSet_1.ChangeSetType.CREATE);
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
         return changeSet.type === ChangeSet_1.ChangeSetType.UPDATE && !Utils_1.Utils.hasObjectKeys(changeSet.payload);
@@ -558,7 +567,7 @@ class UnitOfWork {
     }
     processToManyReference(collection, visited, processed, parent, prop) {
         if (this.isCollectionSelfReferenced(collection, processed)) {
-            this.extraUpdates.add([parent, prop.name, collection, undefined]);
+            this.extraUpdates.add([parent, prop.name, collection, undefined, ChangeSet_1.ChangeSetType.UPDATE]);
             const coll = new entity_1.Collection(parent);
             coll.property = prop;
             parent[prop.name] = coll;
@@ -710,31 +719,33 @@ class UnitOfWork {
         }
         const commitOrder = this.getCommitOrder();
         const commitOrderReversed = [...commitOrder].reverse();
-        // 1. early delete - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
+        // early delete - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const name of commitOrderReversed) {
             await this.commitDeleteChangeSets(groups[ChangeSet_1.ChangeSetType.DELETE_EARLY].get(name) ?? [], ctx);
         }
-        // 2. early update - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
+        // early update - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const name of commitOrder) {
             await this.commitUpdateChangeSets(groups[ChangeSet_1.ChangeSetType.UPDATE_EARLY].get(name) ?? [], ctx);
         }
-        // 3. create
+        // extra updates
+        await this.commitExtraUpdates(ChangeSet_1.ChangeSetType.UPDATE_EARLY, ctx);
+        // create
         for (const name of commitOrder) {
             await this.commitCreateChangeSets(groups[ChangeSet_1.ChangeSetType.CREATE].get(name) ?? [], ctx);
         }
-        // 4. update
+        // update
         for (const name of commitOrder) {
             await this.commitUpdateChangeSets(groups[ChangeSet_1.ChangeSetType.UPDATE].get(name) ?? [], ctx);
         }
-        // 5. extra updates
-        await this.commitExtraUpdates(ctx);
-        // 6. collection updates
+        // extra updates
+        await this.commitExtraUpdates(ChangeSet_1.ChangeSetType.UPDATE, ctx);
+        // collection updates
         await this.commitCollectionUpdates(ctx);
-        // 7. delete - entity deletions need to be in reverse commit order
+        // delete - entity deletions need to be in reverse commit order
         for (const name of commitOrderReversed) {
             await this.commitDeleteChangeSets(groups[ChangeSet_1.ChangeSetType.DELETE].get(name) ?? [], ctx);
         }
-        // 8. take snapshots of all persisted collections
+        // take snapshots of all persisted collections
         const visited = new Set();
         for (const changeSet of this.changeSets.values()) {
             this.takeCollectionSnapshots(changeSet.entity, visited);
@@ -825,9 +836,12 @@ class UnitOfWork {
             await this.runHooks(enums_1.EventType.afterDelete, changeSet);
         }
     }
-    async commitExtraUpdates(ctx) {
+    async commitExtraUpdates(type, ctx) {
         const extraUpdates = [];
         for (const extraUpdate of this.extraUpdates) {
+            if (extraUpdate[4] !== type) {
+                continue;
+            }
             if (Array.isArray(extraUpdate[1])) {
                 extraUpdate[1].forEach((p, i) => extraUpdate[0][p] = extraUpdate[2][i]);
             }

package/utils/Configuration.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = exports.Configuration = void 0;
+exports.Configuration = void 0;
+exports.defineConfig = defineConfig;
 const fs_extra_1 = require("fs-extra");
 const cache_1 = require("../cache");
 const hydration_1 = require("../hydration");
@@ -373,4 +374,3 @@ exports.Configuration = Configuration;
 function defineConfig(options) {
     return options;
 }
-exports.defineConfig = defineConfig;

package/utils/ConfigurationLoader.js

@@ -119,6 +119,7 @@ class ConfigurationLoader {
             transpileOnly: true,
             compilerOptions: {
                 module: 'nodenext',
+                moduleResolution: 'nodenext',
             },
         }).config;
         if (Object.entries(options?.paths ?? {}).length > 0) {

package/utils/Cursor.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { EntityMetadata, FilterObject, Loaded } from '../typings';
 import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver';

package/utils/DataloaderUtils.d.ts

@@ -7,12 +7,12 @@ import { type LoadReferenceOptions } from '../entity/Reference';
 export declare class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the
-     * class name as the index and the corresponging primary keys as the value.
+     * class name as the index and the corresponding primary keys as the value.
      */
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts: readonly [Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?][]): Map<string, Set<Primary<any>>>;
     /**
      * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
-     * makes one query per entity and maps each input reference to the corresponging result.
+     * makes one query per entity and maps each input reference to the corresponding result.
      */
     static getRefBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
     /**
@@ -36,7 +36,7 @@ export declare class DataloaderUtils {
     static getColFilter<T, S extends T>(collection: Collection<any, object>): (result: T) => result is S;
     /**
      * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
-     * makes one query per entity and maps each input collection to the corresponging result.
+     * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
     static getDataloaderType(dataloaderCfg: DataloaderType | boolean): DataloaderType;

package/utils/DataloaderUtils.js

@@ -7,7 +7,7 @@ const enums_1 = require("../enums");
 class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the
-     * class name as the index and the corresponging primary keys as the value.
+     * class name as the index and the corresponding primary keys as the value.
      */
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
@@ -20,7 +20,7 @@ class DataloaderUtils {
                In real-world scenarios (GraphQL) most of the time you will end up batching the same sets of options anyway,
                so we end up getting most of the benefits with the much simpler implementation.
                Also there are scenarios where the single query per entity implementation may end up being slower, for example
-               if the vast majority of the refereces batched for a certain entity  don't have populate options while a few ones have
+               if the vast majority of the references batched for a certain entity  don't have populate options while a few ones have
                a wildcard populate so you end up doing the additional joins for all the entities.
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
@@ -37,7 +37,7 @@ class DataloaderUtils {
     }
     /**
      * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
-     * makes one query per entity and maps each input reference to the corresponging result.
+     * makes one query per entity and maps each input reference to the corresponding result.
      */
     static getRefBatchLoadFn(em) {
         return async (refsWithOpts) => {
@@ -159,7 +159,7 @@ class DataloaderUtils {
     }
     /**
      * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
-     * makes one query per entity and maps each input collection to the corresponging result.
+     * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em) {
         return async (collsWithOpts) => {

package/utils/EntityComparator.d.ts

@@ -3,6 +3,7 @@ import type { Platform } from '../platforms';
 type Comparator<T> = (a: T, b: T) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
+type CompositeKeyPart = string | CompositeKeyPart[];
 export declare class EntityComparator {
     private readonly metadata;
     private readonly platform;
@@ -44,6 +45,18 @@ export declare class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    /**
+     * @internal
+     */
+    propName(name: string, parent?: string): string;
+    /**
+     * @internal respects nested composite keys, e.g. `[1, [2, 3]]`
+     */
+    createCompositeKeyArray(prop: EntityProperty, parents?: EntityProperty[]): string;
+    /**
+     * @internal
+     */
+    formatCompositeKeyPart(part: CompositeKeyPart): string;
     /**
      * @internal Highly performance-sensitive method.
      */