pqb 0.67.0 → 0.67.1

package/dist/index.d.ts

@@ -2696,11 +2696,172 @@ interface AggregateOptions<T extends PickQuerySelectableResultRelationsWindows>
   over?: Over<T>;
 }
 type Over<T extends PickQuerySelectableResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
-type QueryGetSelf = PickQuerySelectable;
-type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression;
+interface ColumnsShape {
+  [K: string]: Column;
+}
+declare namespace ColumnsShape {
+  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
+  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['outputType'] };
+  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['inputType'] } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['inputType'] };
+  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['inputType'] };
+  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
+  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['outputType'] };
+  export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
+    dataType: 'object';
+    type: { [K in keyof Shape]: Shape[K]['type'] };
+    outputType: ShallowSimplify<ObjectOutput<Shape>>;
+    queryType: { [K in keyof Shape]: Shape[K]['queryType'] };
+    operators: OperatorsAny;
+  }
+  export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
+    dataType: 'object';
+    type: { [K in keyof Shape]: Shape[K]['type'] };
+    outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
+    queryType: { [K in keyof Shape]: Shape[K]['queryType'] } | null;
+    operators: OperatorsAny;
+  }
+  export interface MapToPluckColumn<Shape extends Column.QueryColumns> {
+    dataType: 'array';
+    type: Shape['pluck']['type'][];
+    outputType: Shape['pluck']['outputType'][];
+    queryType: Shape['pluck']['queryType'][];
+    operators: OperatorsAny;
+  }
+  export interface MapToObjectArrayColumn<Shape extends Column.QueryColumns> {
+    dataType: 'array';
+    type: { [K in keyof Shape]: Shape[K]['type'] }[];
+    outputType: ShallowSimplify<ObjectOutput<Shape>>[];
+    queryType: { [K in keyof Shape]: Shape[K]['queryType'] }[];
+    operators: OperatorsAny;
+  }
+  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
+  export {};
+}
+interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
+type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
+interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
+  withData: T['withData'];
+}
+type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['maybeSingle'] & SubQueryAddition<T> : K extends keyof T ? T[K] : never };
+interface SelectAsArg<T extends SelectSelf> {
+  [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
+}
+type SelectAsFnReturnType = {
+  result: Column.QueryColumns;
+  returnType: Exclude<QueryReturnType, 'rows'>;
+} | Expression;
+interface SelectAsCheckReturnTypes {
+  [K: string]: PropertyKey | Expression | ((q: never) => SelectAsFnReturnType);
+}
+type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
+type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
+type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never }> : T[K] } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never }[keyof Obj] & string}`;
+type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
+{ [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
+interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
+  result: Column.QueryColumns;
+  returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
+}
+type SelectAsSelectable<Obj> = UnionToIntersection<{ [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? { [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
+  as: C;
+  column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
+} } : never }[keyof Obj]>;
+type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery | Expression) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
+type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
+declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+declare class Select {
+  /**
+   * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
+   *
+   * The last argument can be an object. Keys of the object are column aliases, value can be a column name, sub-query, or raw SQL expression.
+   *
+   * ```ts
+   * import { sql } from './baseTable'
+   *
+   * // select columns of the table:
+   * db.table.select('id', 'name', { idAlias: 'id' });
+   *
+   * // accepts columns with table names:
+   * db.table.select('user.id', 'user.name', { nameAlias: 'user.name' });
+   *
+   * // table name may refer to the current table or a joined table:
+   * db.table
+   *   .join(db.message, 'authorId', 'user.id')
+   *   .select('user.name', 'message.text', { textAlias: 'message.text' });
+   *
+   * // select value from the sub-query,
+   * // this sub-query should return a single record and a single column:
+   * db.table.select({
+   *   subQueryResult: Otherdb.table.select('column').take(),
+   * });
+   *
+   * // select raw SQL value, specify the returning type via <generic> syntax:
+   * db.table.select({
+   *   raw: sql<number>`1 + 2`,
+   * });
+   *
+   * // select raw SQL value, the resulting type can be set by providing a column type in such way:
+   * db.table.select({
+   *   raw: sql`1 + 2`.type((t) => t.integer()),
+   * });
+   *
+   * // same raw SQL query as above, but the sql is returned from a callback
+   * db.table.select({
+   *   raw: () => sql`1 + 2`.type((t) => t.integer()),
+   * });
+   * ```
+   *
+   * When you use the ORM and defined relations, `select` can also accept callbacks with related table queries:
+   *
+   * ```ts
+   * await db.author.select({
+   *   allBooks: (q) => q.books,
+   *   firstBook: (q) => q.books.order({ createdAt: 'ASC' }).take(),
+   *   booksCount: (q) => q.books.count(),
+   * });
+   * ```
+   *
+   * When you're selecting a relation that's connected via `belongsTo` or `hasOne`, it becomes available to use in `order` or in `where`:
+   *
+   * ```ts
+   * // select books with their authors included, order by author name and filter by author column:
+   * await db.books
+   *   .select({
+   *     author: (q) => q.author,
+   *   })
+   *   .order('author.name')
+   *   .where({ 'author.isPopular': true });
+   * ```
+   */
+  select<T extends SelectSelf, Columns extends SelectArgs<T>>(this: T, ...args: Columns): SelectResult<T, Columns>;
+  select<T extends SelectSelf, Obj extends SelectAsArg<T>>(this: T, obj: Obj): SelectResultObj<T, Obj>;
+  select<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+  /**
+   * When querying the table or creating records, all columns are selected by default,
+   * but updating and deleting queries are returning affected row counts by default.
+   *
+   * Use `selectAll` to select all columns. If the `.select` method was applied before it will be discarded.
+   *
+   * ```ts
+   * const selectFull = await db.table
+   *   .select('id', 'name') // discarded by `selectAll`
+   *   .selectAll();
+   *
+   * const updatedFull = await db.table.selectAll().where(conditions).update(data);
+   *
+   * const deletedFull = await db.table.selectAll().where(conditions).delete();
+   * ```
+   */
+  selectAll<T extends SelectSelf>(this: T): SelectResult<T, ['*']>;
+}
+interface QueryGetSelf extends PickQuerySelectable, PickQueryRelationsWithData {}
+type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
 type GetStringArg<T extends PickQuerySelectable> = keyof T['__selectable'] & string;
-type GetResult<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOrThrow<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Arg['result']['value']> : never;
-type GetResultOptional<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOptional<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOptional<T, Arg['result']['value']> : never;
+type ResolveGetArgColumn<Arg> = Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => infer R) ? R extends Expression ? R['result']['value'] : R extends Query.Pick.SingleValueResult ? R['result']['value'] : never : never;
+type GetResult<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOrThrow<T, Arg> : SetQueryReturnsColumnOrThrow<T, ResolveGetArgColumn<Arg>>;
+type GetResultOptional<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOptional<T, Arg> : SetQueryReturnsColumnOptional<T, ResolveGetArgColumn<Arg>>;
 type HeadlineSearchArg<T extends PickQueryTsQuery> = Exclude<T['__tsQuery'], undefined>;
 interface HeadlineParams<T extends PickQuerySelectable> {
   text?: SelectableOrExpressionOfType<T, Column.Pick.QueryColumnOfType<string>>;
@@ -5927,166 +6088,6 @@ declare class QueryTransaction {
    */
   recoverable<T>(this: T): T;
 }
-interface ColumnsShape {
-  [K: string]: Column;
-}
-declare namespace ColumnsShape {
-  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['outputType'] };
-  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['inputType'] } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['inputType'] };
-  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['inputType'] };
-  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
-  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['outputType'] };
-  export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
-    dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify<ObjectOutput<Shape>>;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] };
-    operators: OperatorsAny;
-  }
-  export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
-    dataType: 'object';
-    type: { [K in keyof Shape]: Shape[K]['type'] };
-    outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] } | null;
-    operators: OperatorsAny;
-  }
-  export interface MapToPluckColumn<Shape extends Column.QueryColumns> {
-    dataType: 'array';
-    type: Shape['pluck']['type'][];
-    outputType: Shape['pluck']['outputType'][];
-    queryType: Shape['pluck']['queryType'][];
-    operators: OperatorsAny;
-  }
-  export interface MapToObjectArrayColumn<Shape extends Column.QueryColumns> {
-    dataType: 'array';
-    type: { [K in keyof Shape]: Shape[K]['type'] }[];
-    outputType: ShallowSimplify<ObjectOutput<Shape>>[];
-    queryType: { [K in keyof Shape]: Shape[K]['queryType'] }[];
-    operators: OperatorsAny;
-  }
-  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['outputType'] };
-  export {};
-}
-interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
-type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
-interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
-  withData: T['withData'];
-}
-type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['maybeSingle'] & SubQueryAddition<T> : K extends keyof T ? T[K] : never };
-interface SelectAsArg<T extends SelectSelf> {
-  [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
-}
-type SelectAsFnReturnType = {
-  result: Column.QueryColumns;
-  returnType: Exclude<QueryReturnType, 'rows'>;
-} | Expression;
-interface SelectAsCheckReturnTypes {
-  [K: string]: PropertyKey | Expression | ((q: never) => SelectAsFnReturnType);
-}
-type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
-type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
-type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never }> : T[K] } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never }[keyof Obj] & string}`;
-type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
-{ [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
-interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
-  result: Column.QueryColumns;
-  returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
-}
-type SelectAsSelectable<Obj> = UnionToIntersection<{ [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? { [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
-  as: C;
-  column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
-} } : never }[keyof Obj]>;
-type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery | Expression) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
-type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
-declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
-declare class Select {
-  /**
-   * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
-   *
-   * The last argument can be an object. Keys of the object are column aliases, value can be a column name, sub-query, or raw SQL expression.
-   *
-   * ```ts
-   * import { sql } from './baseTable'
-   *
-   * // select columns of the table:
-   * db.table.select('id', 'name', { idAlias: 'id' });
-   *
-   * // accepts columns with table names:
-   * db.table.select('user.id', 'user.name', { nameAlias: 'user.name' });
-   *
-   * // table name may refer to the current table or a joined table:
-   * db.table
-   *   .join(db.message, 'authorId', 'user.id')
-   *   .select('user.name', 'message.text', { textAlias: 'message.text' });
-   *
-   * // select value from the sub-query,
-   * // this sub-query should return a single record and a single column:
-   * db.table.select({
-   *   subQueryResult: Otherdb.table.select('column').take(),
-   * });
-   *
-   * // select raw SQL value, specify the returning type via <generic> syntax:
-   * db.table.select({
-   *   raw: sql<number>`1 + 2`,
-   * });
-   *
-   * // select raw SQL value, the resulting type can be set by providing a column type in such way:
-   * db.table.select({
-   *   raw: sql`1 + 2`.type((t) => t.integer()),
-   * });
-   *
-   * // same raw SQL query as above, but the sql is returned from a callback
-   * db.table.select({
-   *   raw: () => sql`1 + 2`.type((t) => t.integer()),
-   * });
-   * ```
-   *
-   * When you use the ORM and defined relations, `select` can also accept callbacks with related table queries:
-   *
-   * ```ts
-   * await db.author.select({
-   *   allBooks: (q) => q.books,
-   *   firstBook: (q) => q.books.order({ createdAt: 'ASC' }).take(),
-   *   booksCount: (q) => q.books.count(),
-   * });
-   * ```
-   *
-   * When you're selecting a relation that's connected via `belongsTo` or `hasOne`, it becomes available to use in `order` or in `where`:
-   *
-   * ```ts
-   * // select books with their authors included, order by author name and filter by author column:
-   * await db.books
-   *   .select({
-   *     author: (q) => q.author,
-   *   })
-   *   .order('author.name')
-   *   .where({ 'author.isPopular': true });
-   * ```
-   */
-  select<T extends SelectSelf, Columns extends SelectArgs<T>>(this: T, ...args: Columns): SelectResult<T, Columns>;
-  select<T extends SelectSelf, Obj extends SelectAsArg<T>>(this: T, obj: Obj): SelectResultObj<T, Obj>;
-  select<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
-  /**
-   * When querying the table or creating records, all columns are selected by default,
-   * but updating and deleting queries are returning affected row counts by default.
-   *
-   * Use `selectAll` to select all columns. If the `.select` method was applied before it will be discarded.
-   *
-   * ```ts
-   * const selectFull = await db.table
-   *   .select('id', 'name') // discarded by `selectAll`
-   *   .selectAll();
-   *
-   * const updatedFull = await db.table.selectAll().where(conditions).update(data);
-   *
-   * const deletedFull = await db.table.selectAll().where(conditions).delete();
-   * ```
-   */
-  selectAll<T extends SelectSelf>(this: T): SelectResult<T, ['*']>;
-}
 type SelectItem = string | SelectAs | Expression | undefined;
 interface SelectAs {
   selectAs: SelectAsValue;
@@ -9481,6 +9482,23 @@ declare class QueryGet {
    */
   getOptional<T extends QueryGetSelf, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
 }
+interface QueryPluckSelf extends PickQuerySelectable, PickQueryRelationsWithData {}
+type PluckArg<T extends QueryPluckSelf> = SelectableOrExpression<T> | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
+type PluckResult<T extends QueryPluckSelf, S extends PluckArg<T>> = S extends ((q: never) => infer R) ? R extends Expression ? SetQueryReturnsPluck<T, R> : R extends Query.Pick.SingleValueResult ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+  pluck: R['result']['value'];
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<R['result']['value']['outputType'][]> : T[K] } : never : S extends SelectableOrExpression<T> ? SetQueryReturnsPluck<T, S> : never;
+declare class QueryPluck {
+  /**
+   * `.pluck` returns a single array of a single selected column values:
+   *
+   * ```ts
+   * const ids = await db.table.select('id').pluck();
+   * // ids are an array of all users' id like [1, 2, 3]
+   * ```
+   * @param select - column name or a raw SQL
+   */
+  pluck<T extends QueryPluckSelf, S extends PluckArg<T>>(this: T, select: S): PluckResult<T, S>;
+}
 interface MergeQueryArg extends PickQueryTable, PickQuerySelectable, PickQueryResult, PickQueryReturnType, PickQueryWithData, PickQueryWindows, PickQueryThen, PickQueryHasSelect, PickQueryHasWhere {}
 type MergeQuery<T extends MergeQueryArg, Q extends MergeQueryArg> = { [K in keyof T]: K extends '__hasWhere' | '__hasSelect' ? T[K] & Q[K] : K extends '__selectable' | 'windows' | 'withData' ? Q[K] & Omit<T[K], keyof Q[K]> : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? Q['returnType'] extends undefined ? QueryThenByQuery<T, MergeQueryResult<T, Q>> : Q['returnType'] extends 'all' | 'one' | 'oneOrThrow' | 'rows' ? QueryThenByQuery<Q, MergeQueryResult<T, Q>> : Q['__hasSelect'] extends true ? Q['then'] : T['__hasSelect'] extends true ? T['then'] : Q['then'] : T[K] };
 type MergeQueryResult<T extends PickQueryHasSelectResult, Q extends PickQueryHasSelectResult> = T['__hasSelect'] extends true ? Q['__hasSelect'] extends true ? Omit<T['result'], keyof Q['result']> & Q['result'] : T['result'] : Q['result'];
@@ -9750,7 +9768,7 @@ interface NarrowPluckTypeResult<T extends PickQueryResultReturnType, Narrow> ext
 }
 type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? { [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : Column.Modifiers.QueryColumnToOptional<R['result'][K]> } : K extends 'then' ? QueryIfResultThen<T, R> : T[K] };
 type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'] }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['outputType'] | R['result']['value']['outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['outputType'] | R['result']['value']['outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['outputType'] | R['result'][keyof R['result']]['outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['outputType'] | R['result']['pluck']['outputType'])[]> : QueryThen<void>;
-interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks, QueryUpsert, QueryOrCreate, QueryGet, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow {}
+interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow {}
 declare class QueryMethods<ColumnTypes> {
   /**
    * `.all` is a default behavior, that returns an array of objects:
@@ -9805,16 +9823,6 @@ declare class QueryMethods<ColumnTypes> {
    * ```
    */
   rows<T extends PickQueryResult>(this: T): SetQueryReturnsRows<T>;
-  /**
-   * `.pluck` returns a single array of a single selected column values:
-   *
-   * ```ts
-   * const ids = await db.table.select('id').pluck();
-   * // ids are an array of all users' id like [1, 2, 3]
-   * ```
-   * @param select - column name or a raw SQL
-   */
-  pluck<T extends PickQuerySelectable, S extends SelectableOrExpression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
   /**
    * `.exec` won't parse the response at all, and returns undefined:
    *
@@ -10279,6 +10287,14 @@ declare namespace Query {
     type Arg<T extends Order.ArgThis> = Order.Arg<T>;
     type Args<T extends Order.ArgThis> = Order.Args<T>;
   }
+  namespace Pick {
+    interface SingleValueResult {
+      result: {
+        value: Column.Pick.OutputType;
+      };
+      returnType: 'value' | 'valueOrThrow';
+    }
+  }
 }
 type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['type'] extends Type | null ? K : never }[keyof T['__selectable']];
 type SelectableOrExpressionOfType<T extends PickQuerySelectable, C extends Column.Pick.Type> = SelectableOfType<T, C['type']> | Expression<Column.Pick.QueryColumnOfType<C['type'] | null>>;

package/dist/index.js

@@ -6763,17 +6763,27 @@ const _get = (query, returnType, arg) => {
 	if (q.returning) q.returning = void 0;
 	q.returnType = returnType;
 	let type;
-	if (typeof arg === "string") {
-		const joinedAs = q.valuesJoinedAs?.[arg];
-		type = joinedAs ? q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, arg);
+	let value = arg;
+	if (typeof value === "function") {
+		const item = processSelectAsArg(query, getQueryAs(query), "value", value);
+		if (item !== false) value = item;
+	}
+	if (typeof value === "string") {
+		const joinedAs = q.valuesJoinedAs?.[value];
+		type = joinedAs ? q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, value);
 		q.getColumn = type;
-		const selected = setParserForSelectedString(query, joinedAs ? joinedAs + "." + arg : arg, getQueryAs(query), getValueKey);
+		const selected = setParserForSelectedString(query, joinedAs ? joinedAs + "." + value : value, getQueryAs(query), getValueKey);
 		q.select = selected ? [q.expr = new SelectItemExpression(query, selected, type)] : void 0;
-	} else {
-		type = arg.result.value;
+	} else if (isExpression(value)) {
+		type = value.result.value;
 		q.getColumn = type;
-		addParserForRawExpression(query, getValueKey, arg);
-		q.select = [q.expr = arg];
+		addParserForRawExpression(query, getValueKey, value);
+		q.select = [q.expr = value];
+	} else {
+		const selected = value;
+		q.getColumn = selected.q.getColumn;
+		if (q.getColumn) addColumnParserToQuery(q, getValueKey, q.getColumn);
+		q.select = selected ? [{ selectAs: { value: selected } }] : void 0;
 	}
 	return setQueryOperators(query, type?.operators || Operators.any);
 };
@@ -10888,44 +10898,49 @@ const collectNestedSelectBatches = (batches, rows, path, last) => {
 };
 const emptyArrSQL = new RawSql("'[]'");
 const processSelectArg = (q, as, arg, columnAs) => {
-	const query = q;
 	if (typeof arg === "string") return setParserForSelectedString(q, arg, as, columnAs);
 	const selectAs = {};
 	for (const key in arg) {
-		let value = arg[key];
-		let joinQuery;
-		if (typeof value === "function") {
-			value = resolveSubQueryCallback(q, value);
-			if (isQueryNone(value)) {
-				if (value.q.innerJoinLateral) return false;
-			}
-			if (!isExpression(value)) {
-				if (isRelationQuery(value) && value.q.subQuery !== 1) {
-					joinQuery = true;
-					setSelectRelation(query.q);
-					value = value.joinQuery(value, q);
-					let subQuery;
-					const { returnType, innerJoinLateral } = value.q;
-					if (!returnType || returnType === "all") {
-						subQuery = value.json(false);
-						if (!innerJoinLateral) value.q.coalesceValue = emptyArrSQL;
-					} else if (returnType === "pluck") {
-						subQuery = value.q.select ? value.wrap(cloneQueryBaseUnscoped(value)).jsonAgg(value.q.select[0]) : value.json(false);
-						value.q.coalesceValue = emptyArrSQL;
-					} else if (returnType === "value" || returnType === "valueOrThrow") if (value.q.select) {
-						if (typeof value.q.select[0] === "string") value.q.select[0] = { selectAs: { r: value.q.select[0] } };
-						subQuery = value;
-					} else subQuery = value.json(false);
-					else subQuery = value;
-					const as = _joinLateral(q, innerJoinLateral ? "JOIN" : "LEFT JOIN", subQuery, key, innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow");
-					if (as) value.q.joinedForSelect = _copyQueryAliasToQuery(value, q, as);
-				}
-				value = prepareSubQueryForSql(q, value);
+		const item = processSelectAsArg(q, as, key, arg[key]);
+		if (item === false) return false;
+		selectAs[key] = item;
+	}
+	return { selectAs };
+};
+const processSelectAsArg = (q, as, key, arg) => {
+	const query = q;
+	let value = arg;
+	let joinQuery;
+	if (typeof value === "function") {
+		value = resolveSubQueryCallback(q, value);
+		if (isQueryNone(value)) {
+			if (value.q.innerJoinLateral) return false;
+		}
+		if (!isExpression(value)) {
+			if (isRelationQuery(value) && value.q.subQuery !== 1) {
+				joinQuery = true;
+				setSelectRelation(query.q);
+				value = value.joinQuery(value, q);
+				let subQuery;
+				const { returnType, innerJoinLateral } = value.q;
+				if (!returnType || returnType === "all") {
+					subQuery = value.json(false);
+					if (!innerJoinLateral) value.q.coalesceValue = emptyArrSQL;
+				} else if (returnType === "pluck") {
+					subQuery = value.q.select ? value.wrap(cloneQueryBaseUnscoped(value)).jsonAgg(value.q.select[0]) : value.json(false);
+					value.q.coalesceValue = emptyArrSQL;
+				} else if (returnType === "value" || returnType === "valueOrThrow") if (value.q.select) {
+					if (typeof value.q.select[0] === "string") value.q.select[0] = { selectAs: { r: value.q.select[0] } };
+					subQuery = value;
+				} else subQuery = value.json(false);
+				else subQuery = value;
+				const as = _joinLateral(q, innerJoinLateral || query.q.returnType === "valueOrThrow" ? "JOIN" : "LEFT JOIN", subQuery, key, innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow");
+				if (as) value.q.joinedForSelect = _copyQueryAliasToQuery(value, q, as);
 			}
+			value = prepareSubQueryForSql(q, value);
 		}
-		selectAs[key] = addParserForSelectItem(q, as, key, value, key, joinQuery);
 	}
-	return { selectAs };
+	return addParserForSelectItem(query, as, key, value, key, joinQuery);
 };
 const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
 	const { q } = query;
@@ -12831,6 +12846,28 @@ var Having = class {
 		return pushQueryValueImmutable(_clone(this), "having", args);
 	}
 };
+var QueryPluck = class {
+	/**
+	* `.pluck` returns a single array of a single selected column values:
+	*
+	* ```ts
+	* const ids = await db.table.select('id').pluck();
+	* // ids are an array of all users' id like [1, 2, 3]
+	* ```
+	* @param select - column name or a raw SQL
+	*/
+	pluck(select) {
+		const q = _clone(this);
+		q.q.returnType = "pluck";
+		let selected;
+		if (typeof select === "function") {
+			const item = processSelectAsArg(q, q.q.as || q.table, "pluck", select);
+			if (item !== false) selected = isExpression(item) ? item : { selectAs: { pluck: item } };
+		} else selected = addParserForSelectItem(q, q.q.as || q.table, "pluck", select);
+		q.q.select = selected ? [selected] : void 0;
+		return q;
+	}
+};
 var QueryMap = class {
 	/**
 	* Use `map` to transform individual records of a query result.
@@ -13185,22 +13222,6 @@ var QueryMethods = class {
 		return _queryRows(_clone(this));
 	}
 	/**
-	* `.pluck` returns a single array of a single selected column values:
-	*
-	* ```ts
-	* const ids = await db.table.select('id').pluck();
-	* // ids are an array of all users' id like [1, 2, 3]
-	* ```
-	* @param select - column name or a raw SQL
-	*/
-	pluck(select) {
-		const q = _clone(this);
-		q.q.returnType = "pluck";
-		const selected = addParserForSelectItem(q, q.q.as || q.table, "pluck", select);
-		q.q.select = selected ? [selected] : void 0;
-		return q;
-	}
-	/**
 	* `.exec` won't parse the response at all, and returns undefined:
 	*
 	* ```ts
@@ -13655,6 +13676,7 @@ applyMixins(QueryMethods, [
 	QueryOrCreate,
 	QueryHooks,
 	QueryGet,
+	QueryPluck,
 	MergeQueryMethods,
 	QuerySql,
 	QueryTransform,