pqb 0.71.0 → 0.71.2

package/dist/internal.d.ts

@@ -737,7 +737,7 @@ declare namespace TableData$1 {
     name?: string;
   }
   export interface ColumnIndex {
-    options: Index.ColumnArg & Index.Options;
+    options: Index.ColumnOptionsData;
   }
   export interface ColumnExclude extends ColumnIndex {
     with: string;
@@ -788,7 +788,11 @@ declare namespace TableData$1 {
       order?: string;
       weight?: SearchWeight$1;
     }
-    export interface UniqueOptionsArg<Name extends string = string> {
+    /**
+     * Controls when Postgres checks a unique constraint.
+     */
+    export type UniqueDeferrable = false | 'immediate' | 'deferred';
+    export interface BaseUniqueOptionsArg<Name extends string = string> {
       name?: Name;
       nullsNotDistinct?: boolean;
       using?: string;
@@ -798,23 +802,45 @@ declare namespace TableData$1 {
       where?: string;
       dropMode?: DropMode;
     }
-    export interface OptionsArg extends UniqueOptionsArg {
+    export interface UniqueOptionsArg<Name extends string = string> extends BaseUniqueOptionsArg<Name> {
+      /**
+       * Makes this unique definition a deferrable Postgres constraint.
+       */
+      deferrable?: UniqueDeferrable;
+    }
+    export interface NonUniqueIndexOptionsArg<Name extends string = string> extends BaseUniqueOptionsArg<Name> {
+      unique?: false;
+      deferrable?: never;
+    }
+    export interface UniqueIndexOptionsArg<Name extends string = string> extends UniqueOptionsArg<Name> {
+      unique: true;
+    }
+    export type OptionsArg<Name extends string = string> = NonUniqueIndexOptionsArg<Name> | UniqueIndexOptionsArg<Name>;
+    export type TsVectorArg = OptionsArg & TsVectorOptions;
+    export interface Options extends UniqueOptionsArg, TsVectorOptions {
       unique?: boolean;
     }
-    export interface TsVectorArg extends OptionsArg, TsVectorOptions {}
-    export type Options = TsVectorArg;
     export interface UniqueColumnArg<Name extends string = string> extends ColumnOptions, UniqueOptionsArg<Name> {
       expression?: string;
     }
-    export interface ColumnArg extends UniqueColumnArg {
-      unique?: boolean;
+    export interface NonUniqueColumnArg<Name extends string = string> extends ColumnOptions, BaseUniqueOptionsArg<Name> {
+      expression?: string;
+      unique?: false;
+      deferrable?: never;
+    }
+    export interface UniqueIndexColumnArg<Name extends string = string> extends UniqueColumnArg<Name> {
+      unique: true;
     }
+    export interface ColumnOptionsData extends ColumnOptions, Options {
+      expression?: string;
+    }
+    export type ColumnArg<Name extends string = string> = NonUniqueColumnArg<Name> | UniqueIndexColumnArg<Name>;
     interface TsVectorOptions {
       language?: string;
       languageColumn?: string;
       tsVector?: boolean;
     }
-    export interface TsVectorColumnArg extends ColumnArg, TsVectorOptions {}
+    export type TsVectorColumnArg = ColumnArg & TsVectorOptions;
     export interface ExpressionOptions extends ColumnOptions {
       expression: string;
     }
@@ -2058,11 +2084,11 @@ interface QueryInternal$1<SinglePrimaryKey = any, UniqueColumns = any, UniqueCol
   nestedCreateBatchMax: number;
 }
 type SQLQueryArgs = TemplateLiteralArgs$1 | [RawSqlBase$1];
-interface RawSqlBase$1 extends Expression$1 {
+interface RawSqlBase$1<T extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> extends Expression$1<T> {
   _sql: string | TemplateLiteralArgs$1;
   _values?: RawSQLValues;
 }
-interface RawSql$1<T extends Column$1.Pick.QueryColumn, ColumnTypes> extends Expression$1<T>, RawSqlBase$1, ExpressionTypeMethod {}
+interface RawSql$1<T extends Column$1.Pick.QueryColumn, ColumnTypes> extends Expression$1<T>, RawSqlBase$1<T>, ExpressionTypeMethod {}
 declare class RawSql$1<T extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn, ColumnTypes = DefaultColumnTypes$1<ColumnSchemaConfig$1>> extends Expression$1<T> {
   result: {
     value: T;
@@ -5086,6 +5112,246 @@ interface OperatorsArray$1<T> extends Ord$1<T[]> {
     _opType: number | { [K in Exclude<keyof OperatorsNumber, '__hasSelect'>]?: OperatorsNumber[K]['_opType'] };
   };
 }
+interface ColumnsShape$1 {
+  [K: string]: Column$1;
+}
+declare namespace ColumnsShape$1 {
+  export type DefaultSelectKeys<S extends Column$1.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
+  export type DefaultOutput<Set extends Column$1.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
+  export type Input<Shape extends Column$1.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$1.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
+  export type Output<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export type DefaultSelectOutput<Shape extends Column$1.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$1.QueryColumns> {
+    dataType: 'object';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
+    operators: OperatorsAny;
+  }
+  export interface MapToNullableObjectColumn<Shape extends Column$1.QueryColumns> {
+    dataType: 'object';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>> | undefined;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
+    operators: OperatorsAny;
+  }
+  export interface MapToPluckColumn<Shape extends Column$1.QueryColumns> {
+    dataType: 'array';
+    __type: Shape['pluck']['__type'][];
+    __outputType: Shape['pluck']['__outputType'][];
+    __queryType: Shape['pluck']['__queryType'][];
+    operators: OperatorsAny;
+  }
+  export interface MapToObjectArrayColumn<Shape extends Column$1.QueryColumns> {
+    dataType: 'array';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
+    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>[];
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
+    operators: OperatorsAny;
+  }
+  type ObjectOutput<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export {};
+}
+interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape$1, PickQueryRelations$1, 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$1 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$1 | ((q: SelectAsFnArg<T>) => unknown);
+}
+type SelectAsFnReturnType = {
+  result: Column$1.QueryColumns;
+  returnType: Exclude<QueryReturnType$1, 'rows'>;
+} | Expression$1;
+interface SelectAsCheckReturnTypes {
+  [K: string]: PropertyKey | Expression$1 | ((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$1.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$1 ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery$1) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression$1) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery$1 | Expression$1) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression$1>> | Exclude<ReturnType<Arg>, IsQuery$1>['result']['value'] : never;
+type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape$1.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape$1.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape$1.MapToNullableObjectColumn<Arg['result']> : ColumnsShape$1.MapToObjectColumn<Arg['result']>;
+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$1 | undefined;
+interface SelectAs {
+  selectAs: SelectAsValue;
+}
+interface SelectAsValue {
+  [K: string]: string | Query | Expression$1 | undefined;
+}
+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$1, Result>(this: T, fn: (input: T extends {
+    then: QueryThen<infer Data>;
+  } ? Data : never, queryData: QueryData$1) => Result): { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
+    value: Column$1.Pick.QueryColumnOfType<Result>;
+  } : K extends 'then' ? QueryThen<Result> : T[K] };
+}
 type SelectableOrExpression<T extends PickQuerySelectable = PickQuerySelectable, C extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> = '*' | keyof T['__selectable'] | Expression$1<C>;
 type SelectableOrExpressions<T extends PickQuerySelectable = PickQuerySelectable, C extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> = ('*' | keyof T['__selectable'] | Expression$1<C>)[];
 type ExpressionOutput<T extends PickQuerySelectable, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['__selectable'] ? T['__selectable'][Expr]['column'] : Expr extends Expression$1 ? Expr['result']['value'] : never;
@@ -5096,6 +5362,7 @@ interface ExpressionData$1 extends HasBeforeAndBeforeSet {
   before?: QueryBeforeHook$1[];
   dynamicBefore?: boolean;
   getColumn?: Column$1;
+  transform?: QueryDataTransform[];
 }
 declare abstract class Expression$1<T extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> {
   abstract result: {
@@ -5106,6 +5373,23 @@ declare abstract class Expression$1<T extends Column$1.Pick.QueryColumn = Column
     kind: 'select';
   };
   toSQL(ctx: ToSqlValues$1, 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$1.Pick.QueryColumn;
+    };
+    q: ExpressionData$1;
+  }, Result>(this: Self, fn: (input: Self['result']['value']['__type'], queryData: ExpressionData$1) => Result): Omit<Self, 'result'> & {
+    result: {
+      value: Column$1.Pick.QueryColumnOfType<Result>;
+    };
+  };
   abstract makeSQL(ctx: ToSqlValues$1, quotedAs?: string): string;
 }
 type TemplateLiteralArgs$1 = [strings: TemplateStringsArray, ...values: unknown[]];
@@ -5650,163 +5934,6 @@ declare class FromMethods {
    */
   only<T>(this: T, only?: boolean): T;
 }
-interface ColumnsShape$1 {
-  [K: string]: Column$1;
-}
-declare namespace ColumnsShape$1 {
-  export type DefaultSelectKeys<S extends Column$1.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column$1.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
-  export type Input<Shape extends Column$1.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$1.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
-  export type Output<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
-  export type DefaultSelectOutput<Shape extends Column$1.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$1.QueryColumns> {
-    dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
-    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
-    operators: OperatorsAny;
-  }
-  export interface MapToNullableObjectColumn<Shape extends Column$1.QueryColumns> {
-    dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
-    __outputType: ShallowSimplify$1<ObjectOutput<Shape>> | undefined;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
-    operators: OperatorsAny;
-  }
-  export interface MapToPluckColumn<Shape extends Column$1.QueryColumns> {
-    dataType: 'array';
-    __type: Shape['pluck']['__type'][];
-    __outputType: Shape['pluck']['__outputType'][];
-    __queryType: Shape['pluck']['__queryType'][];
-    operators: OperatorsAny;
-  }
-  export interface MapToObjectArrayColumn<Shape extends Column$1.QueryColumns> {
-    dataType: 'array';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
-    __outputType: ShallowSimplify$1<ObjectOutput<Shape>>[];
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
-    operators: OperatorsAny;
-  }
-  type ObjectOutput<Shape extends Column$1.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
-  export {};
-}
-interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape$1, PickQueryRelations$1, 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$1 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$1 | ((q: SelectAsFnArg<T>) => unknown);
-}
-type SelectAsFnReturnType = {
-  result: Column$1.QueryColumns;
-  returnType: Exclude<QueryReturnType$1, 'rows'>;
-} | Expression$1;
-interface SelectAsCheckReturnTypes {
-  [K: string]: PropertyKey | Expression$1 | ((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$1.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$1 ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery$1) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression$1) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery$1 | Expression$1) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression$1>> | Exclude<ReturnType<Arg>, IsQuery$1>['result']['value'] : never;
-type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape$1.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape$1.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape$1.MapToNullableObjectColumn<Arg['result']> : ColumnsShape$1.MapToObjectColumn<Arg['result']>;
-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$1 | ((q: SelectAsFnArg<T>) => Expression$1 | Query.Pick.SingleValueResult);
 type GetStringArg<T extends PickQuerySelectable> = keyof T['__selectable'] & string;
@@ -6589,13 +6716,6 @@ declare class QueryOrCreate {
    */
   orCreate<T extends UpsertThis$1>(this: T, data: OrCreateArg<CreateData$1<T>>): UpsertResult<T>;
 }
-type SelectItem = string | SelectAs | Expression$1 | undefined;
-interface SelectAs {
-  selectAs: SelectAsValue;
-}
-interface SelectAsValue {
-  [K: string]: string | Query | Expression$1 | undefined;
-}
 type IsolationLevel$1 = 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED' | 'READ UNCOMMITTED';
 interface TransactionOptions$1 extends SqlSessionState$1 {
   /**
@@ -6976,82 +7096,6 @@ type WrapQueryArg = FromQuerySelf;
 declare class QueryWrap {
   wrap<T extends IsQuery$1, Q extends WrapQueryArg, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
 }
-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$1, Result>(this: T, fn: (input: T extends {
-    then: QueryThen<infer Data>;
-  } ? Data : never, queryData: QueryData$1) => Result): { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
-    value: Column$1.Pick.QueryColumnOfType<Result>;
-  } : K extends 'then' ? QueryThen<Result> : T[K] };
-}
 type AfterHook$1<Select extends PropertyKey[], Shape extends Column$1.QueryColumns> = QueryAfterHook$1<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never }[]>;
 type HookSelectArg<T extends PickQueryShape$1> = (keyof T['shape'] & string)[];
 declare class QueryHookUtils$1<T extends PickQueryInputType$1> {
@@ -8231,7 +8275,7 @@ declare abstract class Column$1 {
     data: Column['data'];
     dataType: string;
   }>(this: T, ...args: [options?: TableData$1.Index.TsVectorColumnArg]): T;
-  unique<T extends Column.Pick.Data, const Options extends TableData$1.Index.ColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
+  unique<T extends Column.Pick.Data, const Options extends TableData$1.Index.UniqueColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
   /**
    * Add [EXCLUDE constraint](https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) to the column.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.71.0",
+  "version": "0.71.2",
   "description": "Postgres query builder",
   "keywords": [
     "pg",