@mikro-orm/core 7.0.0-dev.5 → 7.0.0-dev.50

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.5",
+  "version": "7.0.0-dev.50",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -52,10 +52,10 @@
   },
   "dependencies": {
     "dataloader": "2.2.3",
-    "dotenv": "16.4.7",
+    "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "globby": "11.1.0",
-    "mikro-orm": "7.0.0-dev.5",
-    "reflect-metadata": "0.2.2"
+    "mikro-orm": "7.0.0-dev.50",
+    "reflect-metadata": "0.2.2",
+    "tinyglobby": "0.2.13"
   }
 }

package/platforms/Platform.d.ts

@@ -158,7 +158,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 +175,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 +195,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)
      */

package/platforms/Platform.js

@@ -133,7 +133,7 @@ export class Platform {
         return true;
     }
     isBigIntProperty(prop) {
-        return prop.columnTypes && prop.columnTypes[0] === 'bigint';
+        return prop.columnTypes?.[0] === 'bigint';
     }
     getDefaultSchemaName() {
         return undefined;
@@ -288,11 +288,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) {
@@ -455,7 +451,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 +471,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;
     }

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

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;

package/serialization/SerializationContext.js

@@ -37,7 +37,7 @@ export class SerializationContext {
     leave(entityName, prop) {
         const last = this.path.pop();
         /* v8 ignore next 3 */
-        if (!last || last[0] !== entityName || last[1] !== prop) {
+        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);

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

@@ -42,4 +42,7 @@ export class BigIntType extends Type {
     compareAsType() {
         return this.mode ?? 'bigint';
     }
+    compareValues(a, b) {
+        return String(a) === String(b);
+    }
 }

package/types/BooleanType.d.ts

@@ -1,7 +1,7 @@
 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;
     ensureComparable(): boolean;

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

@@ -13,7 +13,7 @@ export class DecimalType extends Type {
         if ((this.mode ?? this.prop?.runtimeType) === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     compareValues(a, b) {
         return this.format(a) === this.format(b);

package/types/DoubleType.js

@@ -8,7 +8,7 @@ export class DoubleType extends Type {
         if (this.prop?.runtimeType === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     getColumnType(prop, platform) {
         return platform.getDoubleDeclarationSQL();

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/Type.d.ts

@@ -3,6 +3,7 @@ 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 +24,7 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
     /**
      * Converts a value from its database representation to its JS representation of this type.
      */
-    convertToJSValue(value: DBType, platform: Platform): JSType;
+    convertToJSValue(value: DBType, platform: Platform, context?: TransformContext): JSType;
     /**
      * Converts a value from its JS representation to its database representation of this type.
      */

package/types/Type.js

@@ -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;
     }
     /**

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