@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.20

package/{dist/query → query}/QueryBuilder.d.ts

@@ -1,8 +1,12 @@
+/// <reference types="node" />
+import { inspect } from 'util';
 import type { Knex } from 'knex';
-import type { AnyEntity, Dictionary, EntityData, EntityProperty, RequiredEntityData, GroupOperator, MetadataStorage, PopulateOptions, QBFilterQuery, QueryOrderMap, QueryResult, FlushMode } from '@mikro-orm/core';
-import { LockMode, QueryFlag } from '@mikro-orm/core';
+import type { AnyEntity, ConnectionType, Dictionary, EntityData, EntityName, EntityProperty, FlushMode, GroupOperator, 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 type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 /**
@@ -24,27 +28,30 @@ import type { Field } from '../typings';
  * const publisher = await qb.getSingleResult();
  * ```
  */
-export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
-    private readonly entityName;
+export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly metadata;
     private readonly driver;
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    readonly alias: string;
+    get mainAlias(): Alias;
+    get alias(): string;
+    get helper(): QueryBuilderHelper;
     /** @internal */
-    type: QueryType;
+    type?: QueryType;
     /** @internal */
     _fields?: Field<T>[];
     /** @internal */
     _populate: PopulateOptions<T>[];
     /** @internal */
+    _populateWhere?: ObjectQuery<T> | PopulateHint;
+    /** @internal */
     _populateMap: Dictionary<string>;
     private aliasCounter;
     private flags;
     private finalized;
     private _joins;
-    private _aliasMap;
+    private _explicitAlias;
     private _schema?;
     private _cond;
     private _data;
@@ -54,6 +61,7 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private _onConflict?;
     private _limit?;
     private _offset?;
+    private _distinctOn?;
     private _joinedProps;
     private _cache?;
     private _indexHint?;
@@ -61,16 +69,20 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private lockMode?;
     private lockTables?;
     private subQueries;
-    private innerPromise?;
+    private _mainAlias?;
+    private _aliases;
+    private _helper?;
     private readonly platform;
     private readonly knex;
-    private readonly helper;
     /**
      * @internal
      */
-    constructor(entityName: string, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: "write" | "read" | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").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").AbstractSqlConnection, import("../AbstractSqlPlatform").AbstractSqlPlatform>> | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
+    distinct(): SelectQueryBuilder<T>;
+    /** postgres only */
+    distinctOn(fields: string | string[]): SelectQueryBuilder<T>;
     insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
     update(data: EntityData<T>): UpdateQueryBuilder<T>;
     delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
@@ -78,9 +90,9 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
     join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    protected getFieldsForJoinedLoad<U extends AnyEntity<U>>(prop: EntityProperty<U>, alias: string): Field<U>[];
+    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>[];
     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;
@@ -88,16 +100,16 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     andWhere(cond: string, params?: any[]): this;
     orWhere(cond: QBFilterQuery<T>): this;
     orWhere(cond: string, params?: any[]): this;
-    orderBy(orderBy: QueryOrderMap<unknown> | QueryOrderMap<unknown>[]): this;
+    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): this;
     groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): this;
     having(cond?: QBFilterQuery | string, params?: any[]): this;
-    onConflict(fields?: string | string[]): this;
+    onConflict(fields?: Field<T> | Field<T>[]): this;
     ignore(): this;
     merge(data?: EntityData<T> | Field<T>[]): this;
     /**
      * @internal
      */
-    populate(populate: PopulateOptions<T>[]): this;
+    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint): this;
     /**
      * @internal
      */
@@ -117,6 +129,12 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: string): this;
+    /**
+     * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
+     * Allows setting a main string alias of the selection data.
+     */
+    from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): QueryBuilder<T>;
+    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): QueryBuilder<T>;
     getKnexQuery(): Knex.QueryBuilder;
     /**
      * Returns the query with parameters as wildcards.
@@ -130,8 +148,18 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * Returns raw interpolated query string with all the parameters inlined.
      */
     getFormattedQuery(): string;
+    /**
+     * @internal
+     */
     getAliasForJoinPath(path?: string): string | undefined;
+    /**
+     * @internal
+     */
     getNextAlias(entityName?: string): string;
+    /**
+     * @internal
+     */
+    getAliasMap(): Dictionary<string>;
     /**
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
@@ -153,11 +181,14 @@ export declare class QueryBuilder<T extends AnyEntity<T> = 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.
      */
     then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[] | number | QueryResult<T>>;
-    private getInnerPromise;
     /**
      * Returns knex 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
@@ -170,23 +201,33 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private init;
     private getQueryBase;
     private finalize;
+    private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;
     private autoJoinPivotTable;
+    private getSchema;
+    private createAlias;
+    private createMainAlias;
+    private fromSubQuery;
+    private fromEntityName;
+    private createQueryBuilderHelper;
+    private ensureFromClause;
+    private ensureNotFinalized;
+    [inspect.custom](depth: number): string;
 }
-export interface RunQueryBuilder<T> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
+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;
     execute<U = QueryResult<T>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<T>>;
 }
-export interface SelectQueryBuilder<T> extends QueryBuilder<T> {
+export interface SelectQueryBuilder<T extends object> extends QueryBuilder<T> {
     execute<U = T[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
     execute<U = T[]>(method: 'all', mapResults?: boolean): Promise<U>;
     execute<U = T>(method: 'get', mapResults?: boolean): Promise<U>;
     execute<U = QueryResult<T>>(method: 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[]>;
 }
-export interface CountQueryBuilder<T> extends QueryBuilder<T> {
+export interface CountQueryBuilder<T extends object> extends QueryBuilder<T> {
     execute<U = {
         count: number;
     }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
@@ -201,11 +242,11 @@ export interface CountQueryBuilder<T> extends QueryBuilder<T> {
     }>>(method: 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
 }
-export interface InsertQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface UpdateQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface UpdateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface DeleteQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface DeleteQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface TruncateQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface TruncateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }