pipework 0.252.0 → 0.252.1

package/src/data/query/pg-core/query-builders/select.types.ts

@@ -0,0 +1,437 @@
+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 } from '../view-base.js';
+import type { PgViewWithSelection } from '../view.js';
+import type { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type {
+	AppendToNullabilityMap,
+	AppendToResult,
+	BuildSubquerySelection,
+	GetSelectTableName,
+	JoinNullability,
+	JoinType,
+	MapColumnsToTableAlias,
+	SelectMode,
+	SelectResult,
+	SetOperator,
+} from '../../query-builders/select.types.js';
+import type { ColumnsSelection, Placeholder, SQL, SQLWrapper, View } from '../../sql/sql.js';
+import type { Subquery } from '../../subquery.js';
+import type { Table, UpdateTableConfig } from '../../table.js';
+import type { Assume, DrizzleTypeError, Equal, ValidateShape, ValueOrArray } from '../../utils.js';
+import type { PgPreparedQuery, PreparedQueryConfig } from '../session.js';
+import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.js';
+
+export interface PgSelectJoinConfig {
+	on: SQL | undefined;
+	table: PgTable | Subquery | PgViewBase | SQL;
+	alias: string | undefined;
+	joinType: JoinType;
+	lateral?: boolean;
+}
+
+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[];
+	// Either fields or fieldsFlat must be defined
+	fields: Record<string, unknown>;
+	fieldsFlat?: SelectedFieldsOrdered;
+	where?: SQL | undefined;
+	having?: SQL | undefined;
+	table: PgTable | Subquery | PgViewBase | SQL;
+	limit?: number | Placeholder | undefined;
+	offset?: number | Placeholder | undefined;
+	joins?: PgSelectJoinConfig[];
+	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+	groupBy?: (PgColumn | SQL | SQL.Aliased)[];
+	lockingClause?: {
+		strength: LockStrength;
+		config: LockConfig;
+	};
+	distinct?: boolean | {
+		on: (PgColumn | SQLWrapper)[];
+	} | undefined;
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+		limit?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
+}
+
+export type TableLikeHasEmptySelection<T extends PgTable | Subquery | PgViewBase | SQL> = T extends Subquery
+	? Equal<T['_']['selectedFields'], {}> extends true ? true : false
+	: false;
+
+export type PgSelectJoin<
+	T extends AnyPgSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends PgTable | Subquery | PgViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? PgSelectWithout<
+		PgSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends Table ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			T['_']['dynamic'],
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type PgSelectJoinFn<
+	T extends AnyPgSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => PgSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type PgSelectCrossJoinFn<
+	T extends AnyPgSelectQueryBuilder,
+	TDynamic extends boolean,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+) => PgSelectJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
+
+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?: ValueOrArray<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;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
+	_type: unknown;
+}
+
+export type PgSelectKind<
+	T extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> = (T & {
+	tableName: TTableName;
+	selection: TSelection;
+	selectMode: TSelectMode;
+	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
+})['_type'];
+
+export interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
+	_type: PgSelectQueryBuilderBase<
+		PgSelectQueryBuilderHKT,
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface PgSelectHKT extends PgSelectHKTBase {
+	_type: PgSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export type CreatePgSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+> = TBuilderMode extends 'db' ? PgSelectBase<TTableName, TSelection, TSelectMode>
+	: PgSelectQueryBuilderBase<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
+
+export type PgSetOperatorExcludedMethods =
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin'
+	| 'where'
+	| 'having'
+	| 'groupBy'
+	| 'for';
+
+export type PgSelectWithout<
+	T extends AnyPgSelectQueryBuilder,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+	TResetExcluded extends boolean = false,
+> = TDynamic extends true ? T : Omit<
+	PgSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
+>;
+
+export type PgSelectPrepare<T extends AnyPgSelect> = PgPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	}
+>;
+
+export type PgSelectDynamic<T extends AnyPgSelectQueryBuilder> = PgSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type PgSelectQueryBuilder<
+	THKT extends PgSelectHKTBase = PgSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult extends any[] = unknown[],
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = PgSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyPgSelectQueryBuilder = PgSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+
+export type AnyPgSetOperatorInterface = PgSetOperatorInterface<any, any, any, any, any, any, any, any>;
+
+export interface PgSetOperatorInterface<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> {
+	_: {
+		readonly hkt: PgSelectHKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+}
+
+export type PgSetOperatorWithResult<TResult extends any[]> = PgSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	TResult,
+	any
+>;
+
+export type PgSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
+
+export type PgSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	PgSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends PgSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly PgSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
+		? Rest extends AnyPgSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+	: never
+	: TValue;
+
+export type PgCreateSetOperatorFn = <
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TValue extends PgSetOperatorWithResult<TResult>,
+	TRest extends PgSetOperatorWithResult<TResult>[],
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: PgSetOperatorInterface<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => PgSelectWithout<
+	PgSelectBase<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	false,
+	PgSetOperatorExcludedMethods,
+	true
+>;
+
+export type GetPgSetOperators = {
+	union: PgCreateSetOperatorFn;
+	intersect: PgCreateSetOperatorFn;
+	except: PgCreateSetOperatorFn;
+	unionAll: PgCreateSetOperatorFn;
+	intersectAll: PgCreateSetOperatorFn;
+	exceptAll: PgCreateSetOperatorFn;
+};