pipework 0.251.0 → 0.252.1

package/src/data/query/pg-core/schema.ts

@@ -0,0 +1,72 @@
+import { entityKind, is } from '../entity.js';
+import { SQL, sql, type SQLWrapper } from '../sql/sql.js';
+import type { NonArray, Writable } from '../utils.js';
+import { type PgEnum, type PgEnumObject, pgEnumObjectWithSchema, pgEnumWithSchema } from './columns/enum.js';
+import { type pgSequence, pgSequenceWithSchema } from './sequence.js';
+import { type PgTableFn, pgTableWithSchema } from './table.js';
+import { type pgMaterializedView, pgMaterializedViewWithSchema, type pgView, pgViewWithSchema } from './view.js';
+
+export class PgSchema<TName extends string = string> implements SQLWrapper {
+	static readonly [entityKind]: string = 'PgSchema';
+	constructor(
+		public readonly schemaName: TName,
+	) {}
+
+	table: PgTableFn<TName> = ((name, columns, extraConfig) => {
+		return pgTableWithSchema(name, columns, extraConfig, this.schemaName);
+	});
+
+	view = ((name, columns) => {
+		return pgViewWithSchema(name, columns, this.schemaName);
+	}) as typeof pgView;
+
+	materializedView = ((name, columns) => {
+		return pgMaterializedViewWithSchema(name, columns, this.schemaName);
+	}) as typeof pgMaterializedView;
+
+	public enum<U extends string, T extends Readonly<[U, ...U[]]>>(
+		enumName: string,
+		values: T | Writable<T>,
+	): PgEnum<Writable<T>>;
+
+	public enum<E extends Record<string, string>>(
+		enumName: string,
+		enumObj: NonArray<E>,
+	): PgEnumObject<E>;
+
+	public enum(enumName: any, input: any): any {
+		return Array.isArray(input)
+			? pgEnumWithSchema(
+				enumName,
+				[...input] as [string, ...string[]],
+				this.schemaName,
+			)
+			: pgEnumObjectWithSchema(enumName, input, this.schemaName);
+	}
+
+	sequence: typeof pgSequence = ((name, options) => {
+		return pgSequenceWithSchema(name, options, this.schemaName);
+	});
+
+	getSQL(): SQL {
+		return new SQL([sql.identifier(this.schemaName)]);
+	}
+
+	shouldOmitSQLParens(): boolean {
+		return true;
+	}
+}
+
+export function isPgSchema(obj: unknown): obj is PgSchema {
+	return is(obj, PgSchema);
+}
+
+export function pgSchema<T extends string>(name: T) {
+	if (name === 'public') {
+		throw new Error(
+			`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use pgTable() instead of creating a schema`,
+		);
+	}
+
+	return new PgSchema(name);
+}

package/src/data/query/pg-core/sequence.ts

@@ -0,0 +1,41 @@
+import { entityKind, is } from '../entity.js';
+
+export type PgSequenceOptions = {
+	increment?: number | string;
+	minValue?: number | string;
+	maxValue?: number | string;
+	startWith?: number | string;
+	cache?: number | string;
+	cycle?: boolean;
+};
+
+export class PgSequence {
+	static readonly [entityKind]: string = 'PgSequence';
+
+	constructor(
+		public readonly seqName: string | undefined,
+		public readonly seqOptions: PgSequenceOptions | undefined,
+		public readonly schema: string | undefined,
+	) {
+	}
+}
+
+export function pgSequence(
+	name: string,
+	options?: PgSequenceOptions,
+): PgSequence {
+	return pgSequenceWithSchema(name, options, undefined);
+}
+
+/** @internal */
+export function pgSequenceWithSchema(
+	name: string,
+	options?: PgSequenceOptions,
+	schema?: string,
+): PgSequence {
+	return new PgSequence(name, options, schema);
+}
+
+export function isPgSequence(obj: unknown): obj is PgSequence {
+	return is(obj, PgSequence);
+}

package/src/data/query/pg-core/session.ts

@@ -0,0 +1,292 @@
+import { type Cache, hashQuery, NoopCache } from '../cache/core/cache.js';
+import type { WithCacheConfig } from '../cache/core/types.js';
+import { entityKind, is } from '../entity.js';
+import { DrizzleQueryError, TransactionRollbackError } from '../errors.js';
+import type { TablesRelationalConfig } from '../relations.js';
+import type { PreparedQuery } from '../session.js';
+import { type Query, type SQL, sql } from '../sql/index.js';
+import { tracer } from '../tracing.js';
+import type { NeonAuthToken } from '../utils.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 abstract class PgPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+	constructor(
+		protected query: Query,
+		// cache instance
+		private cache: Cache | undefined,
+		// per query related metadata
+		private queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		private cacheConfig?: WithCacheConfig,
+	) {
+		// it means that no $withCache options were passed and it should be just enabled
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enable: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enable) {
+			this.cacheConfig = undefined;
+		}
+	}
+
+	protected authToken?: NeonAuthToken | undefined;
+
+	getQuery(): Query {
+		return this.query;
+	}
+
+	mapResult(response: unknown, _isFromBatch?: boolean): unknown {
+		return response;
+	}
+
+	/** @internal */
+	setToken(token?: NeonAuthToken) {
+		this.authToken = token;
+		return this;
+	}
+
+	static readonly [entityKind]: string = 'PgPreparedQuery';
+
+	/** @internal */
+	joinsNotNullableMap?: Record<string, boolean>;
+
+	/** @internal */
+	protected async queryWithCache<T>(
+		queryString: string,
+		params: any[],
+		query: () => Promise<T>,
+	): Promise<T> {
+		if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
+			try {
+				return await query();
+			} catch (e) {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			}
+		}
+
+		// don't do any mutations, if globally is false
+		if (this.cacheConfig && !this.cacheConfig.enable) {
+			try {
+				return await query();
+			} catch (e) {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			}
+		}
+
+		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+		if (
+			(
+				this.queryMetadata.type === 'insert' || this.queryMetadata.type === 'update'
+				|| this.queryMetadata.type === 'delete'
+			) && this.queryMetadata.tables.length > 0
+		) {
+			try {
+				const [res] = await Promise.all([
+					query(),
+					this.cache.onMutate({ tables: this.queryMetadata.tables }),
+				]);
+				return res;
+			} catch (e) {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			}
+		}
+
+		// don't do any reads if globally disabled
+		if (!this.cacheConfig) {
+			try {
+				return await query();
+			} catch (e) {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			}
+		}
+
+		if (this.queryMetadata.type === 'select') {
+			const fromCache = await this.cache.get(
+				this.cacheConfig.tag ?? await hashQuery(queryString, params),
+				this.queryMetadata.tables,
+				this.cacheConfig.tag !== undefined,
+				this.cacheConfig.autoInvalidate,
+			);
+			if (fromCache === undefined) {
+				let result;
+				try {
+					result = await query();
+				} catch (e) {
+					throw new DrizzleQueryError(queryString, params, e as Error);
+				}
+				// put actual key
+				await this.cache.put(
+					this.cacheConfig.tag ?? await hashQuery(queryString, params),
+					result,
+					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
+					this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
+					this.cacheConfig.tag !== undefined,
+					this.cacheConfig.config,
+				);
+				// put flag if we should invalidate or not
+				return result;
+			}
+
+			return fromCache as unknown as T;
+		}
+		try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e as Error);
+		}
+	}
+
+	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+	/** @internal */
+	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
+	/** @internal */
+	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
+
+	/** @internal */
+	abstract all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;
+
+	/** @internal */
+	abstract isResponseInArrayMode(): boolean;
+}
+
+export interface PgTransactionConfig {
+	isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+	accessMode?: 'read only' | 'read write';
+	deferrable?: boolean;
+}
+
+export abstract class PgSession<
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends TablesRelationalConfig = Record<string, never>,
+> {
+	static readonly [entityKind]: string = 'PgSession';
+
+	constructor(protected dialect: PgDialect) {}
+
+	abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		name: string | undefined,
+		isResponseInArrayMode: boolean,
+		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute'],
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgPreparedQuery<T>;
+
+	execute<T>(query: SQL): Promise<T>;
+	/** @internal */
+	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T>;
+	/** @internal */
+	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
+				return this.prepareQuery<PreparedQueryConfig & { execute: T }>(
+					this.dialect.sqlToQuery(query),
+					undefined,
+					undefined,
+					false,
+				);
+			});
+
+			return prepared.setToken(token).execute(undefined, token);
+		});
+	}
+
+	all<T = unknown>(query: SQL): Promise<T[]> {
+		return this.prepareQuery<PreparedQueryConfig & { all: T[] }>(
+			this.dialect.sqlToQuery(query),
+			undefined,
+			undefined,
+			false,
+		).all();
+	}
+
+	async count(sql: SQL): Promise<number>;
+	/** @internal */
+	async count(sql: SQL, token?: NeonAuthToken): Promise<number>;
+	/** @internal */
+	async count(sql: SQL, token?: NeonAuthToken): Promise<number> {
+		const res = await this.execute<[{ count: string }]>(sql, token);
+
+		return Number(
+			res[0]['count'],
+		);
+	}
+
+	abstract transaction<T>(
+		transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
+		config?: PgTransactionConfig,
+	): Promise<T>;
+}
+
+export abstract class PgTransaction<
+	TQueryResult extends PgQueryResultHKT,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends TablesRelationalConfig = Record<string, never>,
+> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'PgTransaction';
+
+	constructor(
+		dialect: PgDialect,
+		session: PgSession<any, any, any>,
+		protected schema: {
+			fullSchema: Record<string, unknown>;
+			schema: TSchema;
+			tableNamesMap: Record<string, string>;
+		} | undefined,
+		protected readonly nestedIndex = 0,
+	) {
+		super(dialect, session, schema);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+
+	/** @internal */
+	getTransactionConfigSQL(config: PgTransactionConfig): SQL {
+		const chunks: string[] = [];
+		if (config.isolationLevel) {
+			chunks.push(`isolation level ${config.isolationLevel}`);
+		}
+		if (config.accessMode) {
+			chunks.push(config.accessMode);
+		}
+		if (typeof config.deferrable === 'boolean') {
+			chunks.push(config.deferrable ? 'deferrable' : 'not deferrable');
+		}
+		return sql.raw(chunks.join(' '));
+	}
+
+	setTransaction(config: PgTransactionConfig): Promise<void> {
+		return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+	}
+
+	abstract override transaction<T>(
+		transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T>;
+}
+
+export interface PgQueryResultHKT {
+	readonly $brand: 'PgQueryResultHKT';
+	readonly row: unknown;
+	readonly type: unknown;
+}
+
+export type PgQueryResultKind<TKind extends PgQueryResultHKT, TRow> = (TKind & {
+	readonly row: TRow;
+})['type'];

package/src/data/query/pg-core/subquery.ts

@@ -0,0 +1,46 @@
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { ColumnsSelection, SQL } from '../sql/sql.js';
+import type { Subquery, WithSubquery, WithSubqueryWithoutSelection } from '../subquery.js';
+import type { QueryBuilder } from './query-builders/query-builder.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'>;
+
+export interface WithAs<TAlias extends string> {
+	<TSelection extends ColumnsSelection>(
+		qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
+	): WithSubqueryWithSelection<TSelection, TAlias>;
+	(
+		qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>),
+	): WithSubqueryWithoutSelection<TAlias>;
+}
+
+export type WithAsSelected<TSelection extends ColumnsSelection, TAlias extends string> = (
+	qb: SQL | ((qb: QueryBuilder) => SQL),
+) => WithSubqueryWithSelection<TSelection, TAlias>;
+
+/** `as` is the only step left once a fence is chosen, so a fence cannot be set twice. */
+export interface WithFenced<TAs> {
+	as: TAs;
+}
+
+export interface WithBuilderResult<TAs> extends WithFenced<TAs> {
+	/** Declare the CTE `AS MATERIALIZED`. */
+	materialized(): WithFenced<TAs>;
+	/** Declare the CTE `AS NOT MATERIALIZED`. */
+	notMaterialized(): WithFenced<TAs>;
+}
+
+export interface WithBuilder {
+	<TAlias extends string>(alias: TAlias): WithBuilderResult<WithAs<TAlias>>;
+	<TAlias extends string, TSelection extends ColumnsSelection>(
+		alias: TAlias,
+		selection: TSelection,
+	): WithBuilderResult<WithAsSelected<TSelection, TAlias>>;
+}

package/src/data/query/pg-core/table.ts

@@ -0,0 +1,252 @@
+import type { BuildColumns, BuildExtraConfigColumns } 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 { getPgColumnBuilders, type PgColumnsBuilders } from './columns/all.js';
+import type { ExtraConfigColumn, PgColumn, PgColumnBuilder, PgColumnBuilderBase } from './columns/common.js';
+import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.js';
+import type { AnyIndexBuilder } from './indexes.js';
+import type { PgPolicy } from './policies.js';
+import type { PrimaryKeyBuilder } from './primary-keys.js';
+import type { UniqueConstraintBuilder } from './unique-constraint.js';
+
+export type PgTableExtraConfigValue =
+	| AnyIndexBuilder
+	| CheckBuilder
+	| ForeignKeyBuilder
+	| PrimaryKeyBuilder
+	| UniqueConstraintBuilder
+	| PgPolicy;
+
+export type PgTableExtraConfig = Record<
+	string,
+	PgTableExtraConfigValue
+>;
+
+export type TableConfig = TableConfigBase<PgColumn>;
+
+/** @internal */
+export const InlineForeignKeys = Symbol.for('drizzle:PgInlineForeignKeys');
+/** @internal */
+export const EnableRLS = Symbol.for('drizzle:EnableRLS');
+
+export class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+	static override readonly [entityKind]: string = 'PgTable';
+
+	/** @internal */
+	static override readonly Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys: InlineForeignKeys as typeof InlineForeignKeys,
+		EnableRLS: EnableRLS as typeof EnableRLS,
+	});
+
+	/**@internal */
+	[InlineForeignKeys]: ForeignKey[] = [];
+
+	/** @internal */
+	[EnableRLS]: boolean = false;
+
+	/** @internal */
+	override [Table.Symbol.ExtraConfigBuilder]: ((self: Record<string, PgColumn>) => PgTableExtraConfig) | undefined =
+		undefined;
+
+	/** @internal */
+	override [Table.Symbol.ExtraConfigColumns]: Record<string, ExtraConfigColumn> = {};
+}
+
+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];
+	}
+	& {
+		enableRLS: () => Omit<
+			PgTableWithColumns<T>,
+			'enableRLS'
+		>;
+	};
+
+/** @internal */
+export function pgTableWithSchema<
+	TTableName extends string,
+	TSchemaName extends string | undefined,
+	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+>(
+	name: TTableName,
+	columns: TColumnsMap | ((columnTypes: PgColumnsBuilders) => TColumnsMap),
+	extraConfig:
+		| ((self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig | PgTableExtraConfigValue[])
+		| undefined,
+	schema: TSchemaName,
+	baseName = name,
+): PgTableWithColumns<{
+	name: TTableName;
+	schema: TSchemaName;
+	columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+	dialect: 'pg';
+}> {
+	const rawTable = new PgTable<{
+		name: TTableName;
+		schema: TSchemaName;
+		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		dialect: 'pg';
+	}>(name, schema, baseName);
+
+	const parsedColumns: TColumnsMap = typeof columns === 'function' ? columns(getPgColumnBuilders()) : columns;
+
+	const builtColumns = Object.fromEntries(
+		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+			const colBuilder = colBuilderBase as PgColumnBuilder;
+			colBuilder.setName(name);
+			const column = colBuilder.build(rawTable);
+			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+			return [name, column];
+		}),
+	) as unknown as BuildColumns<TTableName, TColumnsMap, 'pg'>;
+
+	const builtColumnsForExtraConfig = Object.fromEntries(
+		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+			const colBuilder = colBuilderBase as PgColumnBuilder;
+			colBuilder.setName(name);
+			const column = colBuilder.buildExtraConfigColumn(rawTable);
+			return [name, column];
+		}),
+	) as unknown as BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>;
+
+	const table = Object.assign(rawTable, builtColumns);
+
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+
+	if (extraConfig) {
+		table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig as any;
+	}
+
+	return Object.assign(table, {
+		enableRLS: () => {
+			table[PgTable.Symbol.EnableRLS] = true;
+			return table as PgTableWithColumns<{
+				name: TTableName;
+				schema: TSchemaName;
+				columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+				dialect: 'pg';
+			}>;
+		},
+	});
+}
+
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig?: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+		) => PgTableExtraConfigValue[],
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		dialect: 'pg';
+	}>;
+
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+		extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfigValue[],
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		dialect: 'pg';
+	}>;
+	/**
+	 * @deprecated The third parameter of pgTable is changing and will only accept an array instead of an object
+	 *
+	 * @example
+	 * Deprecated version:
+	 * ```ts
+	 * export const users = pgTable("users", {
+	 * 	id: integer(),
+	 * }, (t) => ({
+	 * 	idx: index('custom_name').on(t.id)
+	 * }));
+	 * ```
+	 *
+	 * New API:
+	 * ```ts
+	 * export const users = pgTable("users", {
+	 * 	id: integer(),
+	 * }, (t) => [
+	 * 	index('custom_name').on(t.id)
+	 * ]);
+	 * ```
+	 */
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+		) => PgTableExtraConfig,
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		dialect: 'pg';
+	}>;
+
+	/**
+	 * @deprecated The third parameter of pgTable is changing and will only accept an array instead of an object
+	 *
+	 * @example
+	 * Deprecated version:
+	 * ```ts
+	 * export const users = pgTable("users", {
+	 * 	id: integer(),
+	 * }, (t) => ({
+	 * 	idx: index('custom_name').on(t.id)
+	 * }));
+	 * ```
+	 *
+	 * New API:
+	 * ```ts
+	 * export const users = pgTable("users", {
+	 * 	id: integer(),
+	 * }, (t) => [
+	 * 	index('custom_name').on(t.id)
+	 * ]);
+	 * ```
+	 */
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+		extraConfig: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig,
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		dialect: 'pg';
+	}>;
+}
+
+export const pgTable: PgTableFn = (name, columns, extraConfig) => {
+	return pgTableWithSchema(name, columns, extraConfig, undefined);
+};
+
+export function pgTableCreator(customizeTableName: (name: string) => string): PgTableFn {
+	return (name, columns, extraConfig) => {
+		return pgTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+	};
+}