@mikro-orm/core 6.3.13-dev.0 → 6.3.13-dev.10

package/MikroORM.d.ts

@@ -66,7 +66,7 @@ export declare class MikroORM<D extends IDatabaseDriver = IDatabaseDriver, EM ex
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
-    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[]): void;
+    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: string | string[]): void;
     /**
      * Gets the SchemaGenerator.
      */

package/MikroORM.js

@@ -186,8 +186,12 @@ class MikroORM {
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
-    discoverEntity(entities) {
+    discoverEntity(entities, reset) {
         entities = utils_1.Utils.asArray(entities);
+        for (const className of utils_1.Utils.asArray(reset)) {
+            this.metadata.reset(className);
+            this.discovery.reset(className);
+        }
         const tmp = this.discovery.discoverReferences(entities);
         const options = this.config.get('discovery');
         new metadata_1.MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);

package/entity/ArrayCollection.js

@@ -307,7 +307,7 @@ class ArrayCollection {
      */
     get property() {
         if (!this._property) {
-            const meta = (0, wrap_1.helper)(this.owner).__meta;
+            const meta = (0, wrap_1.wrap)(this.owner, true).__meta;
             /* istanbul ignore if */
             if (!meta) {
                 throw errors_1.MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');

package/entity/EntityLoader.js

@@ -481,6 +481,9 @@ class EntityLoader {
         }
         const [f, ...r] = field.split('.');
         if (wrapped.__loadedProperties.has(f) && wrapped.__meta.properties[f]?.targetMeta) {
+            if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(wrapped.__meta.properties[f].kind)) {
+                return entity[f].getItems(false).every((item) => this.isPropertyLoaded(item, r.join('.')));
+            }
             return this.isPropertyLoaded(entity[f], r.join('.'));
         }
         /* istanbul ignore next */

package/errors.js

@@ -173,7 +173,7 @@ class MetadataError extends ValidationError {
         return new MetadataError('No entities were discovered');
     }
     static onlyAbstractEntitiesDiscovered() {
-        return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator?');
+        return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator? This can also happen when you have multiple `@mikro-orm/core` packages installed side by side.');
     }
     static duplicateEntityDiscovered(paths, subject = 'entity names') {
         return new MetadataError(`Duplicate ${subject} are not allowed: ${paths.join(', ')}`);

package/metadata/MetadataDiscovery.d.ts

@@ -24,6 +24,7 @@ export declare class MetadataDiscovery {
     private tryDiscoverTargets;
     private discoverDirectories;
     discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[]): EntityMetadata<T>[];
+    reset(className: string): void;
     private prepare;
     private getSchema;
     private discoverEntity;

package/metadata/MetadataDiscovery.js

@@ -242,6 +242,13 @@ class MetadataDiscovery {
         }
         return this.discovered.filter(meta => found.find(m => m.name === meta.className));
     }
+    reset(className) {
+        const exists = this.discovered.findIndex(m => m.className === className);
+        if (exists !== -1) {
+            this.metadata.reset(this.discovered[exists].className);
+            this.discovered.splice(exists, 1);
+        }
+    }
     prepare(entity) {
         if ('schema' in entity && entity.schema instanceof EntitySchema_1.EntitySchema) {
             return entity.schema;
@@ -1132,7 +1139,12 @@ class MetadataDiscovery {
             }
         }
         if (prop.kind === enums_1.ReferenceKind.SCALAR && !(mappedType instanceof types_1.UnknownType)) {
-            prop.columnTypes ??= [mappedType.getColumnType(prop, this.platform)];
+            if (!prop.columnTypes && prop.nativeEnumName && meta.schema !== this.platform.getDefaultSchemaName() && meta.schema && !prop.nativeEnumName.includes('.')) {
+                prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
+            }
+            else {
+                prop.columnTypes ??= [mappedType.getColumnType(prop, this.platform)];
+            }
             // use only custom types provided by user, we don't need to use the ones provided by ORM,
             // with exception for ArrayType and JsonType, those two are handled in
             if (!Object.values(types_1.t).some(type => type === mappedType.constructor)) {

package/package.json

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

package/typings.d.ts

@@ -90,8 +90,8 @@ export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp
 };
 export type ExpandScalar<T> = null | (T extends string ? T | RegExp : T extends Date ? Date | string : T extends bigint ? bigint | string | number : T);
 export type OperatorMap<T> = {
-    $and?: readonly ExpandQuery<T>[];
-    $or?: readonly ExpandQuery<T>[];
+    $and?: ExpandQuery<T>[];
+    $or?: ExpandQuery<T>[];
     $eq?: ExpandScalar<T> | readonly ExpandScalar<T>[];
     $ne?: ExpandScalar<T>;
     $in?: readonly ExpandScalar<T>[];

package/unit-of-work/ChangeSetPersister.js

@@ -180,14 +180,20 @@ class ChangeSetPersister {
             convertCustomTypes: false,
             processCollections: false,
         });
-        const cond = changeSets.map(cs => cs.getPrimaryKey(true));
-        changeSets.forEach((changeSet, idx) => {
-            this.checkConcurrencyKeys(meta, changeSet, cond[idx]);
-        });
-        const res = await this.driver.nativeUpdateMany(meta.className, cond, changeSets.map(cs => cs.payload), options);
+        const cond = [];
+        const payload = [];
+        for (const changeSet of changeSets) {
+            const where = changeSet.getPrimaryKey(true);
+            this.checkConcurrencyKeys(meta, changeSet, where);
+            cond.push(where);
+            payload.push(changeSet.payload);
+        }
+        const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
+        const map = new Map();
+        res.rows?.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
             if (res.rows) {
-                const row = res.rows.find(row => utils_1.Utils.equals(utils_1.Utils.extractPK(row, meta), changeSet.getPrimaryKey()));
+                const row = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
                 this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;

package/utils/EntityComparator.js

@@ -401,7 +401,9 @@ class EntityComparator {
             }
             return true;
         }
-        ret += meta.props.filter(p => p.embedded?.[0] === prop.name).map(childProp => {
+        ret += meta.props.filter(p => p.embedded?.[0] === prop.name
+            // object for JSON embeddable
+            && (p.object || (p.persist !== false))).map(childProp => {
             const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
             const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
             const childCond = `typeof entity${childEntityKey} !== 'undefined'`;