@mikro-orm/sql 7.0.0-rc.3 → 7.0.0

package/query/QueryBuilder.d.ts

@@ -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,72 +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>;
-    protected aliasCounter: number;
-    protected flags: Set<QueryFlag>;
-    protected finalized: boolean;
-    protected populateHintFinalized: boolean;
-    protected _joins: Dictionary<JoinOptions>;
-    protected _explicitAlias: boolean;
-    protected _schema?: string;
-    protected _cond: Dictionary;
-    protected _data: Dictionary;
-    protected _orderBy: QueryOrderMap<Entity>[];
-    protected _groupBy: InternalField<Entity>[];
-    protected _having: Dictionary;
-    protected _returning?: InternalField<Entity>[];
-    protected _onConflict?: OnConflictClause<Entity>[];
-    protected _limit?: number;
-    protected _offset?: number;
-    protected _distinctOn?: string[];
-    protected _joinedProps: Map<string, PopulateOptions<any>>;
-    protected _cache?: boolean | number | [string, number];
-    protected _indexHint?: string;
-    protected _collation?: string;
-    protected _comments: string[];
-    protected _hintComments: string[];
-    protected flushMode?: FlushMode;
-    protected lockMode?: LockMode;
-    protected lockTables?: string[];
-    protected subQueries: Dictionary<string>;
-    protected _mainAlias?: Alias<Entity>;
-    protected _aliases: Dictionary<Alias<any>>;
-    protected _tptAlias: Dictionary<string>;
-    protected _helper?: QueryBuilderHelper;
-    protected _query?: {
-        sql?: string;
-        params?: readonly unknown[];
-        qb: NativeQueryBuilder;
-    };
-    protected _unionQuery?: {
-        sql: string;
-        params: readonly unknown[];
-    };
-    protected _ctes: (CteOptions & {
-        name: string;
-        query: NativeQueryBuilder | RawQueryFragment;
-        recursive?: boolean;
-    })[];
+    get state(): QBState<Entity>;
     protected readonly platform: AbstractSqlPlatform;
-    private tptJoinsApplied;
-    private readonly autoJoinedPaths;
     /**
      * @internal
      */
@@ -682,6 +677,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     from<Name extends string & keyof CTEs, Alias extends string = Name>(target: Name, aliasName?: Alias): SelectQueryBuilder<CTEs[Name], Alias, never, never, never, '*', CTEs>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
+    protected processReturningStatement(qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -852,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.
      */
@@ -877,7 +873,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * For embeddeds: navigates into flattened embeddeds to return the correct field name.
      */
     protected resolveNestedPath(field: string): string | string[];
-    private init;
+    protected init(type: QueryType, data?: any, cond?: any): this;
     private getQueryBase;
     private applyDiscriminatorCondition;
     /**