@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.300

package/serialization/EntitySerializer.js

@@ -15,8 +15,8 @@ function isVisible(meta, propName, options) {
     if (options.exclude?.find(item => item === propName)) {
         return false;
     }
-    const visible = prop && !prop.hidden;
-    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    const visible = prop && !(prop.hidden && !options.includeHidden);
+    const prefixed = prop && !prop.primary && !prop.accessor && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
     return visible && !prefixed;
 }
 function isPopulated(propName, options) {
@@ -41,23 +41,41 @@ export class EntitySerializer {
         }
         const root = wrapped.__serializationContext.root;
         const ret = {};
-        const keys = new Set(meta.primaryKeys);
-        Utils.keys(entity).forEach(prop => keys.add(prop));
+        const props = new Set();
+        if (meta.serializedPrimaryKey && !meta.compositePK) {
+            props.add(meta.serializedPrimaryKey);
+        }
+        else {
+            meta.primaryKeys.forEach(pk => props.add(pk));
+        }
+        if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
+            const entityKeys = new Set(Object.keys(entity));
+            for (const prop of meta.props) {
+                if (entityKeys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    props.add(prop.name);
+                }
+            }
+            for (const key of entityKeys) {
+                if (!meta.properties[key]) {
+                    props.add(key);
+                }
+            }
+        }
         const visited = root.visited.has(entity);
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             if (!isVisible(meta, prop, options)) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = this.processProperty(prop, entity, options);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (options.skipNull && Utils.isPlainObject(val)) {
                 Utils.dropUndefinedProperties(val, null);
@@ -67,7 +85,7 @@ export class EntitySerializer {
             }
             const visible = typeof val !== 'undefined' && !(val === null && options.skipNull);
             if (visible) {
-                ret[this.propertyName(meta, prop, wrapped.__platform)] = val;
+                ret[this.propertyName(meta, prop)] = val;
             }
         }
         if (contextCreated) {
@@ -81,26 +99,26 @@ export class EntitySerializer {
             if (prop.getterName != null) {
                 const visible = entity[prop.getterName] instanceof Function && isVisible(meta, prop.name, options);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, options);
+                    ret[this.propertyName(meta, prop.name)] = this.processProperty(prop.getterName, entity, options);
                 }
             }
             else {
                 // decorated getters
                 const visible = typeof entity[prop.name] !== 'undefined' && isVisible(meta, prop.name, options);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, options);
+                    ret[this.propertyName(meta, prop.name)] = this.processProperty(prop.name, entity, options);
                 }
             }
         }
         return ret;
     }
-    static propertyName(meta, prop, platform) {
-        /* v8 ignore next 3 */
+    static propertyName(meta, prop) {
+        /* v8 ignore next */
         if (meta.properties[prop]?.serializedName) {
             return meta.properties[prop].serializedName;
         }
-        if (meta.properties[prop]?.primary && platform) {
-            return platform.getSerializedPrimaryKeyField(prop);
+        if (meta.properties[prop]?.primary && meta.serializedPrimaryKey) {
+            return meta.serializedPrimaryKey;
         }
         return prop;
     }
@@ -119,7 +137,7 @@ export class EntitySerializer {
             }
             return returnValue;
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!options.ignoreSerializers && serializer) {
             return serializer(value);
         }
@@ -132,7 +150,7 @@ export class EntitySerializer {
         if (Utils.isScalarReference(value)) {
             return value.unwrap();
         }
-        /* v8 ignore next 9 */
+        /* v8 ignore next */
         if (property?.kind === ReferenceKind.EMBEDDED) {
             if (Array.isArray(value)) {
                 return value.map(item => helper(item).toJSON());
@@ -141,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,
@@ -165,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);
         }
@@ -192,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/serialization/EntityTransformer.js

@@ -6,7 +6,7 @@ import { isRaw } from '../utils/RawQueryFragment.js';
 function isVisible(meta, propName, ignoreFields = []) {
     const prop = meta.properties[propName];
     const visible = prop && !prop.hidden;
-    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    const prefixed = prop && !prop.primary && !prop.accessor && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
     return visible && !prefixed && !ignoreFields.includes(propName);
 }
 export class EntityTransformer {
@@ -27,39 +27,51 @@ export class EntityTransformer {
         const root = wrapped.__serializationContext.root;
         const meta = wrapped.__meta;
         const ret = {};
-        const keys = new Set();
+        const props = new Set();
         if (meta.serializedPrimaryKey && !meta.compositePK) {
-            keys.add(meta.serializedPrimaryKey);
+            props.add(meta.serializedPrimaryKey);
         }
         else {
-            meta.primaryKeys.forEach(pk => keys.add(pk));
+            meta.primaryKeys.forEach(pk => props.add(pk));
         }
         if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
-            Utils.keys(entity).forEach(prop => keys.add(prop));
+            const entityKeys = new Set(Object.keys(entity));
+            for (const prop of meta.props) {
+                if (entityKeys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    props.add(prop.name);
+                }
+            }
+            for (const key of entityKeys) {
+                if (!meta.properties[key]) {
+                    props.add(key);
+                }
+            }
         }
         const visited = root.visited.has(entity);
         const includePrimaryKeys = wrapped.__config.get('serialization').includePrimaryKeys;
         if (!visited) {
             root.visited.add(entity);
         }
-        for (const prop of keys) {
+        for (const prop of props) {
             const visible = raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields);
             if (!visible) {
                 continue;
             }
-            const populated = root.isMarkedAsPopulated(meta.className, prop);
-            const partiallyLoaded = root.isPartiallyLoaded(meta.className, prop);
-            const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
-            if (!partiallyLoaded && !populated && !isPrimary) {
-                continue;
+            const populated = root.isMarkedAsPopulated(meta.class, prop);
+            if (!raw) {
+                const partiallyLoaded = root.isPartiallyLoaded(meta.class, prop);
+                const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
+                if (!partiallyLoaded && !populated && !isPrimary) {
+                    continue;
+                }
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = EntityTransformer.processProperty(prop, entity, raw, populated);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (isRaw(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
@@ -67,7 +79,7 @@ export class EntityTransformer {
             if (typeof val === 'undefined') {
                 continue;
             }
-            ret[this.propertyName(meta, prop, wrapped.__platform, raw)] = val;
+            ret[this.propertyName(meta, prop, raw)] = val;
         }
         if (!wrapped.isInitialized() && wrapped.hasPrimaryKey()) {
             return ret;
@@ -76,17 +88,17 @@ export class EntityTransformer {
             // decorated get methods
             if (prop.getterName != null) {
                 const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
+                    ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
                 }
             }
             else {
                 // decorated getters
                 const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
-                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.name, entity, raw, populated);
+                    ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.name, entity, raw, populated);
                 }
             }
         }
@@ -95,15 +107,15 @@ export class EntityTransformer {
         }
         return ret;
     }
-    static propertyName(meta, prop, platform, raw) {
+    static propertyName(meta, prop, raw) {
         if (raw) {
             return prop;
         }
         if (meta.properties[prop].serializedName) {
             return meta.properties[prop].serializedName;
         }
-        if (meta.properties[prop].primary && platform) {
-            return platform.getSerializedPrimaryKeyField(prop);
+        if (meta.properties[prop].primary && meta.serializedPrimaryKey) {
+            return meta.serializedPrimaryKey;
         }
         return prop;
     }

package/serialization/SerializationContext.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityMetadata, PopulateOptions } from '../typings.js';
+import type { AnyEntity, EntityMetadata, EntityName, PopulateOptions } from '../typings.js';
 import type { Configuration } from '../utils/Configuration.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
@@ -10,21 +10,21 @@ export declare class SerializationContext<T extends object> {
     private readonly populate;
     private readonly fields?;
     private readonly exclude?;
-    readonly path: [string, string][];
+    readonly path: [EntityName, string][];
     readonly visited: Set<Partial<any>>;
     private entities;
     constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
     /**
      * Returns true when there is a cycle detected.
      */
-    visit(entityName: string, prop: string): boolean;
-    leave<U>(entityName: string, prop: string): void;
+    visit(entityName: EntityName, prop: string): boolean;
+    leave(entityName: EntityName, prop: string): void;
     close(): void;
     /**
      * When initializing new context, we need to propagate it to the whole entity graph recursively.
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
-    isMarkedAsPopulated(entityName: string, prop: string): boolean;
-    isPartiallyLoaded(entityName: string, prop: string): boolean;
+    isMarkedAsPopulated(entityName: EntityName, prop: string): boolean;
+    isPartiallyLoaded(entityName: EntityName, prop: string): boolean;
     private register;
 }

package/serialization/SerializationContext.js

@@ -36,8 +36,8 @@ export class SerializationContext {
     }
     leave(entityName, prop) {
         const last = this.path.pop();
-        /* v8 ignore next 3 */
-        if (!last || last[0] !== entityName || last[1] !== prop) {
+        /* v8 ignore next */
+        if (last?.[0] !== entityName || last[1] !== prop) {
             throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
         }
     }
@@ -73,18 +73,21 @@ export class SerializationContext {
         }
     }
     isMarkedAsPopulated(entityName, prop) {
-        let populate = this.populate;
+        let populate = this.populate ?? [];
         for (const segment of this.path) {
-            if (!populate) {
-                return false;
-            }
-            const exists = populate.find(p => p.field === segment[1]);
-            if (exists) {
-                // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
-                if (exists.all) {
-                    return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+            const hints = populate.filter(p => p.field === segment[1]);
+            if (hints.length > 0) {
+                const childHints = [];
+                for (const hint of hints) {
+                    // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
+                    if (hint.all) {
+                        return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+                    }
+                    if (hint.children) {
+                        childHints.push(...hint.children);
+                    }
                 }
-                populate = exists.children;
+                populate = childHints;
             }
         }
         return !!populate?.some(p => p.field === prop);
@@ -95,7 +98,7 @@ export class SerializationContext {
         }
         let fields = [...this.fields];
         for (const segment of this.path) {
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (fields.length === 0) {
                 return true;
             }

package/types/ArrayType.d.ts

@@ -1,4 +1,4 @@
-import { Type, type TransformContext } from './Type.js';
+import { type TransformContext, Type } from './Type.js';
 import type { EntityProperty } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {

package/types/ArrayType.js

@@ -1,5 +1,4 @@
 import { Type } from './Type.js';
-import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
 export class ArrayType extends Type {
     toJsValue;
@@ -16,7 +15,7 @@ export class ArrayType extends Type {
         if (Array.isArray(value)) {
             return platform.marshallArray(value.map(i => this.toDbValue(i)));
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (context?.fromQuery) {
             return value;
         }
@@ -26,7 +25,7 @@ export class ArrayType extends Type {
         if (value == null) {
             return value;
         }
-        if (Utils.isString(value)) {
+        if (typeof value === 'string') {
             value = platform.unmarshallArray(value);
         }
         return value.map(i => this.toJsValue(i));

package/types/BigIntType.d.ts

@@ -5,12 +5,15 @@ import type { EntityProperty } from '../typings.js';
  * This type will automatically convert string values returned from the database to native JS bigints (default)
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
-export declare class BigIntType extends Type<string | bigint | number | null | undefined, string | null | undefined> {
-    mode?: "bigint" | "number" | "string" | undefined;
-    constructor(mode?: "bigint" | "number" | "string" | undefined);
-    convertToDatabaseValue(value: string | bigint | null | undefined): string | null | undefined;
-    convertToJSValue(value: string | bigint | null | undefined): bigint | number | string | null | undefined;
-    toJSON(value: string | bigint | null | undefined): string | bigint | null | undefined;
+export declare class BigIntType<Mode extends 'bigint' | 'number' | 'string' = 'bigint'> extends Type<JSTypeByMode<Mode> | null | undefined, string | null | undefined> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToDatabaseValue(value: JSTypeByMode<Mode> | null | undefined): string | null | undefined;
+    convertToJSValue(value: string | bigint | null | undefined): JSTypeByMode<Mode> | null | undefined;
+    toJSON(value: JSTypeByMode<Mode> | null | undefined): JSTypeByMode<Mode> | null | undefined;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    compareValues(a: string, b: string): boolean;
 }
+type JSTypeByMode<Mode extends 'bigint' | 'number' | 'string'> = Mode extends 'bigint' ? bigint : Mode extends 'number' ? number : string;
+export {};

package/types/BigIntType.js

@@ -16,7 +16,7 @@ export class BigIntType extends Type {
         return '' + value;
     }
     convertToJSValue(value) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (value == null) {
             return value;
         }
@@ -42,4 +42,7 @@ export class BigIntType extends Type {
     compareAsType() {
         return this.mode ?? 'bigint';
     }
+    compareValues(a, b) {
+        return String(a) === String(b);
+    }
 }

package/types/BlobType.d.ts

@@ -4,6 +4,5 @@ import type { EntityProperty } from '../typings.js';
 export declare class BlobType extends Uint8ArrayType {
     convertToJSValue(value: Buffer): Buffer | null;
     compareAsType(): string;
-    ensureComparable(): boolean;
     getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/BlobType.js

@@ -12,9 +12,6 @@ export class BlobType extends Uint8ArrayType {
     compareAsType() {
         return 'Buffer';
     }
-    ensureComparable() {
-        return false;
-    }
     getColumnType(prop, platform) {
         return platform.getBlobDeclarationSQL();
     }

package/types/BooleanType.d.ts

@@ -1,8 +1,9 @@
 import { Type } from './Type.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
-export declare class BooleanType extends Type<number | null | undefined, number | null | undefined> {
+export declare class BooleanType extends Type<boolean | null | undefined, boolean | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    convertToJSValue(value: boolean | null | undefined): boolean | null | undefined;
     ensureComparable(): boolean;
 }

package/types/BooleanType.js

@@ -6,6 +6,9 @@ export class BooleanType extends Type {
     compareAsType() {
         return 'boolean';
     }
+    convertToJSValue(value) {
+        return Boolean(value);
+    }
     ensureComparable() {
         return false;
     }

package/types/DecimalType.d.ts

@@ -4,12 +4,14 @@ import type { EntityProperty } from '../typings.js';
 /**
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
-export declare class DecimalType extends Type<string | number, string> {
-    mode?: "number" | "string" | undefined;
-    constructor(mode?: "number" | "string" | undefined);
-    convertToJSValue(value: string): number | string;
+export declare class DecimalType<Mode extends 'number' | 'string' = 'string'> extends Type<JSTypeByMode<Mode>, string> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToJSValue(value: string): JSTypeByMode<Mode>;
     compareValues(a: string, b: string): boolean;
     private format;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
 }
+type JSTypeByMode<Mode extends 'number' | 'string'> = Mode extends 'number' ? number : string;
+export {};

package/types/DecimalType.js

@@ -8,18 +8,18 @@ export class DecimalType extends Type {
         super();
         this.mode = mode;
     }
-    /* v8 ignore next 7 */
+    /* v8 ignore next */
     convertToJSValue(value) {
         if ((this.mode ?? this.prop?.runtimeType) === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     compareValues(a, b) {
         return this.format(a) === this.format(b);
     }
     format(val) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (this.prop?.scale == null) {
             return +val;
         }

package/types/DoubleType.js

@@ -3,12 +3,12 @@ import { Type } from './Type.js';
  * Type that maps an SQL DOUBLE to a JS string or number.
  */
 export class DoubleType extends Type {
-    /* v8 ignore next 7 */
+    /* v8 ignore next */
     convertToJSValue(value) {
         if (this.prop?.runtimeType === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     getColumnType(prop, platform) {
         return platform.getDoubleDeclarationSQL();

package/types/EnumArrayType.js

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 import { ArrayType } from './ArrayType.js';
 import { ValidationError } from '../errors.js';
 function mapHydrator(items, hydrate) {
@@ -19,7 +18,7 @@ export class EnumArrayType extends ArrayType {
         if (Array.isArray(value) && Array.isArray(this.items)) {
             const invalid = value.filter(v => !this.items.includes(v));
             if (invalid.length > 0) {
-                throw new ValidationError(`Invalid enum array items provided in ${this.owner}: ${inspect(invalid)}`);
+                throw ValidationError.invalidEnumArrayItems(this.owner, invalid);
             }
         }
         return super.convertToDatabaseValue(value, platform, context);

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

@@ -12,8 +12,13 @@ export class JsonType extends 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/TinyIntType.js

@@ -6,7 +6,7 @@ export class TinyIntType extends Type {
     compareAsType() {
         return 'number';
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     ensureComparable() {
         return false;
     }

package/types/Type.d.ts

@@ -1,8 +1,8 @@
-import { inspect } from 'node:util';
 import type { Platform } from '../platforms/Platform.js';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings.js';
 export interface TransformContext {
     fromQuery?: boolean;
+    force?: boolean;
     key?: string;
     mode?: 'hydration' | 'query' | 'query-data' | 'discovery' | 'serialization';
 }
@@ -23,7 +23,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.
      */
@@ -78,6 +78,4 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
      * Checks whether the argument is instance of `Type`.
      */
     static isMappedType(data: any): data is Type<any>;
-    /** @ignore */
-    [inspect.custom](depth?: number): string;
 }

package/types/Type.js

@@ -1,4 +1,4 @@
-import { inspect } from 'node:util';
+import { inspect } from '../logging/inspect.js';
 export class Type {
     static types = new Map();
     platform;
@@ -13,7 +13,7 @@ export 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;
     }
     /**
@@ -65,7 +65,7 @@ export class Type {
         return !!data?.__mappedType;
     }
     /** @ignore */
-    [inspect.custom](depth = 2) {
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };
         const hidden = ['prop', 'platform', 'meta'];
         hidden.forEach(k => delete object[k]);