@mikro-orm/knex 6.0.0-dev.13 → 6.0.0-dev.130

package/query/QueryBuilderHelper.js

@@ -8,6 +8,14 @@ const enums_1 = require("./enums");
  * @internal
  */
 class QueryBuilderHelper {
+    entityName;
+    alias;
+    aliasMap;
+    subQueries;
+    knex;
+    driver;
+    platform;
+    metadata;
     constructor(entityName, alias, aliasMap, subQueries, knex, driver) {
         this.entityName = entityName;
         this.alias = alias;
@@ -19,6 +27,10 @@ class QueryBuilderHelper {
         this.metadata = this.driver.getMetadata();
     }
     mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
+        if (core_1.Utils.isRawSql(field)) {
+            return this.knex.raw(field.sql, field.params);
+        }
+        /* istanbul ignore next */
         if (typeof field !== 'string') {
             return field;
         }
@@ -29,22 +41,42 @@ class QueryBuilderHelper {
             for (const p of fields) {
                 const [a, f] = this.splitField(p);
                 const prop = this.getProperty(f, a);
-                if (prop) {
+                const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
+                if (fkIdx2 !== -1) {
+                    parts.push(this.mapper(a !== this.alias ? `${a}.${prop.fieldNames[fkIdx2]}` : prop.fieldNames[fkIdx2], type, value, alias));
+                }
+                else if (prop) {
                     parts.push(...prop.fieldNames.map(f => this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias)));
                 }
                 else {
                     parts.push(this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias));
                 }
             }
+            // flatten the value if we see we are expanding nested composite key
+            // hackish, but cleaner solution would require quite a lot of refactoring
+            if (fields.length !== parts.length && Array.isArray(value)) {
+                value.forEach(row => {
+                    if (Array.isArray(row)) {
+                        const tmp = core_1.Utils.flatten(row);
+                        row.length = 0;
+                        row.push(...tmp);
+                    }
+                });
+            }
             return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
         }
-        let ret = field;
-        const customExpression = QueryBuilderHelper.isCustomExpression(field, !!alias);
+        const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+        if (rawField) {
+            return this.knex.raw(rawField.sql, rawField.params);
+        }
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
+        const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
+        const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
+        let ret = field;
         // embeddable nested path instead of a regular property with table alias, reset alias
         if (prop?.name === a && prop.embeddedProps[f]) {
-            return this.alias + '.' + prop.fieldNames[0];
+            return this.alias + '.' + prop.fieldNames[fkIdx];
         }
         const noPrefix = prop && prop.persist === false;
         if (prop?.fieldNameRaw) {
@@ -56,24 +88,29 @@ class QueryBuilderHelper {
             const as = alias === null ? '' : ` as ${aliased}`;
             return this.knex.raw(`${prop.formula(alias2)}${as}`);
         }
-        if (prop?.customType?.convertToJSValueSQL) {
-            const prefixed = this.prefix(field, isTableNameAliasRequired, true);
-            const valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
+        if (prop?.hasConvertToJSValueSQL) {
+            let valueSQL;
+            if (prop.fieldNames.length > 1 && fkIdx !== -1) {
+                const fk = prop.targetMeta.getPrimaryProps()[fkIdx];
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true, fkIdx);
+                valueSQL = fk.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
+            else {
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true);
+                valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
             if (alias === null) {
                 return this.knex.raw(valueSQL);
             }
-            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[0])}`);
+            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
         // do not wrap custom expressions
-        if (!customExpression) {
-            ret = this.prefix(field);
+        if (!rawField) {
+            ret = this.prefix(field, false, false, fkIdx);
         }
         if (alias) {
             ret += ' as ' + alias;
         }
-        if (customExpression) {
-            return this.knex.raw(ret, value);
-        }
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
         }
@@ -84,88 +121,104 @@ class QueryBuilderHelper {
             return data.map(d => this.processData(d, convertCustomTypes, true));
         }
         const meta = this.metadata.find(this.entityName);
-        data = this.mapData(data, meta?.properties, convertCustomTypes);
+        data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
         if (!core_1.Utils.hasObjectKeys(data) && meta && multi) {
             /* istanbul ignore next */
             data[meta.primaryKeys[0]] = this.platform.usesDefaultKeyword() ? this.knex.raw('default') : undefined;
         }
         return data;
     }
-    joinOneToReference(prop, ownerAlias, alias, type, cond = {}) {
+    joinOneToReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
         const table = this.getTableName(prop.type);
-        const schema = this.driver.getSchemaName(prop.targetMeta);
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
+        schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
         return {
             prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
         };
     }
-    joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}) {
+    joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
             prop, type, cond, ownerAlias, alias,
             table: this.getTableName(prop.type),
-            schema: this.driver.getSchemaName(prop.targetMeta),
+            schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
         };
     }
-    joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path) {
+    joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path, schema) {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
-                prop, type, cond, ownerAlias,
+                prop, type, ownerAlias,
                 alias: pivotAlias,
                 inverseAlias: alias,
                 joinColumns: prop.joinColumns,
                 inverseJoinColumns: prop.inverseJoinColumns,
                 primaryKeys: prop.referencedColumnNames,
+                cond: {},
                 table: pivotMeta.tableName,
-                schema: this.driver.getSchemaName(pivotMeta),
+                schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(pivotMeta, { schema }),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
-        if (type === 'pivotJoin') {
+        if (type === enums_1.JoinType.pivotJoin) {
             return ret;
         }
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
-        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type);
+        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
+        const tmp = prop2.referencedTableName.split('.');
+        ret[`${pivotAlias}.${prop2.name}#${alias}`].schema ??= tmp.length > 1 ? tmp[0] : undefined;
         return ret;
     }
-    joinPivotTable(field, prop, ownerAlias, alias, type, cond = {}) {
-        const pivotMeta = this.metadata.find(field);
-        const prop2 = pivotMeta.relations[0] === prop ? pivotMeta.relations[1] : pivotMeta.relations[0];
-        return {
-            prop, type, cond, ownerAlias, alias,
-            table: pivotMeta.collection,
-            schema: pivotMeta.schema,
-            joinColumns: prop.joinColumns,
-            inverseJoinColumns: prop2.joinColumns,
-            primaryKeys: prop.referencedColumnNames,
-        };
-    }
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
-            let table = `${join.table} as ${join.alias}`;
-            const method = join.type === 'innerJoin' ? 'inner join' : 'left join';
+            let table = join.table;
+            const method = join.type === enums_1.JoinType.pivotJoin ? 'left join' : join.type;
+            const conditions = [];
+            const params = [];
             schema = join.schema && join.schema !== '*' ? join.schema : schema;
             if (schema) {
                 table = `${schema}.${table}`;
             }
-            const conditions = [];
-            const params = [];
-            join.primaryKeys.forEach((primaryKey, idx) => {
-                const left = `${join.ownerAlias}.${primaryKey}`;
-                const right = `${join.alias}.${join.joinColumns[idx]}`;
-                conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
-            });
+            if (!join.subquery) {
+                join.primaryKeys.forEach((primaryKey, idx) => {
+                    const right = `${join.alias}.${join.joinColumns[idx]}`;
+                    if (join.prop.formula) {
+                        const left = join.prop.formula(join.ownerAlias);
+                        conditions.push(`${left} = ${this.knex.ref(right)}`);
+                        return;
+                    }
+                    const left = `${join.ownerAlias}.${primaryKey}`;
+                    conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
+                });
+            }
+            if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
+                const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
+                const alias = join.inverseAlias ?? join.alias;
+                join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
+            }
             Object.keys(join.cond).forEach(key => {
-                conditions.push(this.processJoinClause(key, join.cond[key], params));
+                const needsPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
+                const newKey = needsPrefix ? key : `${join.alias}.${key}`;
+                conditions.push(this.processJoinClause(newKey, join.cond[key], params));
             });
-            return qb.joinRaw(`${method} ${this.knex.ref(table)} on ${conditions.join(' and ')}`, params);
+            let sql = method + ' ';
+            if (join.subquery) {
+                sql += `(${join.subquery})`;
+            }
+            else {
+                sql += this.knex.ref(table);
+            }
+            sql += ` as ${this.knex.ref(join.alias)}`;
+            if (conditions.length > 0) {
+                sql += ` on ${conditions.join(' and ')}`;
+            }
+            return qb.joinRaw(sql, params);
         });
     }
     processJoinClause(key, value, params, operator = '$eq') {
@@ -212,20 +265,14 @@ class QueryBuilderHelper {
         if (operator === '$exists') {
             value = null;
         }
-        if (QueryBuilderHelper.isCustomExpression(key)) {
-            // unwind parameters when ? found in field name
-            const count = key.concat('?').match(/\?/g).length - 1;
-            const values = core_1.Utils.asArray(value);
-            const params1 = values.slice(0, count).map((c) => core_1.Utils.isObject(c) ? JSON.stringify(c) : c);
-            const params2 = values.slice(count);
-            const k = this.mapper(key, enums_1.QueryType.SELECT, params1);
-            const { sql, bindings } = k.toSQL().toNative();
-            if (params2.length > 0) {
-                params.push(...bindings);
-                params.push(...params2);
-                return sql + ' = ?';
+        const rawField = core_1.RawQueryFragment.getKnownFragment(key);
+        if (rawField) {
+            let sql = rawField.sql;
+            params.push(...rawField.params);
+            params.push(...core_1.Utils.asArray(value));
+            if (core_1.Utils.asArray(value).length > 0) {
+                sql += ' = ?';
             }
-            params.push(...bindings);
             return sql;
         }
         const sql = this.mapper(key);
@@ -241,7 +288,7 @@ class QueryBuilderHelper {
         return `(${parts.join(` ${core_1.GroupOperator[operator]} `)})`;
     }
     mapJoinColumns(type, join) {
-        if (join.prop && join.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !join.prop.owner) {
+        if (join.prop && join.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !join.prop.owner) {
             return join.prop.fieldNames.map((fieldName, idx) => {
                 return this.mapper(`${join.alias}.${join.inverseJoinColumns[idx]}`, type, undefined, fieldName);
             });
@@ -251,10 +298,10 @@ class QueryBuilderHelper {
             ...join.inverseJoinColumns.map(col => this.mapper(`${join.alias}.${col}`, type, undefined, `fk__${col}`)),
         ];
     }
-    isOneToOneInverse(field) {
-        const meta = this.metadata.find(this.entityName);
+    isOneToOneInverse(field, meta) {
+        meta ??= this.metadata.find(this.entityName);
         const prop = meta.properties[field];
-        return prop && prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner;
+        return prop && prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
@@ -293,13 +340,13 @@ class QueryBuilderHelper {
     }
     appendOnConflictClause(type, onConflict, qb) {
         onConflict.forEach(item => {
-            const sub = qb.onConflict(item.fields);
+            const sub = item.fields.length > 0 ? qb.onConflict(item.fields) : qb.onConflict();
             core_1.Utils.runIfNotEmpty(() => sub.ignore(), item.ignore);
             core_1.Utils.runIfNotEmpty(() => {
                 let mergeParam = item.merge;
                 if (core_1.Utils.isObject(item.merge)) {
                     mergeParam = {};
-                    Object.keys(item.merge).forEach(key => {
+                    core_1.Utils.keys(item.merge).forEach(key => {
                         const k = this.mapper(key, type);
                         mergeParam[k] = item.merge[key];
                     });
@@ -330,38 +377,37 @@ class QueryBuilderHelper {
     }
     appendQuerySubCondition(qb, type, method, cond, key, operator) {
         const m = operator === '$or' ? 'orWhere' : method;
+        if (cond[key] instanceof core_1.RawQueryFragment) {
+            cond[key] = this.knex.raw(cond[key].sql, cond[key].params);
+        }
         if (this.isSimpleRegExp(cond[key])) {
             return void qb[m](this.mapper(key, type), 'like', this.getRegExpParam(cond[key]));
         }
         if (core_1.Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
             return this.processObjectSubCondition(cond, key, qb, method, m, type);
         }
-        if (QueryBuilderHelper.isCustomExpression(key)) {
-            return this.processCustomExpression(qb, m, key, cond, type);
-        }
         const op = cond[key] === null ? 'is' : '=';
+        const raw = core_1.RawQueryFragment.getKnownFragment(key);
+        if (raw) {
+            const value = core_1.Utils.asArray(cond[key]);
+            if (value.length > 0) {
+                return void qb[m](this.knex.raw(raw.sql, raw.params), op, value[0]);
+            }
+            return void qb[m](this.knex.raw(raw.sql, raw.params));
+        }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), op, cond[key]);
         }
         qb[m](this.mapper(key, type, cond[key], null), op, cond[key]);
     }
-    processCustomExpression(clause, m, key, cond, type) {
-        // unwind parameters when ? found in field name
-        const count = key.concat('?').match(/\?/g).length - 1;
-        const value = core_1.Utils.asArray(cond[key]);
-        const params1 = value.slice(0, count).map((c) => core_1.Utils.isObject(c) ? JSON.stringify(c) : c);
-        const params2 = value.slice(count);
-        const k = this.mapper(key, type, params1);
-        if (params2.length > 0) {
-            const val = params2.length === 1 && params2[0] === null ? null : this.knex.raw('?', params2);
-            return void clause[m](k, val);
-        }
-        clause[m](k);
-    }
     processObjectSubCondition(cond, key, qb, method, m, type) {
         // grouped condition for one field
         let value = cond[key];
-        if (core_1.Utils.getObjectKeysSize(value) > 1) {
+        const size = core_1.Utils.getObjectKeysSize(value);
+        if (core_1.Utils.isPlainObject(value) && size === 0) {
+            return;
+        }
+        if (size > 1) {
             const subCondition = Object.entries(value).map(([subKey, subValue]) => ({ [key]: { [subKey]: subValue } }));
             return subCondition.forEach(sub => this.appendQueryCondition(type, sub, qb, '$and', method));
         }
@@ -370,13 +416,15 @@ class QueryBuilderHelper {
         }
         // operators
         const op = Object.keys(core_1.QueryOperator).find(op => op in value);
+        /* istanbul ignore next */
         if (!op) {
             throw new Error(`Invalid query condition: ${(0, util_1.inspect)(cond)}`);
         }
         const replacement = this.getOperatorReplacement(op, value);
         const fields = core_1.Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op]) && !value[op].every((v) => Array.isArray(v))) {
-            value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, value[op]);
+            const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
+            value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, tmp);
         }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), replacement, value[op]);
@@ -394,7 +442,8 @@ class QueryBuilderHelper {
             }));
         }
         else {
-            qb[m](this.mapper(key, type, undefined, null), replacement, value[op]);
+            const mappedKey = this.mapper(key, type, value[op], null);
+            qb[m](mappedKey, replacement, value[op]);
         }
     }
     getOperatorReplacement(op, value) {
@@ -422,36 +471,63 @@ class QueryBuilderHelper {
     }
     getQueryOrderFromObject(type, orderBy, populate) {
         const ret = [];
-        Object.keys(orderBy).forEach(k => {
-            const direction = orderBy[k];
+        Object.keys(orderBy).forEach(key => {
+            const direction = orderBy[key];
             const order = core_1.Utils.isNumber(direction) ? core_1.QueryOrderNumeric[direction] : direction;
-            if (QueryBuilderHelper.isCustomExpression(k)) {
-                ret.push(`${k} ${order.toLowerCase()}`);
+            const raw = core_1.RawQueryFragment.getKnownFragment(key);
+            if (raw) {
+                ret.push(`${this.platform.formatQuery(raw.sql, raw.params)} ${order.toLowerCase()}`);
                 return;
             }
-            core_1.Utils.splitPrimaryKeys(k).forEach(f => {
+            core_1.Utils.splitPrimaryKeys(key).forEach(f => {
                 // eslint-disable-next-line prefer-const
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop && prop.persist === false && !prop.formula) || QueryBuilderHelper.isCustomExpression(f);
+                const noPrefix = (prop && prop.persist === false && !prop.formula) || core_1.RawQueryFragment.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* istanbul ignore next */
                 const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.knex.ref(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
-                const colPart = customOrder
+                let colPart = customOrder
                     ? this.platform.generateCustomOrder(rawColumn, customOrder)
                     : rawColumn;
-                ret.push(`${colPart} ${order.toLowerCase()}`);
+                if (core_1.Utils.isRawSql(colPart)) {
+                    colPart = this.platform.formatQuery(colPart.sql, colPart.params);
+                }
+                if (Array.isArray(order)) {
+                    order.forEach(part => ret.push(this.getQueryOrderFromObject(type, part, populate)));
+                }
+                else {
+                    ret.push(`${colPart} ${order.toLowerCase()}`);
+                }
             });
         });
         return ret.join(', ');
     }
-    finalize(type, qb, meta) {
-        const useReturningStatement = type === enums_1.QueryType.INSERT && this.platform.usesReturningStatement() && meta && !meta.compositePK;
-        if (useReturningStatement) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.persist !== false && (prop.primary || prop.defaultRaw));
-            qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+    finalize(type, qb, meta, data, returning) {
+        if (!meta || !data || !this.platform.usesReturningStatement()) {
+            return;
+        }
+        // always respect explicit returning hint
+        if (returning && returning.length > 0) {
+            qb.returning(returning.map(field => this.mapper(field, type)));
+            return;
+        }
+        if (type === enums_1.QueryType.INSERT) {
+            const returningProps = meta.hydrateProps
+                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
+                .filter(prop => !(prop.name in data));
+            if (returningProps.length > 0) {
+                qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
+            return;
+        }
+        if (type === enums_1.QueryType.UPDATE) {
+            const returningProps = meta.hydrateProps.filter(prop => core_1.Utils.isRawSql(data[prop.name]));
+            if (returningProps.length > 0) {
+                qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
         }
     }
     splitField(field, greedyAlias = false) {
@@ -489,30 +565,25 @@ class QueryBuilderHelper {
         }
         const versionProperty = meta.properties[meta.versionProperty];
         let sql = this.platform.quoteIdentifier(versionProperty.fieldNames[0]) + ' + 1';
-        if (versionProperty.type.toLowerCase() === 'date') {
+        if (versionProperty.runtimeType === 'Date') {
             sql = this.platform.getCurrentTimestampSQL(versionProperty.length);
         }
         qb.update(versionProperty.fieldNames[0], this.knex.raw(sql));
     }
-    static isCustomExpression(field, hasAlias = false) {
-        // if we do not have alias, we don't consider spaces as custom expressions
-        const re = hasAlias ? /[ ?<>=()'"`:]|^\d/ : /[?<>=()'"`:]|^\d/;
-        return !!field.match(re);
-    }
-    prefix(field, always = false, quote = false) {
+    prefix(field, always = false, quote = false, idx) {
         let ret;
         if (!this.isPrefixed(field)) {
             const alias = always ? (quote ? this.alias : this.platform.quoteIdentifier(this.alias)) + '.' : '';
-            const fieldName = this.fieldName(field, this.alias, always);
-            if (QueryBuilderHelper.isCustomExpression(fieldName)) {
-                return fieldName;
+            const fieldName = this.fieldName(field, this.alias, always, idx);
+            if (fieldName instanceof core_1.RawQueryFragment) {
+                return fieldName.sql;
             }
             ret = alias + fieldName;
         }
         else {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
-            ret = a + '.' + this.fieldName(f, a);
+            ret = a + '.' + this.fieldName(f, a, always, idx);
         }
         if (quote) {
             return this.platform.quoteIdentifier(ret);
@@ -538,25 +609,25 @@ class QueryBuilderHelper {
     isPrefixed(field) {
         return !!field.match(/[\w`"[\]]+\./);
     }
-    fieldName(field, alias, always) {
+    fieldName(field, alias, always, idx = 0) {
         const prop = this.getProperty(field, alias);
         if (!prop) {
             return field;
         }
         if (prop.fieldNameRaw) {
             if (!always) {
-                return prop.fieldNameRaw
-                    .replace(/\[::alias::]\.?/g, '')
-                    .replace(this.platform.quoteIdentifier('') + '.', '');
+                return (0, core_1.raw)(prop.fieldNameRaw
+                    .replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE + '\\.?', 'g'), '')
+                    .replace(this.platform.quoteIdentifier('') + '.', ''));
             }
             if (alias) {
-                return prop.fieldNameRaw.replace(/\[::alias::]/g, alias);
+                return (0, core_1.raw)(prop.fieldNameRaw.replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE, 'g'), alias));
             }
             /* istanbul ignore next */
-            return prop.fieldNameRaw;
+            return (0, core_1.raw)(prop.fieldNameRaw);
         }
         /* istanbul ignore next */
-        return prop.fieldNames?.[0] ?? field;
+        return prop.fieldNames?.[idx] ?? field;
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
@@ -564,7 +635,7 @@ class QueryBuilderHelper {
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
         if (alias && meta) {
             const prop = meta.properties[alias];
-            if (prop?.reference === core_1.ReferenceType.EMBEDDED) {
+            if (prop?.kind === core_1.ReferenceKind.EMBEDDED) {
                 // we want to select the full object property so hydration works as expected
                 if (prop.object) {
                     return prop;
@@ -574,48 +645,16 @@ class QueryBuilderHelper {
                 return nest(prop);
             }
         }
-        return meta?.properties[field];
+        if (meta) {
+            if (meta.properties[field]) {
+                return meta.properties[field];
+            }
+            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        }
+        return undefined;
     }
     isTableNameAliasRequired(type) {
         return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type ?? enums_1.QueryType.SELECT);
     }
-    mapData(data, properties, convertCustomTypes) {
-        if (!properties) {
-            return data;
-        }
-        data = Object.assign({}, data); // copy first
-        Object.keys(data).forEach(k => {
-            const prop = properties[k];
-            if (!prop) {
-                return;
-            }
-            if (prop.embeddedProps && !prop.object) {
-                const copy = data[k];
-                delete data[k];
-                Object.assign(data, this.mapData(copy, prop.embeddedProps, convertCustomTypes));
-                return;
-            }
-            if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = data[k];
-                delete data[k];
-                prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
-                return;
-            }
-            if (prop.customType && convertCustomTypes && !this.platform.isRaw(data[k])) {
-                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query' });
-            }
-            if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(data[k])) {
-                const quoted = this.platform.quoteValue(data[k]);
-                data[k] = this.knex.raw(prop.customType.convertToDatabaseValueSQL(quoted, this.platform).replace(/\?/, '\\?'));
-            }
-            if (!prop.customType && (Array.isArray(data[k]) || core_1.Utils.isPlainObject(data[k]))) {
-                data[k] = JSON.stringify(data[k]);
-            }
-            if (prop.fieldNames) {
-                core_1.Utils.renameKey(data, k, prop.fieldNames[0]);
-            }
-        });
-        return data;
-    }
 }
 exports.QueryBuilderHelper = QueryBuilderHelper;

package/query/ScalarCriteriaNode.d.ts

@@ -3,7 +3,8 @@ import type { IQueryBuilder } from '../typings';
 /**
  * @internal
  */
-export declare class ScalarCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, alias?: string): any;
+    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldJoin(): boolean;
 }

package/query/ScalarCriteriaNode.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScalarCriteriaNode = void 0;
 const core_1 = require("@mikro-orm/core");
 const CriteriaNode_1 = require("./CriteriaNode");
+const enums_1 = require("./enums");
 /**
  * @internal
  */
@@ -13,23 +14,26 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
             const field = `${alias}.${this.prop.name}`;
-            const type = this.prop.reference === core_1.ReferenceType.MANY_TO_MANY ? 'pivotJoin' : 'leftJoin';
+            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? enums_1.JoinType.pivotJoin : enums_1.JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);
             // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
-            if (this.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !parentPath.includes('.')) {
+            if (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !parentPath.includes('.')) {
                 qb.addSelect(field);
             }
         }
         return this.payload;
     }
+    willAutoJoin(qb, alias) {
+        return this.shouldJoin();
+    }
     shouldJoin() {
         if (!this.parent || !this.prop) {
             return false;
         }
-        switch (this.prop.reference) {
-            case core_1.ReferenceType.ONE_TO_MANY: return true;
-            case core_1.ReferenceType.MANY_TO_MANY: return true;
-            case core_1.ReferenceType.ONE_TO_ONE: return !this.prop.owner;
+        switch (this.prop.kind) {
+            case core_1.ReferenceKind.ONE_TO_MANY: return true;
+            case core_1.ReferenceKind.MANY_TO_MANY: return true;
+            case core_1.ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
             default: return false; // SCALAR, MANY_TO_ONE
         }
     }