@mikro-orm/knex 6.0.0-dev.6 → 6.0.0-dev.61

package/index.mjs

@@ -1,26 +1,202 @@
 import mod from "./index.js";
 
 export default mod;
+export const ALIAS_REPLACEMENT = mod.ALIAS_REPLACEMENT;
+export const ALIAS_REPLACEMENT_RE = mod.ALIAS_REPLACEMENT_RE;
+export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
+export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
+export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
 export const AbstractSqlConnection = mod.AbstractSqlConnection;
 export const AbstractSqlDriver = mod.AbstractSqlDriver;
 export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
+export const AfterCreate = mod.AfterCreate;
+export const AfterDelete = mod.AfterDelete;
+export const AfterUpdate = mod.AfterUpdate;
+export const ArrayCollection = mod.ArrayCollection;
 export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
+export const ArrayType = mod.ArrayType;
+export const BaseEntity = mod.BaseEntity;
+export const BeforeCreate = mod.BeforeCreate;
+export const BeforeDelete = mod.BeforeDelete;
+export const BeforeUpdate = mod.BeforeUpdate;
+export const BigIntType = mod.BigIntType;
+export const BlobType = mod.BlobType;
+export const BooleanType = mod.BooleanType;
+export const Cascade = mod.Cascade;
+export const ChangeSet = mod.ChangeSet;
+export const ChangeSetComputer = mod.ChangeSetComputer;
+export const ChangeSetPersister = mod.ChangeSetPersister;
+export const ChangeSetType = mod.ChangeSetType;
+export const Check = mod.Check;
+export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
+export const Collection = mod.Collection;
+export const CommitOrderCalculator = mod.CommitOrderCalculator;
+export const Configuration = mod.Configuration;
+export const ConfigurationLoader = mod.ConfigurationLoader;
+export const Connection = mod.Connection;
+export const ConnectionException = mod.ConnectionException;
+export const ConstraintViolationException = mod.ConstraintViolationException;
+export const CreateRequestContext = mod.CreateRequestContext;
 export const CriteriaNode = mod.CriteriaNode;
 export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
+export const Cursor = mod.Cursor;
+export const DatabaseDriver = mod.DatabaseDriver;
+export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
+export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
 export const DatabaseSchema = mod.DatabaseSchema;
 export const DatabaseTable = mod.DatabaseTable;
+export const DateTimeType = mod.DateTimeType;
+export const DateType = mod.DateType;
+export const DeadlockException = mod.DeadlockException;
+export const DecimalType = mod.DecimalType;
+export const DefaultLogger = mod.DefaultLogger;
+export const DoubleType = mod.DoubleType;
+export const DriverException = mod.DriverException;
+export const EagerProps = mod.EagerProps;
+export const Embeddable = mod.Embeddable;
+export const Embedded = mod.Embedded;
+export const EnsureRequestContext = mod.EnsureRequestContext;
+export const Entity = mod.Entity;
+export const EntityAssigner = mod.EntityAssigner;
+export const EntityCaseNamingStrategy = mod.EntityCaseNamingStrategy;
+export const EntityComparator = mod.EntityComparator;
+export const EntityFactory = mod.EntityFactory;
+export const EntityHelper = mod.EntityHelper;
+export const EntityIdentifier = mod.EntityIdentifier;
+export const EntityLoader = mod.EntityLoader;
 export const EntityManager = mod.EntityManager;
+export const EntityManagerType = mod.EntityManagerType;
+export const EntityMetadata = mod.EntityMetadata;
 export const EntityRepository = mod.EntityRepository;
+export const EntityRepositoryType = mod.EntityRepositoryType;
+export const EntitySchema = mod.EntitySchema;
+export const EntitySerializer = mod.EntitySerializer;
+export const EntityTransformer = mod.EntityTransformer;
+export const EntityValidator = mod.EntityValidator;
+export const Enum = mod.Enum;
+export const EnumArrayType = mod.EnumArrayType;
+export const EnumType = mod.EnumType;
+export const EventManager = mod.EventManager;
+export const EventType = mod.EventType;
+export const EventTypeMap = mod.EventTypeMap;
+export const ExceptionConverter = mod.ExceptionConverter;
+export const FileCacheAdapter = mod.FileCacheAdapter;
+export const Filter = mod.Filter;
+export const FloatType = mod.FloatType;
+export const FlushMode = mod.FlushMode;
+export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
+export const Formula = mod.Formula;
+export const GeneratedCacheAdapter = mod.GeneratedCacheAdapter;
+export const GroupOperator = mod.GroupOperator;
+export const HiddenProps = mod.HiddenProps;
+export const Hydrator = mod.Hydrator;
+export const IdentityMap = mod.IdentityMap;
+export const Index = mod.Index;
+export const IntegerType = mod.IntegerType;
+export const InvalidFieldNameException = mod.InvalidFieldNameException;
+export const IsolationLevel = mod.IsolationLevel;
+export const JsonProperty = mod.JsonProperty;
+export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;
+export const LoadStrategy = mod.LoadStrategy;
+export const LockMode = mod.LockMode;
+export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
+export const ManyToMany = mod.ManyToMany;
+export const ManyToOne = mod.ManyToOne;
+export const MediumIntType = mod.MediumIntType;
+export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
+export const MetadataDiscovery = mod.MetadataDiscovery;
+export const MetadataError = mod.MetadataError;
+export const MetadataProvider = mod.MetadataProvider;
+export const MetadataStorage = mod.MetadataStorage;
+export const MetadataValidator = mod.MetadataValidator;
+export const MikroORM = mod.MikroORM;
+export const MongoNamingStrategy = mod.MongoNamingStrategy;
 export const MonkeyPatchable = mod.MonkeyPatchable;
+export const NodeState = mod.NodeState;
+export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
+export const NotFoundError = mod.NotFoundError;
+export const NotNullConstraintViolationException = mod.NotNullConstraintViolationException;
+export const NullCacheAdapter = mod.NullCacheAdapter;
+export const NullHighlighter = mod.NullHighlighter;
+export const ObjectBindingPattern = mod.ObjectBindingPattern;
 export const ObjectCriteriaNode = mod.ObjectCriteriaNode;
+export const ObjectHydrator = mod.ObjectHydrator;
+export const OnInit = mod.OnInit;
+export const OnLoad = mod.OnLoad;
+export const OneToMany = mod.OneToMany;
+export const OneToOne = mod.OneToOne;
+export const OptimisticLockError = mod.OptimisticLockError;
+export const OptionalProps = mod.OptionalProps;
+export const PlainObject = mod.PlainObject;
+export const Platform = mod.Platform;
+export const PopulateHint = mod.PopulateHint;
+export const PrimaryKey = mod.PrimaryKey;
+export const PrimaryKeyProp = mod.PrimaryKeyProp;
+export const Property = mod.Property;
 export const QueryBuilder = mod.QueryBuilder;
 export const QueryBuilderHelper = mod.QueryBuilderHelper;
+export const QueryFlag = mod.QueryFlag;
+export const QueryHelper = mod.QueryHelper;
+export const QueryOperator = mod.QueryOperator;
+export const QueryOrder = mod.QueryOrder;
+export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const RawQueryFragment = mod.RawQueryFragment;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Reference = mod.Reference;
+export const ReferenceKind = mod.ReferenceKind;
+export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
+export const RequestContext = mod.RequestContext;
+export const SCALAR_TYPES = mod.SCALAR_TYPES;
 export const ScalarCriteriaNode = mod.ScalarCriteriaNode;
 export const SchemaComparator = mod.SchemaComparator;
 export const SchemaGenerator = mod.SchemaGenerator;
 export const SchemaHelper = mod.SchemaHelper;
+export const SerializationContext = mod.SerializationContext;
+export const SerializedPrimaryKey = mod.SerializedPrimaryKey;
+export const ServerException = mod.ServerException;
+export const SimpleLogger = mod.SimpleLogger;
+export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
+export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const StringType = mod.StringType;
+export const Subscriber = mod.Subscriber;
+export const SyntaxErrorException = mod.SyntaxErrorException;
+export const TableExistsException = mod.TableExistsException;
+export const TableNotFoundException = mod.TableNotFoundException;
+export const TextType = mod.TextType;
+export const TimeType = mod.TimeType;
+export const TinyIntType = mod.TinyIntType;
+export const TransactionContext = mod.TransactionContext;
+export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Type = mod.Type;
+export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
+export const Unique = mod.Unique;
+export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
+export const UnitOfWork = mod.UnitOfWork;
+export const UnknownType = mod.UnknownType;
+export const Utils = mod.Utils;
+export const UuidType = mod.UuidType;
+export const ValidationError = mod.ValidationError;
+export const WrappedEntity = mod.WrappedEntity;
+export const assign = mod.assign;
+export const colors = mod.colors;
+export const compareArrays = mod.compareArrays;
+export const compareBooleans = mod.compareBooleans;
+export const compareBuffers = mod.compareBuffers;
+export const compareObjects = mod.compareObjects;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+export const helper = mod.helper;
 export const knex = mod.knex;
+export const parseJsonSafe = mod.parseJsonSafe;
+export const raw = mod.raw;
+export const ref = mod.ref;
+export const rel = mod.rel;
+export const serialize = mod.serialize;
+export const sql = mod.sql;
+export const t = mod.t;
+export const types = mod.types;
+export const wrap = mod.wrap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.6",
+  "version": "6.0.0-dev.61",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -58,14 +58,14 @@
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "11.1.0",
-    "knex": "2.3.0",
+    "fs-extra": "11.1.1",
+    "knex": "2.4.2",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.5.3"
+    "@mikro-orm/core": "^5.6.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.6"
+    "@mikro-orm/core": "~6.0.0-dev.61"
   }
 }

package/query/ArrayCriteriaNode.d.ts

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

package/query/CriteriaNode.d.ts

@@ -1,24 +1,24 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import type { EntityProperty, MetadataStorage } from '@mikro-orm/core';
+import type { EntityKey, EntityProperty, MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, IQueryBuilder } from '../typings';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
  * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
  * @internal
  */
-export declare class CriteriaNode implements ICriteriaNode {
+export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
     protected readonly metadata: MetadataStorage;
     readonly entityName: string;
-    readonly parent?: ICriteriaNode | undefined;
-    readonly key?: string | undefined;
+    readonly parent?: ICriteriaNode<T> | undefined;
+    readonly key?: EntityKey<T> | undefined;
     payload: any;
-    prop?: EntityProperty;
+    prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode | undefined, key?: string | undefined, validate?: boolean);
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean);
+    process(qb: IQueryBuilder<T>, alias?: string): any;
     shouldInline(payload: any): boolean;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
     getPath(addIndex?: boolean): string;

package/query/CriteriaNode.js

@@ -40,7 +40,7 @@ class CriteriaNode {
         return false;
     }
     shouldRename(payload) {
-        const type = this.prop ? this.prop.reference : null;
+        const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
         const customExpression = CriteriaNode.isCustomExpression(this.key);
         const scalar = payload === null || core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
@@ -49,17 +49,17 @@ class CriteriaNode {
             return true;
         }
         switch (type) {
-            case core_1.ReferenceType.MANY_TO_ONE: return false;
-            case core_1.ReferenceType.ONE_TO_ONE: return !this.prop.owner;
-            case core_1.ReferenceType.ONE_TO_MANY: return scalar || operator;
-            case core_1.ReferenceType.MANY_TO_MANY: return scalar || operator;
+            case core_1.ReferenceKind.MANY_TO_ONE: return false;
+            case core_1.ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
+            case core_1.ReferenceKind.ONE_TO_MANY: return scalar || operator;
+            case core_1.ReferenceKind.MANY_TO_MANY: return scalar || operator;
             default: return false;
         }
     }
     renameFieldToPK(qb) {
         const joinAlias = qb.getAliasForJoinPath(this.getPath());
         const alias = joinAlias ?? qb.alias;
-        if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
         // if we found a matching join, we need to use the target table column names, as we use that alias instead of the root
@@ -70,7 +70,7 @@ class CriteriaNode {
     }
     getPath(addIndex = false) {
         // use index on parent only if we are processing to-many relation
-        const addParentIndex = this.prop && [core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(this.prop.reference);
+        const addParentIndex = this.prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
         const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
         const index = addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
@@ -89,7 +89,7 @@ class CriteriaNode {
         const customExpression = CriteriaNode.isCustomExpression(this.key);
         const scalar = this.payload === null || core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
-        return this.prop.reference === core_1.ReferenceType.MANY_TO_MANY && (scalar || operator);
+        return this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
     getPivotPath(path) {
         return `${path}[pivot]`;

package/query/CriteriaNodeFactory.d.ts

@@ -1,12 +1,12 @@
-import type { Dictionary, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
+import type { Dictionary, EntityKey, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings';
 /**
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createScalarNode(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createArrayNode(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createObjectNode(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createObjectItemNode(metadata: MetadataStorage, entityName: string, node: ICriteriaNode, payload: Dictionary, item: string, meta?: EntityMetadata): ICriteriaNode;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
 }

package/query/CriteriaNodeFactory.js

@@ -12,7 +12,7 @@ const CriteriaNode_1 = require("./CriteriaNode");
 class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
         const customExpression = CriteriaNode_1.CriteriaNode.isCustomExpression(key || '');
-        const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const scalar = core_1.Utils.isPrimaryKey(payload) || core_1.Utils.isRawSql(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);
         }
@@ -37,7 +37,7 @@ class CriteriaNodeFactory {
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        if (!parent && Object.keys(payload).every(k => meta?.properties[k]?.reference === core_1.ReferenceType.SCALAR)) {
+        if (!parent && Object.keys(payload).every(k => meta?.properties[k]?.kind === core_1.ReferenceKind.SCALAR)) {
             return this.createScalarNode(metadata, entityName, payload, parent, key);
         }
         const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
@@ -47,24 +47,24 @@ class CriteriaNodeFactory {
         }, {});
         return node;
     }
-    static createObjectItemNode(metadata, entityName, node, payload, item, meta) {
-        const prop = meta?.properties[item];
-        if (prop?.reference !== core_1.ReferenceType.EMBEDDED) {
-            const childEntity = prop && prop.reference !== core_1.ReferenceType.SCALAR ? prop.type : entityName;
-            return this.createNode(metadata, childEntity, payload[item], node, item);
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
+        const prop = meta?.properties[key];
+        if (prop?.kind !== core_1.ReferenceKind.EMBEDDED) {
+            const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
+            return this.createNode(metadata, childEntity, payload[key], node, key);
         }
-        const operator = Object.keys(payload[item]).some(f => core_1.Utils.isOperator(f));
+        const operator = Object.keys(payload[key]).some(f => core_1.Utils.isOperator(f));
         if (operator) {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
-        const map = Object.keys(payload[item]).reduce((oo, k) => {
+        const map = Object.keys(payload[key]).reduce((oo, k) => {
             if (!prop.embeddedProps[k]) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            oo[prop.embeddedProps[k].name] = payload[item][k];
+            oo[prop.embeddedProps[k].name] = payload[key][k];
             return oo;
         }, {});
-        return this.createNode(metadata, entityName, map, node, item);
+        return this.createNode(metadata, entityName, map, node, key);
     }
 }
 exports.CriteriaNodeFactory = CriteriaNodeFactory;

package/query/ObjectCriteriaNode.d.ts

@@ -3,9 +3,9 @@ import type { IQueryBuilder } from '../typings';
 /**
  * @internal
  */
-export declare class ObjectCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, alias?: string): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldInline(payload: any): boolean;
     private inlineChildPayload;
     private shouldAutoJoin;

package/query/ObjectCriteriaNode.js

@@ -21,7 +21,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, this.prop ? alias : ownerAlias);
             const operator = core_1.Utils.isOperator(field);
-            const customExpression = ObjectCriteriaNode.isCustomExpression(field);
+            const isRawField = core_1.RawQueryFragment.isKnownFragment(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -33,8 +33,12 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             else if (childNode.shouldRename(payload)) {
                 o[childNode.renameFieldToPK(qb)] = payload;
             }
-            else if (primaryKey || virtual || operator || customExpression || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
-                o[field.replace(/\[::alias::]/g, alias)] = payload;
+            else if (isRawField) {
+                const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+                o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
+                o[field.replaceAll(core_1.ALIAS_REPLACEMENT, alias)] = payload;
             }
             else {
                 o[`${alias}.${field}`] = payload;
@@ -60,7 +64,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         const customExpression = ObjectCriteriaNode.isCustomExpression(this.key);
         const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(payload) && Object.keys(payload).every(k => core_1.Utils.isOperator(k, false));
-        return !!this.prop && this.prop.reference !== core_1.ReferenceType.SCALAR && !scalar && !operator;
+        return !!this.prop && this.prop.kind !== core_1.ReferenceKind.SCALAR && !scalar && !operator;
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
         const prop = this.metadata.find(this.entityName).properties[field];
@@ -104,15 +108,15 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         if (!this.prop || !this.parent) {
             return false;
         }
-        const embeddable = this.prop.reference === core_1.ReferenceType.EMBEDDED;
-        const knownKey = [core_1.ReferenceType.SCALAR, core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.EMBEDDED].includes(this.prop.reference) || (this.prop.reference === core_1.ReferenceType.ONE_TO_ONE && this.prop.owner);
+        const embeddable = this.prop.kind === core_1.ReferenceKind.EMBEDDED;
+        const knownKey = [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
         const operatorKeys = knownKey && Object.keys(this.payload).every(key => core_1.Utils.isOperator(key, false));
         const primaryKeys = knownKey && Object.keys(this.payload).every(key => {
             const meta = this.metadata.find(this.entityName);
             if (!meta.primaryKeys.includes(key)) {
                 return false;
             }
-            if (!core_1.Utils.isPlainObject(this.payload[key].payload) || ![core_1.ReferenceType.ONE_TO_ONE, core_1.ReferenceType.MANY_TO_ONE].includes(meta.properties[key].reference)) {
+            if (!core_1.Utils.isPlainObject(this.payload[key].payload) || ![core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
                 return true;
             }
             return Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
@@ -125,7 +129,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         const scalar = core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
-        if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY && (scalar || operator)) {
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
             qb.join(field, nestedAlias, undefined, 'pivotJoin', this.getPath());
         }
         else {

package/query/QueryBuilder.d.ts

@@ -1,10 +1,12 @@
+/// <reference types="node" />
+import { inspect } from 'util';
 import type { Knex } from 'knex';
-import type { AnyEntity, ConnectionType, Dictionary, EntityData, EntityName, EntityProperty, FlushMode, GroupOperator, MetadataStorage, ObjectQuery, PopulateOptions, QBFilterQuery, QBQueryOrderMap, QueryResult, RequiredEntityData } from '@mikro-orm/core';
+import type { AnyEntity, ConnectionType, Dictionary, EntityData, EntityName, EntityProperty, FlushMode, GroupOperator, LoggerContext, MetadataStorage, ObjectQuery, PopulateOptions, QBFilterQuery, QBQueryOrderMap, QueryResult, RequiredEntityData } from '@mikro-orm/core';
 import { LockMode, PopulateHint, QueryFlag } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { QueryBuilderHelper } from './QueryBuilderHelper';
 import type { Alias } from './QueryBuilderHelper';
+import { QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 /**
@@ -27,11 +29,13 @@ import type { Field } from '../typings';
  * ```
  */
 export declare class QueryBuilder<T extends object = AnyEntity> {
+    #private;
     private readonly metadata;
     private readonly driver;
     private readonly context?;
     private connectionType?;
     private readonly em?;
+    private readonly loggerContext?;
     get mainAlias(): Alias;
     get alias(): string;
     get helper(): QueryBuilderHelper;
@@ -75,7 +79,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("../AbstractSqlConnection").AbstractSqlConnection>> | undefined);
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, import("..").AbstractSqlPlatform>> | undefined, loggerContext?: LoggerContext | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
     distinct(): SelectQueryBuilder<T>;
@@ -90,7 +94,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): SelectQueryBuilder<T>;
     leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): SelectQueryBuilder<T>;
-    protected getFieldsForJoinedLoad<U extends object>(prop: EntityProperty<U>, alias: string): Field<U>[];
+    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string): Field<T>[];
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -114,7 +118,6 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     ref(field: string): Knex.Ref<string, {
         [x: string]: string;
     }>;
-    raw<R = Knex.Raw>(sql: string, bindings?: Knex.RawBinding[] | Knex.ValueDict): R;
     limit(limit?: number, offset?: number): this;
     offset(offset?: number): this;
     withSchema(schema?: string): this;
@@ -138,6 +141,11 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Returns the query with parameters as wildcards.
      */
     getQuery(): string;
+    toQuery(): {
+        sql: string;
+        _sql: Knex.Sql;
+        params: readonly unknown[];
+    };
     /**
      * Returns the list of all parameters for this query.
      */
@@ -179,6 +187,10 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Executes count query (without offset and limit), returning total count of results
      */
     getCount(field?: string | string[], distinct?: boolean): Promise<number>;
+    /**
+     * Executes the query, returning both array of results and total count query (without offset and limit).
+     */
+    getResultAndCount(): Promise<[T[], number]>;
     /**
      * Provides promise-like interface so we can await the QB instance.
      */
@@ -195,6 +207,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private init;
     private getQueryBase;
     private finalize;
+    private processPopulateWhere;
     private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;
@@ -207,6 +220,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private createQueryBuilderHelper;
     private ensureFromClause;
     private ensureNotFinalized;
+    [inspect.custom](depth: number): string;
 }
 export interface RunQueryBuilder<T extends object> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
     where(cond: QBFilterQuery<T> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;