@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.35

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.35",
   "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",
@@ -54,7 +54,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.33",
+    "mikro-orm": "7.0.0-dev.35",
     "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;
@@ -195,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

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

@@ -91,7 +91,7 @@ type PrimaryPropToType<T, Keys extends (keyof T)[]> = {
 type ReadonlyPrimary<T> = T extends any[] ? Readonly<T> : T;
 export type Primary<T> = IsAny<T> extends true ? any : T extends {
     [PrimaryKeyProp]?: infer PK;
-} ? (PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : (PK extends (keyof T)[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK)) : T extends {
+} ? PK extends undefined ? Omit<T, typeof PrimaryKeyProp> : PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : PK extends (keyof T)[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK : T extends {
     _id?: infer PK;
 } ? ReadonlyPrimary<PK> | string : T extends {
     id?: infer PK;
@@ -451,7 +451,7 @@ export interface EntityMetadata<T = any> {
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
-    expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>) => MaybePromise<RawQueryFragment | object | string>);
+    expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>, stream?: boolean) => MaybePromise<RawQueryFragment | object | string>);
     discriminatorColumn?: EntityKey<T> | AnyString;
     discriminatorValue?: number | string;
     discriminatorMap?: Dictionary<string>;

package/unit-of-work/UnitOfWork.js

@@ -99,6 +99,10 @@ export class UnitOfWork {
                     }
                     data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
+                if (prop.hydrate === false && prop.customType?.ensureComparable(wrapped.__meta, prop)) {
+                    const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                    data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
+                }
                 if (forceUndefined) {
                     if (data[key] === null) {
                         data[key] = undefined;
@@ -194,6 +198,9 @@ export class UnitOfWork {
         if (this.queuedActions.has(meta.className) || this.queuedActions.has(meta.root.className)) {
             return true;
         }
+        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
+            return true;
+        }
         for (const entity of this.identityMap.getStore(meta).values()) {
             if (helper(entity).__initialized && helper(entity).isTouched()) {
                 return true;

package/utils/Configuration.d.ts

@@ -146,6 +146,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             fileName: (className: string) => string;
         };
         preferReadReplicas: true;
+        dynamicImportProvider: (id: string) => Promise<any>;
     };
     private readonly options;
     private readonly logger;
@@ -412,6 +413,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     };
     seeder: SeederOptions;
     preferReadReplicas: boolean;
+    dynamicImportProvider: (id: string) => Promise<unknown>;
     hashAlgorithm: 'md5' | 'sha256';
 }
 export type Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager> = Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions<D, EM>, keyof typeof Configuration.DEFAULTS>> & Partial<MikroORMOptions<D, EM>>;

package/utils/Configuration.js

@@ -134,6 +134,7 @@ export class Configuration {
             fileName: (className) => className,
         },
         preferReadReplicas: true,
+        dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
     };
     options;
     logger;
@@ -142,6 +143,9 @@ export class Configuration {
     cache = new Map();
     extensions = new Map();
     constructor(options, validate = true) {
+        if (options.dynamicImportProvider) {
+            Utils.setDynamicImportProvider(options.dynamicImportProvider);
+        }
         this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);
         this.options.preferTs ??= options.preferTs;

package/utils/EntityComparator.js

@@ -542,10 +542,7 @@ export class EntityComparator {
         context.set('compareObjects', compareObjects);
         context.set('equals', equals);
         for (const prop of meta.comparableProps) {
-            // skip properties that are not hydrated
-            if (prop.hydrate !== false) {
-                lines.push(this.getPropertyComparator(prop, context));
-            }
+            lines.push(this.getPropertyComparator(prop, context));
         }
         // also compare 1:1 inverse sides, important for `factory.mergeData`
         lines.push(`if (options?.includeInverseSides) {`);

package/utils/Utils.d.ts

@@ -15,6 +15,7 @@ export declare function equals(a: any, b: any): boolean;
 export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
     static readonly PK_SEPARATOR = "~~~";
+    static dynamicImportProvider: (id: string) => Promise<any>;
     /**
      * Checks if the argument is not undefined
      */
@@ -236,6 +237,7 @@ export declare class Utils {
      */
     static resolveModulePath(id: string, from?: string): string;
     static dynamicImport<T = any>(id: string): Promise<T>;
+    static setDynamicImportProvider(provider: (id: string) => Promise<unknown>): void;
     static ensureDir(path: string): void;
     static pathExistsSync(path: string): boolean;
     static readJSONSync(path: string): Dictionary;

package/utils/Utils.js

@@ -131,6 +131,8 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
+    /* v8 ignore next */
+    static dynamicImportProvider = (id) => import(id);
     /**
      * Checks if the argument is not undefined
      */
@@ -907,7 +909,11 @@ export class Utils {
     static async dynamicImport(id) {
         /* v8 ignore next */
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
-        return import(specifier);
+        return this.dynamicImportProvider(specifier);
+    }
+    /* v8 ignore next 3 */
+    static setDynamicImportProvider(provider) {
+        this.dynamicImportProvider = provider;
     }
     static ensureDir(path) {
         if (!existsSync(path)) {

package/utils/upsert-utils.d.ts

@@ -1,7 +1,12 @@
-import type { EntityData, EntityMetadata } from '../typings.js';
+import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { type RawQueryFragment } from '../utils/RawQueryFragment.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[];
 /** @internal */
 export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+/** @internal */
+export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | RawQueryFragment | undefined, data: EntityData<T>, where: FilterQuery<T>): {
+    where: FilterQuery<T>;
+    propIndex: number | false;
+};

package/utils/upsert-utils.js

@@ -1,3 +1,5 @@
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from './Utils.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -96,3 +98,44 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     }
     return keys.filter(key => !(key in data));
 }
+function getPropertyValue(obj, key) {
+    if (key.indexOf('.') === -1) {
+        return obj[key];
+    }
+    const parts = key.split('.');
+    let curr = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        curr[parts[i]] ??= {};
+        curr = curr[parts[i]];
+    }
+    return curr[parts[parts.length - 1]];
+}
+/** @internal */
+export function getWhereCondition(meta, onConflictFields, data, where) {
+    const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+    const propIndex = !isRaw(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+    if (onConflictFields || where == null) {
+        if (propIndex !== false && propIndex >= 0) {
+            let key = unique[propIndex];
+            if (key.includes('.')) {
+                const prop = meta.properties[key.substring(0, key.indexOf('.'))];
+                if (prop) {
+                    key = `${prop.fieldNames[0]}${key.substring(key.indexOf('.'))}`;
+                }
+            }
+            where = { [key]: getPropertyValue(data, unique[propIndex]) };
+        }
+        else if (meta.uniques.length > 0) {
+            for (const u of meta.uniques) {
+                if (Utils.asArray(u.properties).every(p => data[p] != null)) {
+                    where = Utils.asArray(u.properties).reduce((o, key) => {
+                        o[key] = data[key];
+                        return o;
+                    }, {});
+                    break;
+                }
+            }
+        }
+    }
+    return { where, propIndex };
+}