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

package/entity/Collection.d.ts

@@ -1,4 +1,4 @@
-import type { EntityDTO, EntityKey, EntityProperty, FilterQuery, IPrimaryKey, Loaded, LoadedCollection, Populate, Primary } from '../typings.js';
+import { type EntityDTO, type EntityKey, type EntityProperty, type FilterQuery, type IPrimaryKey, type Loaded, type LoadedCollection, type Populate, type Primary, CollectionBrand } from '../typings.js';
 import { Reference } from './Reference.js';
 import type { Transaction } from '../connections/Connection.js';
 import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
@@ -17,6 +17,7 @@ export declare class Collection<T extends object, O extends object = object> {
     #private;
     readonly owner: O;
     [k: number]: T;
+    readonly [CollectionBrand]: true;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)

package/entity/EntityFactory.js

@@ -167,9 +167,11 @@ export class EntityFactory {
             return diff2[key] === undefined;
         })
             .forEach(key => delete diff2[key]);
-        // but always add collection properties and formulas if they are part of the `data`
+        // but always add collection properties, formulas, and generated columns if they are part of the `data`,
+        // as these are excluded from `comparableProps` and won't appear in the diff
         Utils.keys(data)
             .filter(key => meta.properties[key]?.formula ||
+            (meta.properties[key]?.generated && !meta.properties[key]?.primary) ||
             [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => (diff2[key] = data[key]));
         // rehydrated with the new values, skip those changed by user

package/metadata/MetadataDiscovery.js

@@ -1267,6 +1267,18 @@ export class MetadataDiscovery {
             if (prop.enum && prop.items && rootProp?.items) {
                 newProp.items = Utils.unique([...rootProp.items, ...prop.items]);
             }
+            // When multiple STI children share the same unique relation (OneToOne/ManyToOne),
+            // replace the simple unique with a composite one including the discriminator column
+            // so different subtypes can independently reference the same target row.
+            if (rootProp?.unique &&
+                newProp.unique &&
+                [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(newProp.kind)) {
+                newProp.unique = false;
+                rootProp.unique = false;
+                meta.root.uniques.push({
+                    properties: [prop.name, meta.root.discriminatorColumn],
+                });
+            }
             newProp.nullable = true;
             newProp.inherited = !rootProp;
             meta.root.addProperty(newProp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.9-dev.0",
+  "version": "7.0.9-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/typings.d.ts

@@ -74,7 +74,7 @@ export type MaybePromise<T> = T | Promise<T>;
  */
 type CollectionShape<T = any> = {
     [k: number]: T;
-    readonly owner: object;
+    readonly [CollectionBrand]: true;
 };
 /**
  * Structural type for matching LoadedCollection (extends CollectionShape with `$` property).
@@ -134,6 +134,8 @@ export type DeepPartial<T> = T & {
 export declare const EntityRepositoryType: unique symbol;
 /** Symbol used to declare the primary key property name(s) on an entity (e.g., `[PrimaryKeyProp]?: 'id'`). */
 export declare const PrimaryKeyProp: unique symbol;
+/** Symbol used as a brand on `CollectionShape` to prevent false structural matches with entities that have properties like `owner`. */
+export declare const CollectionBrand: unique symbol;
 /** Symbol used to declare which properties are optional in `em.create()` (e.g., `[OptionalProps]?: 'createdAt'`). */
 export declare const OptionalProps: unique symbol;
 /** Symbol used to declare which relation properties should be eagerly loaded (e.g., `[EagerProps]?: 'author'`). */

package/typings.js

@@ -9,6 +9,8 @@ import { BaseEntity } from './entity/BaseEntity.js';
 export const EntityRepositoryType = Symbol('EntityRepositoryType');
 /** Symbol used to declare the primary key property name(s) on an entity (e.g., `[PrimaryKeyProp]?: 'id'`). */
 export const PrimaryKeyProp = Symbol('PrimaryKeyProp');
+/** Symbol used as a brand on `CollectionShape` to prevent false structural matches with entities that have properties like `owner`. */
+export const CollectionBrand = Symbol('CollectionBrand');
 /** Symbol used to declare which properties are optional in `em.create()` (e.g., `[OptionalProps]?: 'createdAt'`). */
 export const OptionalProps = Symbol('OptionalProps');
 /** Symbol used to declare which relation properties should be eagerly loaded (e.g., `[EagerProps]?: 'author'`). */

package/unit-of-work/ChangeSetPersister.d.ts

@@ -24,6 +24,12 @@ export declare class ChangeSetPersister {
     private checkConcurrencyKeys;
     private persistManagedEntitiesBatch;
     private mapPrimaryKey;
+    /**
+     * After INSERT + hydration, sync all EntityIdentifier placeholders in composite PK arrays
+     * with the real values now present on the entity. This is needed because `mapPrimaryKey`
+     * only handles the first PK column, but any scalar PK in a composite key may be auto-generated.
+     */
+    private syncCompositeIdentifiers;
     /**
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */

package/unit-of-work/ChangeSetPersister.js

@@ -132,6 +132,7 @@ export class ChangeSetPersister {
             this.mapPrimaryKey(meta, res.insertId ?? res.row?.[meta.primaryKeys[0]], changeSet);
         }
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
+        this.syncCompositeIdentifiers(changeSet);
         this.markAsPopulated(changeSet, meta);
         wrapped.__initialized = true;
         wrapped.__managed = true;
@@ -178,6 +179,7 @@ export class ChangeSetPersister {
             if (res.rows) {
                 this.mapReturnedValues(changeSet.entity, changeSet.payload, res.rows[i], meta);
             }
+            this.syncCompositeIdentifiers(changeSet);
             this.markAsPopulated(changeSet, meta);
             wrapped.__initialized = true;
             wrapped.__managed = true;
@@ -255,6 +257,24 @@ export class ChangeSetPersister {
             wrapped.__identifier.setValue(value);
         }
     }
+    /**
+     * After INSERT + hydration, sync all EntityIdentifier placeholders in composite PK arrays
+     * with the real values now present on the entity. This is needed because `mapPrimaryKey`
+     * only handles the first PK column, but any scalar PK in a composite key may be auto-generated.
+     */
+    syncCompositeIdentifiers(changeSet) {
+        const wrapped = helper(changeSet.entity);
+        if (!Array.isArray(wrapped.__identifier)) {
+            return;
+        }
+        const pks = changeSet.meta.getPrimaryProps();
+        for (let i = 0; i < pks.length; i++) {
+            const ident = wrapped.__identifier[i];
+            if (ident instanceof EntityIdentifier && pks[i].kind === ReferenceKind.SCALAR) {
+                ident.setValue(changeSet.entity[pks[i].name]);
+            }
+        }
+    }
     /**
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */
@@ -413,8 +433,8 @@ export class ChangeSetPersister {
             }
             return;
         }
-        if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
-            changeSet.payload[prop.name] = value.map(item => item.getValue());
+        if (Array.isArray(value) && value.some(item => item instanceof EntityIdentifier)) {
+            changeSet.payload[prop.name] = value.map(item => (item instanceof EntityIdentifier ? item.getValue() : item));
             return;
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {

package/utils/Utils.js

@@ -132,7 +132,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.0.9-dev.0';
+    static #ORM_VERSION = '7.0.9-dev.10';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */