@mikro-orm/knex 7.0.0-dev.1 → 7.0.0-dev.10

package/query/QueryBuilderHelper.d.ts

@@ -1,8 +1,8 @@
 import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
-import { JoinType, QueryType } from './enums';
-import type { Field, JoinOptions } from '../typings';
-import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { NativeQueryBuilder } from './NativeQueryBuilder';
+import { JoinType, QueryType } from './enums.js';
+import type { Field, JoinOptions } from '../typings.js';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * @internal
  */

package/query/QueryBuilderHelper.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryBuilderHelper = void 0;
-const node_util_1 = require("node:util");
-const core_1 = require("@mikro-orm/core");
-const enums_1 = require("./enums");
-const NativeQueryBuilder_1 = require("./NativeQueryBuilder");
+import { inspect } from 'node:util';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * @internal
  */
-class QueryBuilderHelper {
+export class QueryBuilderHelper {
     entityName;
     alias;
     aliasMap;
@@ -25,16 +22,16 @@ class QueryBuilderHelper {
         this.platform = this.driver.getPlatform();
         this.metadata = this.driver.getMetadata();
     }
-    mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
-        if ((0, core_1.isRaw)(field)) {
-            return (0, core_1.raw)(field.sql, field.params);
+    mapper(field, type = QueryType.SELECT, value, alias) {
+        if (isRaw(field)) {
+            return raw(field.sql, field.params);
         }
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (typeof field !== 'string') {
             return field;
         }
         const isTableNameAliasRequired = this.isTableNameAliasRequired(type);
-        const fields = core_1.Utils.splitPrimaryKeys(field);
+        const fields = Utils.splitPrimaryKeys(field);
         if (fields.length > 1) {
             const parts = [];
             for (const p of fields) {
@@ -42,9 +39,6 @@ class QueryBuilderHelper {
                 const prop = this.getProperty(f, a);
                 const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
                 if (fkIdx2 !== -1) {
-                    if (prop?.ownColumns && !prop.ownColumns.includes(f)) {
-                        continue;
-                    }
                     parts.push(this.mapper(a !== this.alias ? `${a}.${prop.fieldNames[fkIdx2]}` : prop.fieldNames[fkIdx2], type, value, alias));
                 }
                 else if (prop) {
@@ -59,18 +53,15 @@ class QueryBuilderHelper {
             if (fields.length !== parts.length && Array.isArray(value)) {
                 value.forEach(row => {
                     if (Array.isArray(row)) {
-                        const tmp = core_1.Utils.flatten(row);
+                        const tmp = Utils.flatten(row);
                         row.length = 0;
                         row.push(...tmp);
                     }
                 });
             }
-            if (parts.length === 1) {
-                return parts[0];
-            }
-            return (0, core_1.raw)('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
+            return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
-        const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+        const rawField = RawQueryFragment.getKnownFragment(field);
         if (rawField) {
             return rawField;
         }
@@ -89,7 +80,7 @@ class QueryBuilderHelper {
         }
         const noPrefix = prop && prop.persist === false;
         if (prop?.fieldNameRaw) {
-            return (0, core_1.raw)(this.prefix(field, isTableNameAliasRequired));
+            return raw(this.prefix(field, isTableNameAliasRequired));
         }
         if (prop?.formula) {
             const alias2 = this.platform.quoteIdentifier(a).toString();
@@ -99,9 +90,9 @@ class QueryBuilderHelper {
             if (!this.isTableNameAliasRequired(type)) {
                 value = value.replaceAll(alias2 + '.', '');
             }
-            return (0, core_1.raw)(`${value}${as}`);
+            return raw(`${value}${as}`);
         }
-        if (prop?.hasConvertToJSValueSQL && type !== enums_1.QueryType.UPSERT) {
+        if (prop?.hasConvertToJSValueSQL && type !== QueryType.UPSERT) {
             let valueSQL;
             if (prop.fieldNames.length > 1 && fkIdx !== -1) {
                 const fk = prop.targetMeta.getPrimaryProps()[fkIdx];
@@ -113,9 +104,9 @@ class QueryBuilderHelper {
                 valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
             }
             if (alias === null) {
-                return (0, core_1.raw)(valueSQL);
+                return raw(valueSQL);
             }
-            return (0, core_1.raw)(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
+            return raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
         // do not wrap custom expressions
         if (!rawField) {
@@ -135,9 +126,9 @@ class QueryBuilderHelper {
         }
         const meta = this.metadata.find(this.entityName);
         data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
-        if (!core_1.Utils.hasObjectKeys(data) && meta && multi) {
-            /* istanbul ignore next */
-            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? (0, core_1.raw)('default') : undefined;
+        if (!Utils.hasObjectKeys(data) && meta && multi) {
+            /* v8 ignore next */
+            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? raw('default') : undefined;
         }
         return data;
     }
@@ -148,7 +139,7 @@ class QueryBuilderHelper {
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
         schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
-        cond = core_1.Utils.merge(cond, prop.where);
+        cond = Utils.merge(cond, prop.where);
         return {
             prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
@@ -179,7 +170,7 @@ class QueryBuilderHelper {
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
-        if (type === enums_1.JoinType.pivotJoin) {
+        if (type === JoinType.pivotJoin) {
             return ret;
         }
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
@@ -191,7 +182,7 @@ class QueryBuilderHelper {
     }
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
-            if ([enums_1.JoinType.nestedInnerJoin, enums_1.JoinType.nestedLeftJoin].includes(join.type)) {
+            if ([JoinType.nestedInnerJoin, JoinType.nestedLeftJoin].includes(join.type)) {
                 return;
             }
             const { sql, params } = this.createJoinExpression(join, joins, schema);
@@ -201,9 +192,9 @@ class QueryBuilderHelper {
     createJoinExpression(join, joins, schema) {
         let table = join.table;
         const method = {
-            [enums_1.JoinType.nestedInnerJoin]: 'inner join',
-            [enums_1.JoinType.nestedLeftJoin]: 'left join',
-            [enums_1.JoinType.pivotJoin]: 'left join',
+            [JoinType.nestedInnerJoin]: 'inner join',
+            [JoinType.nestedLeftJoin]: 'left join',
+            [JoinType.pivotJoin]: 'left join',
         }[join.type] ?? join.type;
         const conditions = [];
         const params = [];
@@ -221,7 +212,7 @@ class QueryBuilderHelper {
                     return;
                 }
                 const left = join.prop.object && join.prop.fieldNameRaw
-                    ? join.prop.fieldNameRaw.replaceAll(core_1.ALIAS_REPLACEMENT, join.ownerAlias)
+                    ? join.prop.fieldNameRaw.replaceAll(ALIAS_REPLACEMENT, join.ownerAlias)
                     : this.platform.quoteIdentifier(`${join.ownerAlias}.${primaryKey}`);
                 conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
             });
@@ -249,7 +240,7 @@ class QueryBuilderHelper {
         }
         const oldAlias = this.alias;
         this.alias = join.alias;
-        const subquery = this._appendQueryCondition(enums_1.QueryType.SELECT, join.cond);
+        const subquery = this._appendQueryCondition(QueryType.SELECT, join.cond);
         this.alias = oldAlias;
         if (subquery.sql) {
             conditions.push(subquery.sql);
@@ -261,7 +252,7 @@ class QueryBuilderHelper {
         return { sql, params };
     }
     mapJoinColumns(type, join) {
-        if (join.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
+        if (join.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((_fieldName, idx) => {
                 const columns = join.prop.owner ? join.joinColumns : join.inverseJoinColumns;
                 return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, `${join.alias}__${columns[idx]}`);
@@ -275,7 +266,7 @@ class QueryBuilderHelper {
     isOneToOneInverse(field, meta) {
         meta ??= this.metadata.find(this.entityName);
         const prop = meta.properties[field.replace(/:ref$/, '')];
-        return prop && prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
+        return prop && prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
@@ -316,11 +307,11 @@ class QueryBuilderHelper {
         onConflict.forEach(item => {
             const { fields, ignore } = item;
             const sub = qb.onConflict({ fields, ignore });
-            core_1.Utils.runIfNotEmpty(() => {
+            Utils.runIfNotEmpty(() => {
                 let mergeParam = item.merge;
-                if (core_1.Utils.isObject(item.merge)) {
+                if (Utils.isObject(item.merge)) {
                     mergeParam = {};
-                    core_1.Utils.keys(item.merge).forEach(key => {
+                    Utils.keys(item.merge).forEach(key => {
                         const k = this.mapper(key, type);
                         mergeParam[k] = item.merge[key];
                     });
@@ -372,20 +363,20 @@ class QueryBuilderHelper {
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
         const params = [];
-        const fields = core_1.Utils.splitPrimaryKeys(key);
+        const fields = Utils.splitPrimaryKeys(key);
         if (this.isSimpleRegExp(cond[key])) {
             parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type))} like ?`);
             params.push(this.getRegExpParam(cond[key]));
             return { sql: parts.join(' and '), params };
         }
-        if (core_1.Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
+        if (Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
             return this.processObjectSubCondition(cond, key, type);
         }
         const op = cond[key] === null ? 'is' : '=';
-        const raw = core_1.RawQueryFragment.getKnownFragment(key);
+        const raw = RawQueryFragment.getKnownFragment(key);
         if (raw) {
-            const sql = raw.sql.replaceAll(core_1.ALIAS_REPLACEMENT, this.alias);
-            const value = core_1.Utils.asArray(cond[key]);
+            const sql = raw.sql.replaceAll(ALIAS_REPLACEMENT, this.alias);
+            const value = Utils.asArray(cond[key]);
             params.push(...raw.params);
             if (value.length > 0) {
                 const val = this.getValueReplacement(fields, value[0], params, key);
@@ -408,13 +399,13 @@ class QueryBuilderHelper {
         const parts = [];
         const params = [];
         let value = cond[key];
-        const size = core_1.Utils.getObjectKeysSize(value);
-        if (core_1.Utils.isPlainObject(value) && size === 0) {
+        const size = Utils.getObjectKeysSize(value);
+        if (Utils.isPlainObject(value) && size === 0) {
             return { sql: '', params };
         }
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
-            const rawField = core_1.RawQueryFragment.getKnownFragment(key);
+            const rawField = RawQueryFragment.getKnownFragment(key);
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
                 key = rawField?.clone().toString() ?? key;
                 return ({ [key]: { [subKey]: subValue } });
@@ -428,13 +419,13 @@ class QueryBuilderHelper {
             value = this.platform.getRegExpValue(value);
         }
         // operators
-        const op = Object.keys(core_1.QueryOperator).find(op => op in value);
-        /* istanbul ignore next */
+        const op = Object.keys(QueryOperator).find(op => op in value);
+        /* v8 ignore next 3 */
         if (!op) {
-            throw new Error(`Invalid query condition: ${(0, node_util_1.inspect)(cond, { depth: 5 })}`);
+            throw new Error(`Invalid query condition: ${inspect(cond, { depth: 5 })}`);
         }
         const replacement = this.getOperatorReplacement(op, value);
-        const fields = core_1.Utils.splitPrimaryKeys(key);
+        const fields = Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op])) {
             const singleTuple = !value[op].every((v) => Array.isArray(v));
             if (!this.platform.allowsComparingTuples()) {
@@ -444,17 +435,17 @@ class QueryBuilderHelper {
                         return `(${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')})`;
                     });
                     parts.push(`(${conds.join(' or ')})`);
-                    params.push(...core_1.Utils.flatten(value[op]));
+                    params.push(...Utils.flatten(value[op]));
                     return { sql: parts.join(' and '), params };
                 }
                 parts.push(...mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`));
-                params.push(...core_1.Utils.flatten(value[op]));
+                params.push(...Utils.flatten(value[op]));
                 return { sql: parts.join(' and '), params };
             }
             if (singleTuple) {
-                const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
+                const tmp = value[op].length === 1 && Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
                 const sql = `(${fields.map(() => '?').join(', ')})`;
-                value[op] = (0, core_1.raw)(sql, tmp);
+                value[op] = raw(sql, tmp);
             }
         }
         if (this.subQueries[key]) {
@@ -465,22 +456,22 @@ class QueryBuilderHelper {
         const [a, f] = this.splitField(key);
         const prop = this.getProperty(f, a);
         if (op === '$fulltext') {
-            /* istanbul ignore next */
+            /* v8 ignore next 3 */
             if (!prop) {
                 throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
             }
-            const { sql, params: params2 } = (0, core_1.raw)(this.platform.getFullTextWhereClause(prop), {
+            const { sql, params: params2 } = raw(this.platform.getFullTextWhereClause(prop), {
                 column: this.mapper(key, type, undefined, null),
                 query: value[op],
             });
             parts.push(sql);
             params.push(...params2);
         }
-        else if (op === '$in' && Array.isArray(value[op]) && value[op].length === 0) {
-            parts.push(`1 = 0`);
+        else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
+            parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof core_1.RawQueryFragment || value[op] instanceof NativeQueryBuilder_1.NativeQueryBuilder) {
-            const query = value[op] instanceof NativeQueryBuilder_1.NativeQueryBuilder ? value[op].toRaw() : value[op];
+        else if (value[op] instanceof RawQueryFragment || value[op] instanceof NativeQueryBuilder) {
+            const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
             if (['$in', '$nin'].includes(op)) {
@@ -506,7 +497,7 @@ class QueryBuilderHelper {
                 }
                 return `(${tmp.join(', ')})`;
             }
-            if (prop?.customType instanceof core_1.ArrayType) {
+            if (prop?.customType instanceof ArrayType) {
                 const item = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
                 params.push(item);
             }
@@ -522,7 +513,7 @@ class QueryBuilderHelper {
         return '?';
     }
     getOperatorReplacement(op, value) {
-        let replacement = core_1.QueryOperator[op];
+        let replacement = QueryOperator[op];
         if (op === '$exists') {
             replacement = value[op] ? 'is not' : 'is';
             value[op] = null;
@@ -548,26 +539,26 @@ class QueryBuilderHelper {
         const ret = [];
         for (const key of Object.keys(orderBy)) {
             const direction = orderBy[key];
-            const order = core_1.Utils.isNumber(direction) ? core_1.QueryOrderNumeric[direction] : direction;
-            const raw = core_1.RawQueryFragment.getKnownFragment(key);
+            const order = Utils.isNumber(direction) ? QueryOrderNumeric[direction] : direction;
+            const raw = RawQueryFragment.getKnownFragment(key);
             if (raw) {
                 ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
                 continue;
             }
-            for (const f of core_1.Utils.splitPrimaryKeys(key)) {
+            for (const f of Utils.splitPrimaryKeys(key)) {
                 // 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 && !prop.embedded) || core_1.RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop && prop.persist === false && !prop.formula && !prop.embedded) || 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.platform.quoteIdentifier(e)).join('.') : column;
+                /* v8 ignore next */
+                const rawColumn = Utils.isString(column) ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
                 let colPart = customOrder
                     ? this.platform.generateCustomOrder(rawColumn, customOrder)
                     : rawColumn;
-                if ((0, core_1.isRaw)(colPart)) {
+                if (isRaw(colPart)) {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
                 if (Array.isArray(order)) {
@@ -590,23 +581,23 @@ class QueryBuilderHelper {
             qb.returning(returning.map(field => this.mapper(field, type)));
             return;
         }
-        if (type === enums_1.QueryType.INSERT) {
+        if (type === 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)));
+                qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
             }
             return;
         }
-        if (type === enums_1.QueryType.UPDATE) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && (0, core_1.isRaw)(data[prop.fieldNames[0]]));
+        if (type === QueryType.UPDATE) {
+            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
                 qb.returning(returningProps.flatMap(prop => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                         const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        return [(0, core_1.raw)(sql)];
+                        return [raw(sql)];
                     }
                     return prop.fieldNames;
                 }));
@@ -633,8 +624,8 @@ class QueryBuilderHelper {
     }
     getLockSQL(qb, lockMode, lockTables = []) {
         const meta = this.metadata.find(this.entityName);
-        if (lockMode === core_1.LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
-            throw core_1.OptimisticLockError.lockFailed(this.entityName);
+        if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
+            throw OptimisticLockError.lockFailed(this.entityName);
         }
         qb.lockMode(lockMode, lockTables);
     }
@@ -648,14 +639,14 @@ class QueryBuilderHelper {
         if (versionProperty.runtimeType === 'Date') {
             sql = this.platform.getCurrentTimestampSQL(versionProperty.length);
         }
-        qb.update({ [versionProperty.fieldNames[0]]: (0, core_1.raw)(sql) });
+        qb.update({ [versionProperty.fieldNames[0]]: raw(sql) });
     }
     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, idx);
-            if (fieldName instanceof core_1.RawQueryFragment) {
+            if (fieldName instanceof RawQueryFragment) {
                 return fieldName.sql;
             }
             ret = alias + fieldName;
@@ -664,7 +655,7 @@ class QueryBuilderHelper {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
             const fieldName = this.fieldName(f, a, always, idx);
-            if (fieldName instanceof core_1.RawQueryFragment) {
+            if (fieldName instanceof RawQueryFragment) {
                 return fieldName.sql;
             }
             ret = a + '.' + fieldName;
@@ -688,7 +679,7 @@ class QueryBuilderHelper {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
             const keys = Object.keys(sub);
             const val = sub[keys[0]];
-            const simple = !core_1.Utils.isPlainObject(val) || core_1.Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !core_1.Utils.isOperator(k));
+            const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {
                 this.append(() => this._appendQueryCondition(type, sub, operator), parts, params);
                 continue;
@@ -707,17 +698,17 @@ class QueryBuilderHelper {
         }
         if (prop.fieldNameRaw) {
             if (!always) {
-                return (0, core_1.raw)(prop.fieldNameRaw
-                    .replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE + '\\.?', 'g'), '')
+                return raw(prop.fieldNameRaw
+                    .replace(new RegExp(ALIAS_REPLACEMENT_RE + '\\.?', 'g'), '')
                     .replace(this.platform.quoteIdentifier('') + '.', ''));
             }
             if (alias) {
-                return (0, core_1.raw)(prop.fieldNameRaw.replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE, 'g'), alias));
+                return raw(prop.fieldNameRaw.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), alias));
             }
-            /* istanbul ignore next */
-            return (0, core_1.raw)(prop.fieldNameRaw);
+            /* v8 ignore next */
+            return raw(prop.fieldNameRaw);
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         return prop.fieldNames?.[idx] ?? field;
     }
     getProperty(field, alias) {
@@ -726,7 +717,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?.kind === core_1.ReferenceKind.EMBEDDED) {
+            if (prop?.kind === ReferenceKind.EMBEDDED) {
                 // we want to select the full object property so hydration works as expected
                 if (prop.object) {
                     return prop;
@@ -745,16 +736,15 @@ class QueryBuilderHelper {
         return undefined;
     }
     isTableNameAliasRequired(type) {
-        return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type);
+        return [QueryType.SELECT, QueryType.COUNT].includes(type);
     }
     processOnConflictCondition(cond, schema) {
         const meta = this.metadata.get(this.entityName);
         const tableName = meta.tableName;
         for (const key of Object.keys(cond)) {
-            const mapped = this.mapper(key, enums_1.QueryType.UPSERT);
-            core_1.Utils.renameKey(cond, key, tableName + '.' + mapped);
+            const mapped = this.mapper(key, QueryType.UPSERT);
+            Utils.renameKey(cond, key, tableName + '.' + mapped);
         }
         return cond;
     }
 }
-exports.QueryBuilderHelper = QueryBuilderHelper;

package/query/ScalarCriteriaNode.d.ts

@@ -1,5 +1,5 @@
-import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings';
+import { CriteriaNode } from './CriteriaNode.js';
+import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings.js';
 /**
  * @internal
  */

package/query/ScalarCriteriaNode.js

@@ -1,32 +1,29 @@
-"use strict";
-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");
-const QueryBuilder_1 = require("./QueryBuilder");
+import { ReferenceKind, Utils } from '@mikro-orm/core';
+import { CriteriaNode } from './CriteriaNode.js';
+import { JoinType } from './enums.js';
+import { QueryBuilder } from './QueryBuilder.js';
 /**
  * @internal
  */
-class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
+export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, options) {
         if (this.shouldJoin()) {
             const path = this.getPath();
             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 = this.aliased(this.prop.name, options?.alias);
-            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? enums_1.JoinType.pivotJoin : enums_1.JoinType.leftJoin;
+            const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : 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.kind === core_1.ReferenceKind.ONE_TO_ONE && !parentPath.includes('.') && !qb._fields?.includes(field)) {
+            if (this.prop.kind === ReferenceKind.ONE_TO_ONE && !parentPath.includes('.') && !qb._fields?.includes(field)) {
                 qb.addSelect(field);
             }
         }
-        if (this.payload instanceof QueryBuilder_1.QueryBuilder) {
+        if (this.payload instanceof QueryBuilder) {
             return this.payload.getNativeQuery().toRaw();
         }
         if (this.payload && typeof this.payload === 'object') {
-            const keys = Object.keys(this.payload).filter(key => core_1.Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
+            const keys = Object.keys(this.payload).filter(key => Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
             for (const key of keys) {
                 this.payload[key] = JSON.stringify(this.payload[key]);
             }
@@ -41,11 +38,10 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return false;
         }
         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;
+            case ReferenceKind.ONE_TO_MANY: return true;
+            case ReferenceKind.MANY_TO_MANY: return true;
+            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
             default: return false; // SCALAR, MANY_TO_ONE
         }
     }
 }
-exports.ScalarCriteriaNode = ScalarCriteriaNode;

package/query/enums.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinType = exports.QueryType = void 0;
-var QueryType;
+export var QueryType;
 (function (QueryType) {
     QueryType["TRUNCATE"] = "TRUNCATE";
     QueryType["SELECT"] = "SELECT";
@@ -10,8 +7,8 @@ var QueryType;
     QueryType["UPDATE"] = "UPDATE";
     QueryType["DELETE"] = "DELETE";
     QueryType["UPSERT"] = "UPSERT";
-})(QueryType || (exports.QueryType = QueryType = {}));
-var JoinType;
+})(QueryType || (QueryType = {}));
+export var JoinType;
 (function (JoinType) {
     JoinType["leftJoin"] = "left join";
     JoinType["innerJoin"] = "inner join";
@@ -20,4 +17,4 @@ var JoinType;
     JoinType["pivotJoin"] = "pivot join";
     JoinType["innerJoinLateral"] = "inner join lateral";
     JoinType["leftJoinLateral"] = "left join lateral";
-})(JoinType || (exports.JoinType = JoinType = {}));
+})(JoinType || (JoinType = {}));

package/query/index.d.ts

@@ -1,9 +1,9 @@
-export * from './enums';
-export * from './QueryBuilderHelper';
-export * from './QueryBuilder';
-export * from './CriteriaNode';
-export * from './ArrayCriteriaNode';
-export * from './ObjectCriteriaNode';
-export * from './ScalarCriteriaNode';
-export * from './CriteriaNodeFactory';
-export * from './NativeQueryBuilder';
+export * from './enums.js';
+export * from './QueryBuilderHelper.js';
+export * from './QueryBuilder.js';
+export * from './CriteriaNode.js';
+export * from './ArrayCriteriaNode.js';
+export * from './ObjectCriteriaNode.js';
+export * from './ScalarCriteriaNode.js';
+export * from './CriteriaNodeFactory.js';
+export * from './NativeQueryBuilder.js';