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

package/EntityManager.js

@@ -1538,11 +1538,12 @@ class EntityManager {
             // we need to prune the `populate` hint from to-one relations, as partially loading them does not require their population, we want just the FK
             const pruneToOneRelations = (meta, fields) => {
                 const ret = [];
-                for (const field of fields) {
+                for (let field of fields) {
                     if (field === enums_1.PopulatePath.ALL || field.startsWith(`${enums_1.PopulatePath.ALL}.`)) {
                         ret.push(...meta.props.filter(prop => prop.lazy || [enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED].includes(prop.kind)).map(prop => prop.name));
                         continue;
                     }
+                    field = field.split(':')[0];
                     if (!field.includes('.') && ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[field].kind)) {
                         ret.push(field);
                         continue;

package/MikroORM.d.ts

@@ -1,5 +1,5 @@
 import type { EntityManagerType, IDatabaseDriver } from './drivers';
-import { MetadataStorage } from './metadata';
+import { MetadataStorage, type EntitySchema } from './metadata';
 import { Configuration, type Options } from './utils';
 import type { EntityManager } from './EntityManager';
 import type { Constructor, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings';
@@ -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(entities: Constructor | Constructor[]): void;
+    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[]): void;
     /**
      * Gets the SchemaGenerator.
      */

package/MikroORM.js

@@ -192,7 +192,10 @@ class MikroORM {
         const options = this.config.get('discovery');
         new metadata_1.MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);
         const metadata = this.discovery.processDiscoveredEntities(tmp);
-        metadata.forEach(meta => this.metadata.set(meta.className, meta));
+        metadata.forEach(meta => {
+            this.metadata.set(meta.className, meta);
+            meta.root = this.metadata.get(meta.root.className);
+        });
         this.metadata.decorate(this.em);
     }
     /**

package/decorators/CreateRequestContext.js

@@ -11,15 +11,9 @@ function CreateRequestContext(getContext, respectExistingContext = false) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
-            // reuse existing context if available
-            if (respectExistingContext && RequestContext_1.RequestContext.currentRequestContext()) {
-                return originalMethod.apply(this, args);
-            }
-            // If we are inside explicit transaction context, we need to create another tx context.
             // Otherwise, the outer tx context would be preferred.
             const txContext = TransactionContext_1.TransactionContext.currentTransactionContext();
             const provider = txContext ? TransactionContext_1.TransactionContext : RequestContext_1.RequestContext;
-            /* istanbul ignore next */
             let orm;
             let em;
             if (typeof getContext === 'function') {
@@ -35,6 +29,10 @@ function CreateRequestContext(getContext, respectExistingContext = false) {
                 em = await this.em;
             }
             const create = async (em) => {
+                // reuse existing context if available for given respect `contextName`
+                if (respectExistingContext && RequestContext_1.RequestContext.getEntityManager(em.name)) {
+                    return originalMethod.apply(this, args);
+                }
                 if (txContext) {
                     em = em.fork({ useContext: true });
                 }

package/entity/EntityLoader.d.ts

@@ -42,6 +42,7 @@ export declare class EntityLoader {
      * preload everything in one call (this will update already existing references in IM)
      */
     private populateMany;
+    private populateScalar;
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;

package/entity/EntityLoader.js

@@ -118,20 +118,18 @@ class EntityLoader {
         const [field, ref] = populate.field.split(':', 2);
         const meta = this.metadata.find(entityName);
         const prop = meta.properties[field];
+        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
+            const filtered = entities.filter(e => !e[prop.name]?.isInitialized());
+            if (filtered.length > 0) {
+                await this.populateScalar(meta, filtered, options, prop);
+            }
+        }
         if (prop.kind === enums_1.ReferenceKind.SCALAR && prop.lazy) {
             const filtered = entities.filter(e => options.refresh || (prop.ref ? !e[prop.name]?.isInitialized() : e[prop.name] === undefined));
             if (options.ignoreLazyScalarProperties || filtered.length === 0) {
                 return entities;
             }
-            const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
-            const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
-            const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
-            const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
-            await this.em.find(meta.className, where, {
-                filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
-                fields: [prop.name],
-                populate: [],
-            });
+            await this.populateScalar(meta, filtered, options, prop);
             return entities;
         }
         if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
@@ -149,6 +147,17 @@ class EntityLoader {
         this.initializeCollections(filtered, prop, field, data, innerOrderBy.length > 0);
         return data;
     }
+    async populateScalar(meta, filtered, options, prop) {
+        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
+        const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
+        const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
+        await this.em.find(meta.className, where, {
+            filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
+            fields: [prop.name],
+            populate: [],
+        });
+    }
     initializeCollections(filtered, prop, field, children, customOrder) {
         if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
             this.initializeOneToMany(filtered, children, prop, field);

package/hydration/ObjectHydrator.js

@@ -165,9 +165,14 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
             ret.push(`    }`);
             ret.push(`  } else if (!entity${entityKey} && data${dataKey} instanceof Collection) {`);
             ret.push(`    entity${entityKey} = data${dataKey};`);
+            if (!this.platform.usesPivotTable() && prop.owner && prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+                ret.push(`  } else if (!entity${entityKey} && Array.isArray(data${dataKey})) {`);
+                const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
+                ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+                ret.push(`    coll.setDirty(false);`);
+            }
             ret.push(`  } else if (!entity${entityKey}) {`);
-            const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
-            ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+            ret.push(`    const coll = Collection.create(entity, '${prop.name}', undefined, newEntity);`);
             ret.push(`    coll.setDirty(false);`);
             ret.push(`  }`);
             return ret;

package/metadata/MetadataDiscovery.js

@@ -121,7 +121,11 @@ class MetadataDiscovery {
         if (combinedCachePath) {
             this.config.get('metadataCache').combined = combinedCachePath;
         }
-        return discovered.map(meta => this.metadata.get(meta.className));
+        return discovered.map(meta => {
+            meta = this.metadata.get(meta.className);
+            meta.sync(true);
+            return meta;
+        });
     }
     findEntities(preferTsNode, sync = false) {
         this.discovered.length = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.10-dev.8",
+  "version": "6.3.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.10-dev.8",
+    "mikro-orm": "6.3.10",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -683,7 +683,7 @@ export type AutoPath<O, P extends string | boolean, E extends string = never, D
 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>;
-type LoadedLoadable<T, E extends object> = T extends Collection<any, any> ? LoadedCollection<E> : T extends Reference<any> ? LoadedReference<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends Scalar | any[] ? T : E;
+type LoadedLoadable<T, E extends object> = T extends Collection<any, any> ? LoadedCollection<E> : T extends Reference<any> ? T & LoadedReference<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends Scalar | any[] ? T : E;
 type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? T extends true ? true : false : false;
 type StringLiteral<T> = T extends string ? string extends T ? never : T : never;
 type Prefix<T, K> = K extends `${infer S}.${string}` ? S : (K extends '*' ? keyof T : K);

package/unit-of-work/ChangeSetComputer.js

@@ -141,14 +141,12 @@ class ChangeSetComputer {
     }
     processToMany(prop, changeSet) {
         const target = changeSet.entity[prop.name];
-        if (!target.isDirty()) {
+        if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
             return;
         }
         this.collectionUpdates.add(target);
-        if (prop.owner || target.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
-            if (!this.platform.usesPivotTable()) {
-                changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
-            }
+        if (prop.owner && !this.platform.usesPivotTable()) {
+            changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }
     }
 }

package/unit-of-work/ChangeSetPersister.js

@@ -185,12 +185,13 @@ class ChangeSetPersister {
             this.checkConcurrencyKeys(meta, changeSet, cond[idx]);
         });
         const res = await this.driver.nativeUpdateMany(meta.className, cond, changeSets.map(cs => cs.payload), options);
-        changeSets.forEach((changeSet, idx) => {
+        for (const changeSet of changeSets) {
             if (res.rows) {
-                this.mapReturnedValues(changeSet.entity, changeSet.payload, res.rows[idx], meta);
+                const row = res.rows.find(row => utils_1.Utils.equals(utils_1.Utils.extractPK(row, meta), changeSet.getPrimaryKey()));
+                this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;
-        });
+        }
     }
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];

package/utils/Utils.d.ts

@@ -1,5 +1,4 @@
 import { type GlobbyOptions } from 'globby';
-import { type URL } from 'node:url';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings';
 import type { Collection } from '../entity/Collection';
 import type { Platform } from '../platforms';

package/utils/Utils.js

@@ -881,6 +881,10 @@ class Utils {
             catch {
                 // ignore
             }
+            // For some reason, ".ts" files do not work with "file://" URLs on Windows.
+            if (id.endsWith('.ts')) {
+                id = (0, node_url_1.fileURLToPath)(id);
+            }
         }
         /* istanbul ignore next */
         return this.dynamicImportProvider(id);