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

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/drivers/IDatabaseDriver.d.ts

@@ -345,6 +345,7 @@ export interface CountByOptions<T extends object> {
     filters?: FilterOptions;
     having?: FilterQuery<T>;
     schema?: string;
+    connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
     loggerContext?: LogContext;
     logging?: LoggingOptions;

package/metadata/MetadataDiscovery.js

@@ -1676,6 +1676,9 @@ export class MetadataDiscovery {
                 if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
                     continue;
                 }
+                if (prop.customType instanceof t.json || ['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
+                    continue;
+                }
                 this.initFieldName(prop);
                 let expression = null;
                 if (prop.enum) {

package/package.json

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

@@ -216,7 +216,10 @@ export class EntityMetadata {
         if (config) {
             const platform = config.getPlatform();
             for (const prop of this.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
+                if (prop.enum &&
+                    !prop.nativeEnumName &&
+                    prop.items?.every(item => typeof item === 'string') &&
+                    !['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
                     const name = platform.getIndexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {

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.8';
+    static #ORM_VERSION = '7.1.13';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

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 */