@mikro-orm/sql 7.0.0-dev.321 → 7.0.0-dev.322

package/plugin/transformer.js

@@ -1,44 +1,52 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
 export class MikroTransformer extends OperationNodeTransformer {
-    em;
-    options;
     /**
      * Context stack to support nested queries (subqueries, CTEs)
      * Each level of query scope has its own Map of table aliases/names to EntityMetadata
      * Top of stack (highest index) is the current scope
      */
-    contextStack = [];
+    #contextStack = [];
     /**
      * Subquery alias map: maps subquery/CTE alias to its source table metadata
      * Used to resolve columns from subqueries/CTEs to their original table definitions
      */
-    subqueryAliasMap = new Map();
-    metadata;
-    platform;
+    #subqueryAliasMap = new Map();
+    #metadata;
+    #platform;
     /**
      * Global map of all entities involved in the query.
      * Populated during AST transformation and used for result transformation.
      */
-    entityMap = new Map();
+    #entityMap = new Map();
+    #em;
+    #options;
     constructor(em, options = {}) {
         super();
-        this.em = em;
-        this.options = options;
-        this.metadata = em.getMetadata();
-        this.platform = em.getDriver().getPlatform();
+        this.#em = em;
+        this.#options = options;
+        this.#metadata = em.getMetadata();
+        this.#platform = em.getDriver().getPlatform();
     }
     reset() {
-        this.subqueryAliasMap.clear();
-        this.entityMap.clear();
+        this.#subqueryAliasMap.clear();
+        this.#entityMap.clear();
     }
     getOutputEntityMap() {
-        return this.entityMap;
+        return this.#entityMap;
+    }
+    /** @internal */
+    getContextStack() {
+        return this.#contextStack;
+    }
+    /** @internal */
+    getSubqueryAliasMap() {
+        return this.#subqueryAliasMap;
     }
     transformSelectQuery(node, queryId) {
         // Push a new context for this query scope (starts with inherited parent context)
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             // Process WITH clause (CTEs) first - they define names available in this scope
             if (node.with) {
@@ -60,12 +68,12 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         finally {
             // Pop the context when exiting this query scope
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformInsertQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             let entityMeta;
             if (node.into) {
@@ -75,12 +83,12 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (meta) {
                         entityMeta = meta;
                         currentContext.set(meta.tableName, meta);
-                        this.entityMap.set(meta.tableName, meta);
+                        this.#entityMap.set(meta.tableName, meta);
                     }
                 }
             }
-            const nodeWithHooks = this.options.processOnCreateHooks && entityMeta ? this.processOnCreateHooks(node, entityMeta) : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processInsertValues(nodeWithHooks, entityMeta) : nodeWithHooks;
+            const nodeWithHooks = this.#options.processOnCreateHooks && entityMeta ? this.processOnCreateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.#options.convertValues && entityMeta ? this.processInsertValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             // Handle ON CONFLICT clause
             let finalNode = nodeWithConvertedValues;
             if (node.onConflict?.updates && entityMeta) {
@@ -91,14 +99,14 @@ export class MikroTransformer extends OperationNodeTransformer {
                     table: node.into, // Dummy table
                     updates: node.onConflict.updates,
                 };
-                const updatesWithHooks = this.options.processOnUpdateHooks
+                const updatesWithHooks = this.#options.processOnUpdateHooks
                     ? this.processOnUpdateHooks(tempUpdateNode, entityMeta).updates
                     : node.onConflict.updates;
                 const tempUpdateNodeWithHooks = {
                     ...tempUpdateNode,
                     updates: updatesWithHooks,
                 };
-                const updatesWithConvertedValues = this.options.convertValues
+                const updatesWithConvertedValues = this.#options.convertValues
                     ? this.processUpdateValues(tempUpdateNodeWithHooks, entityMeta).updates
                     : updatesWithHooks;
                 if (updatesWithConvertedValues && updatesWithConvertedValues !== node.onConflict.updates) {
@@ -115,12 +123,12 @@ export class MikroTransformer extends OperationNodeTransformer {
             return super.transformInsertQuery(finalNode, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformUpdateQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             let entityMeta;
             if (node.table && TableNode.is(node.table)) {
@@ -130,7 +138,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (meta) {
                         entityMeta = meta;
                         currentContext.set(meta.tableName, meta);
-                        this.entityMap.set(meta.tableName, meta);
+                        this.#entityMap.set(meta.tableName, meta);
                     }
                 }
             }
@@ -146,17 +154,17 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            const nodeWithHooks = this.options.processOnUpdateHooks && entityMeta ? this.processOnUpdateHooks(node, entityMeta) : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processUpdateValues(nodeWithHooks, entityMeta) : nodeWithHooks;
+            const nodeWithHooks = this.#options.processOnUpdateHooks && entityMeta ? this.processOnUpdateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.#options.convertValues && entityMeta ? this.processUpdateValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             return super.transformUpdateQuery(nodeWithConvertedValues, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformDeleteQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             const froms = node.from?.froms;
             if (froms && froms.length > 0) {
@@ -167,7 +175,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                         const meta = this.findEntityMetadata(tableName);
                         if (meta) {
                             currentContext.set(meta.tableName, meta);
-                            this.entityMap.set(meta.tableName, meta);
+                            this.#entityMap.set(meta.tableName, meta);
                         }
                     }
                 }
@@ -181,24 +189,24 @@ export class MikroTransformer extends OperationNodeTransformer {
             return super.transformDeleteQuery(node, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformMergeQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             return super.transformMergeQuery(node, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformIdentifier(node, queryId) {
         node = super.transformIdentifier(node, queryId);
         const parent = this.nodeStack[this.nodeStack.length - 2];
         // Transform table names when tableNamingStrategy is 'entity'
-        if (this.options.tableNamingStrategy === 'entity' && parent && SchemableIdentifierNode.is(parent)) {
+        if (this.#options.tableNamingStrategy === 'entity' && parent && SchemableIdentifierNode.is(parent)) {
             const meta = this.findEntityMetadata(node.name);
             if (meta) {
                 return {
@@ -209,7 +217,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         // Transform column names when columnNamingStrategy is 'property'
         // Support ColumnNode, ColumnUpdateNode, and ReferenceNode (for JOIN conditions)
-        if (this.options.columnNamingStrategy === 'property' &&
+        if (this.#options.columnNamingStrategy === 'property' &&
             parent &&
             (ColumnNode.is(parent) || ColumnUpdateNode.is(parent) || ReferenceNode.is(parent))) {
             const ownerMeta = this.findOwnerEntityInContext();
@@ -239,8 +247,8 @@ export class MikroTransformer extends OperationNodeTransformer {
             const tableName = this.getTableName(reference.table);
             if (tableName) {
                 // First, check in subquery alias map (for CTE/subquery columns)
-                if (this.subqueryAliasMap.has(tableName)) {
-                    return this.subqueryAliasMap.get(tableName);
+                if (this.#subqueryAliasMap.has(tableName)) {
+                    return this.#subqueryAliasMap.get(tableName);
                 }
                 // Find entity metadata to get the actual table name
                 // Context uses table names (meta.tableName) as keys, not entity names
@@ -267,16 +275,16 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
         }
         // If no explicit table reference, use the first entity in current context
-        if (this.contextStack.length > 0) {
-            const currentContext = this.contextStack[this.contextStack.length - 1];
+        if (this.#contextStack.length > 0) {
+            const currentContext = this.#contextStack[this.#contextStack.length - 1];
             for (const [alias, meta] of currentContext.entries()) {
                 if (meta) {
                     return meta;
                 }
                 // If the context value is undefined but the alias is in subqueryAliasMap,
                 // use the mapped metadata (for CTE/subquery cases)
-                if (!meta && this.subqueryAliasMap.has(alias)) {
-                    const mappedMeta = this.subqueryAliasMap.get(alias);
+                if (!meta && this.#subqueryAliasMap.has(alias)) {
+                    const mappedMeta = this.#subqueryAliasMap.get(alias);
                     if (mappedMeta) {
                         return mappedMeta;
                     }
@@ -306,7 +314,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         const newRows = node.values.values.map(row => {
             const valuesToAdd = missingProps.map(prop => {
-                const val = prop.onCreate(undefined, this.em);
+                const val = prop.onCreate(undefined, this.#em);
                 return val;
             });
             if (ValueListNode.is(row)) {
@@ -344,7 +352,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         const newUpdates = [...node.updates];
         for (const prop of missingProps) {
-            const val = prop.onUpdate(undefined, this.em);
+            const val = prop.onUpdate(undefined, this.#em);
             newUpdates.push(ColumnUpdateNode.create(ColumnNode.create(prop.name), ValueNode.create(val)));
         }
         return {
@@ -459,7 +467,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         return meta.props.find(prop => prop.fieldNames?.includes(columnName));
     }
     shouldConvertValues() {
-        return !!this.options.convertValues;
+        return !!this.#options.convertValues;
     }
     prepareInputValue(prop, value, enabled) {
         if (!enabled || !prop || value == null) {
@@ -474,14 +482,14 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
         }
         if (prop.customType && !isRaw(value)) {
-            return prop.customType.convertToDatabaseValue(value, this.platform, {
+            return prop.customType.convertToDatabaseValue(value, this.#platform, {
                 fromQuery: true,
                 key: prop.name,
                 mode: 'query-data',
             });
         }
         if (value instanceof Date) {
-            return this.platform.processDateProperty(value);
+            return this.#platform.processDateProperty(value);
         }
         return value;
     }
@@ -492,8 +500,8 @@ export class MikroTransformer extends OperationNodeTransformer {
      */
     lookupInContextStack(tableNameOrAlias) {
         // Search from top of stack (current scope) to bottom (parent scopes)
-        for (let i = this.contextStack.length - 1; i >= 0; i--) {
-            const context = this.contextStack[i];
+        for (let i = this.#contextStack.length - 1; i >= 0; i--) {
+            const context = this.#contextStack[i];
             if (context.has(tableNameOrAlias)) {
                 return context.get(tableNameOrAlias);
             }
@@ -515,10 +523,10 @@ export class MikroTransformer extends OperationNodeTransformer {
                 if (cte.expression?.kind === 'SelectQueryNode') {
                     const sourceMeta = this.extractSourceTableFromSelectQuery(cte.expression);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(cteName, sourceMeta);
+                        this.#subqueryAliasMap.set(cteName, sourceMeta);
                         // Add CTE to entityMap so it can be used for result transformation if needed
                         // (though CTEs usually don't appear in result rows directly, but their columns might)
-                        this.entityMap.set(cteName, sourceMeta);
+                        this.#entityMap.set(cteName, sourceMeta);
                     }
                 }
             }
@@ -548,11 +556,11 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (aliasName) {
                         context.set(aliasName, meta);
                         if (meta) {
-                            this.entityMap.set(aliasName, meta);
+                            this.#entityMap.set(aliasName, meta);
                         }
                         // Also map the alias in subqueryAliasMap if the table name is a CTE
-                        if (this.subqueryAliasMap.has(tableName)) {
-                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        if (this.#subqueryAliasMap.has(tableName)) {
+                            this.#subqueryAliasMap.set(aliasName, this.#subqueryAliasMap.get(tableName));
                         }
                     }
                 }
@@ -565,7 +573,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     // Try to extract the source table from the subquery
                     const sourceMeta = this.extractSourceTableFromSelectQuery(from.node);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                        this.#subqueryAliasMap.set(aliasName, sourceMeta);
                     }
                 }
             }
@@ -584,7 +592,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 const meta = this.findEntityMetadata(tableName);
                 context.set(tableName, meta);
                 if (meta) {
-                    this.entityMap.set(tableName, meta);
+                    this.#entityMap.set(tableName, meta);
                 }
             }
         }
@@ -604,11 +612,11 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (aliasName) {
                         context.set(aliasName, meta);
                         if (meta) {
-                            this.entityMap.set(aliasName, meta);
+                            this.#entityMap.set(aliasName, meta);
                         }
                         // Also map the alias in subqueryAliasMap if the table name is a CTE
-                        if (this.subqueryAliasMap.has(tableName)) {
-                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        if (this.#subqueryAliasMap.has(tableName)) {
+                            this.#subqueryAliasMap.set(aliasName, this.#subqueryAliasMap.get(tableName));
                         }
                     }
                 }
@@ -621,7 +629,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     // Try to extract the source table from the subquery
                     const sourceMeta = this.extractSourceTableFromSelectQuery(joinTable.node);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                        this.#subqueryAliasMap.set(aliasName, sourceMeta);
                     }
                 }
             }
@@ -641,7 +649,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 // Use table name (meta.tableName) as key to match transformUpdateQuery behavior
                 if (meta) {
                     context.set(meta.tableName, meta);
-                    this.entityMap.set(meta.tableName, meta);
+                    this.#entityMap.set(meta.tableName, meta);
                     // Also set with entity name for backward compatibility
                     context.set(tableName, meta);
                 }
@@ -704,11 +712,11 @@ export class MikroTransformer extends OperationNodeTransformer {
      * Find entity metadata by table name or entity name
      */
     findEntityMetadata(name) {
-        const byEntity = this.metadata.getByClassName(name, false);
+        const byEntity = this.#metadata.getByClassName(name, false);
         if (byEntity) {
             return byEntity;
         }
-        const allMetadata = Array.from(this.metadata);
+        const allMetadata = Array.from(this.#metadata);
         const byTable = allMetadata.find(m => m.tableName === name);
         if (byTable) {
             return byTable;
@@ -721,7 +729,7 @@ export class MikroTransformer extends OperationNodeTransformer {
      */
     transformResult(rows, entityMap) {
         // Only transform if columnNamingStrategy is 'property' or convertValues is true, and we have data
-        if ((this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) ||
+        if ((this.#options.columnNamingStrategy !== 'property' && !this.#options.convertValues) ||
             !rows ||
             rows.length === 0) {
             return rows;
@@ -818,7 +826,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 continue;
             }
             const converted = this.prepareOutputValue(prop, transformed[fieldName]);
-            if (this.options.columnNamingStrategy === 'property' && prop.name !== fieldName) {
+            if (this.#options.columnNamingStrategy === 'property' && prop.name !== fieldName) {
                 if (!(prop.name in transformed)) {
                     transformed[prop.name] = converted;
                 }
@@ -828,13 +836,13 @@ export class MikroTransformer extends OperationNodeTransformer {
                 delete transformed[fieldName];
                 continue;
             }
-            if (this.options.convertValues) {
+            if (this.#options.convertValues) {
                 transformed[fieldName] = converted;
             }
         }
         // Second pass: handle relation fields
         // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
-        if (this.options.columnNamingStrategy === 'property') {
+        if (this.#options.columnNamingStrategy === 'property') {
             for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
                 if (fieldName in transformed && !(relationPropertyName in transformed)) {
                     // Move the foreign key value to the relation property name
@@ -846,36 +854,36 @@ export class MikroTransformer extends OperationNodeTransformer {
         return transformed;
     }
     prepareOutputValue(prop, value) {
-        if (!this.options.convertValues || !prop || value == null) {
+        if (!this.#options.convertValues || !prop || value == null) {
             return value;
         }
         if (prop.customType) {
-            return prop.customType.convertToJSValue(value, this.platform);
+            return prop.customType.convertToJSValue(value, this.#platform);
         }
         // Aligned with EntityComparator.getResultMapper logic
         if (prop.runtimeType === 'boolean') {
             // Use !! conversion like EntityComparator: value == null ? value : !!value
             return value == null ? value : !!value;
         }
-        if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+        if (prop.runtimeType === 'Date' && !this.#platform.isNumericProperty(prop)) {
             // Aligned with EntityComparator: exclude numeric timestamp properties
             // If already Date instance or null, return as is
             if (value == null || value instanceof Date) {
                 return value;
             }
             // Handle timezone like EntityComparator.parseDate
-            const tz = this.platform.getTimezone();
+            const tz = this.#platform.getTimezone();
             if (!tz || tz === 'local') {
-                return this.platform.parseDate(value);
+                return this.#platform.parseDate(value);
             }
             // For non-local timezone, check if value already has timezone info
             // Number (timestamp) doesn't need timezone handling, string needs check
             if (typeof value === 'number' ||
                 (typeof value === 'string' && (value.includes('+') || value.lastIndexOf('-') > 10 || value.endsWith('Z')))) {
-                return this.platform.parseDate(value);
+                return this.#platform.parseDate(value);
             }
             // Append timezone if not present (only for string values)
-            return this.platform.parseDate(value + tz);
+            return this.#platform.parseDate(value + tz);
         }
         // For all other runtimeTypes (number, string, bigint, Buffer, object, any, etc.)
         // EntityComparator just assigns directly without conversion

package/query/ObjectCriteriaNode.js

@@ -39,7 +39,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true, ['_schema']);
+                    const qb2 = qb.clone(true, ['schema']);
                     const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
                         .from(parentMeta.class)
@@ -289,12 +289,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
         else {
-            const prev = qb._fields?.slice();
+            const prev = qb.state.fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
             const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
-                qb._fields = prev;
+                qb.state.fields = prev;
             }
         }
         if (options?.type !== 'orderBy') {

package/query/QueryBuilder.d.ts

@@ -1,7 +1,7 @@
 import { type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
-import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper.js';
+import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 import type { ICriteriaNodeProcessOptions, InternalField, JoinOptions } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
@@ -139,6 +139,57 @@ type GroupOperators<RootAlias extends string, Context, Entity, RawAliases extend
 };
 export type AliasedFilterCondition<RootAlias extends string, Context, Entity, RawAliases extends string = never> = (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>) & GroupOperators<RootAlias, Context, Entity, RawAliases>;
 export type QBFilterQuery<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = FilterObject<Entity> & AliasedFilterCondition<RootAlias, Context, Entity, RawAliases>;
+/** @internal */
+export interface QBState<Entity extends object> {
+    type?: QueryType;
+    fields?: InternalField<Entity>[];
+    populate: PopulateOptions<Entity>[];
+    populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    populateFilter?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    resolvedPopulateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    populateMap: Dictionary<string>;
+    aliasCounter: number;
+    flags: Set<QueryFlag>;
+    finalized: boolean;
+    populateHintFinalized: boolean;
+    joins: Dictionary<JoinOptions>;
+    explicitAlias: boolean;
+    schema?: string;
+    cond: Dictionary;
+    data?: Dictionary;
+    orderBy: QueryOrderMap<Entity>[];
+    groupBy: InternalField<Entity>[];
+    having: Dictionary;
+    returning?: InternalField<Entity>[];
+    onConflict?: OnConflictClause<Entity>[];
+    limit?: number;
+    offset?: number;
+    distinctOn?: string[];
+    joinedProps: Map<string, PopulateOptions<any>>;
+    cache?: boolean | number | [string, number];
+    indexHint?: string;
+    collation?: string;
+    comments: string[];
+    hintComments: string[];
+    flushMode?: FlushMode;
+    lockMode?: LockMode;
+    lockTables?: string[];
+    subQueries: Dictionary<string>;
+    mainAlias?: Alias<Entity>;
+    aliases: Dictionary<Alias<any>>;
+    tptAlias: Dictionary<string>;
+    unionQuery?: {
+        sql: string;
+        params: readonly unknown[];
+    };
+    ctes: (CteOptions & {
+        name: string;
+        query: NativeQueryBuilder | RawQueryFragment;
+        recursive?: boolean;
+    })[];
+    tptJoinsApplied: boolean;
+    autoJoinedPaths: string[];
+}
 /**
  * SQL query builder with fluent interface.
  *
@@ -159,6 +210,7 @@ export type QBFilterQuery<Entity, RootAlias extends string = never, Context = ne
  * ```
  */
 export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never, RawAliases extends string = never, Fields extends string = '*', CTEs extends Record<string, object> = {}> implements Subquery {
+    #private;
     protected readonly metadata: MetadataStorage;
     protected readonly driver: AbstractSqlDriver;
     protected readonly context?: Transaction | undefined;
@@ -166,61 +218,15 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected em?: SqlEntityManager | undefined;
     protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
     readonly __subquery: true;
+    /** @internal */
+    static createDefaultState<T extends object>(): QBState<T>;
     get mainAlias(): Alias<Entity>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     get type(): QueryType;
     /** @internal */
-    _type?: QueryType;
-    /** @internal */
-    _fields?: InternalField<Entity>[];
-    /** @internal */
-    _populate: PopulateOptions<Entity>[];
-    /** @internal */
-    _populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
-    /** @internal */
-    _populateFilter?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
-    /** @internal */
-    __populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
-    /** @internal */
-    _populateMap: Dictionary<string>;
-    private aliasCounter;
-    protected flags: Set<QueryFlag>;
-    protected finalized: boolean;
-    private populateHintFinalized;
-    private _joins;
-    private _explicitAlias;
-    private _schema?;
-    protected _cond: Dictionary;
-    private _data;
-    protected _orderBy: QueryOrderMap<Entity>[];
-    private _groupBy;
-    private _having;
-    private _returning?;
-    private _onConflict?;
-    protected _limit?: number;
-    protected _offset?: number;
-    private _distinctOn?;
-    private _joinedProps;
-    private _cache?;
-    private _indexHint?;
-    private _collation?;
-    private _comments;
-    private _hintComments;
-    private flushMode?;
-    private lockMode?;
-    private lockTables?;
-    private subQueries;
-    private _mainAlias?;
-    protected _aliases: Dictionary<Alias<any>>;
-    private _tptAlias;
-    private _helper?;
-    private _query?;
-    private _unionQuery?;
-    private _ctes;
+    get state(): QBState<Entity>;
     protected readonly platform: AbstractSqlPlatform;
-    private tptJoinsApplied;
-    private readonly autoJoinedPaths;
     /**
      * @internal
      */
@@ -842,7 +848,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     withRecursive<Name extends string>(name: Name, query: NativeQueryBuilder | RawQueryFragment, options?: CteOptions): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs & Record<Name, object>>;
     private addCte;
-    clone(reset?: boolean | string[], preserve?: string[]): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
+    clone(reset?: boolean | (keyof QBState<Entity>)[], preserve?: (keyof QBState<Entity>)[]): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs>;
     /**
      * Sets logger context for this query builder.
      */