@mikro-orm/core 6.3.11-dev.1 → 6.3.11-dev.10

package/entity/EntityLoader.js

@@ -26,11 +26,12 @@ class EntityLoader {
         if (entities.length === 0 || Utils_1.Utils.isEmpty(populate)) {
             return this.setSerializationContext(entities, populate, options);
         }
+        const meta = this.metadata.find(entityName);
         if (entities.some(e => !e.__helper)) {
             const entity = entities.find(e => !Utils_1.Utils.isEntity(e));
-            const meta = this.metadata.find(entityName);
             throw errors_1.ValidationError.notDiscoveredEntity(entity, meta, 'populate');
         }
+        const references = entities.filter(e => !(0, wrap_1.helper)(e).isInitialized());
         const visited = options.visited ??= new Set();
         options.where ??= {};
         options.orderBy ??= {};
@@ -39,6 +40,9 @@ class EntityLoader {
         options.validate ??= true;
         options.refresh ??= false;
         options.convertCustomTypes ??= true;
+        if (references.length > 0) {
+            await this.populateScalar(meta, references, options);
+        }
         populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup);
         const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
         /* istanbul ignore next */
@@ -121,7 +125,7 @@ class EntityLoader {
         if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !this.driver.getPlatform().usesPivotTable()) {
             const filtered = entities.filter(e => !e[prop.name]?.isInitialized());
             if (filtered.length > 0) {
-                await this.populateScalar(meta, filtered, options, prop);
+                await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] });
             }
         }
         if (prop.kind === enums_1.ReferenceKind.SCALAR && prop.lazy) {
@@ -129,7 +133,7 @@ class EntityLoader {
             if (options.ignoreLazyScalarProperties || filtered.length === 0) {
                 return entities;
             }
-            await this.populateScalar(meta, filtered, options, prop);
+            await this.populateScalar(meta, filtered, { ...options, fields: [prop.name] });
             return entities;
         }
         if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
@@ -147,14 +151,14 @@ class EntityLoader {
         this.initializeCollections(filtered, prop, field, data, innerOrderBy.length > 0);
         return data;
     }
-    async populateScalar(meta, filtered, options, prop) {
+    async populateScalar(meta, filtered, options) {
         const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
         const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
         const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
-        const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
+        const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
         await this.em.find(meta.className, where, {
             filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging,
-            fields: [prop.name],
+            fields: fields,
             populate: [],
         });
     }
@@ -466,7 +470,7 @@ class EntityLoader {
         return entities.filter(e => Utils_1.Utils.isCollection(e[field]) && !e[field].isInitialized(!ref));
     }
     isPropertyLoaded(entity, field) {
-        if (!entity) {
+        if (!entity || field === '*') {
             return true;
         }
         const wrapped = (0, wrap_1.helper)(entity);

package/hydration/ObjectHydrator.js

@@ -6,6 +6,7 @@ const Collection_1 = require("../entity/Collection");
 const Reference_1 = require("../entity/Reference");
 const Utils_1 = require("../utils/Utils");
 const enums_1 = require("../enums");
+const RawQueryFragment_1 = require("../utils/RawQueryFragment");
 class ObjectHydrator extends Hydrator_1.Hydrator {
     hydrators = {
         full: new Map(),
@@ -48,6 +49,15 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
         context.set('isPrimaryKey', Utils_1.Utils.isPrimaryKey);
         context.set('Collection', Collection_1.Collection);
         context.set('Reference', Reference_1.Reference);
+        const registerCustomType = (prop, convertorKey, method, context) => {
+            context.set(`${method}_${convertorKey}`, (val) => {
+                if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(val)) {
+                    return val;
+                }
+                return prop.customType[method](val, this.platform, { mode: 'serialization' });
+            });
+            return convertorKey;
+        };
         const hydrateScalar = (prop, object, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
@@ -66,8 +76,8 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
             ret.push(`    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             if (prop.customType) {
-                context.set(`convertToJSValue_${convertorKey}`, (val) => prop.customType.convertToJSValue(val, this.platform));
-                context.set(`convertToDatabaseValue_${convertorKey}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'hydration' }));
+                registerCustomType(prop, convertorKey, 'convertToJSValue', context);
+                registerCustomType(prop, convertorKey, 'convertToDatabaseValue', context);
                 ret.push(`    if (convertCustomTypes) {`, `      const value = convertToJSValue_${convertorKey}(data${dataKey});`);
                 if (prop.customType.ensureComparable(meta, prop)) {
                     ret.push(`      data${dataKey} = convertToDatabaseValue_${convertorKey}(value);`);
@@ -142,7 +152,7 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
                 }
             }
             if (prop.customType?.ensureComparable(meta, prop)) {
-                context.set(`convertToDatabaseValue_${this.safeKey(prop.name)}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'hydration' }));
+                registerCustomType(prop, this.safeKey(prop.name), 'convertToDatabaseValue', context);
                 ret.push(`  if (data${dataKey} != null && typeof data${dataKey} !== 'object' && convertCustomTypes) {`);
                 ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getPrimaryKey());`);
                 ret.push(`  }`);

package/logging/Logger.d.ts

@@ -1,17 +1,17 @@
-import type { Dictionary, Highlighter } from '../typings';
+import type { AnyString, Dictionary, Highlighter } from '../typings';
 export interface Logger {
     /**
      * Logs a message inside given namespace.
      */
-    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    log(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
     /**
      * Logs error message inside given namespace.
      */
-    error(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    error(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
     /**
      * Logs warning message inside given namespace.
      */
-    warn(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    warn(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
     /**
      * Logs a message inside given namespace.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.11-dev.1",
+  "version": "6.3.11-dev.10",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.11-dev.1",
+    "mikro-orm": "6.3.11-dev.10",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -175,6 +175,7 @@ export declare abstract class Platform {
     processDateProperty(value: unknown): string | number | Date;
     quoteIdentifier(id: string, quote?: string): string;
     quoteValue(value: any): string;
+    escape(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
     cloneEmbeddable<T>(data: T): T;
     setConfig(config: Configuration): void;

package/platforms/Platform.js

@@ -361,6 +361,10 @@ class Platform {
     quoteValue(value) {
         return value;
     }
+    /* istanbul ignore next */
+    escape(value) {
+        return value;
+    }
     formatQuery(sql, params) {
         if (params.length === 0) {
             return sql;

package/serialization/EntityTransformer.js

@@ -68,9 +68,6 @@ class EntityTransformer {
             }
             ret[this.propertyName(meta, prop, wrapped.__platform, raw)] = val;
         }
-        if (!visited) {
-            root.visited.delete(entity);
-        }
         if (!wrapped.isInitialized() && wrapped.hasPrimaryKey()) {
             return ret;
         }

package/utils/EntityComparator.d.ts

@@ -69,6 +69,7 @@ export declare class EntityComparator {
      */
     private shouldSerialize;
     private getEmbeddedPropertySnapshot;
+    private registerCustomType;
     private getPropertySnapshot;
     /**
      * @internal Highly performance-sensitive method.

package/utils/EntityComparator.js

@@ -5,6 +5,7 @@ const clone_1 = require("./clone");
 const enums_1 = require("../enums");
 const Utils_1 = require("./Utils");
 const JsonType_1 = require("../types/JsonType");
+const RawQueryFragment_1 = require("./RawQueryFragment");
 class EntityComparator {
     metadata;
     platform;
@@ -102,8 +103,7 @@ class EntityComparator {
                 }
                 else {
                     if (meta.properties[pk].customType) {
-                        const convertorKey = this.safeKey(pk);
-                        context.set(`convertToDatabaseValue_${convertorKey}`, (val) => meta.properties[pk].customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' }));
+                        const convertorKey = this.registerCustomType(meta.properties[pk], context);
                         lines.push(`    ${pk}: convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)}),`);
                     }
                     else {
@@ -121,8 +121,7 @@ class EntityComparator {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getPrimaryKey(true);`);
             }
             if (meta.properties[pk].customType) {
-                const convertorKey = this.safeKey(pk);
-                context.set(`convertToDatabaseValue_${convertorKey}`, (val) => meta.properties[pk].customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' }));
+                const convertorKey = this.registerCustomType(meta.properties[pk], context);
                 lines.push(`  return convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)});`);
             }
             else {
@@ -414,8 +413,7 @@ class EntityComparator {
                     .split('\n').map(l => padding + l).join('\n');
             }
             if (shouldProcessCustomType(childProp)) {
-                const convertorKey = this.safeKey(childProp.name);
-                context.set(`convertToDatabaseValue_${convertorKey}`, (val) => childProp.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' }));
+                const convertorKey = this.registerCustomType(childProp, context);
                 if (['number', 'string', 'boolean', 'bigint'].includes(childProp.customType.compareAsType().toLowerCase())) {
                     return `${padding}  if (${childCond}) ret${childDataKey} = convertToDatabaseValue_${convertorKey}(entity${childEntityKey});`;
                 }
@@ -428,8 +426,18 @@ class EntityComparator {
         }
         return `${ret}${padding}}`;
     }
-    getPropertySnapshot(meta, prop, context, dataKey, entityKey, path, level = 1, object) {
+    registerCustomType(prop, context) {
         const convertorKey = this.safeKey(prop.name);
+        context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
+            /* istanbul ignore if */
+            if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(val)) {
+                return val;
+            }
+            return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
+        });
+        return convertorKey;
+    }
+    getPropertySnapshot(meta, prop, context, dataKey, entityKey, path, level = 1, object) {
         const unwrap = prop.ref ? '?.unwrap()' : '';
         let ret = `  if (${this.getPropertyCondition(path)}) {\n`;
         if (['number', 'string', 'boolean'].includes(prop.type.toLowerCase())) {
@@ -444,7 +452,7 @@ class EntityComparator {
         if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE) {
             if (prop.mapToPk) {
                 if (prop.customType) {
-                    context.set(`convertToDatabaseValue_${convertorKey}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' }));
+                    const convertorKey = this.registerCustomType(prop, context);
                     ret += `    ret${dataKey} = convertToDatabaseValue_${convertorKey}(entity${entityKey});\n`;
                 }
                 else {
@@ -468,7 +476,7 @@ class EntityComparator {
             return ret + '  }\n';
         }
         if (prop.customType) {
-            context.set(`convertToDatabaseValue_${convertorKey}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' }));
+            const convertorKey = this.registerCustomType(prop, context);
             if (['number', 'string', 'boolean', 'bigint'].includes(prop.customType.compareAsType().toLowerCase())) {
                 return ret + `    ret${dataKey} = convertToDatabaseValue_${convertorKey}(entity${entityKey}${unwrap});\n  }\n`;
             }

package/utils/Utils.js

@@ -49,10 +49,12 @@ function compareObjects(a, b) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return a.sql === b.sql && compareArrays(a.params, b.params);
     }
-    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') {
-        return a.valueOf() === b.valueOf();
-    }
-    if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') {
+    if ((typeof a === 'function' && typeof b === 'function') ||
+        (typeof a === 'object' && a.client && ['Ref', 'Raw'].includes(a.constructor.name) && typeof b === 'object' && b.client && ['Ref', 'Raw'].includes(b.constructor.name)) || // knex qb
+        (a instanceof Date && b instanceof Date) ||
+        (a instanceof RegExp && b instanceof RegExp) ||
+        (a instanceof String && b instanceof String) ||
+        (a instanceof Number && b instanceof Number)) {
         return a.toString() === b.toString();
     }
     const keys = Object.keys(a);
@@ -881,8 +883,8 @@ class Utils {
             catch {
                 // ignore
             }
-            // For some reason, ".ts" files do not work with "file://" URLs on Windows.
-            if (id.endsWith('.ts')) {
+            // If the extension is not registered, we need to fall back to a file path.
+            if (require.extensions && !require.extensions[(0, node_path_1.extname)(id)]) {
                 id = (0, node_url_1.fileURLToPath)(id);
             }
         }