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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.8-dev.8",
+  "version": "7.1.8",
   "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.",
   "keywords": [
     "data-mapper",

package/utils/AbstractMigrator.d.ts

@@ -95,6 +95,8 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
      */
     unlogMigration(name: string): Promise<void>;
     protected init(): Promise<void>;
+    /** Resolves the migrations path (including source folder auto-detection) without touching the filesystem. */
+    protected resolvePaths(): Promise<void>;
     protected initPaths(): Promise<void>;
     protected initServices(): void;
     protected resolve(params: {

package/utils/AbstractMigrator.js

@@ -9,6 +9,7 @@ export class AbstractMigrator {
     options;
     absolutePath;
     initialized = false;
+    #pathsEnsured = false;
     #listeners = new Map();
     constructor(em) {
         this.em = em;
@@ -303,7 +304,8 @@ export class AbstractMigrator {
         this.initialized = true;
         await this.initPaths();
     }
-    async initPaths() {
+    /** Resolves the migrations path (including source folder auto-detection) without touching the filesystem. */
+    async resolvePaths() {
         if (this.absolutePath || this.options.migrationsList) {
             return;
         }
@@ -312,6 +314,14 @@ export class AbstractMigrator {
         /* v8 ignore next */
         const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
         this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
+    }
+    async initPaths() {
+        await this.resolvePaths();
+        if (this.#pathsEnsured || this.options.migrationsList) {
+            return;
+        }
+        this.#pathsEnsured = true;
+        const { fs } = await import('@mikro-orm/core/fs-utils');
         try {
             fs.ensureDir(this.absolutePath);
         }

package/utils/QueryHelper.d.ts

@@ -40,6 +40,11 @@ export declare class QueryHelper {
     static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
     static isFilterActive<T>(meta: EntityMetadata<T>, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
+    /**
+     * Composite PK conditions are keyed by a hash of all the PK names, which `findProperty` cannot
+     * resolve, so the custom types have to be applied positionally instead.
+     */
+    private static processCompositeCustomTypes;
     private static isSupportedOperator;
     private static processJsonCondition;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;

package/utils/QueryHelper.js

@@ -227,6 +227,13 @@ export class QueryHelper {
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
+            else if (!prop &&
+                meta?.compositePK &&
+                convertCustomTypes &&
+                Array.isArray(value) &&
+                key === Utils.getPrimaryKeyHash(meta.primaryKeys)) {
+                value = QueryHelper.processCompositeCustomTypes(value, meta, platform);
+            }
             // oxfmt-ignore
             const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? !['$eq', '$elemMatch'].includes(Object.keys(value)[0]) : !Array.isArray(value));
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
@@ -321,6 +328,24 @@ export class QueryHelper {
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
     }
+    /**
+     * Composite PK conditions are keyed by a hash of all the PK names, which `findProperty` cannot
+     * resolve, so the custom types have to be applied positionally instead.
+     */
+    static processCompositeCustomTypes(value, meta, platform) {
+        const props = meta.primaryKeys.map(pk => meta.properties[pk]);
+        if (!props.some(prop => prop.customType)) {
+            return value;
+        }
+        // the tuple can be longer than the PK when the user passes a malformed condition
+        const convert = (tuple) => tuple.map((val, idx) => {
+            if (!props[idx]?.customType) {
+                return val;
+            }
+            return QueryHelper.processCustomType(props[idx], val, platform, undefined, true);
+        });
+        return value.every(val => Array.isArray(val)) ? value.map(val => convert(val)) : convert(value);
+    }
     static isSupportedOperator(key) {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }

package/utils/TransactionManager.d.ts

@@ -50,6 +50,12 @@ export declare class TransactionManager {
      * Merges entities from fork to parent EntityManager.
      */
     private mergeEntitiesToParent;
+    /**
+     * Returns the property names a given property is tracked and snapshotted under, paired with their values.
+     * Inlined embeddables are hydrated as a single object, so only their leaves tell whether it is complete.
+     */
+    private getTrackedValues;
+    private restore;
     /**
      * Registers a deletion handler to unset entity identities after flush.
      */

package/utils/TransactionManager.js

@@ -169,19 +169,52 @@ export class TransactionManager {
                 if (!wrapped.__initialized && parentWrapped.__initialized) {
                     continue;
                 }
-                parentWrapped.__data = wrapped.__data;
-                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                const parentData = parentWrapped.__data;
+                const parentSnapshot = parentWrapped.__originalEntityData;
+                parentWrapped.__data = { ...wrapped.__data };
+                const originalEntityData = { ...wrapped.__originalEntityData };
                 for (const prop of meta.hydrateProps) {
+                    const tracked = this.getTrackedValues(prop, entity[prop.name]);
+                    // the fork entity can be partially loaded, and propagating a property it does not know about
+                    // would clobber the parent state, so we restore both its value and its snapshot entries
+                    if (!tracked.every(([key, value]) => value !== undefined || wrapped.__loadedProperties.has(key))) {
+                        this.restore(parentWrapped.__data, parentData, prop.name);
+                        tracked.forEach(([key]) => this.restore(originalEntityData, parentSnapshot, key));
+                        continue;
+                    }
                     if (prop.kind === ReferenceKind.SCALAR) {
                         parentEntity[prop.name] = entity[prop.name];
                     }
                 }
+                if (wrapped.__originalEntityData) {
+                    parentWrapped.__originalEntityData = originalEntityData;
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));
             }
         }
     }
+    /**
+     * Returns the property names a given property is tracked and snapshotted under, paired with their values.
+     * Inlined embeddables are hydrated as a single object, so only their leaves tell whether it is complete.
+     */
+    getTrackedValues(prop, value) {
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+            return Object.values(prop.embeddedProps).flatMap(child => {
+                return this.getTrackedValues(child, value?.[child.embedded[1]]);
+            });
+        }
+        return [[prop.name, value]];
+    }
+    restore(target, source, key) {
+        if (source && key in source) {
+            target[key] = source[key];
+        }
+        else {
+            delete target[key];
+        }
+    }
     /**
      * Registers a deletion handler to unset entity identities after flush.
      */

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.8-dev.8';
+    static #ORM_VERSION = '7.1.8';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */