drizzle-orm 0.28.3 → 0.28.4

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

@@ -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>>>;
+}

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

@@ -1,14 +1,14 @@
-import type { SelectedFields as SelectedFieldsBase, SelectedFieldsFlat as SelectedFieldsFlatBase, SelectedFieldsOrdered as SelectedFieldsOrderedBase } from '../../operations';
-import type { PgColumn } from '../columns';
-import type { PgTable, PgTableWithColumns } from '../table';
-import type { PgViewBase, PgViewWithSelection } from '../view';
-import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode } from '../../query-builders/select.types';
-import type { Placeholder, SQL, SQLWrapper } from '../../sql';
-import type { Subquery } from '../../subquery';
-import type { Table, UpdateTableConfig } from '../../table';
-import type { Assume } from '../../utils';
-import { type ColumnsSelection, type View } from '../../view';
-import type { PgSelect, PgSelectQueryBuilder } from './select';
+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;

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

@@ -0,0 +1,53 @@
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgTable } from '../table.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import { type InferModel } from '../../table.js';
+import { type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
+export interface PgUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: PgTable;
+    returning?: SelectedFieldsOrdered;
+}
+export type PgUpdateSetSource<TTable extends PgTable> = {
+    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key]> | SQL;
+} & {};
+export declare class PgUpdateBuilder<TTable extends PgTable, TQueryResult extends QueryResultHKT> {
+    private table;
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: PgSession, dialect: PgDialect);
+    set(values: PgUpdateSetSource<TTable>): PgUpdate<TTable, TQueryResult>;
+}
+export interface PgUpdate<TTable extends PgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
+}
+export declare class PgUpdate<TTable extends PgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+        readonly return: TReturning;
+    };
+    private config;
+    constructor(table: TTable, set: UpdateSet, session: PgSession, dialect: PgDialect);
+    where(where: SQL | undefined): this;
+    returning(): PgUpdate<TTable, TQueryResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): PgUpdate<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): Omit<Query, 'typings'>;
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}

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

@@ -0,0 +1,53 @@
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgTable } from '../table.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import { type InferModel } from '../../table.js';
+import { type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
+export interface PgUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: PgTable;
+    returning?: SelectedFieldsOrdered;
+}
+export type PgUpdateSetSource<TTable extends PgTable> = {
+    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key]> | SQL;
+} & {};
+export declare class PgUpdateBuilder<TTable extends PgTable, TQueryResult extends QueryResultHKT> {
+    private table;
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: PgSession, dialect: PgDialect);
+    set(values: PgUpdateSetSource<TTable>): PgUpdate<TTable, TQueryResult>;
+}
+export interface PgUpdate<TTable extends PgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
+}
+export declare class PgUpdate<TTable extends PgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+        readonly return: TReturning;
+    };
+    private config;
+    constructor(table: TTable, set: UpdateSet, session: PgSession, dialect: PgDialect);
+    where(where: SQL | undefined): this;
+    returning(): PgUpdate<TTable, TQueryResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): PgUpdate<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): Omit<Query, 'typings'>;
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
+}

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

@@ -1,14 +1,14 @@
-import type { GetColumnData } from '../../column';
-import { entityKind } from '../../entity';
-import type { PgDialect } from '../dialect';
-import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session';
-import type { PgTable } from '../table';
-import type { SelectResultFields } from '../../query-builders/select.types';
-import { QueryPromise } from '../../query-promise';
-import type { Query, SQL, SQLWrapper } from '../../sql';
-import { type InferModel } from '../../table';
-import { type UpdateSet } from '../../utils';
-import type { SelectedFields, SelectedFieldsOrdered } from './select.types';
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { PgDialect } from '../dialect.js';
+import type { PgSession, PreparedQuery, PreparedQueryConfig, QueryResultHKT, QueryResultKind } from '../session.js';
+import type { PgTable } from '../table.js';
+import type { SelectResultFields } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { Query, SQL, SQLWrapper } from '../../sql/index.js';
+import { type InferModel } from '../../table.js';
+import { type UpdateSet } from '../../utils.js';
+import type { SelectedFields, SelectedFieldsOrdered } from './select.types.js';
 export interface PgUpdateConfig {
     where?: SQL | undefined;
     set: UpdateSet;

package/pg-core/schema.d.cts

@@ -0,0 +1,13 @@
+import { entityKind } from '../entity.js';
+import { type PgTableFn } from './table.js';
+import { type pgMaterializedView, type pgView } from './view.js';
+export declare class PgSchema<TName extends string = string> {
+    readonly schemaName: TName;
+    static readonly [entityKind]: string;
+    constructor(schemaName: TName);
+    table: PgTableFn<TName>;
+    view: typeof pgView;
+    materializedView: typeof pgMaterializedView;
+}
+export declare function isPgSchema(obj: unknown): obj is PgSchema;
+export declare function pgSchema<T extends string>(name: T): PgSchema<T>;

package/pg-core/schema.d.mts

@@ -0,0 +1,13 @@
+import { entityKind } from '../entity.js';
+import { type PgTableFn } from './table.js';
+import { type pgMaterializedView, type pgView } from './view.js';
+export declare class PgSchema<TName extends string = string> {
+    readonly schemaName: TName;
+    static readonly [entityKind]: string;
+    constructor(schemaName: TName);
+    table: PgTableFn<TName>;
+    view: typeof pgView;
+    materializedView: typeof pgMaterializedView;
+}
+export declare function isPgSchema(obj: unknown): obj is PgSchema;
+export declare function pgSchema<T extends string>(name: T): PgSchema<T>;

package/pg-core/schema.d.ts

@@ -1,6 +1,6 @@
-import { entityKind } from '../entity';
-import { type PgTableFn } from './table';
-import { type pgMaterializedView, type pgView } from './view';
+import { entityKind } from '../entity.js';
+import { type PgTableFn } from './table.js';
+import { type pgMaterializedView, type pgView } from './view.js';
 export declare class PgSchema<TName extends string = string> {
     readonly schemaName: TName;
     static readonly [entityKind]: string;

package/pg-core/session.d.cts

@@ -0,0 +1,54 @@
+import { entityKind } from '../entity.js';
+import { type TablesRelationalConfig } from '../relations.js';
+import { type Query, type SQL } from '../sql/index.js';
+import { PgDatabase } from './db.js';
+import type { PgDialect } from './dialect.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
+export interface PreparedQueryConfig {
+    execute: unknown;
+    all: unknown;
+    values: unknown;
+}
+export declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+    static readonly [entityKind]: string;
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+}
+export interface PgTransactionConfig {
+    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+    accessMode?: 'read only' | 'read write';
+    deferrable?: boolean;
+}
+export declare abstract class PgSession<TQueryResult extends QueryResultHKT = QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> {
+    protected dialect: PgDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: PgDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): PreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}
+export declare abstract class PgTransaction<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: PgDialect, session: PgSession<any, any, any>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+    setTransaction(config: PgTransactionConfig): Promise<void>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+export interface QueryResultHKT {
+    readonly $brand: 'QueryRowHKT';
+    readonly row: unknown;
+    readonly type: unknown;
+}
+export type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
+})['type'];

package/pg-core/session.d.mts

@@ -0,0 +1,54 @@
+import { entityKind } from '../entity.js';
+import { type TablesRelationalConfig } from '../relations.js';
+import { type Query, type SQL } from '../sql/index.js';
+import { PgDatabase } from './db.js';
+import type { PgDialect } from './dialect.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
+export interface PreparedQueryConfig {
+    execute: unknown;
+    all: unknown;
+    values: unknown;
+}
+export declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+    static readonly [entityKind]: string;
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+}
+export interface PgTransactionConfig {
+    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+    accessMode?: 'read only' | 'read write';
+    deferrable?: boolean;
+}
+export declare abstract class PgSession<TQueryResult extends QueryResultHKT = QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> {
+    protected dialect: PgDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: PgDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): PreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}
+export declare abstract class PgTransaction<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: PgDialect, session: PgSession<any, any, any>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+    setTransaction(config: PgTransactionConfig): Promise<void>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+export interface QueryResultHKT {
+    readonly $brand: 'QueryRowHKT';
+    readonly row: unknown;
+    readonly type: unknown;
+}
+export type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
+})['type'];

package/pg-core/session.d.ts

@@ -1,9 +1,9 @@
-import { entityKind } from '../entity';
-import { type TablesRelationalConfig } from '../relations';
-import { type Query, type SQL } from '../sql';
-import { PgDatabase } from './db';
-import type { PgDialect } from './dialect';
-import type { SelectedFieldsOrdered } from './query-builders/select.types';
+import { entityKind } from '../entity.js';
+import { type TablesRelationalConfig } from '../relations.js';
+import { type Query, type SQL } from '../sql/index.js';
+import { PgDatabase } from './db.js';
+import type { PgDialect } from './dialect.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
 export interface PreparedQueryConfig {
     execute: unknown;
     all: unknown;

package/pg-core/subquery.d.cts

@@ -0,0 +1,5 @@
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { Subquery, WithSubquery } from '../subquery.js';
+import { type ColumnsSelection } from '../view.js';
+export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;
+export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;

package/pg-core/subquery.d.mts

@@ -0,0 +1,5 @@
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { Subquery, WithSubquery } from '../subquery.js';
+import { type ColumnsSelection } from '../view.js';
+export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;
+export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;

package/pg-core/subquery.d.ts

@@ -1,5 +1,5 @@
-import type { AddAliasToSelection } from '../query-builders/select.types';
-import type { Subquery, WithSubquery } from '../subquery';
-import { type ColumnsSelection } from '../view';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { Subquery, WithSubquery } from '../subquery.js';
+import { type ColumnsSelection } from '../view.js';
 export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;
 export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;

package/pg-core/table.d.cts

@@ -0,0 +1,28 @@
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '../table.js';
+import type { CheckBuilder } from './checks.js';
+import type { PgColumn, PgColumnBuilderBase } from './columns/common.js';
+import type { ForeignKeyBuilder } from './foreign-keys.js';
+import type { AnyIndexBuilder } from './indexes.js';
+import type { PrimaryKeyBuilder } from './primary-keys.js';
+import type { UniqueConstraintBuilder } from './unique-constraint.js';
+export type PgTableExtraConfig = Record<string, AnyIndexBuilder | CheckBuilder | ForeignKeyBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder>;
+export type TableConfig = TableConfigBase<PgColumn>;
+export declare class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+    static readonly [entityKind]: string;
+}
+export type AnyPgTable<TPartial extends Partial<TableConfig> = {}> = PgTable<UpdateTableConfig<TableConfig, TPartial>>;
+export type PgTableWithColumns<T extends TableConfig> = PgTable<T> & {
+    [Key in keyof T['columns']]: T['columns'][Key];
+};
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+    <TTableName extends string, TColumnsMap extends Record<string, PgColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig): PgTableWithColumns<{
+        name: TTableName;
+        schema: TSchema;
+        columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+        dialect: 'pg';
+    }>;
+}
+export declare const pgTable: PgTableFn;
+export declare function pgTableCreator(customizeTableName: (name: string) => string): PgTableFn;

package/pg-core/table.d.mts

@@ -0,0 +1,28 @@
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '../table.js';
+import type { CheckBuilder } from './checks.js';
+import type { PgColumn, PgColumnBuilderBase } from './columns/common.js';
+import type { ForeignKeyBuilder } from './foreign-keys.js';
+import type { AnyIndexBuilder } from './indexes.js';
+import type { PrimaryKeyBuilder } from './primary-keys.js';
+import type { UniqueConstraintBuilder } from './unique-constraint.js';
+export type PgTableExtraConfig = Record<string, AnyIndexBuilder | CheckBuilder | ForeignKeyBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder>;
+export type TableConfig = TableConfigBase<PgColumn>;
+export declare class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+    static readonly [entityKind]: string;
+}
+export type AnyPgTable<TPartial extends Partial<TableConfig> = {}> = PgTable<UpdateTableConfig<TableConfig, TPartial>>;
+export type PgTableWithColumns<T extends TableConfig> = PgTable<T> & {
+    [Key in keyof T['columns']]: T['columns'][Key];
+};
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+    <TTableName extends string, TColumnsMap extends Record<string, PgColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig): PgTableWithColumns<{
+        name: TTableName;
+        schema: TSchema;
+        columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+        dialect: 'pg';
+    }>;
+}
+export declare const pgTable: PgTableFn;
+export declare function pgTableCreator(customizeTableName: (name: string) => string): PgTableFn;

package/pg-core/table.d.ts

@@ -1,12 +1,12 @@
-import type { BuildColumns } from '../column-builder';
-import { entityKind } from '../entity';
-import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '../table';
-import type { CheckBuilder } from './checks';
-import type { PgColumn, PgColumnBuilder } from './columns/common';
-import type { ForeignKeyBuilder } from './foreign-keys';
-import type { AnyIndexBuilder } from './indexes';
-import type { PrimaryKeyBuilder } from './primary-keys';
-import type { UniqueConstraintBuilder } from './unique-constraint';
+import type { BuildColumns } from '../column-builder.js';
+import { entityKind } from '../entity.js';
+import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '../table.js';
+import type { CheckBuilder } from './checks.js';
+import type { PgColumn, PgColumnBuilderBase } from './columns/common.js';
+import type { ForeignKeyBuilder } from './foreign-keys.js';
+import type { AnyIndexBuilder } from './indexes.js';
+import type { PrimaryKeyBuilder } from './primary-keys.js';
+import type { UniqueConstraintBuilder } from './unique-constraint.js';
 export type PgTableExtraConfig = Record<string, AnyIndexBuilder | CheckBuilder | ForeignKeyBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder>;
 export type TableConfig = TableConfigBase<PgColumn>;
 export declare class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
@@ -17,7 +17,7 @@ export type PgTableWithColumns<T extends TableConfig> = PgTable<T> & {
     [Key in keyof T['columns']]: T['columns'][Key];
 };
 export interface PgTableFn<TSchema extends string | undefined = undefined> {
-    <TTableName extends string, TColumnsMap extends Record<string, PgColumnBuilder>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig): PgTableWithColumns<{
+    <TTableName extends string, TColumnsMap extends Record<string, PgColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig): PgTableWithColumns<{
         name: TTableName;
         schema: TSchema;
         columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;

package/pg-core/unique-constraint.d.cts

@@ -0,0 +1,25 @@
+import { entityKind } from '../entity.js';
+import type { PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
+export declare function unique(name?: string): UniqueOnConstraintBuilder;
+export declare function uniqueKeyName(table: PgTable, columns: string[]): string;
+export declare class UniqueConstraintBuilder {
+    private name?;
+    static readonly [entityKind]: string;
+    constructor(columns: PgColumn[], name?: string | undefined);
+    nullsNotDistinct(): this;
+}
+export declare class UniqueOnConstraintBuilder {
+    static readonly [entityKind]: string;
+    constructor(name?: string);
+    on(...columns: [PgColumn, ...PgColumn[]]): UniqueConstraintBuilder;
+}
+export declare class UniqueConstraint {
+    readonly table: PgTable;
+    static readonly [entityKind]: string;
+    readonly columns: PgColumn[];
+    readonly name?: string;
+    readonly nullsNotDistinct: boolean;
+    constructor(table: PgTable, columns: PgColumn[], nullsNotDistinct: boolean, name?: string);
+    getName(): string | undefined;
+}

package/pg-core/unique-constraint.d.mts

@@ -0,0 +1,25 @@
+import { entityKind } from '../entity.js';
+import type { PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
+export declare function unique(name?: string): UniqueOnConstraintBuilder;
+export declare function uniqueKeyName(table: PgTable, columns: string[]): string;
+export declare class UniqueConstraintBuilder {
+    private name?;
+    static readonly [entityKind]: string;
+    constructor(columns: PgColumn[], name?: string | undefined);
+    nullsNotDistinct(): this;
+}
+export declare class UniqueOnConstraintBuilder {
+    static readonly [entityKind]: string;
+    constructor(name?: string);
+    on(...columns: [PgColumn, ...PgColumn[]]): UniqueConstraintBuilder;
+}
+export declare class UniqueConstraint {
+    readonly table: PgTable;
+    static readonly [entityKind]: string;
+    readonly columns: PgColumn[];
+    readonly name?: string;
+    readonly nullsNotDistinct: boolean;
+    constructor(table: PgTable, columns: PgColumn[], nullsNotDistinct: boolean, name?: string);
+    getName(): string | undefined;
+}

package/pg-core/unique-constraint.d.ts

@@ -1,6 +1,6 @@
-import { entityKind } from '../entity';
-import type { PgColumn } from './columns';
-import { PgTable } from './table';
+import { entityKind } from '../entity.js';
+import type { PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
 export declare function unique(name?: string): UniqueOnConstraintBuilder;
 export declare function uniqueKeyName(table: PgTable, columns: string[]): string;
 export declare class UniqueConstraintBuilder {