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

package/EntityManager.js

@@ -889,7 +889,7 @@ export class EntityManager {
             const name = Utils.className(entityName);
             /* v8 ignore next */
             where = Utils.isEntity(where) ? helper(where).getPrimaryKey() : where;
-            throw failHandler(name, where);
+            throw failHandler(name, QueryHelper.processParams(where));
         }
         return entity;
     }
@@ -994,10 +994,14 @@ export class EntityManager {
         });
         const uniqueFields = options.onConflictFields ??
             (Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
-        const returning = getOnConflictReturningFields(meta, data, uniqueFields, options);
+        const platform = this.getPlatform();
+        const returning = getOnConflictReturningFields(meta, data, uniqueFields, options, platform);
+        if (options.onConflictWhere && !ret.row) {
+            returning.push(...Object.keys(data));
+        }
         if (options.onConflictAction === 'ignore' ||
             !helper(entity).hasPrimaryKey() ||
-            (returning.length > 0 && !(this.getPlatform().usesReturningStatement() && ret.row))) {
+            (returning.length > 0 && !((platform.usesReturningStatement() || platform.usesOutputStatement()) && ret.row))) {
             const where = {};
             if (Array.isArray(uniqueFields)) {
                 for (const prop of uniqueFields) {
@@ -1088,6 +1092,32 @@ export class EntityManager {
             }
             return ret;
         }
+        // merge fields are derived from the first row, rows of a different shape need their own statement
+        if (!options.onConflictMergeFields && options.onConflictAction !== 'ignore') {
+            const pks = this.metadata.get(entityName).primaryKeys;
+            const shapes = new Map();
+            data.forEach((row, i) => {
+                // entity instances carry their unset properties as `undefined` keys, while in plain rows those are merged as `null`
+                const shape = Object.keys(row)
+                    .filter(key => !pks.includes(key) && !(Utils.isEntity(row) && row[key] === undefined))
+                    .sort()
+                    .join();
+                const idx = shapes.get(shape) ?? [];
+                shapes.set(shape, idx);
+                idx.push(i);
+            });
+            if (shapes.size > 1) {
+                const ret = [];
+                for (const idx of shapes.values()) {
+                    const res = await this.upsertMany(entityName, idx.map(i => data[i]), options);
+                    idx.forEach((i, j) => (ret[i] = res[j]));
+                }
+                // rows resolving to the same entity are returned once, as in the single statement path
+                return [...new Set(ret.filter(entity => entity))];
+            }
+        }
+        // the rows are replaced with their processed copies below, keep the caller's array intact
+        data = [...data];
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data[0]);
         const generatedFields = new Set();
@@ -1147,6 +1177,10 @@ export class EntityManager {
                 platform: this.getPlatform(),
             });
             row = QueryHelper.processObjectParams(row);
+            // hooks and the result merging need `data[i]` to be the same object as the processed row
+            if (!Utils.isEntity(data[i])) {
+                data[i] = row;
+            }
             validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
@@ -1177,9 +1211,9 @@ export class EntityManager {
         entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.#unitOfWork
-                .getChangeSetPersister()
-                .mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], res.rows?.[i], meta, true);
+            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], 
+            // A suppressed conflict omits its row; positional mapping would hydrate a different entity.
+            res.rows?.length === allData.length ? res.rows[i] : undefined, meta, true);
             const entity = Utils.isEntity(data[i])
                 ? data[i]
                 : em.#entityFactory.create(entityName, row, {
@@ -1197,8 +1231,13 @@ export class EntityManager {
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
         const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
-        const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
-        const reloadFields = returning.length > 0 && !(this.getPlatform().usesReturningStatement() && res.rows?.length === data.length);
+        const platform = this.getPlatform();
+        const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options, platform);
+        if (options.onConflictWhere && res.rows?.length !== allData.length) {
+            returning.push(...meta.comparableProps.filter(p => !p.lazy && !p.embeddable).map(p => p.name));
+        }
+        const reloadFields = returning.length > 0 &&
+            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === data.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
             const add = new Set(propIndex !== false && propIndex >= 0
@@ -1229,8 +1268,9 @@ export class EntityManager {
                 const row = data2.find(row => {
                     const tmp = {};
                     add.forEach(k => {
-                        if (!meta.properties[k]?.primary) {
-                            tmp[k] = row[k];
+                        const prop = meta.properties[k];
+                        if (!prop?.primary) {
+                            tmp[k] = prop?.customType ? prop.customType.convertToDatabaseValue(row[k], this.getPlatform()) : row[k];
                         }
                     });
                     return this.#comparator.matching(entityName, cond, tmp);

package/entity/defineEntity.d.ts

@@ -267,7 +267,7 @@ export declare class UniversalPropertyOptionsBuilder<in out Value, in out Option
         autoincrement: false;
     }, IncludeKeys>, IncludeKeys>;
     /**
-     * Add the property to the `returning` statement.
+     * Add the property to the `returning` clause of inserts, updates and upserts, reloading the database value into the entity.
      */
     returning(returning?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**

package/entity/defineEntity.js

@@ -88,7 +88,7 @@ export class UniversalPropertyOptionsBuilder {
         return this.assignOptions({ autoincrement });
     }
     /**
-     * Add the property to the `returning` statement.
+     * Add the property to the `returning` clause of inserts, updates and upserts, reloading the database value into the entity.
      */
     returning(returning = true) {
         return this.assignOptions({ returning });

package/metadata/MetadataDiscovery.d.ts

@@ -128,6 +128,8 @@ export declare class MetadataDiscovery {
     private initRelation;
     /** Resolves the `through` option of a virtual to-one relation into a read-only formula property. */
     private initThroughRelation;
+    /** `returning` is only honoured for physical columns that can be hydrated back into the entity. */
+    private initReturning;
     private initColumnType;
     private getMappedType;
     private getPrefix;

package/metadata/MetadataDiscovery.js

@@ -174,6 +174,7 @@ export class MetadataDiscovery {
             this.initRelation(p);
             this.initThroughRelation(m, p);
             this.initColumnType(p);
+            this.initReturning(p);
         });
         forEachProp((m, p) => this.initIndexes(m, p));
         filtered.forEach(meta => this.autoWireBidirectionalProperties(meta));
@@ -2129,6 +2130,16 @@ export class MetadataDiscovery {
         prop.persist = false;
         prop.formula = columns => this.#platform.getThroughRelationFormula(prop, columns);
     }
+    /** `returning` is only honoured for physical columns that can be hydrated back into the entity. */
+    initReturning(prop) {
+        const owning = prop.kind === ReferenceKind.SCALAR ||
+            prop.kind === ReferenceKind.MANY_TO_ONE ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) ||
+            (prop.kind === ReferenceKind.EMBEDDED && prop.object);
+        if (prop.returning && (!owning || prop.persist === false || prop.hydrate === false || prop.formula)) {
+            prop.returning = false;
+        }
+    }
     initColumnType(prop) {
         this.initUnsigned(prop);
         // Get the target properties for FK relations - use targetKey property if specified, otherwise PKs

package/metadata/types.d.ts

@@ -175,7 +175,7 @@ export interface PropertyOptions<Owner> {
      */
     autoincrement?: boolean;
     /**
-     * Add the property to the `returning` statement.
+     * Add the property to the `returning` clause of inserts, updates and upserts, reloading the database value into the entity.
      */
     returning?: boolean;
     /**

package/package.json

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

package/utils/QueryHelper.d.ts

@@ -35,6 +35,8 @@ export declare class QueryHelper {
      */
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
+    /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
+    private static cloneWhere;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
     /** @internal Sentinel wrapping for arguments accessed while statically resolving an `rls` filter condition. */

package/utils/QueryHelper.js

@@ -56,15 +56,16 @@ export class QueryHelper {
             return params.map(item => QueryHelper.processParams(item));
         }
         if (Utils.isPlainObject(params)) {
-            QueryHelper.processObjectParams(params);
+            return QueryHelper.processObjectParams(params);
         }
         return params;
     }
     static processObjectParams(params = {}) {
+        const ret = (Array.isArray(params) ? [...params] : { ...params });
         Utils.getObjectQueryKeys(params).forEach(k => {
-            params[k] = QueryHelper.processParams(params[k]);
+            ret[k] = QueryHelper.processParams(params[k]);
         });
-        return params;
+        return ret;
     }
     /**
      * converts `{ account: { $or: [ [Object], [Object] ] } }`
@@ -167,10 +168,26 @@ export class QueryHelper {
         });
         return false;
     }
+    /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
+    static cloneWhere(where) {
+        if (Array.isArray(where)) {
+            return where.map(item => QueryHelper.cloneWhere(item));
+        }
+        if (!Utils.isPlainObject(where)) {
+            return where;
+        }
+        const ret = {};
+        Utils.getObjectQueryKeys(where).forEach(k => (ret[k] = QueryHelper.cloneWhere(where[k])));
+        return ret;
+    }
     static processWhere(options) {
         // eslint-disable-next-line prefer-const
         let { where, entityName, metadata, platform, aliased = true, convertCustomTypes = true, root = true } = options;
         const meta = metadata.find(entityName);
+        // the condition is normalized in place, so work on a copy to keep the one the caller passed in intact
+        if (root) {
+            where = QueryHelper.cloneWhere(where);
+        }
         // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
         if (meta && root) {
             QueryHelper.liftGroupOperators(where, meta, metadata);

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.2.2-dev.0';
+    static #ORM_VERSION = '7.2.2-dev.10';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;

package/utils/upsert-utils.d.ts

@@ -1,6 +1,7 @@
 import type { EntityData, EntityKey, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import { type Raw } from '../utils/RawQueryFragment.js';
+import type { Platform } from '../platforms/Platform.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T>): (keyof T)[];
 /**
@@ -12,7 +13,7 @@ export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefin
  */
 export declare function getOnCreateGeneratedFields<T extends object>(meta: EntityMetadata<T>, data: T | EntityData<T>): EntityKey<T>[];
 /** @internal */
-export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T, P>, platform?: Platform): (keyof T)[] | '*';
 /** @internal */
 export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | Raw | undefined, data: EntityData<T>, where: FilterQuery<T>): {
     where: FilterQuery<T>;

package/utils/upsert-utils.js

@@ -89,11 +89,15 @@ export function getOnCreateGeneratedFields(meta, data) {
         .map(prop => prop.name);
 }
 /** @internal */
-export function getOnConflictReturningFields(meta, data, uniqueFields, options) {
+export function getOnConflictReturningFields(meta, data, uniqueFields, options, platform) {
     /* v8 ignore next */
     if (!meta) {
         return '*';
     }
+    // props with explicit `returning` hint are reloaded even when supplied, as the database might normalize them
+    const returning = platform?.usesReturningStatement() || platform?.usesOutputStatement()
+        ? meta.props.filter(p => p.returning).map(p => p.name)
+        : [];
     const keys = meta.comparableProps
         .filter(p => {
         if (p.lazy || p.embeddable) {
@@ -112,17 +116,17 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
         keys.push(meta.versionProperty);
     }
     if (options.onConflictAction === 'ignore') {
-        return keys;
+        return Utils.unique([...keys, ...returning]);
     }
     if (options.onConflictMergeFields) {
         const onConflictMergeFields = expandFields(meta, options.onConflictMergeFields);
-        return keys.filter(key => !onConflictMergeFields.includes(key));
+        return Utils.unique([...keys.filter(key => !onConflictMergeFields.includes(key)), ...returning]);
     }
     if (options.onConflictExcludeFields) {
         const onConflictExcludeFields = expandFields(meta, options.onConflictExcludeFields);
-        return [...new Set(keys.concat(...onConflictExcludeFields))];
+        return Utils.unique([...keys, ...onConflictExcludeFields, ...returning]);
     }
-    return keys.filter(key => !(key in data));
+    return Utils.unique([...keys.filter(key => !(key in data)), ...returning]);
 }
 function getPropertyValue(obj, key) {
     if (!key.includes('.')) {