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

package/EntityManager.js

@@ -1,4 +1,4 @@
-import { getOnConflictReturningFields, getWhereCondition, resetUntouchedCollections } from './utils/upsert-utils.js';
+import { getOnConflictReturningFields, getOnCreateGeneratedFields, getWhereCondition, resetUntouchedCollections, } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
 import { QueryHelper } from './utils/QueryHelper.js';
@@ -793,6 +793,7 @@ export class EntityManager {
         }
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data);
+        let generatedFields = [];
         if (Utils.isEntity(data)) {
             entity = data;
             if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
@@ -800,6 +801,7 @@ export class EntityManager {
                 return entity;
             }
             where = helper(entity).getPrimaryKey();
+            generatedFields = getOnCreateGeneratedFields(meta, entity);
             em.#entityFactory.assignDefaultValues(entity, meta);
             data = em.#comparator.prepareEntity(entity);
         }
@@ -812,6 +814,7 @@ export class EntityManager {
                     return em.assign(exists, data);
                 }
             }
+            generatedFields = getOnCreateGeneratedFields(meta, data);
             em.#entityFactory.assignDefaultValues(data, meta, true);
             for (const key of Object.keys(data)) {
                 const prop = meta.properties[key];
@@ -820,6 +823,10 @@ export class EntityManager {
                 }
             }
         }
+        // `onCreate` generated values are for the insert clause only, they must not overwrite an existing row
+        if (generatedFields.length > 0 && !options.onConflictMergeFields) {
+            options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
+        }
         where = getWhereCondition(meta, options.onConflictFields, data, where).where;
         data = QueryHelper.processObjectParams(data);
         validateParams(data, 'insert data');
@@ -939,6 +946,7 @@ export class EntityManager {
         }
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data[0]);
+        const generatedFields = new Set();
         const allData = [];
         const allWhere = [];
         const entities = new Map();
@@ -956,6 +964,7 @@ export class EntityManager {
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
+                getOnCreateGeneratedFields(meta, entity).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(entity, meta);
                 entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
@@ -972,6 +981,7 @@ export class EntityManager {
                         continue;
                     }
                 }
+                getOnCreateGeneratedFields(meta, row).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(row, meta, true);
                 for (const key of Object.keys(row)) {
                     const prop = meta.properties[key];
@@ -1000,6 +1010,10 @@ export class EntityManager {
         if (entities.size === data.length) {
             return [...entities.keys()];
         }
+        // `onCreate` generated values are for the insert clause only, they must not overwrite existing rows
+        if (generatedFields.size > 0 && !options.onConflictMergeFields) {
+            options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
+        }
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
             for (const dto of data) {
                 const entity = entitiesByData.get(dto) ?? dto;

package/entity/EntityLoader.js

@@ -445,7 +445,10 @@ export class EntityLoader {
                 }
             }
         }
-        if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && items.length !== children.length) {
+        // a missing target row means an orphaned reference, unless the query was narrowed by a populate condition
+        if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) &&
+            items.length !== children.length &&
+            Utils.isEmpty(options.where)) {
             const nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
             const itemsMap = new Set();
             const childrenMap = new Set();
@@ -667,7 +670,8 @@ export class EntityLoader {
                     }
                     return cond;
                 });
-                if (child.length > 0) {
+                // partial extraction from `$or` is unsound — the parent may have matched via a dropped branch
+                if (child.length > 0 && (op === '$and' || child.length === where[op].length)) {
                     subCond[op] = child;
                 }
             }

package/metadata/MetadataDiscovery.js

@@ -451,10 +451,13 @@ export class MetadataDiscovery {
     initManyToOneFieldName(prop, name) {
         const meta2 = prop.targetMeta;
         const ret = [];
-        for (const primaryKey of meta2.primaryKeys) {
-            this.initFieldName(meta2.properties[primaryKey]);
-            for (const fieldName of meta2.properties[primaryKey].fieldNames) {
-                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK));
+        // with `targetKey` on a composite PK target, derive the FK field name from that property
+        // instead of the PKs (simple PK targets keep the PK based naming for backwards compatibility)
+        const referencedKeys = prop.targetKey && meta2.compositePK ? [prop.targetKey] : meta2.primaryKeys;
+        for (const referencedKey of referencedKeys) {
+            this.initFieldName(meta2.properties[referencedKey]);
+            for (const fieldName of meta2.properties[referencedKey].fieldNames) {
+                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, !prop.targetKey && meta2.compositePK));
             }
         }
         return ret;
@@ -1050,11 +1053,12 @@ export class MetadataDiscovery {
         }
         // TPT children have their own tables that don't contain the parent's columns,
         // so propagating parent indexes/uniques/checks/triggers would target missing columns.
+        // deep equality, as the subclass items might be copies of the base class ones (e.g. with TC39 decorators)
         if (meta.inheritanceType !== 'tpt' || !meta.tptParent) {
-            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
-            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
-            meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers]);
+            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes], Utils.equals);
+            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques], Utils.equals);
+            meta.checks = Utils.unique([...base.checks, ...meta.checks], Utils.equals);
+            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers], Utils.equals);
         }
         const pks = Object.values(meta.properties)
             .filter(p => p.primary)
@@ -2075,6 +2079,7 @@ export class MetadataDiscovery {
             prop.columnTypes.push(...columnTypes);
             if (!targetMeta.compositePK || prop.targetKey) {
                 prop.customType = referencedProp.customType;
+                prop.collation ??= referencedProp.collation;
             }
         }
     }

package/package.json

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

package/utils/Utils.d.ts

@@ -58,7 +58,7 @@ export declare class Utils {
     /**
      * Gets array without duplicates.
      */
-    static unique<T = string>(items: T[]): T[];
+    static unique<T = string>(items: T[], equals?: (a: T, b: T) => boolean): T[];
     /**
      * Merges all sources into the target recursively.
      */

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.13-dev.0';
+    static #ORM_VERSION = '7.1.13-dev.10';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -216,10 +216,13 @@ export class Utils {
     /**
      * Gets array without duplicates.
      */
-    static unique(items) {
+    static unique(items, equals) {
         if (items.length < 2) {
             return items;
         }
+        if (equals) {
+            return items.filter((a, idx) => items.findIndex(b => equals(a, b)) === idx);
+        }
         return [...new Set(items)];
     }
     /**

package/utils/upsert-utils.d.ts

@@ -1,8 +1,16 @@
-import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
+import type { EntityData, EntityKey, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import { type Raw } from '../utils/RawQueryFragment.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T>): (keyof T)[];
+/**
+ * Detects properties that will get their value generated by an `onCreate` hook during the upsert,
+ * i.e. those with an `onCreate` hook and no value provided. Such values are meant for the insert
+ * clause only and must not overwrite an existing row via the `on conflict do update set` clause.
+ * The property filter mirrors `EntityFactory.assignDefaultValues`.
+ * @internal
+ */
+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)[] | '*';
 /** @internal */

package/utils/upsert-utils.js

@@ -72,6 +72,22 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
     }
     return keys;
 }
+/**
+ * Detects properties that will get their value generated by an `onCreate` hook during the upsert,
+ * i.e. those with an `onCreate` hook and no value provided. Such values are meant for the insert
+ * clause only and must not overwrite an existing row via the `on conflict do update set` clause.
+ * The property filter mirrors `EntityFactory.assignDefaultValues`.
+ * @internal
+ */
+export function getOnCreateGeneratedFields(meta, data) {
+    return meta.props
+        .filter(prop => prop.onCreate &&
+        !prop.embedded &&
+        ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+        !(prop.getter && !prop.setter) &&
+        data[prop.name] == null)
+        .map(prop => prop.name);
+}
 /** @internal */
 export function getOnConflictReturningFields(meta, data, uniqueFields, options) {
     /* v8 ignore next */