@mikro-orm/core 7.0.16-dev.9 → 7.0.16

package/EntityManager.js

@@ -1,4 +1,4 @@
-import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
+import { getOnConflictReturningFields, 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';
@@ -360,6 +360,13 @@ export class EntityManager {
             if (!joined && !hint.filter) {
                 continue;
             }
+            // Polymorphic to-one relations are already filtered via per-target LEFT JOINs created
+            // for the `:ref filter` hint; emitting a populate-filter entry here would auto-join only
+            // the first target meta and either drop rows pointing to other targets or reference
+            // parent-table-only columns on the child sub-table alias for TPT children.
+            if (prop.polymorphic && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                continue;
+            }
             const filters = QueryHelper.mergePropertyFilters(prop.filters, options.filters);
             const where = await this.applyFilters(prop.targetMeta.class, {}, filters, 'read', {
                 ...options,
@@ -806,7 +813,10 @@ export class EntityManager {
         data = QueryHelper.processObjectParams(data);
         validateParams(data, 'insert data');
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
-            await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity: data, em, meta }, meta);
+            await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity: entity ?? data, em, meta }, meta);
+            if (entity) {
+                data = em.#comparator.prepareEntity(entity);
+            }
         }
         const ret = await em.driver.nativeUpdate(entityName, where, data, {
             ctx: em.#transactionContext,
@@ -855,6 +865,7 @@ export class EntityManager {
             em.getHydrator().hydrate(entity, meta, data2, em.#entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
+        resetUntouchedCollections(meta, entity);
         const snapshot = this.#comparator.prepareEntity(entity);
         em.#unitOfWork.register(entity, snapshot, { refresh: true });
         if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
@@ -921,6 +932,7 @@ export class EntityManager {
         const allWhere = [];
         const entities = new Map();
         const entitiesByData = new Map();
+        const entitiesByAllDataIdx = new Map();
         for (let i = 0; i < data.length; i++) {
             let row = data[i];
             let where;
@@ -934,6 +946,7 @@ export class EntityManager {
                 }
                 where = helper(entity).getPrimaryKey();
                 em.#entityFactory.assignDefaultValues(entity, meta);
+                entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
             }
             else {
@@ -981,6 +994,9 @@ export class EntityManager {
                 const entity = entitiesByData.get(dto) ?? dto;
                 await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity, em, meta }, meta);
             }
+            for (const [idx, entity] of entitiesByAllDataIdx) {
+                allData[idx] = em.#comparator.prepareEntity(entity);
+            }
         }
         const res = await em.driver.nativeUpdateMany(entityName, allWhere, allData, {
             ctx: em.#transactionContext,
@@ -1081,6 +1097,7 @@ export class EntityManager {
         }
         for (const [entity] of entities) {
             // recompute the data as there might be some values missing (e.g. those with db column defaults)
+            resetUntouchedCollections(meta, entity);
             const snapshot = this.#comparator.prepareEntity(entity);
             em.#unitOfWork.register(entity, snapshot, { refresh: true });
         }

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
-export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaColumns, FormulaTable, SchemaTable, SchemaColumns, EntityDataPropValue, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaColumns, FormulaTable, SchemaTable, SchemaColumns, SchemaColumnRef, EntityDataPropValue, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/MetadataDiscovery.js

@@ -963,9 +963,13 @@ export class MetadataDiscovery {
                 meta.propertyOrder.set(prop.name, (order += 0.01));
             });
         }
-        meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
-        meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
-        meta.checks = Utils.unique([...base.checks, ...meta.checks]);
+        // TPT children have their own tables that don't contain the parent's columns,
+        // so propagating parent indexes/uniques/checks would target missing columns.
+        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]);
+        }
         const pks = Object.values(meta.properties)
             .filter(p => p.primary)
             .map(p => p.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.16-dev.9",
+  "version": "7.0.16",
   "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

@@ -579,19 +579,37 @@ export type SchemaTable = {
 export type FormulaColumns<T> = Record<PropertyName<T>, string> & {
     toString(): string;
 };
+/**
+ * Column reference for schema callbacks. Behaves like a string (coercible via `toString()`),
+ * with arbitrary nested property access for embedded sub-columns (e.g. `cols.address.city`).
+ */
+export type SchemaColumnRef = string & {
+    readonly [key: string]: SchemaColumnRef;
+};
 /**
  * Column mapping for schema callbacks (indexes, checks, generated columns).
  * Maps property names to field names. For TPT entities, only includes properties
  * that belong to the current table (not inherited properties from parent tables).
+ * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+ * while coercing to the embedded property's own column name via `toString()` (matches the
+ * pre-7712 behaviour, regardless of any custom `prefix`).
+ */
+export type SchemaColumns<T> = Record<PropertyName<T>, SchemaColumnRef>;
+/**
+ * Callback for custom index expressions. Receives column mappings, table info, and the index name.
+ * The runtime `columns` object includes nested entries for embedded properties (see `SchemaColumnRef`);
+ * cast to `SchemaColumns<T>` if you need typed nested access.
  */
-export type SchemaColumns<T> = Record<PropertyName<T>, string>;
-/** Callback for custom index expressions. Receives column mappings, table info, and the index name. */
 export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable, indexName: string) => string | Raw;
 /** Callback for computed (formula) properties. Receives column mappings and table info, returns a SQL expression. */
 export type FormulaCallback<T> = (columns: FormulaColumns<T>, table: FormulaTable) => string | Raw;
 /** Callback for CHECK constraint expressions. Receives column mappings and table info. */
-export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
-/** Callback for generated (computed) column expressions. Receives column mappings and table info. */
+export type CheckCallback<T> = (columns: SchemaColumns<T>, table: SchemaTable) => string | Raw;
+/**
+ * Callback for generated (computed) column expressions. Receives column mappings and table info.
+ * The runtime `columns` object includes nested entries for embedded properties (see `SchemaColumnRef`);
+ * cast to `SchemaColumns<T>` if you need typed nested access.
+ */
 export type GeneratedColumnCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 /** Definition of a CHECK constraint on a table or property. */
 export interface CheckConstraint<T = any> {
@@ -728,8 +746,12 @@ export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entit
     /**
      * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
      * For TPT entities, only includes properties that belong to the current table (ownProps).
+     * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+     * while still coercing to the embedded column prefix when used as a string (GH #7712).
      */
     createSchemaColumnMappingObject(): SchemaColumns<Entity>;
+    /** @internal Recursively builds a column mapping for an embedded property's sub-columns. */
+    private static buildEmbeddedColumnMapping;
     get tableName(): string;
     set tableName(name: string);
     get uniqueName(): string;

package/typings.js

@@ -116,16 +116,37 @@ export class EntityMetadata {
     /**
      * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
      * For TPT entities, only includes properties that belong to the current table (ownProps).
+     * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+     * while still coercing to the embedded column prefix when used as a string (GH #7712).
      */
     createSchemaColumnMappingObject() {
         // For TPT entities, only include properties that belong to this entity's table
         const props = this.inheritanceType === 'tpt' && this.ownProps ? this.ownProps : Object.values(this.properties);
-        return props.reduce((o, prop) => {
-            if (prop.fieldNames) {
-                o[prop.name] = prop.fieldNames[0];
+        const result = {};
+        for (const prop of props) {
+            if (!prop.fieldNames) {
+                continue;
             }
-            return o;
-        }, {});
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.embeddedProps) {
+                result[prop.name] = EntityMetadata.buildEmbeddedColumnMapping(prop);
+                continue;
+            }
+            result[prop.name] = prop.fieldNames[0];
+        }
+        return result;
+    }
+    /** @internal Recursively builds a column mapping for an embedded property's sub-columns. */
+    static buildEmbeddedColumnMapping(embeddedProp) {
+        const result = {};
+        for (const [name, sub] of Object.entries(embeddedProp.embeddedProps)) {
+            result[name] =
+                sub.kind === ReferenceKind.EMBEDDED && sub.embeddedProps
+                    ? EntityMetadata.buildEmbeddedColumnMapping(sub)
+                    : sub.fieldNames[0];
+        }
+        const prefix = embeddedProp.fieldNames[0];
+        Object.defineProperty(result, 'toString', { value: () => prefix, enumerable: false });
+        return result;
     }
     get tableName() {
         return this.collection;

package/utils/Utils.js

@@ -141,7 +141,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.16-dev.9';
+    static #ORM_VERSION = '7.0.16';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/upsert-utils.d.ts

@@ -10,3 +10,5 @@ export declare function getWhereCondition<T extends object>(meta: EntityMetadata
     where: FilterQuery<T>;
     propIndex: number | false;
 };
+/** @internal */
+export declare function resetUntouchedCollections<Entity extends object>(meta: EntityMetadata<Entity>, entity: Entity): void;

package/utils/upsert-utils.js

@@ -1,5 +1,8 @@
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from './Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { Collection } from '../entity/Collection.js';
+import { helper } from '../entity/wrap.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -52,7 +55,9 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
         });
     }
     const keys = Object.keys(data).flatMap(f => {
-        if (!(Array.isArray(uniqueFields) && !uniqueFields.includes(f))) {
+        // skip explicitly listed unique fields; for raw onConflictFields we can't introspect the
+        // fragment, so merge all data keys (the user is responsible for not corrupting them).
+        if (Array.isArray(uniqueFields) && uniqueFields.includes(f)) {
             return [];
         }
         const prop = meta?.properties[f];
@@ -142,3 +147,23 @@ export function getWhereCondition(meta, onConflictFields, data, where) {
     }
     return { where, propIndex };
 }
+/** @internal */
+export function resetUntouchedCollections(meta, entity) {
+    // for entities passed in via `em.create()` and then upserted, collection-kind relations
+    // were initialized as empty-but-initialized by the hydrator (newEntity=true). once the
+    // upsert resolves the entity to a possibly existing row, that state is stale and would
+    // cause `em.populate()` to skip those collections. replace them with a fresh
+    // uninitialized collection so populate can load them.
+    if (helper(entity).__originalEntityData) {
+        return;
+    }
+    for (const prop of meta.relations) {
+        if (prop.kind !== ReferenceKind.MANY_TO_MANY && prop.kind !== ReferenceKind.ONE_TO_MANY) {
+            continue;
+        }
+        const collection = entity[prop.name];
+        if (Utils.isCollection(collection) && collection.isInitialized() && !collection.isDirty()) {
+            Collection.create(entity, prop.name, undefined, false);
+        }
+    }
+}