@mikro-orm/core 7.0.0-dev.9 → 7.0.0-dev.90

package/platforms/Platform.d.ts

@@ -1,7 +1,6 @@
-import { inspect } from 'node:util';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -30,7 +29,6 @@ export declare abstract class Platform {
     usesEnumCheckConstraints(): boolean;
     getSchemaHelper(): unknown;
     indexForeignKeys(): boolean;
-    allowsMultiInsert(): boolean;
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -48,11 +46,6 @@ export declare abstract class Platform {
      * Converts scalar primary key representation to native driver wrapper (e.g. string to mongodb's ObjectId)
      */
     denormalizePrimaryKey(data: IPrimaryKey): IPrimaryKey;
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -158,7 +151,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;
@@ -175,7 +168,9 @@ export declare abstract class Platform {
     getExtension<T>(extensionName: string, extensionKey: string, moduleName: string, em: EntityManager): T;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
     processDateProperty(value: unknown): string | number | Date;
-    quoteIdentifier(id: string, quote?: string): string;
+    quoteIdentifier(id: string | {
+        toString: () => string;
+    }, quote?: string): string;
     quoteValue(value: any): string;
     escape(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
@@ -193,7 +188,7 @@ export declare abstract class Platform {
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCustomPrimaryKeyNames(): boolean;
     isPopulated<T>(key: string, populate: readonly PopulateOptions<T>[] | boolean): boolean;
-    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean, ignoreInlineEmbeddables?: boolean): boolean;
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */
@@ -225,6 +220,4 @@ export declare abstract class Platform {
      * @internal
      */
     clone(): this;
-    /** @ignore */
-    [inspect.custom](): string;
 }

package/platforms/Platform.js

@@ -1,10 +1,9 @@
-import { inspect } from 'node:util';
 import { clone } from '../utils/clone.js';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
-import { ArrayType, BigIntType, BlobType, Uint8ArrayType, BooleanType, CharacterType, DateType, DecimalType, DoubleType, JsonType, SmallIntType, TimeType, TinyIntType, Type, UuidType, StringType, IntegerType, FloatType, DateTimeType, TextType, EnumType, UnknownType, MediumIntType, IntervalType, } from '../types/index.js';
-import { parseJsonSafe, Utils } from '../utils/Utils.js';
+import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
+import { parseJsonSafe } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { RawQueryFragment } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
@@ -48,9 +47,6 @@ export class Platform {
     indexForeignKeys() {
         return false;
     }
-    allowsMultiInsert() {
-        return true;
-    }
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -78,15 +74,6 @@ export class Platform {
     denormalizePrimaryKey(data) {
         return data;
     }
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field) {
-        return field;
-    }
-    usesDifferentSerializedPrimaryKey() {
-        return false;
-    }
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -133,7 +120,7 @@ export class Platform {
         return true;
     }
     isBigIntProperty(prop) {
-        return prop.columnTypes && prop.columnTypes[0] === 'bigint';
+        return prop.columnTypes?.[0] === 'bigint';
     }
     getDefaultSchemaName() {
         return undefined;
@@ -169,7 +156,7 @@ export class Platform {
         return `text`;
     }
     getEnumTypeDeclarationSQL(column) {
-        if (column.items?.every(item => Utils.isString(item))) {
+        if (column.items?.every(item => typeof item === 'string')) {
             return `enum('${column.items.join("','")}')`;
         }
         return this.getTinyIntTypeDeclarationSQL(column);
@@ -269,7 +256,7 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     getJsonIndexDefinition(index) {
         return index.columnNames;
     }
@@ -288,11 +275,7 @@ export 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 parseJsonSafe(value);
     }
     convertDateToJSValue(value) {
@@ -306,7 +289,7 @@ export class Platform {
     }
     parseDate(value) {
         const date = new Date(value);
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (isNaN(date.getTime())) {
             return value;
         }
@@ -336,19 +319,10 @@ export class Platform {
         if (extension) {
             return extension;
         }
-        /* v8 ignore next 4 */
-        const module = Utils.tryRequire({
-            module: moduleName,
-            warning: `Please install ${moduleName} package.`,
-        });
-        /* v8 ignore next 3 */
-        if (module) {
-            return this.config.getCachedService(module[extensionName], em);
-        }
-        /* v8 ignore next 2 */
-        throw new Error(`${extensionName} extension not registered.`);
+        /* v8 ignore next */
+        throw new Error(`${extensionName} extension not registered. Provide it in the ORM config, or use the async \`MikroORM.init()\` method to load extensions automatically.`);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         throw new Error(`${driver.constructor.name} does not support SchemaGenerator`);
     }
@@ -365,7 +339,7 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     escape(value) {
         return value;
     }
@@ -455,7 +429,7 @@ export class Platform {
     isPopulated(key, populate) {
         return populate === true || (populate !== false && populate.some(p => p.field === key || p.all));
     }
-    shouldHaveColumn(prop, populate, exclude, includeFormulas = true) {
+    shouldHaveColumn(prop, populate, exclude, includeFormulas = true, ignoreInlineEmbeddables = true) {
         if (exclude?.includes(prop.name)) {
             return false;
         }
@@ -475,7 +449,7 @@ export class Platform {
             return true;
         }
         if (prop.kind === ReferenceKind.EMBEDDED) {
-            return !!prop.object;
+            return prop.object || ignoreInlineEmbeddables;
         }
         return prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner;
     }
@@ -522,9 +496,9 @@ export class Platform {
     clone() {
         return this;
     }
-    /* v8 ignore next 4 */
     /** @ignore */
-    [inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[${this.constructor.name}]`;
     }
 }

package/serialization/EntitySerializer.d.ts

@@ -17,6 +17,8 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     forceObject?: boolean;
     /** Ignore custom property serializers. */
     ignoreSerializers?: boolean;
+    /** Include properties marked as `hidden`. */
+    includeHidden?: boolean;
     /** Skip properties with `null` value. */
     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. */

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,13 +41,31 @@ 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;
             }
@@ -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());

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,22 +27,32 @@ 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;
@@ -67,7 +77,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;
@@ -78,7 +88,7 @@ export class EntityTransformer {
                 const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
                 const populated = root.isMarkedAsPopulated(meta.className, 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 {
@@ -86,7 +96,7 @@ export class EntityTransformer {
                 const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
                 const populated = root.isMarkedAsPopulated(meta.className, 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 +105,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.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,13 +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;
         }

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);