@mikro-orm/core 6.2.10-dev.8 → 6.2.10-dev.81

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> {
@@ -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.
      */

package/utils/EntityComparator.js

@@ -206,6 +206,50 @@ class EntityComparator {
         this.snapshotGenerators.set(entityName, snapshotGenerator);
         return snapshotGenerator;
     }
+    /**
+     * @internal
+     */
+    propName(name, parent = 'result') {
+        return parent + this.wrap(name);
+    }
+    /**
+     * @internal respects nested composite keys, e.g. `[1, [2, 3]]`
+     */
+    createCompositeKeyArray(prop, parents = []) {
+        if (!prop.targetMeta) {
+            let fieldName = prop.fieldNames[0];
+            // traverse all parents, mapping my field name to each parent's field name until we reach the root
+            for (let i = parents.length - 1; i >= 0; i--) {
+                const parent = parents[i];
+                // look for the field name in the parent's referencedColumnNames, except for M:N without a custom pivot entity
+                //   (in that case, the field names are the referenced PK's )
+                const target = parent.kind === enums_1.ReferenceKind.MANY_TO_MANY && parent.pivotEntity === parent.pivotTable ?
+                    parent.referencedPKs : parent.referencedColumnNames;
+                const idx = target.indexOf(fieldName);
+                fieldName = parent.fieldNames[idx];
+            }
+            return this.propName(fieldName);
+        }
+        const parts = [];
+        prop.targetMeta.getPrimaryProps().forEach(pk => {
+            const part = this.createCompositeKeyArray(pk, [...parents, prop]);
+            parts.push(part);
+        });
+        return this.formatCompositeKeyPart(parts);
+    }
+    /**
+     * @internal
+     */
+    formatCompositeKeyPart(part) {
+        if (!Array.isArray(part)) {
+            return part;
+        }
+        if (part.length === 1) {
+            return this.formatCompositeKeyPart(part[0]);
+        }
+        const formatted = part.map(this.formatCompositeKeyPart).join(', ');
+        return `[${formatted}]`;
+    }
     /**
      * @internal Highly performance-sensitive method.
      */
@@ -217,22 +261,6 @@ class EntityComparator {
         const meta = this.metadata.get(entityName);
         const lines = [];
         const context = new Map();
-        const propName = (name, parent = 'result') => parent + this.wrap(name);
-        // respects nested composite keys, e.g. `[1, [2, 3]]`
-        const createCompositeKeyArray = (prop, fieldNames = prop.fieldNames, idx = 0) => {
-            if (!prop.targetMeta) {
-                return propName(fieldNames[idx++]);
-            }
-            const parts = [];
-            for (const pk of prop.targetMeta.getPrimaryProps()) {
-                parts.push(createCompositeKeyArray(pk, fieldNames, idx));
-                idx += pk.fieldNames.length;
-            }
-            if (parts.length < 2) {
-                return parts[0];
-            }
-            return '[' + parts.join(', ') + ']';
-        };
         const tz = this.platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
@@ -255,28 +283,28 @@ class EntityComparator {
                 return;
             }
             if (prop.targetMeta && prop.fieldNames.length > 1) {
-                lines.push(`  if (${prop.fieldNames.map(field => `typeof ${propName(field)} === 'undefined'`).join(' && ')}) {`);
-                lines.push(`  } else if (${prop.fieldNames.map(field => `${propName(field)} != null`).join(' && ')}) {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${createCompositeKeyArray(prop)};`);
-                lines.push(...prop.fieldNames.map(field => `    ${propName(field, 'mapped')} = true;`));
-                lines.push(`  } else if (${prop.fieldNames.map(field => `${propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
-                lines.push(...prop.fieldNames.map(field => `    ${propName(field, 'mapped')} = true;`), '  }');
+                lines.push(`  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
+                lines.push(`  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
+                lines.push(`    ret${this.wrap(prop.name)} = ${this.createCompositeKeyArray(prop)};`);
+                lines.push(...prop.fieldNames.map(field => `    ${this.propName(field, 'mapped')} = true;`));
+                lines.push(`  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
+                lines.push(...prop.fieldNames.map(field => `    ${this.propName(field, 'mapped')} = true;`), '  }');
                 return;
             }
             if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
                 return;
             }
             if (prop.runtimeType === 'boolean') {
-                lines.push(`  if (typeof ${propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${propName(prop.fieldNames[0])} == null ? ${propName(prop.fieldNames[0])} : !!${propName(prop.fieldNames[0])};`);
-                lines.push(`    ${propName(prop.fieldNames[0], 'mapped')} = true;`);
+                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : !!${this.propName(prop.fieldNames[0])};`);
+                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
             else if (prop.runtimeType === 'Date') {
-                lines.push(`  if (typeof ${propName(prop.fieldNames[0])} !== 'undefined') {`);
+                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
                 context.set('parseDate', (value) => this.platform.parseDate(value));
-                parseDate('ret' + this.wrap(prop.name), propName(prop.fieldNames[0]));
-                lines.push(`    ${propName(prop.fieldNames[0], 'mapped')} = true;`);
+                parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]));
+                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
             else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
@@ -288,15 +316,15 @@ class EntityComparator {
                     }
                     return item == null ? item : this.getResultMapper(prop.type)(item);
                 });
-                lines.push(`  if (typeof ${propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${propName(prop.fieldNames[0])} == null ? ${propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${propName(prop.fieldNames[0])});`);
-                lines.push(`    ${propName(prop.fieldNames[0], 'mapped')} = true;`);
+                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
+                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
             else if (prop.kind !== enums_1.ReferenceKind.EMBEDDED) {
-                lines.push(`  if (typeof ${propName(prop.fieldNames[0])} !== 'undefined') {`);
-                lines.push(`    ret${this.wrap(prop.name)} = ${propName(prop.fieldNames[0])};`);
-                lines.push(`    ${propName(prop.fieldNames[0], 'mapped')} = true;`);
+                lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
+                lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
         });

package/utils/RawQueryFragment.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { AnyString, Dictionary, EntityKey } from '../typings';
 export declare class RawQueryFragment {
@@ -89,7 +88,7 @@ export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> |
 export declare function sql(sql: readonly string[], ...values: unknown[]): any;
 export declare namespace sql {
     var ref: <T extends object>(...keys: string[]) => RawQueryFragment;
-    var now: (length?: number | undefined) => string;
+    var now: (length?: number) => string;
     var lower: <T extends object>(key: string | ((alias: string) => string)) => string;
     var upper: <T extends object>(key: string | ((alias: string) => string)) => string;
 }

package/utils/RawQueryFragment.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSqlFunction = exports.sql = exports.raw = exports.ALIAS_REPLACEMENT_RE = exports.ALIAS_REPLACEMENT = exports.RawQueryFragment = void 0;
+exports.ALIAS_REPLACEMENT_RE = exports.ALIAS_REPLACEMENT = exports.RawQueryFragment = void 0;
+exports.raw = raw;
+exports.sql = sql;
+exports.createSqlFunction = createSqlFunction;
 const util_1 = require("util");
 const Utils_1 = require("./Utils");
 class RawQueryFragment {
@@ -152,7 +155,6 @@ function raw(sql, params) {
     }
     return new RawQueryFragment(sql, params);
 }
-exports.raw = raw;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *
@@ -174,14 +176,12 @@ function sql(sql, ...values) {
         return valueExists ? text + '?' : text;
     }, ''), values);
 }
-exports.sql = sql;
 function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);
     }
     return raw(a => `${func}(${(key(a))})`);
 }
-exports.createSqlFunction = createSqlFunction;
 sql.ref = (...keys) => raw('??', [keys.join('.')]);
 sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));
 sql.lower = (key) => createSqlFunction('lower', key);

package/utils/Utils.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { type GlobbyOptions } from 'globby';
 import { type URL } from 'url';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings';
@@ -190,9 +188,9 @@ export declare class Utils {
     static isCollection<T extends object, O extends object = object>(item: any): item is Collection<T, O>;
     static fileURLToPath(url: string | URL): string;
     /**
-     * Resolves and normalizes a series of path parts relative to each preceeding part.
+     * Resolves and normalizes a series of path parts relative to each preceding part.
      * If any part is a `file:` URL, it is converted to a local path. If any part is an
-     * absolute path, it replaces preceeding paths (similar to `path.resolve` in NodeJS).
+     * absolute path, it replaces preceding paths (similar to `path.resolve` in NodeJS).
      * Trailing directory separators are removed, and all directory separators are converted
      * to POSIX-style separators (`/`).
      */
@@ -257,10 +255,10 @@ export declare class Utils {
     static keys<T extends object>(obj: T): (keyof T)[];
     static values<T extends object>(obj: T): T[keyof T][];
     static entries<T extends object>(obj: T): [keyof T, T[keyof T]][];
-    static isRawSql(value: unknown): value is {
+    static isRawSql<T = {
         sql: string;
         params: unknown[];
         use: () => void;
-    };
+    }>(value: unknown): value is T;
     static primaryKeyToObject<T>(meta: EntityMetadata<T>, primaryKey: Primary<T> | T, visible?: (keyof T)[]): T;
 }