@mikro-orm/core 7.0.0-dev.12 → 7.0.0-dev.120

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

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

package/types/Uint8ArrayType.d.ts

@@ -5,6 +5,5 @@ export declare class Uint8ArrayType extends Type<Uint8Array | null> {
     convertToDatabaseValue(value: Uint8Array): Buffer;
     convertToJSValue(value: Buffer): Uint8Array | null;
     compareAsType(): string;
-    ensureComparable(): boolean;
     getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/Uint8ArrayType.js

@@ -7,7 +7,7 @@ export class Uint8ArrayType extends Type {
         return Buffer.from(value);
     }
     convertToJSValue(value) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!value) {
             return value;
         }
@@ -22,9 +22,6 @@ export class Uint8ArrayType extends Type {
     compareAsType() {
         return 'Buffer';
     }
-    ensureComparable() {
-        return false;
-    }
     getColumnType(prop, platform) {
         return platform.getBlobDeclarationSQL();
     }

package/types/index.d.ts

@@ -19,7 +19,7 @@ import { StringType } from './StringType.js';
 import { TextType } from './TextType.js';
 import { TimeType } from './TimeType.js';
 import { TinyIntType } from './TinyIntType.js';
-import { IType, TransformContext, Type } from './Type.js';
+import { type IType, type TransformContext, Type } from './Type.js';
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 import { UnknownType } from './UnknownType.js';
 import { UuidType } from './UuidType.js';