@mikro-orm/core 6.5.9-dev.0 → 6.5.9-dev.2

package/entity/defineEntity.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToOneOptionsBuilder = exports.OneToManyOptionsBuilderOnlyMappedBy = exports.OneToManyOptionsBuilder = exports.ManyToOneOptionsBuilder = exports.ManyToManyOptionsBuilder = exports.ReferenceOptionsBuilder = exports.EmbeddedOptionsBuilder = exports.EnumOptionsBuilder = exports.PropertyOptionsBuilder = void 0;
+exports.p = exports.OneToManyOptionsBuilderOnlyMappedBy = exports.UniversalPropertyOptionsBuilder = void 0;
 exports.defineEntity = defineEntity;
 const types_1 = require("../types");
 const EntitySchema_1 = require("../metadata/EntitySchema");
 /** @internal */
-class PropertyOptionsBuilder {
+class UniversalPropertyOptionsBuilder {
     '~options';
     '~type';
     constructor(options) {
         this['~options'] = options;
     }
     assignOptions(options) {
-        return new PropertyOptionsBuilder({ ...this['~options'], ...options });
+        return new UniversalPropertyOptionsBuilder({ ...this['~options'], ...options });
+    }
+    $type() {
+        return this.assignOptions({});
     }
     /**
      * Alias for `fieldName`.
@@ -326,20 +329,6 @@ class PropertyOptionsBuilder {
     ignoreSchemaChanges(...ignoreSchemaChanges) {
         return this.assignOptions({ ignoreSchemaChanges });
     }
-    $type() {
-        return this.assignOptions({});
-    }
-}
-exports.PropertyOptionsBuilder = PropertyOptionsBuilder;
-/** @internal */
-class EnumOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new EnumOptionsBuilder({ ...this['~options'], ...options });
-    }
     array(array = true) {
         return this.assignOptions({ array });
     }
@@ -347,17 +336,6 @@ class EnumOptionsBuilder extends PropertyOptionsBuilder {
     nativeEnumName(nativeEnumName) {
         return this.assignOptions({ nativeEnumName });
     }
-}
-exports.EnumOptionsBuilder = EnumOptionsBuilder;
-/** @internal */
-class EmbeddedOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new EmbeddedOptionsBuilder({ ...this['~options'], ...options });
-    }
     prefix(prefix) {
         return this.assignOptions({ prefix });
     }
@@ -367,17 +345,6 @@ class EmbeddedOptionsBuilder extends PropertyOptionsBuilder {
     object(object = true) {
         return this.assignOptions({ object });
     }
-    array(array = true) {
-        return this.assignOptions({ array });
-    }
-}
-exports.EmbeddedOptionsBuilder = EmbeddedOptionsBuilder;
-/** @internal */
-class ReferenceOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade(...cascade) {
         return this.assignOptions({ cascade });
@@ -390,17 +357,6 @@ class ReferenceOptionsBuilder extends PropertyOptionsBuilder {
     strategy(strategy) {
         return this.assignOptions({ strategy });
     }
-}
-exports.ReferenceOptionsBuilder = ReferenceOptionsBuilder;
-/** @internal */
-class ManyToManyOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], ...options });
-    }
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner(owner = true) {
         return this.assignOptions({ owner });
@@ -469,180 +425,66 @@ class ManyToManyOptionsBuilder extends ReferenceOptionsBuilder {
     updateRule(updateRule) {
         return this.assignOptions({ updateRule });
     }
-}
-exports.ManyToManyOptionsBuilder = ManyToManyOptionsBuilder;
-/** @internal */
-class ManyToOneOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], ...options });
-    }
-    /** Point to the inverse side property name. */
-    inversedBy(inversedBy) {
-        return this.assignOptions({ inversedBy });
-    }
     /** Map this relation to the primary key value instead of an entity. */
     mapToPk(mapToPk = true) {
         return this.assignOptions({ mapToPk });
     }
-    /** 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) {
-        return this.assignOptions({ joinColumn });
-    }
-    /** 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. */
-    joinColumns(...joinColumns) {
-        return this.assignOptions({ joinColumns });
+    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
+    deferMode(deferMode) {
+        return this.assignOptions({ deferMode });
     }
     /** 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) {
         return this.assignOptions({ ownColumns });
     }
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName(referenceColumnName) {
-        return this.assignOptions({ referenceColumnName });
-    }
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames(...referencedColumnNames) {
-        return this.assignOptions({ referencedColumnNames });
-    }
-    /** What to do when the target entity gets deleted. */
-    deleteRule(deleteRule) {
-        return this.assignOptions({ deleteRule });
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint(createForeignKeyConstraint = true) {
+        return this.assignOptions({ createForeignKeyConstraint });
     }
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule(updateRule) {
-        return this.assignOptions({ updateRule });
-    }
-    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
-    deferMode(deferMode) {
-        return this.assignOptions({ deferMode });
-    }
-}
-exports.ManyToOneOptionsBuilder = ManyToOneOptionsBuilder;
-/** @internal */
-class OneToManyOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], ...options });
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName(foreignKeyName) {
+        return this.assignOptions({ foreignKeyName });
     }
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval(orphanRemoval = true) {
         return this.assignOptions({ orphanRemoval });
     }
-    /** Set default ordering. */
-    orderBy(orderBy) {
-        return this.assignOptions({ orderBy });
-    }
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where(where) {
-        return this.assignOptions({ where });
-    }
-    /** 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) {
-        return this.assignOptions({ joinColumn });
-    }
-    /** 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. */
-    joinColumns(...joinColumns) {
-        return this.assignOptions({ joinColumns });
-    }
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    inverseJoinColumn(inverseJoinColumn) {
-        return this.assignOptions({ inverseJoinColumn });
-    }
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    inverseJoinColumns(...inverseJoinColumns) {
-        return this.assignOptions({ inverseJoinColumns });
-    }
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName(referenceColumnName) {
-        return this.assignOptions({ referenceColumnName });
-    }
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames(...referencedColumnNames) {
-        return this.assignOptions({ referencedColumnNames });
-    }
 }
-exports.OneToManyOptionsBuilder = OneToManyOptionsBuilder;
+exports.UniversalPropertyOptionsBuilder = UniversalPropertyOptionsBuilder;
 /** @internal */
-class OneToManyOptionsBuilderOnlyMappedBy {
-    constructor(options) {
-        this['~options'] = options;
-    }
+class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], mappedBy });
+        return new UniversalPropertyOptionsBuilder({ ...this['~options'], mappedBy });
     }
 }
 exports.OneToManyOptionsBuilderOnlyMappedBy = OneToManyOptionsBuilderOnlyMappedBy;
-/** @internal */
-class OneToOneOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    assignOptions(options) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], ...options });
-    }
-    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
-    owner(owner = true) {
-        return this.assignOptions({ owner });
-    }
-    /** Point to the inverse side property name. */
-    inversedBy(inversedBy) {
-        return this.assignOptions({ inversedBy });
-    }
-    /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk = true) {
-        return this.assignOptions({ mapToPk });
-    }
-    /** 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) {
-        return this.assignOptions({ ownColumns });
-    }
-    /** What to do when the target entity gets deleted. */
-    deleteRule(deleteRule) {
-        return this.assignOptions({ deleteRule });
-    }
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule(updateRule) {
-        return this.assignOptions({ updateRule });
-    }
-    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
-    deferMode(deferMode) {
-        return this.assignOptions({ deferMode });
-    }
-}
-exports.OneToOneOptionsBuilder = OneToOneOptionsBuilder;
 function createPropertyBuilders(options) {
-    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, () => new PropertyOptionsBuilder({ type: value })]));
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, () => new UniversalPropertyOptionsBuilder({ type: value })]));
 }
 const propertyBuilders = {
     ...createPropertyBuilders(types_1.types),
-    bigint: (mode) => new PropertyOptionsBuilder({ type: new types_1.types.bigint(mode) }),
-    array: (toJsValue = i => i, toDbValue = i => i) => new PropertyOptionsBuilder({ type: new types_1.types.array(toJsValue, toDbValue) }),
-    decimal: (mode) => new PropertyOptionsBuilder({ type: new types_1.types.decimal(mode) }),
-    json: () => new PropertyOptionsBuilder({ type: types_1.types.json }),
-    formula: (formula) => new PropertyOptionsBuilder({ formula }),
-    type: (type) => new PropertyOptionsBuilder({ type }),
-    enum: (items) => new EnumOptionsBuilder({
+    bigint: (mode) => new UniversalPropertyOptionsBuilder({ type: new types_1.types.bigint(mode) }),
+    array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types_1.types.array(toJsValue, toDbValue) }),
+    decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types_1.types.decimal(mode) }),
+    json: () => new UniversalPropertyOptionsBuilder({ type: types_1.types.json }),
+    formula: (formula) => new UniversalPropertyOptionsBuilder({ formula }),
+    datetime: (length) => new UniversalPropertyOptionsBuilder({ type: types_1.types.datetime, length }),
+    time: (length) => new UniversalPropertyOptionsBuilder({ type: types_1.types.time, length }),
+    type: (type) => new UniversalPropertyOptionsBuilder({ type }),
+    enum: (items) => new UniversalPropertyOptionsBuilder({
         enum: true,
         items,
     }),
-    embedded: (target) => new EmbeddedOptionsBuilder({
+    embedded: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'embedded',
     }),
-    manyToMany: (target) => new ManyToManyOptionsBuilder({
+    manyToMany: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'm:n',
     }),
-    manyToOne: (target) => new ManyToOneOptionsBuilder({
+    manyToOne: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'm:1',
     }),
@@ -650,11 +492,12 @@ const propertyBuilders = {
         entity: () => target,
         kind: '1:m',
     }),
-    oneToOne: (target) => new OneToOneOptionsBuilder({
+    oneToOne: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: '1:1',
     }),
 };
+exports.p = propertyBuilders;
 function getBuilderOptions(builder) {
     return '~options' in builder ? builder['~options'] : builder;
 }

package/index.mjs

@@ -56,7 +56,6 @@ export const DriverException = mod.DriverException;
 export const EagerProps = mod.EagerProps;
 export const Embeddable = mod.Embeddable;
 export const Embedded = mod.Embedded;
-export const EmbeddedOptionsBuilder = mod.EmbeddedOptionsBuilder;
 export const EnsureRequestContext = mod.EnsureRequestContext;
 export const Entity = mod.Entity;
 export const EntityAssigner = mod.EntityAssigner;
@@ -77,7 +76,6 @@ export const EntityTransformer = mod.EntityTransformer;
 export const EntityValidator = mod.EntityValidator;
 export const Enum = mod.Enum;
 export const EnumArrayType = mod.EnumArrayType;
-export const EnumOptionsBuilder = mod.EnumOptionsBuilder;
 export const EnumType = mod.EnumType;
 export const EventManager = mod.EventManager;
 export const EventType = mod.EventType;
@@ -107,9 +105,7 @@ export const LoadStrategy = mod.LoadStrategy;
 export const LockMode = mod.LockMode;
 export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
 export const ManyToMany = mod.ManyToMany;
-export const ManyToManyOptionsBuilder = mod.ManyToManyOptionsBuilder;
 export const ManyToOne = mod.ManyToOne;
-export const ManyToOneOptionsBuilder = mod.ManyToOneOptionsBuilder;
 export const MediumIntType = mod.MediumIntType;
 export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
 export const MetadataDiscovery = mod.MetadataDiscovery;
@@ -130,10 +126,8 @@ export const ObjectHydrator = mod.ObjectHydrator;
 export const OnInit = mod.OnInit;
 export const OnLoad = mod.OnLoad;
 export const OneToMany = mod.OneToMany;
-export const OneToManyOptionsBuilder = mod.OneToManyOptionsBuilder;
 export const OneToManyOptionsBuilderOnlyMappedBy = mod.OneToManyOptionsBuilderOnlyMappedBy;
 export const OneToOne = mod.OneToOne;
-export const OneToOneOptionsBuilder = mod.OneToOneOptionsBuilder;
 export const Opt = mod.Opt;
 export const OptimisticLockError = mod.OptimisticLockError;
 export const OptionalProps = mod.OptionalProps;
@@ -144,7 +138,6 @@ export const PopulatePath = mod.PopulatePath;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
-export const PropertyOptionsBuilder = mod.PropertyOptionsBuilder;
 export const QueryFlag = mod.QueryFlag;
 export const QueryHelper = mod.QueryHelper;
 export const QueryOperator = mod.QueryOperator;
@@ -155,7 +148,6 @@ export const ReadOnlyException = mod.ReadOnlyException;
 export const Ref = mod.Ref;
 export const Reference = mod.Reference;
 export const ReferenceKind = mod.ReferenceKind;
-export const ReferenceOptionsBuilder = mod.ReferenceOptionsBuilder;
 export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
 export const RequestContext = mod.RequestContext;
 export const RequiredNullable = mod.RequiredNullable;
@@ -185,6 +177,7 @@ export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
 export const Unique = mod.Unique;
 export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
 export const UnitOfWork = mod.UnitOfWork;
+export const UniversalPropertyOptionsBuilder = mod.UniversalPropertyOptionsBuilder;
 export const UnknownType = mod.UnknownType;
 export const Utils = mod.Utils;
 export const UuidType = mod.UuidType;
@@ -206,6 +199,7 @@ export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const getWhereCondition = mod.getWhereCondition;
 export const helper = mod.helper;
+export const p = mod.p;
 export const parseJsonSafe = mod.parseJsonSafe;
 export const quote = mod.quote;
 export const raw = mod.raw;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.9-dev.0",
+  "version": "6.5.9-dev.2",
   "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.9-dev.0",
+    "mikro-orm": "6.5.9-dev.2",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -156,7 +156,7 @@ export declare abstract class Platform {
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;

package/platforms/Platform.js

@@ -288,11 +288,7 @@ class Platform {
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
     }
-    convertJsonToJSValue(value, prop) {
-        const isObjectEmbedded = prop.embedded && prop.object;
-        if ((this.convertsJsonAutomatically() || isObjectEmbedded) && ['json', 'jsonb', this.getJsonDeclarationSQL()].includes(prop.columnTypes[0])) {
-            return value;
-        }
+    convertJsonToJSValue(value, context) {
         return (0, Utils_1.parseJsonSafe)(value);
     }
     convertDateToJSValue(value) {

package/types/JsonType.d.ts

@@ -5,7 +5,7 @@ export declare class JsonType extends Type<unknown, string | null> {
     convertToDatabaseValue(value: unknown, platform: Platform, context?: TransformContext): string | null;
     convertToJSValueSQL(key: string, platform: Platform): string;
     convertToDatabaseValueSQL(key: string, platform: Platform): string;
-    convertToJSValue(value: string | unknown, platform: Platform): unknown;
+    convertToJSValue(value: string | unknown, platform: Platform, context?: TransformContext): unknown;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     ensureComparable<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>): boolean;
     compareAsType(): string;

package/types/JsonType.js

@@ -15,8 +15,13 @@ class JsonType extends Type_1.Type {
     convertToDatabaseValueSQL(key, platform) {
         return key + platform.castColumn(this.prop);
     }
-    convertToJSValue(value, platform) {
-        return platform.convertJsonToJSValue(value, this.prop);
+    convertToJSValue(value, platform, context) {
+        const isJsonColumn = ['json', 'jsonb', platform.getJsonDeclarationSQL()].includes(this.prop.columnTypes[0]);
+        const isObjectEmbedded = this.prop.embedded && this.prop.object;
+        if ((platform.convertsJsonAutomatically() || isObjectEmbedded) && isJsonColumn && !context?.force) {
+            return value;
+        }
+        return platform.convertJsonToJSValue(value, context);
     }
     getColumnType(prop, platform) {
         return platform.getJsonDeclarationSQL();

package/types/Type.d.ts

@@ -3,6 +3,7 @@ import type { Platform } from '../platforms';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings';
 export interface TransformContext {
     fromQuery?: boolean;
+    force?: boolean;
     key?: string;
     mode?: 'hydration' | 'query' | 'query-data' | 'discovery' | 'serialization';
 }
@@ -23,7 +24,7 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
     /**
      * Converts a value from its database representation to its JS representation of this type.
      */
-    convertToJSValue(value: DBType, platform: Platform): JSType;
+    convertToJSValue(value: DBType, platform: Platform, context?: TransformContext): JSType;
     /**
      * Converts a value from its JS representation to its database representation of this type.
      */

package/types/Type.js

@@ -16,7 +16,7 @@ class Type {
     /**
      * Converts a value from its database representation to its JS representation of this type.
      */
-    convertToJSValue(value, platform) {
+    convertToJSValue(value, platform, context) {
         return value;
     }
     /**

package/unit-of-work/UnitOfWork.js

@@ -99,8 +99,8 @@ 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);
+                    const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                    data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
                 }
                 if (forceUndefined) {
                     if (data[key] === null) {