pqb 0.71.0 → 0.71.2

package/dist/index.d.ts

@@ -714,7 +714,7 @@ declare namespace TableData {
     name?: string;
   }
   export interface ColumnIndex {
-    options: Index.ColumnArg & Index.Options;
+    options: Index.ColumnOptionsData;
   }
   export interface ColumnExclude extends ColumnIndex {
     with: string;
@@ -765,7 +765,11 @@ declare namespace TableData {
       order?: string;
       weight?: SearchWeight;
     }
-    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;
@@ -775,23 +779,45 @@ declare namespace TableData {
       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;
     }
@@ -5335,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;
@@ -5893,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;
@@ -5903,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: {
@@ -5913,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;
@@ -6265,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;
@@ -7597,7 +7717,7 @@ declare abstract class Column {
     data: Column['data'];
     dataType: string;
   }>(this: T, ...args: [options?: TableData.Index.TsVectorColumnArg]): T;
-  unique<T extends Column.Pick.Data, const Options extends TableData.Index.ColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
+  unique<T extends Column.Pick.Data, const Options extends TableData.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.
    *
@@ -8795,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;