@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.30

package/cache/FileCacheAdapter.js

@@ -1,16 +1,18 @@
-import globby from 'globby';
+import { globSync } from 'tinyglobby';
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
+    hashAlgorithm;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.hashAlgorithm = hashAlgorithm;
     }
     /**
      * @inheritDoc
@@ -51,7 +53,7 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = globby.sync(path);
+        const files = globSync(path);
         files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
@@ -77,6 +79,6 @@ export class FileCacheAdapter {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION);
+        return Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
     }
 }

package/connections/Connection.d.ts

@@ -45,15 +45,17 @@ export declare abstract class Connection {
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<Transaction>;
-    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
     getClientUrl(): string;

package/connections/Connection.js

@@ -46,10 +46,10 @@ export class Connection {
     async begin(options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     getConnectionOptions() {

package/decorators/Check.d.ts

@@ -1,3 +1,3 @@
-import type { CheckConstraint } from '../typings.js';
-export declare function Check<T>(options: CheckOptions<T>): (target: any, propertyName?: string) => any;
+import type { CheckConstraint, EntityClass } from '../typings.js';
+export declare function Check<T>(options: CheckOptions<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
 export type CheckOptions<T = any> = CheckConstraint<T>;

package/decorators/Embeddable.d.ts

@@ -1,8 +1,8 @@
-import type { Dictionary } from '../typings.js';
-export declare function Embeddable(options?: EmbeddableOptions): <T>(target: T & Dictionary) => T & Dictionary;
-export type EmbeddableOptions = {
-    discriminatorColumn?: string;
+import type { AnyString, Dictionary, EntityClass } from '../typings.js';
+export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
+export interface EmbeddableOptions<T> {
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     abstract?: boolean;
-};
+}

package/decorators/Embeddable.js

@@ -3,7 +3,7 @@ export function Embeddable(options = {}) {
     return function (target) {
         const meta = MetadataStorage.getMetadataFromDecorator(target);
         meta.class = target;
-        meta.name = target.name;
+        meta.name = meta.class.name;
         meta.embeddable = true;
         Object.assign(meta, options);
         return target;

package/decorators/Embedded.d.ts

@@ -1,18 +1,12 @@
-import type { AnyEntity } from '../typings.js';
-export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
+import type { AnyEntity, EntityName } from '../typings.js';
+import type { PropertyOptions } from './Property.js';
+export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => any;
 /** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
 export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export type EmbeddedOptions = {
-    entity?: string | (() => AnyEntity | AnyEntity[]);
-    type?: string;
+export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
+    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
-    nullable?: boolean;
     object?: boolean;
     array?: boolean;
-    hidden?: boolean;
-    serializer?: (value: any) => any;
-    serializedName?: string;
-    groups?: string[];
-    persist?: boolean;
-};
+}

package/decorators/Entity.d.ts

@@ -1,18 +1,33 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings.js';
+import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } from '../typings.js';
 import type { FindOptions } from '../drivers/IDatabaseDriver.js';
-export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
-export type EntityOptions<T> = {
+export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
+export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
+    /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
+    /** Sets the schema name. */
     schema?: string;
+    /** Override default collection/table name. Alias for `tableName`. */
     collection?: string;
-    discriminatorColumn?: string;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorMap?: Dictionary<string>;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorValue?: number | string;
+    /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
+    /** Specify comment to table. (SQL only) */
     comment?: string;
+    /**	Marks entity as abstract, such entities are inlined during discovery. */
     abstract?: boolean;
+    /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
+    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
     virtual?: boolean;
-    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object);
+    /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
+    hasTriggers?: boolean;
+    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
+    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>) => object);
+    /** Set {@doclink repositories#custom-repository | custom repository class}. */
     repository?: () => Constructor;
 };

package/decorators/Entity.js

@@ -8,6 +8,5 @@ export function Entity(options = {}) {
         if (!options.abstract || meta.discriminatorColumn) {
             meta.name = target.name;
         }
-        return target;
     };
 }

package/decorators/Enum.d.ts

@@ -1,6 +1,6 @@
 import type { PropertyOptions } from './Property.js';
 import type { AnyEntity, Dictionary } from '../typings.js';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: AnyEntity, propertyName: string) => any;
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
 export interface EnumOptions<T> extends PropertyOptions<T> {
     items?: (number | string)[] | (() => Dictionary);
     array?: boolean;

package/decorators/Formula.d.ts

@@ -1,5 +1,4 @@
-import type { AnyEntity } from '../typings.js';
 import type { PropertyOptions } from './Property.js';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
 export interface FormulaOptions<T> extends PropertyOptions<T> {
 }

package/decorators/Indexed.d.ts

@@ -1,17 +1,19 @@
-import type { AnyEntity, Dictionary } from '../typings.js';
+import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings.js';
 import type { DeferMode } from '../enums.js';
-export declare function Index<T>(options?: IndexOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-export declare function Unique<T>(options?: UniqueOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-interface BaseOptions<T> {
+export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+type MaybeArray<T> = T | T[];
+type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+interface BaseOptions<T, H extends string> {
     name?: string;
-    properties?: keyof T | (keyof T)[];
+    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
-    expression?: string;
+    expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
 }
-export interface UniqueOptions<T> extends BaseOptions<T> {
+export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
 }
-export interface IndexOptions<T> extends BaseOptions<T> {
+export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
 }
 export {};

package/decorators/Indexed.js

@@ -3,7 +3,7 @@ import { Utils } from '../utils/Utils.js';
 function createDecorator(options, unique) {
     return function (target, propertyName) {
         const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties = options.properties || propertyName;
+        options.properties ??= propertyName;
         const key = unique ? 'uniques' : 'indexes';
         meta[key].push(options);
         if (!propertyName) {

package/decorators/ManyToMany.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
-import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings.js';
+import type { EntityName, FilterQuery, AnyString } from '../typings.js';
 import { type QueryOrderMap } from '../enums.js';
-export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
@@ -37,4 +37,6 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/decorators/ManyToOne.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
 import { type DeferMode } from '../enums.js';
-import type { AnyEntity, AnyString, EntityName } from '../typings.js';
-export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+import type { AnyString, EntityName } from '../typings.js';
+export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
@@ -27,4 +27,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName?: string;
 }

package/decorators/OneToMany.d.ts

@@ -1,9 +1,9 @@
 import type { ReferenceOptions } from './Property.js';
 import { ReferenceKind, type QueryOrderMap } from '../enums.js';
-import type { EntityName, AnyEntity, FilterQuery } from '../typings.js';
-export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
-export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+import type { EntityName, FilterQuery } from '../typings.js';
+export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: Owner, propertyName: string) => any;
+export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
+export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
 export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval?: boolean;

package/decorators/OneToOne.d.ts

@@ -1,7 +1,7 @@
 import { type DeferMode } from '../enums.js';
 import { type OneToManyOptions } from './OneToMany.js';
 import type { AnyString, EntityName } from '../typings.js';
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: import("../typings.js").AnyEntity, propertyName: string) => any;
+export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => any;
 export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
@@ -21,4 +21,8 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName?: string;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/decorators/PrimaryKey.d.ts

@@ -1,7 +1,6 @@
 import type { PropertyOptions } from './Property.js';
-import type { AnyEntity } from '../typings.js';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/decorators/Property.d.ts

@@ -3,7 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.

package/decorators/Transactional.d.ts

@@ -2,6 +2,7 @@ import type { TransactionOptions } from '../enums.js';
 import type { ContextProvider } from '../typings.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
+    contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.

package/decorators/Transactional.js

@@ -14,10 +14,10 @@ export function Transactional(options = {}) {
             throw new Error('@Transactional() should be use with async functions');
         }
         descriptor.value = async function (...args) {
-            const { context, ...txOptions } = options;
+            const { context, contextName, ...txOptions } = options;
             const em = (await resolveContextProvider(this, context))
-                || TransactionContext.getEntityManager()
-                || RequestContext.getEntityManager();
+                || TransactionContext.getEntityManager(contextName)
+                || RequestContext.getEntityManager(contextName);
             if (!em) {
                 throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }

package/drivers/IDatabaseDriver.d.ts

@@ -146,8 +146,11 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
 export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
@@ -163,6 +166,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -197,6 +201,8 @@ export interface CountOptions<T extends object, P extends string = never> {
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
@@ -218,6 +224,7 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;

package/entity/ArrayCollection.d.ts

@@ -6,6 +6,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     protected readonly items: Set<T>;
     protected initialized: boolean;
     protected dirty: boolean;
+    protected partial: boolean;
     protected snapshot: T[] | undefined;
     protected _count?: number;
     private _property?;
@@ -14,7 +15,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     getItems(): T[];
     toArray<TT extends T>(): EntityDTO<TT>[];
     toJSON(): EntityDTO<T>[];
-    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string): U[];
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
     add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
     /**
      * @internal
@@ -25,7 +26,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     /**
      * @internal
      */
-    hydrate(items: T[], forcePropagate?: boolean): void;
+    hydrate(items: T[], forcePropagate?: boolean, partial?: boolean): void;
     /**
      * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
      * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
@@ -83,6 +84,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     count(): number;
     isInitialized(fully?: boolean): boolean;
     isDirty(): boolean;
+    isPartial(): boolean;
     isEmpty(): boolean;
     setDirty(dirty?: boolean): void;
     get length(): number;

package/entity/ArrayCollection.js

@@ -9,6 +9,7 @@ export class ArrayCollection {
     items = new Set();
     initialized = true;
     dirty = false;
+    partial = false; // mark partially loaded collections, propagation is disabled for those
     snapshot = []; // used to create a diff of the collection at commit time, undefined marks overridden values so we need to wipe when flushing
     _count;
     _property;
@@ -40,15 +41,22 @@ export class ArrayCollection {
     }
     getIdentifiers(field) {
         const items = this.getItems();
+        const targetMeta = this.property.targetMeta;
         if (items.length === 0) {
             return [];
         }
-        field ??= this.property.targetMeta.serializedPrimaryKey;
+        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : targetMeta.serializedPrimaryKey;
+        const cb = (i, f) => {
+            if (Utils.isEntity(i[f], true)) {
+                return wrap(i[f], true).getPrimaryKey();
+            }
+            return i[f];
+        };
         return items.map(i => {
-            if (Utils.isEntity(i[field], true)) {
-                return wrap(i[field], true).getPrimaryKey();
+            if (Array.isArray(field)) {
+                return field.map(f => cb(i, f));
             }
-            return i[field];
+            return cb(i, field);
         });
     }
     add(entity, ...entities) {
@@ -100,11 +108,12 @@ export class ArrayCollection {
     /**
      * @internal
      */
-    hydrate(items, forcePropagate) {
+    hydrate(items, forcePropagate, partial) {
         for (let i = 0; i < this.items.size; i++) {
             delete this[i];
         }
         this.initialized = true;
+        this.partial = !!partial;
         this.items.clear();
         this._count = 0;
         this.add(items);
@@ -267,6 +276,9 @@ export class ArrayCollection {
     isDirty() {
         return this.dirty;
     }
+    isPartial() {
+        return this.partial;
+    }
     isEmpty() {
         return this.count() === 0;
     }
@@ -383,7 +395,7 @@ export class ArrayCollection {
     /** @ignore */
     [inspect.custom](depth = 2) {
         const object = { ...this };
-        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
+        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly', 'partial'];
         hidden.forEach(k => delete object[k]);
         const ret = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;

package/entity/Collection.d.ts

@@ -2,7 +2,7 @@ import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Popul
 import { ArrayCollection } from './ArrayCollection.js';
 import { Reference } from './Reference.js';
 import type { Transaction } from '../connections/Connection.js';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver.js';
+import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;
@@ -12,7 +12,6 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
 export declare class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
     private readonly?;
     private _populated?;
-    private _em?;
     private _snapshot?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**

package/entity/Collection.js

@@ -7,7 +7,6 @@ import { helper } from './wrap.js';
 export class Collection extends ArrayCollection {
     readonly;
     _populated;
-    _em;
     // this is for some reason needed for TS, otherwise it can fail with `Type instantiation is excessively deep and possibly infinite.`
     _snapshot;
     constructor(owner, items, initialized = true) {
@@ -220,11 +219,21 @@ export class Collection extends ArrayCollection {
         const em = this.getEntityManager();
         if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
             const order = [...this.items]; // copy order of references
-            const customOrder = !!options.orderBy;
-            // eslint-disable-next-line dot-notation
-            const items = await em['colLoader'].load([this, options]);
-            if (!customOrder) {
-                this.reorderItems(items, order);
+            const orderBy = this.createOrderBy(options.orderBy);
+            const customOrder = orderBy.length > 0;
+            const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
+            const loader = pivotTable ? 'colLoaderMtoN' : 'colLoader';
+            const items = await em[loader].load([
+                this,
+                { ...options, orderBy },
+            ]);
+            if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
+                this.initialized = true;
+                this.dirty = false;
+                if (!customOrder) {
+                    this.reorderItems(items, order);
+                }
+                return this;
             }
             this.items.clear();
             let i = 0;
@@ -254,7 +263,7 @@ export class Collection extends ArrayCollection {
     }
     getEntityManager(items = [], required = true) {
         const wrapped = helper(this.owner);
-        let em = (this._em ?? wrapped.__em);
+        let em = wrapped.__em;
         if (!em) {
             for (const i of items) {
                 if (i && helper(i).__em) {
@@ -263,9 +272,6 @@ export class Collection extends ArrayCollection {
                 }
             }
         }
-        if (em) {
-            Object.defineProperty(this, '_em', { value: em });
-        }
         if (!em && required) {
             throw ValidationError.entityNotManaged(this.owner);
         }

package/entity/EntityAssigner.d.ts

@@ -36,7 +36,7 @@ export interface AssignOptions<Convert extends boolean> {
      */
     onlyProperties?: boolean;
     /**
-     * With `onlyOwnProperties` enabled, to-many relations are skipped, and payloads of to-one relations are converted
+     * With `onlyOwnProperties` enabled, inverse sides of to-many relations are skipped, and payloads of other relations are converted
      * to foreign keys. Defaults to `false`.
      */
     onlyOwnProperties?: boolean;

package/entity/EntityAssigner.js

@@ -42,9 +42,17 @@ export class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
+            if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                if (!prop.owner) {
+                    return;
+                }
+                else if (value?.map) {
+                    value = value.map((v) => Utils.extractPK(v, prop.targetMeta));
+                }
+            }
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 value = Utils.extractPK(value, prop.targetMeta);
             }

package/entity/EntityFactory.d.ts

@@ -4,6 +4,11 @@ import type { EntityComparator } from '../utils/EntityComparator.js';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
     merge?: boolean;
     refresh?: boolean;
     convertCustomTypes?: boolean;
@@ -27,6 +32,7 @@ export declare class EntityFactory {
     createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
     getComparator(): EntityComparator;
     private createEntity;
+    private assignDefaultValues;
     private hydrate;
     private findEntity;
     private processDiscriminatorColumn;