pqb 0.71.1 → 0.71.2

package/dist/index.d.ts

@@ -5361,11 +5361,11 @@ interface DbSqlQuery {
    */
   getOptional<T>(...args: SQLQueryArgs): Promise<T | undefined>;
 }
-interface RawSqlBase extends Expression {
+interface RawSqlBase<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> extends Expression<T> {
   _sql: string | TemplateLiteralArgs;
   _values?: RawSQLValues;
 }
-interface RawSql<T extends Column.Pick.QueryColumn, ColumnTypes> extends Expression<T>, RawSqlBase, ExpressionTypeMethod {}
+interface RawSql<T extends Column.Pick.QueryColumn, ColumnTypes> extends Expression<T>, RawSqlBase<T>, ExpressionTypeMethod {}
 declare class RawSql<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends Expression<T> {
   result: {
     value: T;
@@ -5919,6 +5919,250 @@ declare const Operators: {
   json: OperatorsJson;
   array: OperatorsArray<unknown>;
 };
+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'] ? RelationQueryMaybeSingle<T['relations'][K]> & 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;
+}
+interface SelectAsValue {
+  [K: string]: string | Query | Expression | undefined;
+}
+declare const getShapeFromSelect: (q: IsQuery, isSubQuery?: boolean) => Column.QueryColumns;
+type QueryDataTransform = QueryDataTransformFn | {
+  map: (record: unknown, index: number, array: unknown) => unknown;
+  thisArg?: unknown;
+};
+interface QueryDataTransformFn {
+  (data: unknown, queryData: unknown): unknown;
+}
+/**
+ * See `transform` query method.
+ * This helper applies all transform functions to a result.
+ *
+ * @param queryData - query data
+ * @param returnType - return type of the query, for proper `map` handling
+ * @param fns - array of transform functions, can be undefined
+ * @param result - query result to transform
+ */
+declare class QueryTransform {
+  /**
+   * Transform the result of the query right after loading it.
+   *
+   * `transform` method should be called in the last order, other methods can't be chained after calling it.
+   *
+   * It is meant to transform the whole result of a query, for transforming individual records consider using {@link QueryMap.map}.
+   *
+   * The [hooks](/guide/hooks.html) that are going to run after the query will receive the query result **before** transferring.
+   *
+   * Consider the following example of a cursor-based pagination by `id`:
+   *
+   * ```ts
+   * const lastId: number | undefined = req.query.cursor;
+   *
+   * type Result = {
+   *   nodes: { id: number; text: string }[];
+   *   cursor?: number;
+   * };
+   *
+   * // result is only for demo, it will be inferred
+   * const posts: Result = await db.post
+   *   .select('id', 'text')
+   *   .where({ id: { lt: lastId } })
+   *   .order({ id: 'DESC' })
+   *   .limit(100)
+   *   .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id }));
+   * ```
+   *
+   * You can also use the `tranform` on nested sub-queries:
+   *
+   * ```ts
+   * type Result = {
+   *   nodes: {
+   *     id: number;
+   *     text: string;
+   *     comments: { nodes: { id: number; text: string }[]; cursor?: number };
+   *   }[];
+   *   cursor?: number;
+   * };
+   *
+   * const postsWithComments: Result = await db.post
+   *   .select('id', 'text')
+   *   .select({
+   *     comments: (q) =>
+   *       q.comments
+   *         .select('id', 'text')
+   *         .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id })),
+   *   })
+   *   .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id }));
+   * ```
+   *
+   * @param fn - function to transform query result with
+   */
+  transform<T extends IsQuery, Result>(this: T, fn: (input: T extends {
+    then: QueryThen<infer Data>;
+  } ? Data : never, queryData: QueryData) => Result): { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
+    value: Column.Pick.QueryColumnOfType<Result>;
+  } : K extends 'then' ? QueryThen<Result> : T[K] };
+}
 type SelectableOrExpression<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = '*' | keyof T['__selectable'] | Expression<C>;
 type SelectableOrExpressions<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = ('*' | keyof T['__selectable'] | Expression<C>)[];
 type ExpressionOutput<T extends PickQuerySelectable, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['__selectable'] ? T['__selectable'][Expr]['column'] : Expr extends Expression ? Expr['result']['value'] : never;
@@ -5929,6 +6173,7 @@ interface ExpressionData extends HasBeforeAndBeforeSet {
   before?: QueryBeforeHook[];
   dynamicBefore?: boolean;
   getColumn?: Column;
+  transform?: QueryDataTransform[];
 }
 declare abstract class Expression<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> {
   abstract result: {
@@ -5939,6 +6184,23 @@ declare abstract class Expression<T extends Column.Pick.QueryColumn = Column.Pic
     kind: 'select';
   };
   toSQL(ctx: ToSqlValues, quotedAs?: string): string;
+  /**
+   * Transform the expression value after loading it.
+   *
+   * It is meant to transform expressions selected by a query.
+   *
+   * @param fn - function to transform expression value with
+   */
+  transform<Self extends {
+    result: {
+      value: Column.Pick.QueryColumn;
+    };
+    q: ExpressionData;
+  }, Result>(this: Self, fn: (input: Self['result']['value']['__type'], queryData: ExpressionData) => Result): Omit<Self, 'result'> & {
+    result: {
+      value: Column.Pick.QueryColumnOfType<Result>;
+    };
+  };
   abstract makeSQL(ctx: ToSqlValues, quotedAs?: string): string;
 }
 declare const isExpression: (arg: unknown) => arg is Expression;
@@ -6291,174 +6553,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'] ? RelationQueryMaybeSingle<T['relations'][K]> & 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;
-}
-interface SelectAsValue {
-  [K: string]: string | Query | Expression | undefined;
-}
-declare const getShapeFromSelect: (q: IsQuery, isSubQuery?: boolean) => Column.QueryColumns;
 type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never }[]>;
 type HookSelectArg<T extends PickQueryShape> = (keyof T['shape'] & string)[];
 declare const _hookSelectColumns: (query: Query, columns: string[], asFn: (as: string[]) => void) => void;
@@ -8821,82 +8915,6 @@ interface QueryComputedArg<ColumnTypes, Shape extends Column.QueryColumns> exten
     column: Column.Pick.QueryColumn;
   } };
 }
-type QueryDataTransform = QueryDataTransformFn | {
-  map: (record: unknown, index: number, array: unknown) => unknown;
-  thisArg?: unknown;
-};
-interface QueryDataTransformFn {
-  (data: unknown, queryData: unknown): unknown;
-}
-/**
- * See `transform` query method.
- * This helper applies all transform functions to a result.
- *
- * @param queryData - query data
- * @param returnType - return type of the query, for proper `map` handling
- * @param fns - array of transform functions, can be undefined
- * @param result - query result to transform
- */
-declare class QueryTransform {
-  /**
-   * Transform the result of the query right after loading it.
-   *
-   * `transform` method should be called in the last order, other methods can't be chained after calling it.
-   *
-   * It is meant to transform the whole result of a query, for transforming individual records consider using {@link QueryMap.map}.
-   *
-   * The [hooks](/guide/hooks.html) that are going to run after the query will receive the query result **before** transferring.
-   *
-   * Consider the following example of a cursor-based pagination by `id`:
-   *
-   * ```ts
-   * const lastId: number | undefined = req.query.cursor;
-   *
-   * type Result = {
-   *   nodes: { id: number; text: string }[];
-   *   cursor?: number;
-   * };
-   *
-   * // result is only for demo, it will be inferred
-   * const posts: Result = await db.post
-   *   .select('id', 'text')
-   *   .where({ id: { lt: lastId } })
-   *   .order({ id: 'DESC' })
-   *   .limit(100)
-   *   .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id }));
-   * ```
-   *
-   * You can also use the `tranform` on nested sub-queries:
-   *
-   * ```ts
-   * type Result = {
-   *   nodes: {
-   *     id: number;
-   *     text: string;
-   *     comments: { nodes: { id: number; text: string }[]; cursor?: number };
-   *   }[];
-   *   cursor?: number;
-   * };
-   *
-   * const postsWithComments: Result = await db.post
-   *   .select('id', 'text')
-   *   .select({
-   *     comments: (q) =>
-   *       q.comments
-   *         .select('id', 'text')
-   *         .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id })),
-   *   })
-   *   .transform((nodes) => ({ nodes, cursor: nodes.at(-1)?.id }));
-   * ```
-   *
-   * @param fn - function to transform query result with
-   */
-  transform<T extends IsQuery, Result>(this: T, fn: (input: T extends {
-    then: QueryThen<infer Data>;
-  } ? Data : never, queryData: QueryData) => Result): { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
-    value: Column.Pick.QueryColumnOfType<Result>;
-  } : K extends 'then' ? QueryThen<Result> : T[K] };
-}
 type WhereItem = {
   [K: string]: unknown | {
     [K: string]: unknown | SubQueryForSql | Expression;

package/dist/index.js

@@ -319,6 +319,17 @@ var Expression = class {
 		}
 		return sql;
 	}
+	/**
+	* Transform the expression value after loading it.
+	*
+	* It is meant to transform expressions selected by a query.
+	*
+	* @param fn - function to transform expression value with
+	*/
+	transform(fn) {
+		pushOrNewArrayToObjectImmutable(this.q, "transform", fn);
+		return this;
+	}
 };
 const isExpression = (arg) => arg instanceof Expression;
 const isTemplateLiteralArgs = (args) => Array.isArray(args[0]) && "raw" in args[0] && Array.isArray(args[0].raw);
@@ -391,7 +402,7 @@ const templateLiteralToSQL = (template, ctx, quotedAs) => {
 	for (let last = parts.length - 1; i < last; i++) {
 		sql += parts[i];
 		const value = template[i + 1];
-		if (value instanceof Expression) sql += value.toSQL(ctx, quotedAs);
+		if (isExpression(value)) sql += value.toSQL(ctx, quotedAs);
 		else {
 			values.push(value);
 			literalValues.push(sql.length);
@@ -7666,7 +7677,7 @@ const encodeRow = (ctx, values, QueryClass, row, runtimeDefaults, quotedAs, hook
 };
 const encodeValue = (ctx, values, QueryClass, value, quotedAs) => {
 	if (value && typeof value === "object") {
-		if (value instanceof Expression) return value.toSQL(ctx, quotedAs);
+		if (isExpression(value)) return value.toSQL(ctx, quotedAs);
 		else if (value instanceof QueryClass) return `(${moveMutativeQueryToCte(ctx, value)})`;
 		else if ("fromHook" in value) return value.fromHook;
 	}
@@ -7985,7 +7996,7 @@ var FnExpression = class extends Expression {
 		const q = this.q;
 		sql.push(this.args.map((arg) => {
 			if (typeof arg === "string") return arg === "*" ? "*" : fnArgToSql(ctx, q, arg, quotedAs);
-			else if (arg instanceof Expression) return arg.toSQL(ctx, quotedAs);
+			else if (isExpression(arg)) return arg.toSQL(ctx, quotedAs);
 			else if ("pairs" in arg) {
 				const args = [];
 				const { pairs } = arg;
@@ -10989,7 +11000,8 @@ const processSelectAsArg = (q, selectAs, as, key, arg, columnAlias, outerReturnT
 		}
 		if (isExpression(value)) column = value.result.value;
 		else {
-			if (isRelationQuery(value) && value.q.subQuery !== 1) {
+			const isSelfReferencingQuery = value.q.subQuery === 1;
+			if (isRelationQuery(value) && !isSelfReferencingQuery) {
 				joinQuery = true;
 				setSelectRelation(query.q);
 				value = value.joinQuery(value, q);
@@ -11010,17 +11022,17 @@ const processSelectAsArg = (q, selectAs, as, key, arg, columnAlias, outerReturnT
 				if (as) value.q.joinedForSelect = _copyQueryAliasToQuery(value, q, as);
 			}
 			if (value.q.getColumn?.data.skipValueToArray) value.q.notFoundDefault ??= null;
-			else if (!value.q.type && (value.q.returnType === "value" || value.q.returnType === "valueOrThrow")) {
+			else if (!value.q.type && (value.q.returnType === "value" || value.q.returnType === "valueOrThrow") && !isSelfReferencingQuery) {
 				const column = Object.create(value.q.getColumn || UnknownColumn.instance);
 				column.data = {
 					...column.data,
-					name: void 0,
 					valueToArray: true
 				};
+				if (joinQuery) column.data.name = void 0;
 				value.q.getColumn = column;
 				if (value.q.expr) value.q.expr.q.getColumn = column;
 			}
-			if (outerReturnType === "value" && value.q.returnType === "valueOrThrow") value.q.returnType = "value";
+			if ((outerReturnType === "value" || isSelfReferencingQuery) && value.q.returnType === "valueOrThrow") value.q.returnType = "value";
 			column = value.q.getColumn;
 			value = prepareSubQueryForSql(q, value);
 		}