drizzle-orm 0.28.3 → 0.28.4

package/pg-core/query-builders/refresh-materialized-view.d.cts

@@ -0,0 +1,26 @@
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgMaterializedView } from '../view.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query } from '../../sql/index.js';
+export interface PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+}
+export declare class PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    private config;
+    constructor(view: PgMaterializedView, session: PgSession, dialect: PgDialect);
+    concurrently(): this;
+    withNoData(): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: QueryResultKind<TQueryResult, never>;
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}

package/pg-core/query-builders/refresh-materialized-view.d.mts

@@ -0,0 +1,26 @@
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgMaterializedView } from '../view.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query } from '../../sql/index.js';
+export interface PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+}
+export declare class PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    private config;
+    constructor(view: PgMaterializedView, session: PgSession, dialect: PgDialect);
+    concurrently(): this;
+    withNoData(): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: QueryResultKind<TQueryResult, never>;
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}

package/pg-core/query-builders/refresh-materialized-view.d.ts

@@ -1,9 +1,9 @@
-import { entityKind } from '../../entity';
-import type { PgDialect } from '../dialect';
-import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session';
-import type { PgMaterializedView } from '../view';
-import { QueryPromise } from '../../query-promise';
-import type { Query } from '../../sql';
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgMaterializedView } from '../view.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query } from '../../sql/index.js';
 export interface PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
 }
 export declare class PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {

package/pg-core/query-builders/select.d.cts

@@ -0,0 +1,211 @@
+import { entityKind } from '../../entity.js';
+import type { PgColumn } from '../columns/index.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import type { PgTable } from '../table.js';
+import { PgViewBase } from '../view.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import { type Placeholder, type Query, SQL, type SQLWrapper } from '../../sql/index.js';
+import { Subquery } from '../../subquery.js';
+import { type ValueOrArray } from '../../utils.js';
+import { type ColumnsSelection } from '../../view.js';
+import type { JoinFn, LockConfig, LockStrength, PgSelectConfig, PgSelectHKT, PgSelectHKTBase, PgSelectQueryBuilderHKT, SelectedFields } from './select.types.js';
+type CreatePgSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? PgSelect<TTableName, TSelection, TSelectMode> : PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
+export declare class PgSelectBuilder<TSelection extends SelectedFields | undefined, TBuilderMode extends 'db' | 'qb' = 'db'> {
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: PgSession | undefined;
+        dialect: PgDialect;
+        withList?: Subquery[];
+        distinct?: boolean | {
+            on: (PgColumn | SQLWrapper)[];
+        };
+    });
+    /**
+     * Specify the table, subquery, or other target that you're
+     * building a select query against.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM|Postgres from documentation}
+     */
+    from<TFrom extends PgTable | Subquery | PgViewBase | SQL>(source: TFrom): CreatePgSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
+}
+export declare abstract class PgSelectQueryBuilder<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly selectMode: TSelectMode;
+        readonly selection: TSelection;
+        readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+    };
+    protected config: PgSelectConfig;
+    protected joinsNotNullableMap: Record<string, boolean>;
+    private tableName;
+    private isPartialSelect;
+    protected session: PgSession | undefined;
+    protected dialect: PgDialect;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+        table: PgSelectConfig['table'];
+        fields: PgSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: PgSession | undefined;
+        dialect: PgDialect;
+        withList: Subquery[];
+        distinct: boolean | {
+            on: (PgColumn | SQLWrapper)[];
+        } | undefined;
+    });
+    private createJoin;
+    /**
+     * For each row of the table, include
+     * values from a matching row of the joined
+     * table, if there is a matching row. If not,
+     * all of the columns of the joined table
+     * will be set to null.
+     */
+    leftJoin: JoinFn<THKT, TTableName, TSelectMode, "left", TSelection, TNullabilityMap>;
+    /**
+     * Includes all of the rows of the joined table.
+     * If there is no matching row in the main table,
+     * all the columns of the main table will be
+     * set to null.
+     */
+    rightJoin: JoinFn<THKT, TTableName, TSelectMode, "right", TSelection, TNullabilityMap>;
+    /**
+     * This is the default type of join.
+     *
+     * For each row of the table, the joined table
+     * needs to have a matching row, or it will
+     * be excluded from results.
+     */
+    innerJoin: JoinFn<THKT, TTableName, TSelectMode, "inner", TSelection, TNullabilityMap>;
+    /**
+     * Rows from both the main & joined are included,
+     * regardless of whether or not they have matching
+     * rows in the other table.
+     */
+    fullJoin: JoinFn<THKT, TTableName, TSelectMode, "full", TSelection, TNullabilityMap>;
+    /**
+     * Specify a condition to narrow the result set. Multiple
+     * conditions can be combined with the `and` and `or`
+     * functions.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Find cars made in the year 2000
+     * db.select().from(cars).where(eq(cars.year, 2000));
+     * ```
+     */
+    where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Sets the HAVING clause of this query, which often
+     * used with GROUP BY and filters rows after they've been
+     * grouped together and combined.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING|Postgres having clause documentation}
+     */
+    having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Specify the GROUP BY of this query: given
+     * a list of columns or SQL expressions, Postgres will
+     * combine all rows with the same values in those columns
+     * into a single row.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Group and count people by their last names
+     * db.select({
+     *    lastName: people.lastName,
+     *    count: sql<number>`count(*)::integer`
+     * }).from(people).groupBy(people.lastName);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-GROUPBY|Postgres GROUP BY documentation}
+     */
+    groupBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+    groupBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Specify the ORDER BY clause of this query: a number of
+     * columns or SQL expressions that will control sorting
+     * of results. You can specify whether results are in ascending
+     * or descending order with the `asc()` and `desc()` operators.
+     *
+     * ## Examples
+     *
+     * ```
+     * // Select cars by year released
+     * db.select().from(cars).orderBy(cars.year);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-ORDERBY|Postgres ORDER BY documentation}
+     */
+    orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+    orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Set the maximum number of rows that will be
+     * returned by this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the first 10 people from this query.
+     * db.select().from(people).limit(10);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT|Postgres LIMIT documentation}
+     */
+    limit(limit: number | Placeholder): this;
+    /**
+     * Skip a number of rows when returning results
+     * from this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the 10th-20th people from this query.
+     * db.select().from(people).offset(10).limit(10);
+     * ```
+     */
+    offset(offset: number | Placeholder): this;
+    /**
+     * The FOR clause specifies a lock strength for this query
+     * that controls how strictly it acquires exclusive access to
+     * the rows being queried.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
+     */
+    for(strength: LockStrength, config?: LockConfig): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+}
+export interface PgSelect<TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap>, QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+}
+export declare class PgSelect<TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+    static readonly [entityKind]: string;
+    private _prepare;
+    /**
+     * Create a prepared statement for this query. This allows
+     * the database to remember this query for the given session
+     * and call it by name, rather than specifying the full query.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+     */
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}
+export {};

package/pg-core/query-builders/select.d.mts

@@ -0,0 +1,211 @@
+import { entityKind } from '../../entity.js';
+import type { PgColumn } from '../columns/index.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import type { PgTable } from '../table.js';
+import { PgViewBase } from '../view.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import { type Placeholder, type Query, SQL, type SQLWrapper } from '../../sql/index.js';
+import { Subquery } from '../../subquery.js';
+import { type ValueOrArray } from '../../utils.js';
+import { type ColumnsSelection } from '../../view.js';
+import type { JoinFn, LockConfig, LockStrength, PgSelectConfig, PgSelectHKT, PgSelectHKTBase, PgSelectQueryBuilderHKT, SelectedFields } from './select.types.js';
+type CreatePgSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? PgSelect<TTableName, TSelection, TSelectMode> : PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
+export declare class PgSelectBuilder<TSelection extends SelectedFields | undefined, TBuilderMode extends 'db' | 'qb' = 'db'> {
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: PgSession | undefined;
+        dialect: PgDialect;
+        withList?: Subquery[];
+        distinct?: boolean | {
+            on: (PgColumn | SQLWrapper)[];
+        };
+    });
+    /**
+     * Specify the table, subquery, or other target that you're
+     * building a select query against.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM|Postgres from documentation}
+     */
+    from<TFrom extends PgTable | Subquery | PgViewBase | SQL>(source: TFrom): CreatePgSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
+}
+export declare abstract class PgSelectQueryBuilder<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly selectMode: TSelectMode;
+        readonly selection: TSelection;
+        readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+    };
+    protected config: PgSelectConfig;
+    protected joinsNotNullableMap: Record<string, boolean>;
+    private tableName;
+    private isPartialSelect;
+    protected session: PgSession | undefined;
+    protected dialect: PgDialect;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+        table: PgSelectConfig['table'];
+        fields: PgSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: PgSession | undefined;
+        dialect: PgDialect;
+        withList: Subquery[];
+        distinct: boolean | {
+            on: (PgColumn | SQLWrapper)[];
+        } | undefined;
+    });
+    private createJoin;
+    /**
+     * For each row of the table, include
+     * values from a matching row of the joined
+     * table, if there is a matching row. If not,
+     * all of the columns of the joined table
+     * will be set to null.
+     */
+    leftJoin: JoinFn<THKT, TTableName, TSelectMode, "left", TSelection, TNullabilityMap>;
+    /**
+     * Includes all of the rows of the joined table.
+     * If there is no matching row in the main table,
+     * all the columns of the main table will be
+     * set to null.
+     */
+    rightJoin: JoinFn<THKT, TTableName, TSelectMode, "right", TSelection, TNullabilityMap>;
+    /**
+     * This is the default type of join.
+     *
+     * For each row of the table, the joined table
+     * needs to have a matching row, or it will
+     * be excluded from results.
+     */
+    innerJoin: JoinFn<THKT, TTableName, TSelectMode, "inner", TSelection, TNullabilityMap>;
+    /**
+     * Rows from both the main & joined are included,
+     * regardless of whether or not they have matching
+     * rows in the other table.
+     */
+    fullJoin: JoinFn<THKT, TTableName, TSelectMode, "full", TSelection, TNullabilityMap>;
+    /**
+     * Specify a condition to narrow the result set. Multiple
+     * conditions can be combined with the `and` and `or`
+     * functions.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Find cars made in the year 2000
+     * db.select().from(cars).where(eq(cars.year, 2000));
+     * ```
+     */
+    where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Sets the HAVING clause of this query, which often
+     * used with GROUP BY and filters rows after they've been
+     * grouped together and combined.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING|Postgres having clause documentation}
+     */
+    having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Specify the GROUP BY of this query: given
+     * a list of columns or SQL expressions, Postgres will
+     * combine all rows with the same values in those columns
+     * into a single row.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Group and count people by their last names
+     * db.select({
+     *    lastName: people.lastName,
+     *    count: sql<number>`count(*)::integer`
+     * }).from(people).groupBy(people.lastName);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-GROUPBY|Postgres GROUP BY documentation}
+     */
+    groupBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+    groupBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Specify the ORDER BY clause of this query: a number of
+     * columns or SQL expressions that will control sorting
+     * of results. You can specify whether results are in ascending
+     * or descending order with the `asc()` and `desc()` operators.
+     *
+     * ## Examples
+     *
+     * ```
+     * // Select cars by year released
+     * db.select().from(cars).orderBy(cars.year);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-ORDERBY|Postgres ORDER BY documentation}
+     */
+    orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+    orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Set the maximum number of rows that will be
+     * returned by this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the first 10 people from this query.
+     * db.select().from(people).limit(10);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT|Postgres LIMIT documentation}
+     */
+    limit(limit: number | Placeholder): this;
+    /**
+     * Skip a number of rows when returning results
+     * from this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the 10th-20th people from this query.
+     * db.select().from(people).offset(10).limit(10);
+     * ```
+     */
+    offset(offset: number | Placeholder): this;
+    /**
+     * The FOR clause specifies a lock strength for this query
+     * that controls how strictly it acquires exclusive access to
+     * the rows being queried.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
+     */
+    for(strength: LockStrength, config?: LockConfig): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+}
+export interface PgSelect<TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap>, QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+}
+export declare class PgSelect<TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+    static readonly [entityKind]: string;
+    private _prepare;
+    /**
+     * Create a prepared statement for this query. This allows
+     * the database to remember this query for the given session
+     * and call it by name, rather than specifying the full query.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+     */
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}
+export {};

package/pg-core/query-builders/select.d.ts

@@ -1,18 +1,18 @@
-import { entityKind } from '../../entity';
-import type { PgColumn } from '../columns';
-import type { PgDialect } from '../dialect';
-import type { PgSession, PreparedQuery, PreparedQueryConfig } from '../session';
-import type { SubqueryWithSelection } from '../subquery';
-import type { PgTable } from '../table';
-import { PgViewBase } from '../view';
-import { TypedQueryBuilder } from '../../query-builders/query-builder';
-import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types';
-import { QueryPromise } from '../../query-promise';
-import { type Placeholder, type Query, SQL, type SQLWrapper } from '../../sql';
-import { Subquery } from '../../subquery';
-import { type ValueOrArray } from '../../utils';
-import { type ColumnsSelection } from '../../view';
-import type { JoinFn, LockConfig, LockStrength, PgSelectConfig, PgSelectHKT, PgSelectHKTBase, PgSelectQueryBuilderHKT, SelectedFields } from './select.types';
+import { entityKind } from '../../entity.js';
+import type { PgColumn } from '../columns/index.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import type { PgTable } from '../table.js';
+import { PgViewBase } from '../view.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import { type Placeholder, type Query, SQL, type SQLWrapper } from '../../sql/index.js';
+import { Subquery } from '../../subquery.js';
+import { type ValueOrArray } from '../../utils.js';
+import { type ColumnsSelection } from '../../view.js';
+import type { JoinFn, LockConfig, LockStrength, PgSelectConfig, PgSelectHKT, PgSelectHKTBase, PgSelectQueryBuilderHKT, SelectedFields } from './select.types.js';
 type CreatePgSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? PgSelect<TTableName, TSelection, TSelectMode> : PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
 export declare class PgSelectBuilder<TSelection extends SelectedFields | undefined, TBuilderMode extends 'db' | 'qb' = 'db'> {
     static readonly [entityKind]: string;

package/pg-core/query-builders/select.types.d.cts

@@ -0,0 +1,79 @@
+import type { SelectedFields as SelectedFieldsBase, SelectedFieldsFlat as SelectedFieldsFlatBase, SelectedFieldsOrdered as SelectedFieldsOrderedBase } from '../../operations.js';
+import type { PgColumn } from '../columns/index.js';
+import type { PgTable, PgTableWithColumns } from '../table.js';
+import type { PgViewBase, PgViewWithSelection } from '../view.js';
+import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types.js';
+import type { Placeholder, SQL, SQLWrapper } from '../../sql/index.js';
+import type { Subquery } from '../../subquery.js';
+import type { Table, UpdateTableConfig } from '../../table.js';
+import type { Assume } from '../../utils.js';
+import { type ColumnsSelection, type View } from '../../view.js';
+import type { PgSelect, PgSelectQueryBuilder } from './select.js';
+export interface Join {
+    on: SQL | undefined;
+    table: PgTable | Subquery | PgViewBase | SQL;
+    alias: string | undefined;
+    joinType: JoinType;
+    lateral?: boolean;
+}
+export type AnyPgSelect = PgSelect<any, any, any, any>;
+export type BuildAliasTable<TTable extends PgTable | View, TAlias extends string> = TTable extends Table ? PgTableWithColumns<UpdateTableConfig<TTable['_']['config'], {
+    name: TAlias;
+    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'pg'>;
+}>> : TTable extends View ? PgViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'pg'>> : never;
+export interface PgSelectConfig {
+    withList?: Subquery[];
+    fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
+    where?: SQL;
+    having?: SQL;
+    table: PgTable | Subquery | PgViewBase | SQL;
+    limit?: number | Placeholder;
+    offset?: number | Placeholder;
+    joins?: Join[];
+    orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+    groupBy?: (PgColumn | SQL | SQL.Aliased)[];
+    lockingClauses?: {
+        strength: LockStrength;
+        config: LockConfig;
+    }[];
+    distinct?: boolean | {
+        on: (PgColumn | SQLWrapper)[];
+    };
+}
+export type JoinFn<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends PgTable | Subquery | PgViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => PgSelectKind<THKT, TTableName, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends Table ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
+export type SelectedFieldsFlat = SelectedFieldsFlatBase<PgColumn>;
+export type SelectedFields = SelectedFieldsBase<PgColumn, PgTable>;
+export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<PgColumn>;
+export type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
+export type LockConfig = {
+    of?: PgTable;
+} & ({
+    noWait: true;
+    skipLocked?: undefined;
+} | {
+    noWait?: undefined;
+    skipLocked: true;
+} | {
+    noWait?: undefined;
+    skipLocked?: undefined;
+});
+export interface PgSelectHKTBase {
+    tableName: string | undefined;
+    selection: unknown;
+    selectMode: SelectMode;
+    nullabilityMap: unknown;
+    _type: unknown;
+}
+export type PgSelectKind<T extends PgSelectHKTBase, TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
+    tableName: TTableName;
+    selection: TSelection;
+    selectMode: TSelectMode;
+    nullabilityMap: TNullabilityMap;
+})['_type'];
+export interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
+    _type: PgSelectQueryBuilder<this, this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}
+export interface PgSelectHKT extends PgSelectHKTBase {
+    _type: PgSelect<this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}