@mikro-orm/core 7.0.0-dev.4 → 7.0.0-dev.41

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

@@ -4,10 +4,10 @@ import { ValidationError } from '../errors.js';
 import { ReferenceKind, DataloaderType } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
+import { QueryHelper } from '../utils/QueryHelper.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) {
@@ -33,6 +33,7 @@ export class Collection extends ArrayCollection {
     async load(options = {}) {
         if (this.isInitialized(true) && !options.refresh) {
             const em = this.getEntityManager(this.items, false);
+            options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
             await em?.populate(this.items, options.populate, options);
             this.setSerializationContext(options);
         }
@@ -218,13 +219,24 @@ export class Collection extends ArrayCollection {
             return this;
         }
         const em = this.getEntityManager();
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
         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 +266,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 +275,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,12 +4,18 @@ 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;
     recomputeSnapshot?: boolean;
     schema?: string;
     parentSchema?: string;
+    normalizeAccessors?: boolean;
 }
 export declare class EntityFactory {
     private readonly em;
@@ -27,6 +33,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;

package/entity/EntityFactory.js

@@ -4,6 +4,7 @@ import { EventType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
 import { EntityHelper } from './EntityHelper.js';
+import { JsonType } from '../types/JsonType.js';
 export class EntityFactory {
     em;
     driver;
@@ -45,6 +46,7 @@ export class EntityFactory {
         let wrapped = exists && helper(exists);
         if (wrapped && !options.refresh) {
             wrapped.__processing = true;
+            Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
             if (wrapped.isInitialized()) {
@@ -70,9 +72,11 @@ export class EntityFactory {
                             continue;
                         }
                         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                        }
+                        if (prop.customType instanceof JsonType && this.platform.convertsJsonAutomatically()) {
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                         }
-                        data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
                 }
             }
@@ -112,7 +116,7 @@ export class EntityFactory {
         if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.className, existsData, data);
+        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
         Utils.keys(diff).forEach(key => delete diff2[key]);
         Utils.keys(diff2).filter(key => {
@@ -135,6 +139,10 @@ export class EntityFactory {
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
                 diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
+                const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
+                diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
+            }
             originalEntityData[key] = diff2[key] === null ? nullVal : diff2[key];
             helper(entity).__loadedProperties.add(key);
         });
@@ -152,6 +160,7 @@ export class EntityFactory {
                 this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
+        this.unitOfWork.normalizeEntityData(meta, originalEntityData);
         helper(entity).__touched = false;
     }
     createReference(entityName, id, options = {}) {
@@ -170,8 +179,8 @@ export class EntityFactory {
         if (Array.isArray(id)) {
             id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
-        const exists = this.unitOfWork.getById(entityName, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
         }
@@ -230,17 +239,28 @@ export class EntityFactory {
         }
         return entity;
     }
+    assignDefaultValues(entity, meta) {
+        for (const prop of meta.props) {
+            if (prop.onCreate) {
+                entity[prop.name] ??= prop.onCreate(entity, this.em);
+            }
+        }
+    }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
-            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         else {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         Utils.keys(data).forEach(key => {
             helper(entity)?.__loadedProperties.add(key);
             helper(entity)?.__serializationContext.fields?.add(key);
         });
+        const processOnCreateHooksEarly = options.processOnCreateHooksEarly ?? this.config.get('processOnCreateHooksEarly');
+        if (options.newEntity && processOnCreateHooksEarly) {
+            this.assignDefaultValues(entity, meta);
+        }
     }
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
@@ -250,7 +270,7 @@ export class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -284,7 +304,7 @@ export class EntityFactory {
         return meta.constructorParams.map(k => {
             if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
                 const pk = Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
+                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }

package/entity/EntityHelper.js

@@ -87,7 +87,7 @@ export class EntityHelper {
                 });
                 return;
             }
-            if (prop.inherited || prop.primary || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
+            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
                 return;
             }
             Object.defineProperty(meta.prototype, prop.name, {
@@ -113,7 +113,18 @@ export class EntityHelper {
     static defineCustomInspect(meta) {
         // @ts-ignore
         meta.prototype[inspect.custom] ??= function (depth = 2) {
-            const object = { ...this };
+            const object = {};
+            const keys = new Set(Utils.keys(this)); // .sort((a, b) => (meta.propertyOrder.get(a) ?? 0) - (meta.propertyOrder.get(b) ?? 0));
+            for (const prop of meta.props) {
+                if (keys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    object[prop.name] = this[prop.name];
+                }
+            }
+            for (const key of keys) {
+                if (!meta.properties[key]) {
+                    object[key] = this[key];
+                }
+            }
             // ensure we dont have internal symbols in the POJO
             [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
             meta.props
@@ -146,10 +157,13 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                    old[prop.inversedBy].removeWithoutPropagation(this);
+                }
                 wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
@@ -169,6 +183,13 @@ export class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (prop.ref && owner[prop.name]) {
+                // eslint-disable-next-line dot-notation
+                owner[prop.name]['property'] = prop;
+            }
+            if (Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
@@ -207,6 +228,7 @@ export class EntityHelper {
         }
         if (old?.[prop2.name] != null) {
             delete helper(old).__data[prop2.name];
+            old[prop2.name] = null;
         }
     }
     static ensurePropagation(entity) {

package/entity/EntityLoader.d.ts

@@ -1,7 +1,7 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, ConnectionType, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
-import type { EntityField } from '../drivers/IDatabaseDriver.js';
+import type { EntityField, FilterOptions } from '../drivers/IDatabaseDriver.js';
 import type { LoggingOptions } from '../logging/Logger.js';
 export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
     where?: FilterQuery<Entity>;
@@ -14,7 +14,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     lookup?: boolean;
     convertCustomTypes?: boolean;
     ignoreLazyScalarProperties?: boolean;
-    filters?: Dictionary<boolean | Dictionary> | string[] | boolean;
+    filters?: FilterOptions;
     strategy?: LoadStrategy;
     lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
     schema?: string;
@@ -49,7 +49,8 @@ export declare class EntityLoader {
     private findChildren;
     private mergePrimaryCondition;
     private populateField;
-    private findChildrenFromPivotTable;
+    /** @internal */
+    findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
     private buildFields;
     private getChildReferences;