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

package/EntityManager.js

@@ -678,24 +678,7 @@ class EntityManager {
                 }
             }
         }
-        const unique = options.onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
-        const propIndex = !utils_1.Utils.isRawSql(unique) && unique.findIndex(p => data[p] != null);
-        if (options.onConflictFields || where == null) {
-            if (propIndex !== false && propIndex >= 0) {
-                where = { [unique[propIndex]]: data[unique[propIndex]] };
-            }
-            else if (meta.uniques.length > 0) {
-                for (const u of meta.uniques) {
-                    if (utils_1.Utils.asArray(u.properties).every(p => data[p] != null)) {
-                        where = utils_1.Utils.asArray(u.properties).reduce((o, key) => {
-                            o[key] = data[key];
-                            return o;
-                        }, {});
-                        break;
-                    }
-                }
-            }
-        }
+        where = (0, utils_1.getWhereCondition)(meta, options.onConflictFields, data, where).where;
         data = utils_1.QueryHelper.processObjectParams(data);
         em.validator.validateParams(data, 'insert data');
         if (em.eventManager.hasListeners(enums_1.EventType.beforeUpsert, meta)) {
@@ -830,31 +813,17 @@ class EntityManager {
                     }
                 }
             }
-            const unique = meta.props.filter(p => p.unique).map(p => p.name);
-            propIndex = unique.findIndex(p => row[p] != null);
-            if (options.onConflictFields || where == null) {
-                if (propIndex >= 0) {
-                    where = { [unique[propIndex]]: row[unique[propIndex]] };
-                }
-                else if (meta.uniques.length > 0) {
-                    for (const u of meta.uniques) {
-                        if (utils_1.Utils.asArray(u.properties).every(p => row[p] != null)) {
-                            where = utils_1.Utils.asArray(u.properties).reduce((o, key) => {
-                                o[key] = row[key];
-                                return o;
-                            }, {});
-                            break;
-                        }
-                    }
-                }
-            }
-            row = utils_1.QueryHelper.processObjectParams(row);
+            const unique = options.onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+            propIndex = !utils_1.Utils.isRawSql(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+            const tmp = (0, utils_1.getWhereCondition)(meta, options.onConflictFields, row, where);
+            propIndex = tmp.propIndex;
             where = utils_1.QueryHelper.processWhere({
-                where,
+                where: tmp.where,
                 entityName,
                 metadata: this.metadata,
                 platform: this.getPlatform(),
             });
+            row = utils_1.QueryHelper.processObjectParams(row);
             em.validator.validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
@@ -896,7 +865,7 @@ class EntityManager {
         const reloadFields = returning.length > 0 && !(this.getPlatform().usesReturningStatement() && res.rows?.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 >= 0 ? [unique[propIndex]] : []);
+            const add = new Set(propIndex !== false && propIndex >= 0 ? [unique[propIndex]] : []);
             for (const cond of loadPK.values()) {
                 utils_1.Utils.keys(cond).forEach(key => add.add(key));
             }

package/entity/defineEntity.d.ts

@@ -6,7 +6,7 @@ import type { ManyToOneOptions } from '../decorators/ManyToOne';
 import type { OneToManyOptions } from '../decorators/OneToMany';
 import type { OneToOneOptions } from '../decorators/OneToOne';
 import type { ManyToManyOptions } from '../decorators/ManyToMany';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt } from '../typings';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass } from '../typings';
 import type { Reference, ScalarReference } from './Reference';
 import type { SerializeOptions } from '../serialization/EntitySerializer';
 import type { Cascade, DeferMode, LoadStrategy, QueryOrderMap } from '../enums';
@@ -390,7 +390,11 @@ export declare class ManyToOneOptionsBuilder<TargetValue extends object> extends
     /** Point to the inverse side property name. */
     inversedBy(inversedBy: (string & keyof TargetValue) | ((e: TargetValue) => any)): this;
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk?: boolean): this;
+    mapToPk<T extends boolean = true>(mapToPk?: T): this & {
+        '~options': {
+            mapToPk: T;
+        };
+    };
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn(joinColumn: string): this;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
@@ -458,7 +462,11 @@ export declare class OneToOneOptionsBuilder<TargetValue extends object> extends
     /** Point to the inverse side property name. */
     inversedBy(inversedBy: (string & keyof TargetValue) | ((e: TargetValue) => any)): this;
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk?: boolean): this;
+    mapToPk<T extends boolean = true>(mapToPk?: T): this & {
+        '~options': {
+            mapToPk: T;
+        };
+    };
     /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
     ownColumns(...ownColumns: string[]): this;
     /** What to do when the target entity gets deleted. */
@@ -506,6 +514,11 @@ export declare function defineEntity<Properties extends Record<string, any>, con
     properties: Properties | ((properties: typeof propertyBuilders) => Properties);
     primaryKeys?: PK & InferPrimaryKey<Properties>[];
 }): EntitySchema<InferEntityFromProperties<Properties, PK>, never>;
+export declare function defineEntity<Entity = any, Base = never>(meta: Omit<Partial<EntityMetadata<Entity>>, 'properties'> & {
+    class: EntityClass<Entity>;
+    extends?: string | EntitySchema<Base>;
+    properties: Record<string, any> | ((properties: typeof propertyBuilders) => Record<string, any>);
+}): EntitySchema<Entity, Base>;
 export declare namespace defineEntity {
     var properties: {
         bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => PropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}>;
@@ -577,27 +590,38 @@ type InferBuilderValue<Builder> = Builder extends {
     '~type'?: {
         value: infer Value;
     };
-} ? MaybeHidden<MaybeOpt<MaybeRef<MaybeNullable<MaybeArray<Value, Builder>, Builder>, Builder>, Builder>, Builder> : never;
+} ? MaybeHidden<MaybeOpt<MaybeScalarRef<MaybeNullable<MaybeRelationRef<MaybeMapToPk<MaybeArray<Value, Builder>, Builder>, Builder>, Builder>, Builder>, Builder>, Builder> : never;
 type MaybeArray<Value, Builder> = Builder extends {
     '~options': {
         array: true;
     };
 } ? Value[] : Value;
+type MaybeMapToPk<Value, Builder> = Builder extends {
+    '~options': {
+        mapToPk: true;
+    };
+} ? Primary<Value> : Value;
 type MaybeNullable<Value, Builder> = Builder extends {
     '~options': {
         nullable: true;
     };
 } ? Value | null | undefined : Value;
-type MaybeRef<Value, Builder> = Builder extends {
+type MaybeRelationRef<Value, Builder> = Builder extends {
+    '~options': {
+        mapToPk: true;
+    };
+} ? Value : Builder extends {
     '~options': {
         ref: false;
     };
 } ? Value : Builder extends {
     '~options': {
+        ref: true;
         kind: '1:1';
     };
 } ? Value extends object ? Reference<Value> : never : Builder extends {
     '~options': {
+        ref: true;
         kind: 'm:1';
     };
 } ? Value extends object ? Reference<Value> : never : Builder extends {
@@ -608,12 +632,25 @@ type MaybeRef<Value, Builder> = Builder extends {
     '~options': {
         kind: 'm:n';
     };
-} ? Value extends object ? Collection<Value> : never : Builder extends {
+} ? Value extends object ? Collection<Value> : never : Value;
+type MaybeScalarRef<Value, Builder> = Builder extends {
+    '~options': {
+        ref: false;
+    };
+} ? Value : Builder extends {
+    '~options': {
+        kind: '1:1' | 'm:1' | '1:m' | 'm:n';
+    };
+} ? Value : Builder extends {
     '~options': {
         ref: true;
     };
 } ? ScalarReference<Value> : Value;
 type MaybeOpt<Value, Builder> = Builder extends {
+    '~options': {
+        mapToPk: true;
+    };
+} ? Value extends Opt<infer OriginalValue> ? OriginalValue : Value : Builder extends {
     '~options': {
         autoincrement: true;
     };

package/entity/defineEntity.js

@@ -645,7 +645,6 @@ const propertyBuilders = {
     manyToOne: (target) => new ManyToOneOptionsBuilder({
         entity: () => target,
         kind: 'm:1',
-        ref: true,
     }),
     oneToMany: (target) => new OneToManyOptionsBuilderOnlyMappedBy({
         entity: () => target,
@@ -654,7 +653,6 @@ const propertyBuilders = {
     oneToOne: (target) => new OneToOneOptionsBuilder({
         entity: () => target,
         kind: '1:1',
-        ref: true,
     }),
 };
 function getBuilderOptions(builder) {

package/index.mjs

@@ -204,6 +204,7 @@ export const expandDotPaths = mod.expandDotPaths;
 export const getLoadingStrategy = mod.getLoadingStrategy;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
+export const getWhereCondition = mod.getWhereCondition;
 export const helper = mod.helper;
 export const parseJsonSafe = mod.parseJsonSafe;
 export const quote = mod.quote;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.8-dev.8",
+  "version": "6.5.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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.2",
     "globby": "11.1.0",
-    "mikro-orm": "6.5.8-dev.8",
+    "mikro-orm": "6.5.8",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -193,7 +193,7 @@ export declare abstract class Platform {
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCustomPrimaryKeyNames(): boolean;
     isPopulated<T>(key: string, populate: PopulateOptions<T>[] | boolean): boolean;
-    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean, ignoreInlineEmbeddables?: boolean): boolean;
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */

package/platforms/Platform.js

@@ -452,7 +452,7 @@ class Platform {
     isPopulated(key, populate) {
         return populate === true || (populate !== false && populate.some(p => p.field === key || p.all));
     }
-    shouldHaveColumn(prop, populate, exclude, includeFormulas = true) {
+    shouldHaveColumn(prop, populate, exclude, includeFormulas = true, ignoreInlineEmbeddables = true) {
         if (exclude?.includes(prop.name)) {
             return false;
         }
@@ -472,7 +472,7 @@ class Platform {
             return true;
         }
         if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
-            return !!prop.object;
+            return prop.object || ignoreInlineEmbeddables;
         }
         return prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner;
     }

package/unit-of-work/UnitOfWork.js

@@ -98,6 +98,10 @@ class UnitOfWork {
                     }
                     data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
+                if (prop.hydrate === false && prop.customType?.ensureComparable(wrapped.__meta, prop)) {
+                    const converted = prop.customType.convertToJSValue(data[key], this.platform);
+                    data[key] = prop.customType.convertToDatabaseValue(converted, this.platform);
+                }
                 if (forceUndefined) {
                     if (data[key] === null) {
                         data[key] = undefined;

package/utils/EntityComparator.js

@@ -545,10 +545,7 @@ class EntityComparator {
         context.set('compareObjects', Utils_1.compareObjects);
         context.set('equals', Utils_1.equals);
         for (const prop of meta.comparableProps) {
-            // skip properties that are not hydrated
-            if (prop.hydrate !== false) {
-                lines.push(this.getPropertyComparator(prop, context));
-            }
+            lines.push(this.getPropertyComparator(prop, context));
         }
         // also compare 1:1 inverse sides, important for `factory.mergeData`
         lines.push(`if (options?.includeInverseSides) {`);

package/utils/upsert-utils.d.ts

@@ -1,7 +1,12 @@
-import type { EntityData, EntityMetadata } from '../typings';
+import type { EntityData, EntityMetadata, FilterQuery } from '../typings';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver';
 import type { RawQueryFragment } from '../utils/RawQueryFragment';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[];
 /** @internal */
 export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+/** @internal */
+export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | RawQueryFragment | undefined, data: EntityData<T>, where: FilterQuery<T>): {
+    where: FilterQuery<T>;
+    propIndex: number | false;
+};

package/utils/upsert-utils.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOnConflictFields = getOnConflictFields;
 exports.getOnConflictReturningFields = getOnConflictReturningFields;
+exports.getWhereCondition = getWhereCondition;
+const Utils_1 = require("./Utils");
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -100,3 +102,44 @@ function getOnConflictReturningFields(meta, data, uniqueFields, options) {
     }
     return keys.filter(key => !(key in data));
 }
+function getPropertyValue(obj, key) {
+    if (key.indexOf('.') === -1) {
+        return obj[key];
+    }
+    const parts = key.split('.');
+    let curr = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        curr[parts[i]] ??= {};
+        curr = curr[parts[i]];
+    }
+    return curr[parts[parts.length - 1]];
+}
+/** @internal */
+function getWhereCondition(meta, onConflictFields, data, where) {
+    const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+    const propIndex = !Utils_1.Utils.isRawSql(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+    if (onConflictFields || where == null) {
+        if (propIndex !== false && propIndex >= 0) {
+            let key = unique[propIndex];
+            if (key.includes('.')) {
+                const prop = meta.properties[key.substring(0, key.indexOf('.'))];
+                if (prop) {
+                    key = `${prop.fieldNames[0]}${key.substring(key.indexOf('.'))}`;
+                }
+            }
+            where = { [key]: getPropertyValue(data, unique[propIndex]) };
+        }
+        else if (meta.uniques.length > 0) {
+            for (const u of meta.uniques) {
+                if (Utils_1.Utils.asArray(u.properties).every(p => data[p] != null)) {
+                    where = Utils_1.Utils.asArray(u.properties).reduce((o, key) => {
+                        o[key] = data[key];
+                        return o;
+                    }, {});
+                    break;
+                }
+            }
+        }
+    }
+    return { where, propIndex };
+}