@mikro-orm/core 6.2.10-dev.7 → 6.2.10-dev.71

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -8,6 +8,14 @@ export declare abstract class AbstractNamingStrategy implements NamingStrategy {
      */
     getEntityName(tableName: string, schemaName?: string): string;
     columnNameToProperty(columnName: string): string;
+    /**
+     * @inheritDoc
+     */
+    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    /**
+     * @inheritDoc
+     */
+    enumValueToEnumProperty(enumValue: string, columnName: string, tableName: string, schemaName?: string): string;
     aliasName(entityName: string, index: number): string;
     abstract classToTableName(entityName: string): string;
     abstract joinColumnName(propertyName: string): string;

package/naming-strategy/AbstractNamingStrategy.js

@@ -47,6 +47,18 @@ class AbstractNamingStrategy {
         }
         return propName;
     }
+    /**
+     * @inheritDoc
+     */
+    getEnumClassName(columnName, tableName, schemaName) {
+        return this.getEntityName(`${tableName}_${columnName}`, schemaName);
+    }
+    /**
+     * @inheritDoc
+     */
+    enumValueToEnumProperty(enumValue, columnName, tableName, schemaName) {
+        return enumValue.toUpperCase();
+    }
     aliasName(entityName, index) {
         // Take only the first letter of the prefix to keep character counts down since some engines have character limits
         return entityName.charAt(0).toLowerCase() + index;

package/naming-strategy/NamingStrategy.d.ts

@@ -15,6 +15,27 @@ export interface NamingStrategy {
      * Return a column name for a property
      */
     propertyToColumnName(propertyName: string, object?: boolean): string;
+    /**
+     * Get an enum class name.
+     *
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return A new class name that will be used for the enum.
+     */
+    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    /**
+     * Get an enum option name for a given enum value.
+     *
+     * @param enumValue The enum value to generate a name for.
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return The name of the enum property that will hold the value.
+     */
+    enumValueToEnumProperty(enumValue: string, columnName: string, tableName: string, schemaName?: string): string;
     /**
      * Return a name of the entity class based on database table name (used in `EntityGenerator`).
      * Default implementation ignores the schema name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.2.10-dev.7",
+  "version": "6.2.10-dev.71",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.2.10-dev.7",
+    "mikro-orm": "6.2.10-dev.71",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -69,7 +69,6 @@ export declare abstract class Platform {
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     getDefaultVersionLength(): number;
     allowsComparingTuples(): boolean;
-    allowsUniqueBatchUpdates(): boolean;
     isBigIntProperty(prop: EntityProperty): boolean;
     isRaw(value: any): boolean;
     getDefaultSchemaName(): string | undefined;

package/platforms/Platform.js

@@ -123,9 +123,6 @@ class Platform {
     allowsComparingTuples() {
         return true;
     }
-    allowsUniqueBatchUpdates() {
-        return true;
-    }
     isBigIntProperty(prop) {
         return prop.columnTypes && prop.columnTypes[0] === 'bigint';
     }

package/serialization/EntitySerializer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serialize = exports.EntitySerializer = void 0;
+exports.EntitySerializer = void 0;
+exports.serialize = serialize;
 const wrap_1 = require("../entity/wrap");
 const Utils_1 = require("../utils/Utils");
 const enums_1 = require("../enums");
@@ -210,4 +211,3 @@ function serialize(entities, options) {
     }
     return EntitySerializer.serialize(entities, options);
 }
-exports.serialize = serialize;

package/types/BigIntType.d.ts

@@ -6,8 +6,8 @@ import type { EntityProperty } from '../typings';
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
 export declare class BigIntType extends Type<string | bigint | number | null | undefined, string | null | undefined> {
-    mode?: "string" | "number" | "bigint" | undefined;
-    constructor(mode?: "string" | "number" | "bigint" | undefined);
+    mode?: ("bigint" | "number" | "string") | undefined;
+    constructor(mode?: ("bigint" | "number" | "string") | undefined);
     convertToDatabaseValue(value: string | bigint | null | undefined): string | null | undefined;
     convertToJSValue(value: string | bigint | null | undefined): bigint | number | string | null | undefined;
     toJSON(value: string | bigint | null | undefined): string | bigint | null | undefined;

package/types/BigIntType.js

@@ -29,7 +29,7 @@ class BigIntType extends Type_1.Type {
                 return String(value);
             case 'bigint':
             default:
-                return BigInt(value);
+                return BigInt(String(value));
         }
     }
     toJSON(value) {

package/types/BlobType.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Uint8ArrayType } from './Uint8ArrayType';
 import type { Platform } from '../platforms';
 import type { EntityProperty } from '../typings';

package/types/DecimalType.d.ts

@@ -5,8 +5,8 @@ import type { EntityProperty } from '../typings';
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
 export declare class DecimalType extends Type<string | number, string> {
-    mode?: "string" | "number" | undefined;
-    constructor(mode?: "string" | "number" | undefined);
+    mode?: ("number" | "string") | undefined;
+    constructor(mode?: ("number" | "string") | undefined);
     convertToJSValue(value: string): number | string;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;

package/types/Type.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { Platform } from '../platforms';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings';
@@ -59,7 +58,7 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
      * Gets the SQL declaration snippet for a field of this type.
      */
     getColumnType(prop: EntityProperty, platform: Platform): string;
-    static getType<JSType, DBType = JSType>(cls: Constructor<Type<JSType, DBType>>): Type<JSType, DBType>;
+    static getType<JSType, DBType = JSType, TypeClass extends Constructor<Type<JSType, DBType>> = Constructor<Type<JSType, DBType>>>(cls: TypeClass): InstanceType<TypeClass>;
     /**
      * Checks whether the argument is instance of `Type`.
      */

package/types/Uint8ArrayType.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Type } from './Type';
 import type { Platform } from '../platforms';
 import type { EntityProperty } from '../typings';

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';
@@ -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>;
@@ -537,6 +537,7 @@ export interface GenerateOptions {
     readOnlyPivotTables?: boolean;
     customBaseEntityName?: string;
     useCoreBaseEntity?: boolean;
+    coreImportsPrefix?: string;
     onInitialMetadata?: MetadataProcessor;
     onProcessedMetadata?: MetadataProcessor;
 }
@@ -668,7 +669,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 +680,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 +695,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 +711,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 +721,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.
      */