@mikro-orm/core 7.0.0-dev.21 → 7.0.0-dev.211

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,49 @@ 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 populated = root.isMarkedAsPopulated(meta.class, prop);
+            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 +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;
@@ -76,17 +86,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 +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.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';