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

package/query/QueryBuilder.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryBuilder = void 0;
-const node_util_1 = require("node:util");
-const core_1 = require("@mikro-orm/core");
-const enums_1 = require("./enums");
-const QueryBuilderHelper_1 = require("./QueryBuilderHelper");
-const CriteriaNodeFactory_1 = require("./CriteriaNodeFactory");
-const NativeQueryBuilder_1 = require("./NativeQueryBuilder");
+import { inspect } from 'node:util';
+import { helper, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import { QueryBuilderHelper } from './QueryBuilderHelper.js';
+import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * SQL query builder with fluent interface.
  *
@@ -26,7 +23,7 @@ const NativeQueryBuilder_1 = require("./NativeQueryBuilder");
  * const publisher = await qb.getSingleResult();
  * ```
  */
-class QueryBuilder {
+export class QueryBuilder {
     metadata;
     driver;
     context;
@@ -45,7 +42,7 @@ class QueryBuilder {
         return this._helper;
     }
     get type() {
-        return this._type ?? enums_1.QueryType.SELECT;
+        return this._type ?? QueryType.SELECT;
     }
     /** @internal */
     _populate = [];
@@ -54,7 +51,7 @@ class QueryBuilder {
     /** @internal */
     rawFragments = new Set();
     aliasCounter = 0;
-    flags = new Set([core_1.QueryFlag.CONVERT_CUSTOM_TYPES]);
+    flags = new Set([QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
     populateHintFinalized = false;
     _joins = {};
@@ -104,75 +101,75 @@ class QueryBuilder {
     }
     select(fields, distinct = false) {
         this.ensureNotFinalized();
-        this._fields = core_1.Utils.asArray(fields);
+        this._fields = Utils.asArray(fields);
         if (distinct) {
-            this.flags.add(core_1.QueryFlag.DISTINCT);
+            this.flags.add(QueryFlag.DISTINCT);
         }
-        return this.init(enums_1.QueryType.SELECT);
+        return this.init(QueryType.SELECT);
     }
     addSelect(fields) {
         this.ensureNotFinalized();
-        if (this._type && this._type !== enums_1.QueryType.SELECT) {
+        if (this._type && this._type !== QueryType.SELECT) {
             return this;
         }
-        return this.select([...core_1.Utils.asArray(this._fields), ...core_1.Utils.asArray(fields)]);
+        return this.select([...Utils.asArray(this._fields), ...Utils.asArray(fields)]);
     }
     distinct() {
         this.ensureNotFinalized();
-        return this.setFlag(core_1.QueryFlag.DISTINCT);
+        return this.setFlag(QueryFlag.DISTINCT);
     }
     /** postgres only */
     distinctOn(fields) {
         this.ensureNotFinalized();
-        this._distinctOn = core_1.Utils.asArray(fields);
+        this._distinctOn = Utils.asArray(fields);
         return this;
     }
     insert(data) {
-        return this.init(enums_1.QueryType.INSERT, data);
+        return this.init(QueryType.INSERT, data);
     }
     update(data) {
-        return this.init(enums_1.QueryType.UPDATE, data);
+        return this.init(QueryType.UPDATE, data);
     }
     delete(cond) {
-        return this.init(enums_1.QueryType.DELETE, undefined, cond);
+        return this.init(QueryType.DELETE, undefined, cond);
     }
     truncate() {
-        return this.init(enums_1.QueryType.TRUNCATE);
+        return this.init(QueryType.TRUNCATE);
     }
     count(field, distinct = false) {
         if (field) {
-            this._fields = core_1.Utils.asArray(field);
+            this._fields = Utils.asArray(field);
         }
         else if (distinct || this.hasToManyJoins()) {
             this._fields = this.mainAlias.metadata.primaryKeys;
         }
         else {
-            this._fields = [(0, core_1.raw)('*')];
+            this._fields = [raw('*')];
         }
         if (distinct) {
-            this.flags.add(core_1.QueryFlag.DISTINCT);
+            this.flags.add(QueryFlag.DISTINCT);
         }
-        return this.init(enums_1.QueryType.COUNT);
+        return this.init(QueryType.COUNT);
     }
-    join(field, alias, cond = {}, type = enums_1.JoinType.innerJoin, path, schema) {
+    join(field, alias, cond = {}, type = JoinType.innerJoin, path, schema) {
         this.joinReference(field, alias, cond, type, path, schema);
         return this;
     }
     innerJoin(field, alias, cond = {}, schema) {
-        this.join(field, alias, cond, enums_1.JoinType.innerJoin, undefined, schema);
+        this.join(field, alias, cond, JoinType.innerJoin, undefined, schema);
         return this;
     }
     innerJoinLateral(field, alias, cond, schema) {
-        this.join(field, alias, cond, enums_1.JoinType.innerJoinLateral, undefined, schema);
+        this.join(field, alias, cond, JoinType.innerJoinLateral, undefined, schema);
         return this;
     }
     leftJoin(field, alias, cond = {}, schema) {
-        return this.join(field, alias, cond, enums_1.JoinType.leftJoin, undefined, schema);
+        return this.join(field, alias, cond, JoinType.leftJoin, undefined, schema);
     }
     leftJoinLateral(field, alias, cond, schema) {
-        return this.join(field, alias, cond, enums_1.JoinType.leftJoinLateral, undefined, schema);
+        return this.join(field, alias, cond, JoinType.leftJoinLateral, undefined, schema);
     }
-    joinAndSelect(field, alias, cond = {}, type = enums_1.JoinType.innerJoin, path, fields, schema) {
+    joinAndSelect(field, alias, cond = {}, type = JoinType.innerJoin, path, fields, schema) {
         if (!this._type) {
             this.select('*');
         }
@@ -188,7 +185,7 @@ class QueryBuilder {
             this._joins[`${fromAlias}.${prop.name}#${alias}`].subquery = subquery;
         }
         const populate = this._joinedProps.get(fromAlias);
-        const item = { field: prop.name, strategy: core_1.LoadStrategy.JOINED, children: [] };
+        const item = { field: prop.name, strategy: LoadStrategy.JOINED, children: [] };
         if (populate) {
             populate.children.push(item);
         }
@@ -200,16 +197,16 @@ class QueryBuilder {
         return this;
     }
     leftJoinAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.leftJoin, undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, JoinType.leftJoin, undefined, fields, schema);
     }
     leftJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.leftJoinLateral, undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, JoinType.leftJoinLateral, undefined, fields, schema);
     }
     innerJoinAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.innerJoin, undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, JoinType.innerJoin, undefined, fields, schema);
     }
     innerJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, enums_1.JoinType.innerJoinLateral, undefined, fields, schema);
+        return this.joinAndSelect(field, alias, cond, JoinType.innerJoinLateral, undefined, fields, schema);
     }
     getFieldsForJoinedLoad(prop, alias, explicitFields) {
         const fields = [];
@@ -243,9 +240,12 @@ class QueryBuilder {
             }
         }
         prop.targetMeta.props
-            .filter(prop => explicitFields
-            ? explicitFields.includes(prop.name) || explicitFields.includes(`${alias}.${prop.name}`) || prop.primary
-            : this.platform.shouldHaveColumn(prop, populate))
+            .filter(prop => {
+            if (!explicitFields) {
+                return this.platform.shouldHaveColumn(prop, populate);
+            }
+            return prop.primary && !explicitFields.includes(prop.name) && !explicitFields.includes(`${alias}.${prop.name}`);
+        })
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
@@ -253,16 +253,50 @@ class QueryBuilder {
      * Apply filters to the QB where condition.
      */
     async applyFilters(filterOptions = {}) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!this.em) {
             throw new Error('Cannot apply filters, this QueryBuilder is not attached to an EntityManager');
         }
         const cond = await this.em.applyFilters(this.mainAlias.entityName, {}, filterOptions, 'read');
         this.andWhere(cond);
     }
+    autoJoinedPaths = [];
+    /**
+     * @internal
+     */
+    scheduleFilterCheck(path) {
+        this.autoJoinedPaths.push(path);
+    }
+    /**
+     * @internal
+     */
+    async applyJoinedFilters(em, filterOptions = {}) {
+        for (const path of this.autoJoinedPaths) {
+            const join = this.getJoinForPath(path);
+            if (join.type === JoinType.pivotJoin) {
+                continue;
+            }
+            const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
+            if (Utils.hasObjectKeys(cond)) {
+                // remove nested filters, we only care about scalars here, nesting would require another join branch
+                for (const key of Object.keys(cond)) {
+                    if (Utils.isPlainObject(cond[key]) && Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every'].includes(k)))) {
+                        delete cond[key];
+                    }
+                }
+                if (Utils.hasObjectKeys(join.cond)) {
+                    /* istanbul ignore next */
+                    join.cond = { $and: [join.cond, cond] };
+                }
+                else {
+                    join.cond = { ...cond };
+                }
+            }
+        }
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
-        if (subQuery instanceof core_1.RawQueryFragment) {
+        if (subQuery instanceof RawQueryFragment) {
             this.subQueries[alias] = this.platform.formatQuery(subQuery.sql, subQuery.params);
         }
         else {
@@ -272,34 +306,34 @@ class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
-        const rawField = core_1.RawQueryFragment.getKnownFragment(cond);
+        const rawField = RawQueryFragment.getKnownFragment(cond);
         if (rawField) {
             const sql = this.platform.formatQuery(rawField.sql, rawField.params);
-            cond = { [(0, core_1.raw)(`(${sql})`)]: core_1.Utils.asArray(params) };
+            cond = { [raw(`(${sql})`)]: Utils.asArray(params) };
             operator ??= '$and';
         }
-        else if (core_1.Utils.isString(cond)) {
-            cond = { [(0, core_1.raw)(`(${cond})`, core_1.Utils.asArray(params))]: [] };
+        else if (Utils.isString(cond)) {
+            cond = { [raw(`(${cond})`, Utils.asArray(params))]: [] };
             operator ??= '$and';
         }
         else {
-            cond = core_1.QueryHelper.processWhere({
+            cond = QueryHelper.processWhere({
                 where: cond,
                 entityName: this.mainAlias.entityName,
                 metadata: this.metadata,
                 platform: this.platform,
                 aliasMap: this.getAliasMap(),
-                aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
-                convertCustomTypes: this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES),
+                aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
+                convertCustomTypes: this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES),
             });
         }
         const op = operator || params;
-        const topLevel = !op || !core_1.Utils.hasObjectKeys(this._cond);
-        const criteriaNode = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
+        const topLevel = !op || !Utils.hasObjectKeys(this._cond);
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
         const ignoreBranching = this.__populateWhere === 'infer';
-        if ([enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
+        if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
             // use sub-query to support joining
-            this.setFlag(this.type === enums_1.QueryType.UPDATE ? core_1.QueryFlag.UPDATE_SUB_QUERY : core_1.QueryFlag.DELETE_SUB_QUERY);
+            this.setFlag(this.type === QueryType.UPDATE ? QueryFlag.UPDATE_SUB_QUERY : QueryFlag.DELETE_SUB_QUERY);
             this.select(this.mainAlias.metadata.primaryKeys, true);
         }
         if (topLevel) {
@@ -327,32 +361,32 @@ class QueryBuilder {
     orderBy(orderBy) {
         this.ensureNotFinalized();
         this._orderBy = [];
-        core_1.Utils.asArray(orderBy).forEach(o => {
-            const processed = core_1.QueryHelper.processWhere({
+        Utils.asArray(orderBy).forEach(o => {
+            const processed = QueryHelper.processWhere({
                 where: o,
                 entityName: this.mainAlias.entityName,
                 metadata: this.metadata,
                 platform: this.platform,
                 aliasMap: this.getAliasMap(),
-                aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
+                aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
                 convertCustomTypes: false,
                 type: 'orderBy',
             });
-            this._orderBy.push(CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true }));
+            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
         });
         return this;
     }
     groupBy(fields) {
         this.ensureNotFinalized();
-        this._groupBy = core_1.Utils.asArray(fields);
+        this._groupBy = Utils.asArray(fields);
         return this;
     }
     having(cond = {}, params, operator) {
         this.ensureNotFinalized();
-        if (core_1.Utils.isString(cond)) {
-            cond = { [(0, core_1.raw)(`(${cond})`, params)]: [] };
+        if (Utils.isString(cond)) {
+            cond = { [raw(`(${cond})`, params)]: [] };
         }
-        cond = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
+        cond = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
         if (!this._having || !operator) {
             this._having = cond;
         }
@@ -373,11 +407,11 @@ class QueryBuilder {
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
-            fields: (0, core_1.isRaw)(fields)
+            fields: isRaw(fields)
                 ? fields
-                : core_1.Utils.asArray(fields).flatMap(f => {
+                : Utils.asArray(fields).flatMap(f => {
                     const key = f.toString();
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     return meta.properties[key]?.fieldNames ?? [key];
                 }),
         });
@@ -401,7 +435,7 @@ class QueryBuilder {
         return this;
     }
     returning(fields) {
-        this._returning = core_1.Utils.asArray(fields);
+        this._returning = Utils.asArray(fields);
         return this;
     }
     /**
@@ -434,8 +468,8 @@ class QueryBuilder {
     }
     setLockMode(mode, tables) {
         this.ensureNotFinalized();
-        if (mode != null && mode !== core_1.LockMode.OPTIMISTIC && !this.context) {
-            throw core_1.ValidationError.transactionRequired();
+        if (mode != null && mode !== LockMode.OPTIMISTIC && !this.context) {
+            throw ValidationError.transactionRequired();
         }
         this.lockMode = mode;
         this.lockTables = tables;
@@ -477,7 +511,7 @@ class QueryBuilder {
      */
     comment(comment) {
         this.ensureNotFinalized();
-        this._comments.push(...core_1.Utils.asArray(comment));
+        this._comments.push(...Utils.asArray(comment));
         return this;
     }
     /**
@@ -487,7 +521,7 @@ class QueryBuilder {
      */
     hintComment(comment) {
         this.ensureNotFinalized();
-        this._hintComments.push(...core_1.Utils.asArray(comment));
+        this._hintComments.push(...Utils.asArray(comment));
         return this;
     }
     from(target, aliasName) {
@@ -496,7 +530,7 @@ class QueryBuilder {
             this.fromSubQuery(target, aliasName);
         }
         else {
-            const entityName = core_1.Utils.className(target);
+            const entityName = Utils.className(target);
             if (aliasName && this._mainAlias && entityName !== this._mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this._mainAlias.aliasName}'`);
             }
@@ -511,22 +545,22 @@ class QueryBuilder {
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
-        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
-        core_1.Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
-        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), this._having);
-        core_1.Utils.runIfNotEmpty(() => {
+        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
+        Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
+        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), this._having);
+        Utils.runIfNotEmpty(() => {
             const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
             if (queryOrder.length > 0) {
-                const sql = core_1.Utils.unique(queryOrder).join(', ');
+                const sql = Utils.unique(queryOrder).join(', ');
                 qb.orderBy(sql);
                 return;
             }
         }, this._orderBy);
-        core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
-        core_1.Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
-        core_1.Utils.runIfNotEmpty(() => qb.comment(this._comments), this._comments);
-        core_1.Utils.runIfNotEmpty(() => qb.hintComment(this._hintComments), this._hintComments);
-        core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(enums_1.QueryType.UPSERT, this._onConflict, qb), this._onConflict);
+        Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
+        Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
+        Utils.runIfNotEmpty(() => qb.comment(this._comments), this._comments);
+        Utils.runIfNotEmpty(() => qb.hintComment(this._hintComments), this._hintComments);
+        Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(QueryType.UPSERT, this._onConflict, qb), this._onConflict);
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
@@ -538,7 +572,7 @@ class QueryBuilder {
      * @internal
      */
     clearRawFragmentsCache() {
-        this.rawFragments.forEach(key => core_1.RawQueryFragment.remove(key));
+        this.rawFragments.forEach(key => RawQueryFragment.remove(key));
         this.rawFragments.clear();
     }
     /**
@@ -552,7 +586,7 @@ class QueryBuilder {
      */
     toRaw() {
         const { sql, params } = this.toQuery();
-        return (0, core_1.raw)(sql, params);
+        return raw(sql, params);
     }
     toQuery() {
         if (this._query?.sql) {
@@ -640,12 +674,12 @@ class QueryBuilder {
         options = typeof options === 'boolean' ? { mapResults: options } : (options ?? {});
         options.mergeResults ??= true;
         options.mapResults ??= true;
-        const isRunType = [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type);
+        const isRunType = [QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE, QueryType.TRUNCATE].includes(this.type);
         method ??= isRunType ? 'run' : 'all';
         if (!this.connectionType && isRunType) {
             this.connectionType = 'write';
         }
-        if (!this.finalized && method === 'get' && this.type === enums_1.QueryType.SELECT) {
+        if (!this.finalized && method === 'get' && this.type === QueryType.SELECT) {
             this.limit(1);
         }
         const query = this.toQuery();
@@ -698,14 +732,14 @@ class QueryBuilder {
         const res = await this.execute('all', true);
         const entities = [];
         function propagatePopulateHint(entity, hint) {
-            (0, core_1.helper)(entity).__serializationContext.populate = hint.concat((0, core_1.helper)(entity).__serializationContext.populate ?? []);
+            helper(entity).__serializationContext.populate = hint.concat(helper(entity).__serializationContext.populate ?? []);
             hint.forEach(hint => {
                 const [propName] = hint.field.split(':', 2);
-                const value = core_1.Reference.unwrapReference(entity[propName]);
-                if (core_1.Utils.isEntity(value)) {
+                const value = Reference.unwrapReference(entity[propName]);
+                if (Utils.isEntity(value)) {
                     propagatePopulateHint(value, hint.children ?? []);
                 }
-                else if (core_1.Utils.isCollection(value)) {
+                else if (Utils.isCollection(value)) {
                     value.populated();
                     value.getItems(false).forEach(item => propagatePopulateHint(item, hint.children ?? []));
                 }
@@ -719,7 +753,7 @@ class QueryBuilder {
                 break;
             }
         }
-        return core_1.Utils.unique(entities);
+        return Utils.unique(entities);
     }
     /**
      * Executes the query, returning the first result or null
@@ -736,7 +770,7 @@ class QueryBuilder {
      */
     async getCount(field, distinct) {
         let res;
-        if (this.type === enums_1.QueryType.COUNT) {
+        if (this.type === QueryType.COUNT) {
             res = await this.execute('get', false);
         }
         else {
@@ -756,26 +790,6 @@ class QueryBuilder {
             await this.clone().getCount(),
         ];
     }
-    /**
-     * Provides promise-like interface so we can await the QB instance.
-     */
-    then(onfulfilled, onrejected) {
-        let type = this.type;
-        if (this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(core_1.QueryFlag.DELETE_SUB_QUERY)) {
-            type = enums_1.QueryType.UPDATE;
-        }
-        switch (type) {
-            case enums_1.QueryType.INSERT:
-            case enums_1.QueryType.UPDATE:
-            case enums_1.QueryType.DELETE:
-            case enums_1.QueryType.UPSERT:
-            case enums_1.QueryType.TRUNCATE:
-                return this.execute('run').then(onfulfilled, onrejected);
-            case enums_1.QueryType.COUNT:
-                return this.getCount().then(onfulfilled, onrejected);
-            case enums_1.QueryType.SELECT: return this.getResultList().then(onfulfilled, onrejected);
-        }
-    }
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
@@ -785,7 +799,7 @@ class QueryBuilder {
         if (alias.includes('.')) {
             const [a, f] = alias.split('.');
             const meta = this.metadata.find(a);
-            /* istanbul ignore next */
+            /* v8 ignore next */
             alias = meta?.properties[f]?.fieldNames[0] ?? alias;
         }
         qb.as(alias);
@@ -805,15 +819,15 @@ class QueryBuilder {
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
             '_comments', '_hintComments', 'rawFragments', 'aliasCounter',
         ];
-        core_1.RawQueryFragment.cloneRegistry = this.rawFragments;
+        RawQueryFragment.cloneRegistry = this.rawFragments;
         for (const prop of Object.keys(this)) {
             if (reset.includes(prop) || ['_helper', '_query'].includes(prop)) {
                 continue;
             }
-            qb[prop] = properties.includes(prop) ? core_1.Utils.copy(this[prop]) : this[prop];
+            qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
         }
-        delete core_1.RawQueryFragment.cloneRegistry;
-        /* istanbul ignore else */
+        delete RawQueryFragment.cloneRegistry;
+        /* v8 ignore next 3 */
         if (this._fields && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
@@ -846,11 +860,11 @@ class QueryBuilder {
         if (res instanceof QueryBuilder) {
             return `(${res.getFormattedQuery()}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
-        if (res instanceof core_1.RawQueryFragment) {
+        if (res instanceof RawQueryFragment) {
             const query = this.platform.formatQuery(res.sql, res.params);
             return `(${query}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         return res;
     }
     joinReference(field, alias, cond, type, path, schema, subquery) {
@@ -858,14 +872,14 @@ class QueryBuilder {
         if (typeof field === 'object') {
             const prop = {
                 name: '__subquery__',
-                kind: core_1.ReferenceKind.MANY_TO_ONE,
+                kind: ReferenceKind.MANY_TO_ONE,
             };
             if (field instanceof QueryBuilder) {
                 prop.type = field.mainAlias.entityName;
                 prop.targetMeta = field.mainAlias.metadata;
                 field = field.getNativeQuery();
             }
-            if (field instanceof core_1.RawQueryFragment) {
+            if (field instanceof RawQueryFragment) {
                 field = this.platform.formatQuery(field.sql, field.params);
             }
             this._joins[`${this.alias}.${prop.name}#${alias}`] = {
@@ -894,22 +908,22 @@ class QueryBuilder {
             throw new Error(`Trying to join ${q(field)}, but ${q(fromField)} is not a defined relation on ${meta.className}.`);
         }
         this.createAlias(prop.type, alias);
-        cond = core_1.QueryHelper.processWhere({
+        cond = QueryHelper.processWhere({
             where: cond,
             entityName: this.mainAlias.entityName,
             metadata: this.metadata,
             platform: this.platform,
             aliasMap: this.getAliasMap(),
-            aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
+            aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
-        if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
         }
-        else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
+        else if (prop.kind === ReferenceKind.MANY_TO_MANY) {
             let pivotAlias = alias;
-            if (type !== enums_1.JoinType.pivotJoin) {
+            if (type !== JoinType.pivotJoin) {
                 const oldPivotAlias = this.getAliasForJoinPath(path + '[pivot]');
                 pivotAlias = oldPivotAlias ?? this.getNextAlias(prop.pivotEntity);
                 aliasedName = `${fromAlias}.${prop.name}#${pivotAlias}`;
@@ -918,7 +932,7 @@ class QueryBuilder {
             Object.assign(this._joins, joins);
             this.createAlias(prop.pivotEntity, pivotAlias);
         }
-        else if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE) {
+        else if (prop.kind === ReferenceKind.ONE_TO_ONE) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
         }
         else { // MANY_TO_ONE
@@ -935,12 +949,12 @@ class QueryBuilder {
             return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined);
         };
         fields.forEach(field => {
-            const rawField = core_1.RawQueryFragment.getKnownFragment(field, false);
+            const rawField = RawQueryFragment.getKnownFragment(field, false);
             if (rawField) {
                 ret.push(rawField);
                 return;
             }
-            if (!core_1.Utils.isString(field)) {
+            if (!Utils.isString(field)) {
                 ret.push(field);
                 return;
             }
@@ -951,23 +965,23 @@ class QueryBuilder {
             }
             const [a, f] = this.helper.splitField(field);
             const prop = this.helper.getProperty(f, a);
-            /* istanbul ignore next */
-            if (prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+            /* v8 ignore next 3 */
+            if (prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                 return;
             }
             if (prop?.persist === false && !prop.embedded && !prop.formula && type === 'where') {
                 return;
             }
-            if (prop?.embedded || (prop?.kind === core_1.ReferenceKind.EMBEDDED && prop.object)) {
+            if (prop?.embedded || (prop?.kind === ReferenceKind.EMBEDDED && prop.object)) {
                 const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
                 const aliased = this._aliases[a] ? `${a}.${name}` : name;
                 ret.push(getFieldName(aliased));
                 return;
             }
-            if (prop?.kind === core_1.ReferenceKind.EMBEDDED) {
+            if (prop?.kind === ReferenceKind.EMBEDDED) {
                 const nest = (prop) => {
                     for (const childProp of Object.values(prop.embeddedProps)) {
-                        if (childProp.fieldNames && (childProp.kind !== core_1.ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
+                        if (childProp.fieldNames && (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
                             ret.push(getFieldName(childProp.fieldNames[0]));
                         }
                         else {
@@ -985,9 +999,9 @@ class QueryBuilder {
             ret.push(getFieldName(field));
         });
         const meta = this.mainAlias.metadata;
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
-        if (this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
+        if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
             for (const p of requiresSQLConversion) {
                 ret.push(this.helper.mapper(p.name, this.type));
             }
@@ -1000,22 +1014,22 @@ class QueryBuilder {
                 }
             }
         }
-        return core_1.Utils.unique(ret);
+        return Utils.unique(ret);
     }
     init(type, data, cond) {
         this.ensureNotFinalized();
         this._type = type;
-        if ([enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE].includes(type) && core_1.Utils.hasObjectKeys(this._cond)) {
+        if ([QueryType.UPDATE, QueryType.DELETE].includes(type) && Utils.hasObjectKeys(this._cond)) {
             throw new Error(`You are trying to call \`qb.where().${type.toLowerCase()}()\`. Calling \`qb.${type.toLowerCase()}()\` before \`qb.where()\` is required.`);
         }
         if (!this.helper.isTableNameAliasRequired(type)) {
             delete this._fields;
         }
         if (data) {
-            if (core_1.Utils.isEntity(data)) {
-                data = this.em?.getComparator().prepareEntity(data) ?? (0, core_1.serialize)(data);
+            if (Utils.isEntity(data)) {
+                data = this.em?.getComparator().prepareEntity(data) ?? serialize(data);
             }
-            this._data = this.helper.processData(data, this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES), false);
+            this._data = this.helper.processData(data, this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES), false);
         }
         if (cond) {
             this.where(cond);
@@ -1031,7 +1045,7 @@ class QueryBuilder {
         const tableName = subQuery ? subQuery.as(aliasName) : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
         if (metadata?.virtual && processVirtualEntity) {
-            qb.from((0, core_1.raw)(this.fromVirtual(metadata)), { indexHint: this._indexHint });
+            qb.from(raw(this.fromVirtual(metadata)), { indexHint: this._indexHint });
         }
         else {
             qb.from(tableName, {
@@ -1041,34 +1055,34 @@ class QueryBuilder {
             });
         }
         switch (this.type) {
-            case enums_1.QueryType.SELECT:
+            case QueryType.SELECT:
                 qb.select(this.prepareFields(this._fields));
                 if (this._distinctOn) {
                     qb.distinctOn(this.prepareFields(this._distinctOn));
                 }
-                else if (this.flags.has(core_1.QueryFlag.DISTINCT)) {
+                else if (this.flags.has(QueryFlag.DISTINCT)) {
                     qb.distinct();
                 }
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
-            case enums_1.QueryType.COUNT: {
+            case QueryType.COUNT: {
                 const fields = this._fields.map(f => this.helper.mapper(f, this.type));
-                qb.count(fields, this.flags.has(core_1.QueryFlag.DISTINCT));
+                qb.count(fields, this.flags.has(QueryFlag.DISTINCT));
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
             }
-            case enums_1.QueryType.INSERT:
+            case QueryType.INSERT:
                 qb.insert(this._data);
                 break;
-            case enums_1.QueryType.UPDATE:
+            case QueryType.UPDATE:
                 qb.update(this._data);
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 this.helper.updateVersionProperty(qb, this._data);
                 break;
-            case enums_1.QueryType.DELETE:
+            case QueryType.DELETE:
                 qb.delete();
                 break;
-            case enums_1.QueryType.TRUNCATE:
+            case QueryType.TRUNCATE:
                 qb.truncate();
                 break;
         }
@@ -1104,31 +1118,31 @@ class QueryBuilder {
         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)))
+                .filter(prop => prop.formula && (!prop.lazy || this.flags.has(QueryFlag.INCLUDE_LAZY_FORMULAS)))
                 .map(prop => {
                 const alias = this.platform.quoteIdentifier(this.mainAlias.aliasName);
                 const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                 return `${prop.formula(alias)} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
-                if (f instanceof core_1.RawQueryFragment) {
+                if (f instanceof RawQueryFragment) {
                     return f.sql === field && f.params.length === 0;
                 }
                 return f === field;
             }))
-                .forEach(field => this._fields.push((0, core_1.raw)(field)));
+                .forEach(field => this._fields.push(raw(field)));
         }
-        core_1.QueryHelper.processObjectParams(this._data);
-        core_1.QueryHelper.processObjectParams(this._cond);
-        core_1.QueryHelper.processObjectParams(this._having);
+        QueryHelper.processObjectParams(this._data);
+        QueryHelper.processObjectParams(this._cond);
+        QueryHelper.processObjectParams(this._having);
         // automatically enable paginate flag when we detect to-many joins, but only if there is no `group by` clause
-        if (!this.flags.has(core_1.QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
-            this.flags.add(core_1.QueryFlag.PAGINATE);
+        if (!this.flags.has(QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
+            this.flags.add(QueryFlag.PAGINATE);
         }
-        if (meta && this.flags.has(core_1.QueryFlag.PAGINATE) && (this._limit > 0 || this._offset > 0)) {
+        if (meta && this.flags.has(QueryFlag.PAGINATE) && (this._limit > 0 || this._offset > 0)) {
             this.wrapPaginateSubQuery(meta);
         }
-        if (meta && (this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(core_1.QueryFlag.DELETE_SUB_QUERY))) {
+        if (meta && (this.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(QueryFlag.DELETE_SUB_QUERY))) {
             this.wrapModifySubQuery(meta);
         }
         this.finalized = true;
@@ -1139,10 +1153,10 @@ class QueryBuilder {
             return;
         }
         const meta = this.mainAlias.metadata;
-        if (meta && this.flags.has(core_1.QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
+        if (meta && this.flags.has(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`))
+                .filter(prop => prop.kind === 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));
         }
@@ -1158,7 +1172,7 @@ class QueryBuilder {
                 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] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, 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;
             }
@@ -1169,16 +1183,16 @@ class QueryBuilder {
     }
     processPopulateWhere(filter) {
         const key = filter ? '_populateFilter' : '_populateWhere';
-        if (this[key] == null || this[key] === core_1.PopulateHint.ALL) {
+        if (this[key] == null || this[key] === PopulateHint.ALL) {
             return;
         }
         let joins = Object.values(this._joins);
         for (const join of joins) {
             join.cond_ ??= join.cond;
-            join.cond = filter ? { ...join.cond } : {};
+            join.cond = { ...join.cond };
         }
         if (typeof this[key] === 'object') {
-            const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
+            const cond = CriteriaNodeFactory
                 .createNode(this.metadata, this.mainAlias.entityName, this[key])
                 .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true });
             // there might be new joins created by processing the `populateWhere` object
@@ -1188,11 +1202,11 @@ class QueryBuilder {
     }
     mergeOnConditions(joins, cond, filter, op) {
         for (const k of Object.keys(cond)) {
-            if (core_1.Utils.isOperator(k)) {
+            if (Utils.isOperator(k)) {
                 if (Array.isArray(cond[k])) {
                     cond[k].forEach((c) => this.mergeOnConditions(joins, c, filter, k));
                 }
-                /* istanbul ignore next */
+                /* v8 ignore next */
                 this.mergeOnConditions(joins, cond[k], filter, k);
             }
             const [alias] = this.helper.splitField(k);
@@ -1202,13 +1216,13 @@ class QueryBuilder {
                 // https://stackoverflow.com/a/56815807/3665878
                 if (parentJoin && !filter) {
                     const nested = (parentJoin.nested ??= new Set());
-                    join.type = join.type === enums_1.JoinType.innerJoin || ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(parentJoin.prop.kind))
-                        ? enums_1.JoinType.nestedInnerJoin
-                        : enums_1.JoinType.nestedLeftJoin;
+                    join.type = join.type === JoinType.innerJoin || ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(parentJoin.prop.kind))
+                        ? JoinType.nestedInnerJoin
+                        : JoinType.nestedLeftJoin;
                     nested.add(join);
                 }
                 if (join.cond[k]) {
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     join.cond = { [op ?? '$and']: [join.cond, { [k]: cond[k] }] };
                 }
                 else if (op === '$or') {
@@ -1222,10 +1236,8 @@ 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);
+            return [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }
     wrapPaginateSubQuery(meta) {
@@ -1245,8 +1257,8 @@ class QueryBuilder {
             const orderBy = [];
             for (const orderMap of this._orderBy) {
                 for (const [field, direction] of Object.entries(orderMap)) {
-                    if (core_1.RawQueryFragment.isKnownFragment(field)) {
-                        const rawField = core_1.RawQueryFragment.getKnownFragment(field, false);
+                    if (RawQueryFragment.isKnownFragment(field)) {
+                        const rawField = RawQueryFragment.getKnownFragment(field, false);
                         this.rawFragments.add(field);
                         orderBy.push({ [rawField.clone()]: direction });
                         continue;
@@ -1259,7 +1271,7 @@ class QueryBuilder {
                         addToSelect.push(fieldName);
                     }
                     const quoted = this.platform.quoteIdentifier(fieldName);
-                    const key = (0, core_1.raw)(`min(${quoted}${type})`);
+                    const key = raw(`min(${quoted}${type})`);
                     orderBy.push({ [key]: direction });
                 }
             }
@@ -1273,17 +1285,17 @@ class QueryBuilder {
                     if (typeof field === 'object' && field && '__as' in field) {
                         return field.__as === prop;
                     }
-                    if (field instanceof core_1.RawQueryFragment) {
+                    if (field instanceof RawQueryFragment) {
                         // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                         return field.sql.includes(prop);
                     }
                     return false;
                 });
-                /* istanbul ignore next */
-                if (field instanceof core_1.RawQueryFragment) {
+                /* v8 ignore next 3 */
+                if (field instanceof RawQueryFragment) {
                     innerQuery.select(field);
                 }
-                else if (field instanceof NativeQueryBuilder_1.NativeQueryBuilder) {
+                else if (field instanceof NativeQueryBuilder) {
                     innerQuery.select(field.toRaw());
                 }
                 else if (field) {
@@ -1297,11 +1309,11 @@ class QueryBuilder {
         subSubQuery.select(pks).from(innerQuery);
         this._limit = undefined;
         this._offset = undefined;
-        if (!this._fields.some(f => core_1.RawQueryFragment.isKnownFragment(f))) {
+        if (!this._fields.some(f => RawQueryFragment.isKnownFragment(f))) {
             this.pruneExtraJoins(meta);
         }
         const { sql, params } = subSubQuery.compile();
-        this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: (0, core_1.raw)(sql, params) } });
+        this.select(this._fields).where({ [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) } });
     }
     pruneExtraJoins(meta) {
         // remove joins that are not used for population or ordering to improve performance
@@ -1344,14 +1356,14 @@ class QueryBuilder {
         // wrap one more time to get around MySQL limitations
         // https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause
         const subSubQuery = this.platform.createNativeQueryBuilder();
-        const method = this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) ? 'update' : 'delete';
+        const method = this.flags.has(QueryFlag.UPDATE_SUB_QUERY) ? 'update' : 'delete';
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
         this._cond = {}; // otherwise we would trigger validation error
         this._joins = {}; // included in the subquery
         subSubQuery.select(pks).from(subQuery.as(this.mainAlias.aliasName));
         const { sql, params } = subSubQuery.compile();
         this[method](this._data).where({
-            [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: (0, core_1.raw)(sql, params) },
+            [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) },
         });
     }
     getSchema(alias) {
@@ -1385,10 +1397,10 @@ class QueryBuilder {
         this.createMainAlias(entityName, aliasName);
     }
     createQueryBuilderHelper() {
-        return new QueryBuilderHelper_1.QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver);
+        return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver);
     }
     ensureFromClause() {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!this._mainAlias) {
             throw new Error(`Cannot proceed to build a query because the main alias is not set.`);
         }
@@ -1398,9 +1410,9 @@ class QueryBuilder {
             throw new Error('This QueryBuilder instance is already finalized, clone it first if you want to modify it.');
         }
     }
-    /* istanbul ignore next */
+    /* v8 ignore start */
     /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
+    [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['metadata', 'driver', 'context', 'platform', 'type'];
         Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);
@@ -1413,19 +1425,18 @@ class QueryBuilder {
         if (this._schema) {
             object.schema = this._schema;
         }
-        if (!core_1.Utils.isEmpty(this._cond)) {
+        if (!Utils.isEmpty(this._cond)) {
             object.where = this._cond;
         }
         if (this._onConflict?.[0]) {
             prefix = 'Upsert';
             object.onConflict = this._onConflict[0];
         }
-        if (!core_1.Utils.isEmpty(this._orderBy)) {
+        if (!Utils.isEmpty(this._orderBy)) {
             object.orderBy = this._orderBy;
         }
         const name = this._mainAlias ? `${prefix}QueryBuilder<${this._mainAlias?.entityName}>` : 'QueryBuilder';
-        const ret = (0, node_util_1.inspect)(object, { depth });
+        const ret = inspect(object, { depth });
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.QueryBuilder = QueryBuilder;