@mikro-orm/knex 6.4.2-dev.0 → 6.4.2-dev.10

package/AbstractSqlDriver.js

@@ -248,7 +248,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     relationPojo[prop.name] = root[alias];
                 }
             });
-            const targetProps = ref
+            const mapToPk = !!(ref || prop.mapToPk);
+            const targetProps = mapToPk
                 ? meta2.getPrimaryProps()
                 : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             const tz = this.platform.getTimezone();
@@ -290,7 +291,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             for (const prop of targetProps) {
                 prop.fieldNames.map(name => delete root[`${relationAlias}__${name}`]);
             }
-            if (ref) {
+            if (mapToPk) {
                 const tmp = Object.values(relationPojo);
                 /* istanbul ignore next */
                 relationPojo = (meta2.compositePK ? tmp : tmp[0]);
@@ -870,6 +871,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
                 return true;
             }
+            // skip redundant joins for 1:1 owner population hints when using `mapToPk`
+            if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
+                return false;
+            }
             if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
                 // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
                 return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
@@ -972,10 +977,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
             });
             const childExclude = exclude ? core_1.Utils.extractChildElements(exclude, prop.name) : exclude;
-            if (!ref) {
+            if (!ref && !prop.mapToPk) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path, count));
             }
-            else if (hint.filter) {
+            else if (hint.filter || prop.mapToPk) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.2-dev.0",
+  "version": "6.4.2-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",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.4.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.2-dev.0",
+    "@mikro-orm/core": "6.4.2-dev.10",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.d.ts

@@ -80,6 +80,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected aliasCounter: number;
     protected flags: Set<QueryFlag>;
     protected finalized: boolean;
+    protected populateHintFinalized: boolean;
     protected _joins: Dictionary<JoinOptions>;
     protected _explicitAlias: boolean;
     protected _schema?: string;
@@ -285,6 +286,8 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private getQueryBase;
     private applyDiscriminatorCondition;
     private finalize;
+    /** @internal */
+    processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
     private hasToManyJoins;

package/query/QueryBuilder.js

@@ -62,6 +62,7 @@ class QueryBuilder {
     aliasCounter = 0;
     flags = new Set([core_1.QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
+    populateHintFinalized = false;
     _joins = {};
     _explicitAlias = false;
     _schema;
@@ -150,7 +151,7 @@ class QueryBuilder {
         if (field) {
             this._fields = core_1.Utils.asArray(field);
         }
-        else if (this.hasToManyJoins()) {
+        else if (distinct || this.hasToManyJoins()) {
             this._fields = this.mainAlias.metadata.primaryKeys;
         }
         else {
@@ -699,7 +700,7 @@ class QueryBuilder {
         const res = await this.execute('all', true);
         const entities = [];
         function propagatePopulateHint(entity, hint) {
-            (0, core_1.helper)(entity).__serializationContext.populate ??= hint;
+            (0, core_1.helper)(entity).__serializationContext.populate = hint.concat((0, core_1.helper)(entity).__serializationContext.populate ?? []);
             hint.forEach(hint => {
                 const [propName] = hint.field.split(':', 2);
                 const value = core_1.Reference.unwrapReference(entity[propName]);
@@ -742,6 +743,7 @@ class QueryBuilder {
         }
         else {
             const qb = this.type === undefined ? this : this.clone();
+            qb.processPopulateHint(); // needs to happen sooner so `qb.hasToManyJoins()` reports correctly
             qb.count(field, distinct ?? qb.hasToManyJoins()).limit(undefined).offset(undefined).orderBy([]);
             res = await qb.execute('get', false);
         }
@@ -1121,30 +1123,7 @@ class QueryBuilder {
         }
         const meta = this.mainAlias.metadata;
         this.applyDiscriminatorCondition();
-        if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
-            const relationsToPopulate = this._populate.map(({ field }) => field);
-            meta.relations
-                .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name) && !relationsToPopulate.includes(`${prop.name}:ref`))
-                .map(prop => ({ field: `${prop.name}:ref` }))
-                .forEach(item => this._populate.push(item));
-        }
-        this._populate.forEach(({ field }) => {
-            const [fromAlias, fromField] = this.helper.splitField(field);
-            const aliasedField = `${fromAlias}.${fromField}`;
-            const join = Object.keys(this._joins).find(k => `${aliasedField}#${this._joins[k].alias}` === k);
-            if (join && this._joins[join] && this.helper.isOneToOneInverse(fromField)) {
-                this._populateMap[join] = this._joins[join].alias;
-                return;
-            }
-            if (meta && this.helper.isOneToOneInverse(fromField)) {
-                const prop = meta.properties[fromField];
-                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
-                const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-                this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
-                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
-                this._populateMap[aliasedName] = this._joins[aliasedName].alias;
-            }
-        });
+        this.processPopulateHint();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(core_1.QueryFlag.INCLUDE_LAZY_FORMULAS)))
@@ -1161,8 +1140,6 @@ class QueryBuilder {
             }))
                 .forEach(field => this._fields.push((0, core_1.raw)(field)));
         }
-        this.processPopulateWhere(false);
-        this.processPopulateWhere(true);
         core_1.QueryHelper.processObjectParams(this._data);
         core_1.QueryHelper.processObjectParams(this._cond);
         core_1.QueryHelper.processObjectParams(this._having);
@@ -1178,6 +1155,40 @@ class QueryBuilder {
         }
         this.finalized = true;
     }
+    /** @internal */
+    processPopulateHint() {
+        if (this.populateHintFinalized) {
+            return;
+        }
+        const meta = this.mainAlias.metadata;
+        if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
+            const relationsToPopulate = this._populate.map(({ field }) => field);
+            meta.relations
+                .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name) && !relationsToPopulate.includes(`${prop.name}:ref`))
+                .map(prop => ({ field: `${prop.name}:ref` }))
+                .forEach(item => this._populate.push(item));
+        }
+        this._populate.forEach(({ field }) => {
+            const [fromAlias, fromField] = this.helper.splitField(field);
+            const aliasedField = `${fromAlias}.${fromField}`;
+            const join = Object.keys(this._joins).find(k => `${aliasedField}#${this._joins[k].alias}` === k);
+            if (join && this._joins[join] && this.helper.isOneToOneInverse(fromField)) {
+                this._populateMap[join] = this._joins[join].alias;
+                return;
+            }
+            if (meta && this.helper.isOneToOneInverse(fromField)) {
+                const prop = meta.properties[fromField];
+                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
+                const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
+                this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
+                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
+                this._populateMap[aliasedName] = this._joins[aliasedName].alias;
+            }
+        });
+        this.processPopulateWhere(false);
+        this.processPopulateWhere(true);
+        this.populateHintFinalized = true;
+    }
     processPopulateWhere(filter) {
         const key = filter ? '_populateFilter' : '_populateWhere';
         if (this[key] == null || this[key] === core_1.PopulateHint.ALL) {
@@ -1233,7 +1244,9 @@ class QueryBuilder {
         }
     }
     hasToManyJoins() {
+        // console.log(this._joins);
         return Object.values(this._joins).some(join => {
+            // console.log(join.prop.name, join.prop.kind, [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind));
             return [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }

package/schema/SchemaHelper.d.ts

@@ -75,4 +75,6 @@ export declare abstract class SchemaHelper {
         ignoreSchema?: string[];
         managementDbName?: string;
     };
+    private processComment;
+    protected handleMultilineComment(comment: string): string;
 }

package/schema/SchemaHelper.js

@@ -147,7 +147,7 @@ class SchemaHelper {
         core_1.Utils.runIfNotEmpty(() => col.nullable(), column.nullable && guard('nullable'));
         core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable && !column.generated);
         core_1.Utils.runIfNotEmpty(() => col.unsigned(), column.unsigned);
-        core_1.Utils.runIfNotEmpty(() => col.comment(column.comment), column.comment);
+        core_1.Utils.runIfNotEmpty(() => col.comment(this.processComment(column.comment)), column.comment);
         this.configureColumnDefault(column, col, knex, changedProperties);
         return col;
     }
@@ -425,5 +425,11 @@ class SchemaHelper {
     get options() {
         return this.platform.getConfig().get('schemaGenerator');
     }
+    processComment(comment) {
+        return this.platform.getSchemaHelper().handleMultilineComment(comment);
+    }
+    handleMultilineComment(comment) {
+        return comment.replaceAll('\n', '\\n');
+    }
 }
 exports.SchemaHelper = SchemaHelper;