@mikro-orm/core 6.4.16-dev.8 → 6.4.16

package/EntityManager.d.ts

@@ -27,6 +27,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     readonly name: string;
     protected readonly refLoader: DataLoader<[Reference<any>, (Omit<import("./entity").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [Reference<any>, (Omit<import("./entity").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
     protected readonly colLoader: DataLoader<[import("./entity").Collection<any, object>, (Omit<import("./entity").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./entity").Collection<any, object>, (Omit<import("./entity").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
+    protected readonly colLoaderMtoN: DataLoader<[import("./entity").Collection<any, object>, (Omit<import("./entity").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./entity").Collection<any, object>, (Omit<import("./entity").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
     private readonly validator;
     private readonly repositoryMap;
     private readonly entityLoader;

package/EntityManager.js

@@ -29,6 +29,7 @@ class EntityManager {
     name;
     refLoader = new dataloader_1.default(utils_1.DataloaderUtils.getRefBatchLoadFn(this));
     colLoader = new dataloader_1.default(utils_1.DataloaderUtils.getColBatchLoadFn(this));
+    colLoaderMtoN = new dataloader_1.default(utils_1.DataloaderUtils.getManyToManyColBatchLoadFn(this));
     validator;
     repositoryMap = {};
     entityLoader;
@@ -488,7 +489,7 @@ class EntityManager {
             flushMode: enums_1.FlushMode.COMMIT,
         });
         if (reloaded) {
-            this.config.getHydrator(this.metadata).hydrate(entity, (0, entity_1.helper)(entity).__meta, (0, entity_1.helper)(reloaded).toPOJO(), this.getEntityFactory(), 'full');
+            this.config.getHydrator(this.metadata).hydrate(entity, (0, entity_1.helper)(entity).__meta, (0, entity_1.helper)(reloaded).toPOJO(), this.getEntityFactory(), 'full', false, true);
         }
         else {
             this.getUnitOfWork().unsetIdentity(entity);

package/decorators/Entity.d.ts

@@ -13,6 +13,7 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     abstract?: boolean;
     readonly?: boolean;
     virtual?: boolean;
+    hasTriggers?: boolean;
     expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>) => object);
     repository?: () => Constructor;
 };

package/entity/Collection.js

@@ -224,8 +224,9 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             const order = [...this.items]; // copy order of references
             const orderBy = this.createOrderBy(options.orderBy);
             const customOrder = orderBy.length > 0;
-            // eslint-disable-next-line dot-notation
-            const items = await em['colLoader'].load([
+            const pivotTable = this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
+            const loader = pivotTable ? 'colLoaderMtoN' : 'colLoader';
+            const items = await em[loader].load([
                 this,
                 { ...options, orderBy },
             ]);

package/errors.d.ts

@@ -24,6 +24,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
     static cannotUseOperatorsInsideEmbeddables(className: string, propName: string, payload: unknown): ValidationError;
+    static cannotUseGroupOperatorsInsideScalars(className: string, propName: string, payload: unknown): ValidationError;
     static invalidEmbeddableQuery(className: string, propName: string, embeddableType: string): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {

package/errors.js

@@ -98,6 +98,9 @@ class ValidationError extends Error {
     static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
         return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${(0, node_util_1.inspect)(payload)})`);
     }
+    static cannotUseGroupOperatorsInsideScalars(className, propName, payload) {
+        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${(0, node_util_1.inspect)(payload)})`);
+    }
     static invalidEmbeddableQuery(className, propName, embeddableType) {
         return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
     }

package/metadata/MetadataDiscovery.js

@@ -1004,7 +1004,7 @@ class MetadataDiscovery {
             return o;
         }, {});
     }
-    getDefaultVersionValue(prop) {
+    getDefaultVersionValue(meta, prop) {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
         }
@@ -1012,7 +1012,9 @@ class MetadataDiscovery {
         if (prop.default != null) {
             return '' + this.platform.quoteVersionValue(prop.default, prop);
         }
-        if (prop.type.toLowerCase() === 'date') {
+        this.initCustomType(meta, prop, true);
+        const type = prop.customType?.runtimeType ?? prop.runtimeType ?? prop.type;
+        if (type === 'Date') {
             prop.length ??= this.platform.getDefaultVersionLength();
             return this.platform.getCurrentTimestampSQL(prop.length);
         }
@@ -1083,13 +1085,13 @@ class MetadataDiscovery {
         if (prop.version) {
             this.initDefaultValue(prop);
             meta.versionProperty = prop.name;
-            prop.defaultRaw = this.getDefaultVersionValue(prop);
+            prop.defaultRaw = this.getDefaultVersionValue(meta, prop);
         }
         if (prop.concurrencyCheck && !prop.primary) {
             meta.concurrencyCheckKeys.add(prop.name);
         }
     }
-    initCustomType(meta, prop) {
+    initCustomType(meta, prop, simple = false) {
         // `prop.type` might be actually instance of custom type class
         if (types_1.Type.isMappedType(prop.type) && !prop.customType) {
             prop.customType = prop.type;
@@ -1100,6 +1102,9 @@ class MetadataDiscovery {
             prop.customType = new prop.type();
             prop.type = prop.customType.constructor.name;
         }
+        if (simple) {
+            return;
+        }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new types_1.JsonType();
         }

package/package.json

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

package/typings.d.ts

@@ -477,6 +477,7 @@ export interface EntityMetadata<T = any> {
     polymorphs?: EntityMetadata[];
     root: EntityMetadata<T>;
     definedProperties: Dictionary;
+    hasTriggers?: boolean;
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
 }

package/utils/DataloaderUtils.d.ts

@@ -35,9 +35,14 @@ export declare class DataloaderUtils {
      */
     static getColFilter<T, S extends T>(collection: Collection<any>): (result: T) => result is S;
     /**
-     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * 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>;
+    /**
+     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponding result.
+     */
+    static getManyToManyColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
     static getDataloaderType(dataloaderCfg: DataloaderType | boolean): DataloaderType;
 }

package/utils/DataloaderUtils.js

@@ -156,29 +156,11 @@ class DataloaderUtils {
         };
     }
     /**
-     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em) {
         return async (collsWithOpts) => {
-            const prop = collsWithOpts[0][0].property;
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
-                const options = {};
-                const wrap = (cond) => ({ [prop.name]: cond });
-                const orderBy = Utils_1.Utils.asArray(collsWithOpts[0][1]?.orderBy).map(o => wrap(o));
-                const populate = wrap(collsWithOpts[0][1]?.populate);
-                const owners = collsWithOpts.map(c => c[0].owner);
-                const $or = [];
-                // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
-                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
-                const fk = `${alias}.${Utils_1.Utils.getPrimaryKeyHash(prop.joinColumns)}`;
-                for (const c of collsWithOpts) {
-                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
-                    options.refresh ??= c[1]?.refresh;
-                }
-                options.where = wrap({ $or });
-                return em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, collsWithOpts[0][1]?.ref);
-            }
             const entitiesAndOptsMap = DataloaderUtils.groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts);
             const promises = DataloaderUtils.entitiesAndOptsMapToQueries(entitiesAndOptsMap, em);
             const resultsMap = new Map(await Promise.all(promises));
@@ -196,6 +178,42 @@ class DataloaderUtils {
             });
         };
     }
+    /**
+     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponding result.
+     */
+    static getManyToManyColBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            for (const [col, opts] of collsWithOpts) {
+                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const value = groups.get(key) ?? [];
+                value.push([col, opts ?? {}]);
+                groups.set(key, value);
+            }
+            const ret = [];
+            for (const group of groups.values()) {
+                const prop = group[0][0].property;
+                const options = {};
+                const wrap = (cond) => ({ [prop.name]: cond });
+                const orderBy = Utils_1.Utils.asArray(group[0][1]?.orderBy).map(o => wrap(o));
+                const populate = wrap(group[0][1]?.populate);
+                const owners = group.map(c => c[0].owner);
+                const $or = [];
+                // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
+                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const fk = `${alias}.${Utils_1.Utils.getPrimaryKeyHash(prop.joinColumns)}`;
+                for (const c of group) {
+                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
+                    options.refresh ??= c[1]?.refresh;
+                }
+                options.where = wrap({ $or });
+                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                ret.push(...r);
+            }
+            return ret;
+        };
+    }
     static getDataloaderType(dataloaderCfg) {
         switch (dataloaderCfg) {
             case true: