@mikro-orm/core 6.3.8-dev.6 → 6.3.8-dev.7

package/EntityManager.d.ts

@@ -227,7 +227,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      *
      * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
      */
-    upsert<Entity extends object>(entityNameOrEntity: EntityName<Entity> | Entity, data?: EntityData<Entity> | NoInfer<Entity>, options?: UpsertOptions<Entity>): Promise<Entity>;
+    upsert<Entity extends object, Fields extends string = any>(entityNameOrEntity: EntityName<Entity> | Entity, data?: EntityData<Entity> | NoInfer<Entity>, options?: UpsertOptions<Entity, Fields>): Promise<Entity>;
     /**
      * Creates or updates the entity, based on whether it is already present in the database.
      * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
@@ -253,7 +253,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      *
      * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
      */
-    upsertMany<Entity extends object>(entityNameOrEntity: EntityName<Entity> | Entity[], data?: (EntityData<Entity> | NoInfer<Entity>)[], options?: UpsertManyOptions<Entity>): Promise<Entity[]>;
+    upsertMany<Entity extends object, Fields extends string = any>(entityNameOrEntity: EntityName<Entity> | Entity[], data?: (EntityData<Entity> | NoInfer<Entity>)[], options?: UpsertManyOptions<Entity, Fields>): Promise<Entity[]>;
     /**
      * Runs your callback wrapped inside a database transaction.
      */

package/drivers/IDatabaseDriver.d.ts

@@ -141,13 +141,13 @@ export interface NativeInsertUpdateOptions<T> {
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
 }
-export interface UpsertOptions<Entity> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
+export interface UpsertOptions<Entity, Fields extends string = never> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
     onConflictFields?: (keyof Entity)[] | RawQueryFragment;
     onConflictAction?: 'ignore' | 'merge';
-    onConflictMergeFields?: (keyof Entity)[];
-    onConflictExcludeFields?: (keyof Entity)[];
+    onConflictMergeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
+    onConflictExcludeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
 }
-export interface UpsertManyOptions<Entity> extends UpsertOptions<Entity> {
+export interface UpsertManyOptions<Entity, Fields extends string = never> extends UpsertOptions<Entity, Fields> {
     batchSize?: number;
 }
 export interface CountOptions<T extends object, P extends string = never> {

package/entity/EntityRepository.d.ts

@@ -41,7 +41,7 @@ export declare class EntityRepository<Entity extends object> {
      *
      * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
      */
-    upsert(entityOrData?: EntityData<Entity> | Entity, options?: UpsertOptions<Entity>): Promise<Entity>;
+    upsert<Fields extends string = any>(entityOrData?: EntityData<Entity> | Entity, options?: UpsertOptions<Entity, Fields>): Promise<Entity>;
     /**
      * Creates or updates the entity, based on whether it is already present in the database.
      * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
@@ -67,7 +67,7 @@ export declare class EntityRepository<Entity extends object> {
      *
      * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
      */
-    upsertMany(entitiesOrData?: EntityData<Entity>[] | Entity[], options?: UpsertManyOptions<Entity>): Promise<Entity[]>;
+    upsertMany<Fields extends string = any>(entitiesOrData?: EntityData<Entity>[] | Entity[], options?: UpsertManyOptions<Entity, Fields>): Promise<Entity[]>;
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.8-dev.6",
+  "version": "6.3.8-dev.7",
   "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.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.8-dev.6",
+    "mikro-orm": "6.3.8-dev.7",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/upsert-utils.d.ts

@@ -4,4 +4,4 @@ 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>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[] | '*';
+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)[] | '*';

package/utils/upsert-utils.js

@@ -2,21 +2,76 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOnConflictFields = getOnConflictFields;
 exports.getOnConflictReturningFields = getOnConflictReturningFields;
+function expandEmbeddedProperties(prop, key) {
+    if (prop.object) {
+        return [prop.name];
+    }
+    return Object.values(prop.embeddedProps).flatMap(p => {
+        /* istanbul ignore next */
+        if (p.embeddable && !p.object) {
+            return expandEmbeddedProperties(p);
+        }
+        return [p.name];
+    });
+}
+/**
+ * Expands dot paths and stars
+ */
+function expandFields(meta, fields) {
+    return fields.flatMap(f => {
+        if (f === '*' && meta) {
+            return meta.comparableProps.filter(p => !p.lazy && !p.embeddable).map(p => p.name);
+        }
+        if (f.includes('.')) {
+            const [k, ...tmp] = f.split('.');
+            const rest = tmp.join('.');
+            const prop = meta?.properties[k];
+            if (prop?.embeddable) {
+                if (rest === '*') {
+                    return expandEmbeddedProperties(prop);
+                }
+                return expandEmbeddedProperties(prop, rest);
+            }
+        }
+        const prop = meta?.properties[f];
+        if (prop?.embeddable) {
+            return expandEmbeddedProperties(prop);
+        }
+        return [f];
+    });
+}
 /** @internal */
 function getOnConflictFields(meta, data, uniqueFields, options) {
     if (options.onConflictMergeFields) {
-        return options.onConflictMergeFields;
+        const onConflictMergeFields = expandFields(meta, options.onConflictMergeFields);
+        return onConflictMergeFields.flatMap(f => {
+            const prop = meta?.properties[f];
+            /* istanbul ignore next */
+            if (prop?.embeddable && !prop.object) {
+                return Object.values(prop.embeddedProps).map(p => p.name);
+            }
+            return f;
+        });
     }
-    const keys = Object.keys(data).filter(f => {
-        return Array.isArray(uniqueFields) && !uniqueFields.includes(f) && !meta?.properties[f]?.embeddable;
+    const keys = Object.keys(data).flatMap(f => {
+        if (!(Array.isArray(uniqueFields) && !uniqueFields.includes(f))) {
+            return [];
+        }
+        const prop = meta?.properties[f];
+        if (prop?.embeddable && !prop.object) {
+            return expandEmbeddedProperties(prop);
+        }
+        return [f];
     });
     if (options.onConflictExcludeFields) {
-        return keys.filter(f => !options.onConflictExcludeFields.includes(f));
+        const onConflictExcludeFields = expandFields(meta, options.onConflictExcludeFields);
+        return keys.filter(f => !onConflictExcludeFields.includes(f));
     }
     return keys;
 }
 /** @internal */
 function getOnConflictReturningFields(meta, data, uniqueFields, options) {
+    /* istanbul ignore next */
     if (!meta) {
         return '*';
     }
@@ -28,10 +83,12 @@ function getOnConflictReturningFields(meta, data, uniqueFields, options) {
         return keys;
     }
     if (options.onConflictMergeFields) {
-        return keys.filter(key => !options.onConflictMergeFields.includes(key));
+        const onConflictMergeFields = expandFields(meta, options.onConflictMergeFields);
+        return keys.filter(key => !onConflictMergeFields.includes(key));
     }
     if (options.onConflictExcludeFields) {
-        return [...new Set(keys.concat(...options.onConflictExcludeFields))];
+        const onConflictExcludeFields = expandFields(meta, options.onConflictExcludeFields);
+        return [...new Set(keys.concat(...onConflictExcludeFields))];
     }
     return keys.filter(key => !(key in data));
 }