@mikro-orm/core 7.0.0-dev.115 → 7.0.0-dev.117

package/EntityManager.js

@@ -571,13 +571,13 @@ export class EntityManager {
         let found = false;
         for (const e of fork.unitOfWork.getIdentityMap()) {
             const ref = em.getReference(e.constructor, helper(e).getPrimaryKey());
-            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true });
+            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true, convertCustomTypes: true });
             em.config.getHydrator(this.metadata).hydrate(ref, helper(ref).__meta, data, em.entityFactory, 'full', false, true);
             Utils.merge(helper(ref).__originalEntityData, this.comparator.prepareEntity(e));
             found ||= ref === entity;
         }
         if (!found) {
-            const data = helper(reloaded).serialize({ ignoreSerializers: true, includeHidden: true });
+            const data = helper(reloaded).serialize({ ignoreSerializers: true, includeHidden: true, convertCustomTypes: true });
             em.config.getHydrator(this.metadata).hydrate(entity, wrapped.__meta, data, em.entityFactory, 'full', false, true);
             Utils.merge(wrapped.__originalEntityData, this.comparator.prepareEntity(reloaded));
         }

package/metadata/MetadataDiscovery.js

@@ -822,7 +822,7 @@ export class MetadataDiscovery {
         const glue = object ? '~' : '_';
         for (const prop of Object.values(embeddable.properties)) {
             const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) + prop.name;
-            meta.properties[name] = Utils.copy(prop, false);
+            meta.properties[name] = Utils.copy(prop);
             meta.properties[name].name = name;
             meta.properties[name].embedded = [embeddedProp.name, prop.name];
             meta.propertyOrder.set(name, (order += 0.01));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.115",
+  "version": "7.0.0-dev.117",
   "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.",
   "exports": {
     "./package.json": "./package.json",

package/serialization/EntitySerializer.d.ts

@@ -4,6 +4,7 @@ export declare class EntitySerializer {
     static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): EntityDTO<Loaded<T, P>>;
     private static propertyName;
     private static processProperty;
+    private static processCustomType;
     private static extractChildOptions;
     private static processEntity;
     private static processCollection;
@@ -23,6 +24,8 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     skipNull?: boolean;
     /** Only include properties for a specific group. If a property does not specify any group, it will be included, otherwise only properties with a matching group are included. */
     groups?: string[];
+    /** Convert custom types to their database representation. By default, the `Type.toJSON` method is invoked instead. */
+    convertCustomTypes?: boolean;
 }
 /**
  * Converts entity instance to POJO, converting the `Collection`s to arrays and unwrapping the `Reference` wrapper, while respecting the serialization options.

package/serialization/EntitySerializer.js

@@ -159,12 +159,20 @@ export class EntitySerializer {
                 return helper(value).toJSON();
             }
         }
-        const customType = property?.customType;
-        if (customType) {
-            return customType.toJSON(value, wrapped.__platform);
+        if (property.customType) {
+            return this.processCustomType(value, property, wrapped.__platform, options.convertCustomTypes);
         }
         return wrapped.__platform.normalizePrimaryKey(value);
     }
+    static processCustomType(value, prop, platform, convertCustomTypes) {
+        if (!prop.customType) {
+            return value;
+        }
+        if (convertCustomTypes) {
+            return prop.customType.convertToDatabaseValue(value, platform, { mode: 'serialization' });
+        }
+        return prop.customType.toJSON(value, platform);
+    }
     static extractChildOptions(options, prop) {
         return {
             ...options,
@@ -183,10 +191,7 @@ export class EntitySerializer {
         if (expand) {
             return this.serialize(child, childOptions);
         }
-        let pk = wrapped.getPrimaryKey();
-        if (prop.customType) {
-            pk = prop.customType.toJSON(pk, wrapped.__platform);
-        }
+        const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
             return Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -210,10 +215,7 @@ export class EntitySerializer {
             if (populated || !wrapped.__managed) {
                 return this.serialize(item, this.extractChildOptions(options, prop.name));
             }
-            let pk = wrapped.getPrimaryKey();
-            if (prop.customType) {
-                pk = prop.customType.toJSON(pk, wrapped.__platform);
-            }
+            const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
                 return Utils.primaryKeyToObject(wrapped.__meta, pk);
             }

package/utils/EntityComparator.js

@@ -3,6 +3,7 @@ import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
 export class EntityComparator {
     metadata;
     platform;
@@ -517,8 +518,11 @@ export class EntityComparator {
                     return val;
                 };
                 context.set('toArray', toArray);
+                context.set('EntityIdentifier', EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (entity${entityKey}?.__helper.__identifier && !entity${entityKey}.__helper.hasPrimaryKey()) {\n`;
+                ret += `      ret${dataKey} = entity${entityKey}?.__helper.__identifier;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      ret${dataKey} = toArray(entity${entityKey}.__helper.getPrimaryKey(true));\n`;
                 ret += `    }\n`;

package/utils/RawQueryFragment.d.ts

@@ -13,6 +13,7 @@ export declare class RawQueryFragment {
     [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
     get [Symbol.toStringTag](): string;
     toJSON(): string;
+    clone(): this;
     static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
     static hasObjectFragments(object: unknown): boolean;
     static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;

package/utils/RawQueryFragment.js

@@ -33,6 +33,9 @@ export class RawQueryFragment {
     toJSON() {
         return `raw('${this.sql}')`;
     }
+    clone() {
+        return this;
+    }
     static isKnownFragmentSymbol(key) {
         return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
     }

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.115';
+    static #ORM_VERSION = '7.0.0-dev.117';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */