pqb 0.57.1 → 0.57.2

package/dist/postgres-js.d.ts

@@ -1,11 +1,1081 @@
-import * as orchid_core from 'orchid-core';
-import { ColumnSchemaConfig, AdapterConfigBase, AdapterBase, QueryResultRow, QueryResult, QueryArraysResult, QueryError } from 'orchid-core';
-import postgres, { Error } from 'postgres';
+import * as pqb from 'pqb';
 import { DbOptions, DefaultSchemaConfig, DefaultColumnTypes, DbResult } from 'pqb';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import postgres, { Error as Error$1 } from 'postgres';
+
+type MaybePromise<T> = T | Promise<T>;
+interface FnUnknownToUnknown {
+    (a: unknown): unknown;
+}
+interface RecordKeyTrue {
+    [K: string]: true;
+}
+interface RecordString {
+    [K: string]: string;
+}
+interface RecordUnknown {
+    [K: string]: unknown;
+}
+type EmptyObject = {};
+
+type ExpressionChain = (OperatorToSQL<unknown, unknown> | unknown)[];
+interface ExpressionData {
+    chain?: ExpressionChain;
+    expr?: Expression;
+}
+declare abstract class Expression<T extends QueryColumn = QueryColumn> {
+    abstract result: {
+        value: T;
+    };
+    abstract q: ExpressionData;
+    meta: {
+        kind: 'select';
+    };
+    toSQL(ctx: {
+        values: unknown[];
+    }, quotedAs?: string): string;
+    abstract makeSQL(ctx: {
+        values: unknown[];
+    }, quotedAs?: string): string;
+}
+type TemplateLiteralArgs = [
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+];
+type RawSQLValues = RecordUnknown;
+declare abstract class ExpressionTypeMethod {
+    type<T extends {
+        q: {
+            expr?: Expression;
+        };
+        columnTypes: unknown;
+    }, C extends QueryColumn>(this: T, fn: (types: T['columnTypes']) => C): // Omit is optimal
+    Omit<T, 'result'> & {
+        result: {
+            value: C;
+        };
+    };
+}
+interface RawSQLBase<T extends QueryColumn = QueryColumn, ColumnTypes = unknown> extends Expression<T>, ExpressionTypeMethod {
+}
+declare abstract class RawSQLBase<T extends QueryColumn = QueryColumn, ColumnTypes = unknown> extends Expression<T> {
+    _sql: string | TemplateLiteralArgs;
+    _values?: RecordUnknown | undefined;
+    result: {
+        value: T;
+    };
+    q: ExpressionData;
+    abstract columnTypes: ColumnTypes;
+    abstract makeSQL(ctx: {
+        values: unknown[];
+    }): string;
+    constructor(_sql: string | TemplateLiteralArgs, _values?: RecordUnknown | undefined);
+    values<Self extends RawSQLBase>(this: Self, values: RawSQLValues): Self;
+    toCode(t: string): string;
+}
+
+interface OperatorBase<Value> {
+    (this: any, arg: Value): any;
+    _opType: Value;
+}
+/**
+ * Function to turn the operator expression into SQL.
+ *
+ * @param key - SQL of the target to apply operator for, can be a quoted column name or an SQL expression wrapped with parens.
+ * @param args - arguments of operator function.
+ * @param ctx - context object for SQL conversions, for collecting query variables.
+ * @param quotedAs - quoted table name.
+ */
+interface OperatorToSQL<Value, Ctx> {
+    (key: string, args: [Value], ctx: Ctx, quotedAs?: string): string;
+}
+
+interface ColumnSchemaGetterTableClass {
+    prototype: {
+        columns: {
+            shape: ColumnTypesBase;
+        };
+    };
+    inputSchema(): unknown;
+    querySchema(): unknown;
+    pkeySchema(): unknown;
+    createSchema(): unknown;
+}
+interface ColumnTypeSchemaArg {
+    type: unknown;
+    nullable<T extends ColumnTypeBase>(this: T): NullableColumn<T, unknown, unknown, unknown>;
+    encode: unknown;
+    parse: unknown;
+    parseNull: unknown;
+    asType: unknown;
+    narrowType: unknown;
+    narrowAllTypes: unknown;
+    error?: unknown;
+}
+interface ColumnSchemaConfig<T extends ColumnTypeBase = ColumnTypeBase> extends ColumnTypeSchemaArg {
+    dateAsNumber: unknown;
+    dateAsDate: unknown;
+    enum: unknown;
+    array: unknown;
+    boolean(): unknown;
+    buffer(): unknown;
+    unknown(): unknown;
+    never(): unknown;
+    stringSchema(): unknown;
+    stringMin(max: number): unknown;
+    stringMax(max: number): unknown;
+    stringMinMax(min: number, max: number): unknown;
+    number(): unknown;
+    int(): unknown;
+    stringNumberDate(): unknown;
+    timeInterval(): unknown;
+    bit(max?: number): unknown;
+    uuid(): unknown;
+    json(): T;
+    inputSchema(this: ColumnSchemaGetterTableClass): unknown;
+    outputSchema(this: ColumnSchemaGetterTableClass): unknown;
+    querySchema(this: ColumnSchemaGetterTableClass): unknown;
+    createSchema(this: ColumnSchemaGetterTableClass): unknown;
+    updateSchema(this: ColumnSchemaGetterTableClass): unknown;
+    pkeySchema(this: ColumnSchemaGetterTableClass): unknown;
+    smallint(): T;
+    integer(): T;
+    real(): T;
+    smallSerial(): T;
+    serial(): T;
+    bigint(): T;
+    decimal(precision?: number, scale?: number): T;
+    doublePrecision(): T;
+    bigSerial(): T;
+    money(): T;
+    varchar(limit?: number): T;
+    text(): T;
+    string(limit?: number): T;
+    citext(): T;
+    date(): T;
+    timestampNoTZ(precision?: number): T;
+    timestamp(precision?: number): T;
+    geographyPointSchema(): unknown;
+}
+
+interface PickQueryShape {
+    shape: QueryColumns;
+}
+interface PickQueryInputType {
+    inputType: unknown;
+}
+
+declare class QueryHookUtils<T extends PickQueryInputType> {
+    query: IsQuery;
+    columns: string[];
+    private key;
+    constructor(query: IsQuery, columns: string[], key: 'hookCreateSet' | 'hookUpdateSet');
+    set: (data: { [K in keyof T["inputType"]]?: T["inputType"][K] | (() => QueryOrExpression<T["inputType"][K]>) | undefined; }) => void;
+}
+
+interface ColumnsShapeBase {
+    [K: string]: ColumnTypeBase;
+}
+type NullableColumn<T extends ColumnTypeBase, InputSchema, OutputSchema, QuerySchema> = {
+    [K in keyof T]: K extends 'type' ? T['type'] | null : K extends 'inputType' ? T['inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends 'outputType' ? T['outputType'] | (unknown extends T['nullType'] ? null : T['nullType']) : K extends 'outputSchema' ? OutputSchema : K extends 'queryType' ? T['queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? // `Omit` here is faster than ternaries
+    Omit<T['operators'], 'equals' | 'not'> & OperatorsNullable<T['queryType']> : T[K];
+};
+interface DataNullable {
+    isNullable: true;
+    optional: true;
+}
+interface OperatorsNullable<T> {
+    equals: OperatorBase<T | null>;
+    not: OperatorBase<T | null>;
+}
+interface PickColumnBaseData {
+    data: ColumnDataBase;
+}
+type ColumnWithDefault<T extends PickColumnBaseData, Value> = {
+    [K in keyof T]: K extends 'data' ? {
+        [K in keyof T['data']]: K extends 'default' ? Value extends null ? never : Value : K extends 'optional' ? true : T['data'][K];
+    } : T[K];
+};
+type ColumnDefaultSelect<T extends PickColumnBaseData, Value extends boolean> = {
+    [K in keyof T]: K extends 'data' ? {
+        [K in keyof T['data']]: K extends 'explicitSelect' ? Value extends true ? false : true : T['data'][K];
+    } : T[K];
+};
+interface ColumnDataAppReadOnly {
+    data: {
+        appReadOnly: true;
+    };
+}
+type ColumnTypesBase = {
+    [K in string]: ColumnTypeBase;
+};
+interface ColumnDataBase {
+    key: string;
+    name?: string;
+    optional: true | undefined;
+    isNullable?: true;
+    primaryKey?: string;
+    default: unknown;
+    defaultDefault: unknown;
+    runtimeDefault?(): unknown;
+    explicitSelect?: boolean;
+    as?: ColumnTypeBase;
+    unique?: string;
+    modifyQuery?(q: QueryBaseCommon, column: ColumnTypeBase): void;
+    checks?: ColumnDataCheckBase[];
+    isOfCustomType?: boolean;
+    errors?: RecordString;
+    defaultTimestamp?: 'createdAt' | 'updatedAt';
+    alias?: string;
+    extension?: string;
+    encode?(input: any): unknown;
+    parse?(input: any): unknown;
+    parseItem?(input: string): unknown;
+    parseNull?(): unknown;
+    jsonCast?: string;
+    readOnly?: boolean;
+    appReadOnly: true | undefined;
+    setOnCreate?(arg: QueryHookUtils<PickQueryInputType>): unknown;
+    setOnUpdate?(arg: QueryHookUtils<PickQueryInputType>): unknown;
+    setOnSave?(arg: QueryHookUtils<PickQueryInputType>): unknown;
+    typmod?: number;
+    virtual?: true;
+}
+interface ColumnDataCheckBase {
+    sql: RawSQLBase;
+    name?: string;
+}
+interface QueryColumn<T = unknown, Op = any> {
+    dataType: string;
+    type: T;
+    outputType: T;
+    queryType: T;
+    operators: Op;
+}
+interface QueryColumns {
+    [K: string]: QueryColumn;
+}
+interface QueryColumnData {
+    explicitSelect?: boolean;
+    primaryKey?: string;
+    unique?: string;
+    optional?: true;
+    isNullable?: true;
+    default?: unknown;
+    name?: string;
+    readOnly?: boolean;
+    appReadOnly: true | undefined;
+}
+interface QueryColumnInit extends QueryColumn {
+    inputType: unknown;
+    data: QueryColumnData;
+}
+interface QueryColumnsInit {
+    [K: string]: QueryColumnInit;
+}
+interface ColumnToCodeCtx {
+    t: string;
+    table: string;
+    currentSchema: string;
+    migration?: boolean;
+    snakeCase?: boolean;
+}
+declare abstract class ColumnTypeBase<Schema extends ColumnTypeSchemaArg = ColumnTypeSchemaArg, Type = unknown, InputSchema = any, Ops = any, InputType = Type, OutputType = Type, OutputSchema = InputSchema, QueryType = InputType, QuerySchema = InputSchema, Data extends ColumnDataBase = ColumnDataBase> {
+    inputSchema: InputSchema;
+    outputSchema: OutputSchema;
+    querySchema: QuerySchema;
+    abstract dataType: string;
+    abstract operators: Ops;
+    abstract toCode(ctx: ColumnToCodeCtx, key: string): Code;
+    abstract toSQL(): string;
+    type: Type;
+    inputType: InputType;
+    outputType: OutputType;
+    queryType: QueryType;
+    nullType: unknown;
+    nullSchema: unknown;
+    isNullable: boolean;
+    data: Data;
+    error: Schema['error'];
+    _parse?: (input: unknown) => unknown;
+    constructor(schema: ColumnTypeSchemaArg, inputSchema: InputSchema, outputSchema?: OutputSchema, querySchema?: QuerySchema);
+    /**
+     * Set a default value to a column. Columns that have defaults become optional when creating a record.
+     *
+     * If you provide a value or a raw SQL, such default should be set on the column in migration to be applied on a database level.
+     *
+     * Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     // values as defaults:
+     *     int: t.integer().default(123),
+     *     text: t.text().default('text'),
+     *
+     *     // raw SQL default:
+     *     timestamp: t.timestamp().default(t.sql`now()`),
+     *
+     *     // runtime default, each new records gets a new random value:
+     *     random: t.numeric().default(() => Math.random()),
+     *   }));
+     * }
+     * ```
+     *
+     * @param value - default value or a function returning a value
+     */
+    default<T extends Pick<ColumnTypeBase, 'type' | 'inputType' | 'data'>, Value extends T['inputType'] | null | RawSQLBase | (() => T['inputType'])>(this: T, value: Value): ColumnWithDefault<T, Value>;
+    /**
+     * Use `hasDefault` to let the column be omitted when creating records.
+     *
+     * It's better to use {@link default} instead so the value is explicit and serves as a hint.
+     */
+    hasDefault<T extends PickColumnBaseData>(this: T): ColumnWithDefault<T, RawSQLBase>;
+    /**
+     * Set a database-level validation check to a column. `check` accepts a raw SQL.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     // validate rank to be from 1 to 10
+     *     rank: t.integer().check(t.sql`1 >= "rank" AND "rank" <= 10`),
+     *     // constraint name can be passed as a second argument
+     *     column: t.integer().check(t.sql`...`, 'check_name'),
+     *     // a single column can have multiple checks
+     *     multiChecksColumn: t
+     *       .integer()
+     *       .check(t.sql`...`)
+     *       .check(t.sql`...`, 'optional_name'),
+     *   }));
+     * });
+     * ```
+     *
+     * @param sql - raw SQL expression
+     * @param name - to specify a constraint name
+     */
+    check<T extends PickColumnBaseData>(this: T, sql: RawSQLBase, name?: string): T;
+    /**
+     * Use `nullable` to mark the column as nullable. By default, all columns are required.
+     *
+     * Nullable columns are optional when creating records.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     name: t.integer().nullable(),
+     *   }));
+     * }
+     * ```
+     */
+    nullable: Schema['nullable'];
+    /**
+     * Set a custom function to process value for the column when creating or updating a record.
+     *
+     * The type of `input` argument will be used as the type of the column when creating and updating.
+     *
+     * If you have a validation library [installed and configured](/guide/columns-validation-methods.html),
+     * first argument is a schema to validate the input.
+     *
+     * ```ts
+     * import { z } from 'zod';
+     *
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     // encode boolean, number, or string to text before saving
+     *     column: t
+     *       .string()
+     *       // when having validation library, the first argument is a validation schema
+     *       .encode(
+     *         z.boolean().or(z.number()).or(z.string()),
+     *         (input: boolean | number | string) => String(input),
+     *       )
+     *       // no schema argument otherwise
+     *       .encode((input: boolean | number | string) => String(input)),
+     *   }));
+     * }
+     *
+     * // numbers and booleans will be converted to a string:
+     * await db.table.create({ column: 123 });
+     * await db.table.create({ column: true });
+     * await db.table.where({ column: 'true' }).update({ column: false });
+     * ```
+     *
+     * @param fn - function to encode value for a database, argument type is specified by you, return type must be compatible with a database
+     */
+    encode: Schema['encode'];
+    /**
+     * Set a custom function to process value after loading it from a database.
+     *
+     * The type of input is the type of column before `.parse`, the resulting type will replace the type of column.
+     *
+     * If you have a validation library [installed and configured](/guide/columns-validation-methods.html),
+     * first argument is a schema for validating the output.
+     *
+     * For handling `null` values use {@link parseNull} instead or in addition.
+     *
+     * ```ts
+     * import { z } from 'zod';
+     * import { number, integer } from 'valibot';
+     *
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     columnZod: t
+     *       .string()
+     *       // when having validation library, the first argument is a schema
+     *       .parse(z.number().int(), (input) => parseInt(input))
+     *       // no schema argument otherwise
+     *       .parse((input) => parseInt(input)),
+     *
+     *     columnValibot: t
+     *       .string()
+     *       .parse(number([integer()]), (input) => parseInt(input))
+     *       .parse((input) => parseInt(input)),
+     *   }));
+     * }
+     *
+     * // column will be parsed to a number
+     * const value: number = await db.table.get('column');
+     * ```
+     *
+     * @param fn - function to parse a value from the database, argument is the type of this column, return type is up to you
+     */
+    parse: Schema['parse'];
+    /**
+     * Use `parseNull` to specify runtime defaults at selection time.
+     *
+     * The `parseNull` function is only triggered for `nullable` columns.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     column: t
+     *       .integer()
+     *       .parse(String) // parse non-nulls to string
+     *       .parseNull(() => false), // replace nulls with false
+     *       .nullable(),
+     *   }));
+     * }
+     *
+     * const record = await db.table.take()
+     * record.column // can be a string or boolean, not null
+     * ```
+     *
+     * If you have a validation library [installed and configured](/guide/columns-validation-methods),
+     * first argument is a schema for validating the output.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     column: t
+     *       .integer()
+     *       .parse(z.string(), String) // parse non-nulls to string
+     *       .parseNull(z.literal(false), () => false), // replace nulls with false
+     *     .nullable(),
+     *   }));
+     * }
+     *
+     * const record = await db.table.take()
+     * record.column // can be a string or boolean, not null
+     *
+     * Table.outputSchema().parse({
+     *   column: false, // the schema expects strings or `false` literals, not nulls
+     * })
+     * ```
+     */
+    parseNull: Schema['parseNull'];
+    /**
+     * This method changes a column type without modifying its behavior.
+     * This is needed when converting columns to a validation schema, the converter will pick a different type specified by `.as`.
+     *
+     * Before calling `.as` need to use `.encode` with the input of the same type as the input of the target column,
+     * and `.parse` which returns the correct type.
+     *
+     * ```ts
+     * // column has the same type as t.integer()
+     * const column = t
+     *   .string()
+     *   .encode((input: number) => input)
+     *   .parse((text) => parseInt(text))
+     *   .as(t.integer());
+     * ```
+     *
+     * @param column - other column type to inherit from
+     */
+    as<T extends {
+        inputType: unknown;
+        outputType: unknown;
+        data: ColumnDataBase;
+    }, C extends Omit<ColumnTypeBase, 'inputType' | 'outputType'> & {
+        inputType: T['inputType'];
+        outputType: T['outputType'];
+    }>(this: T, column: C): C;
+    /**
+     * @deprecated use narrowType instead
+     */
+    asType: Schema['asType'];
+    /**
+     * `narrowType` narrows TypeScript types of a column. It sets input, output, query type altogether.
+     *
+     * For example, to narrow a `string` type to a union of string literals.
+     *
+     * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowType` has the following syntax:
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     size: t.string().narrowType((t) => t<'small' | 'medium' | 'large'>()),
+     *   }));
+     * }
+     *
+     * // size will be typed as 'small' | 'medium' | 'large'
+     * const size = await db.table.get('size');
+     * ```
+     *
+     * - `input` is for `create`, `update` methods.
+     * - `output` is for the data that is loaded from a database and parsed if the column has `parse`.
+     * - `query` is used in `where` and other query methods, it should be compatible with the actual database column type.
+     *
+     * When integrating with a [validation library](/guide/columns-validation-methods), also provide validation schemas:
+     *
+     * ```ts
+     * const sizeSchema = z.union([
+     *   z.literal('small'),
+     *   z.literal('medium'),
+     *   z.literal('large'),
+     * ]);
+     *
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     size: t.text().narrowType(sizeSchema),
+     *   }));
+     * }
+     *
+     * // size will be typed as 'small' | 'medium' | 'large'
+     * const size = await db.table.get('size');
+     * ```
+     */
+    narrowType: Schema['narrowType'];
+    /**
+     * Allows to narrow different TypeScript types of a column granularly.
+     *
+     * Use it when the column's input is different from output.
+     *
+     * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowAllTypes` has the following syntax:
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     size: t.string().narrowAllTypes((t) =>
+     *       t<{
+     *         // what types are accepted when creating/updating
+     *         input: 'small' | 'medium' | 'large';
+     *         // how types are retured from a database
+     *         output: 'small' | 'medium' | 'large';
+     *         // what types the column accepts in `where` and similar
+     *         query: 'small' | 'medium' | 'large';
+     *       }>(),
+     *     ),
+     *   }));
+     * }
+     *
+     * // size will be typed as 'small' | 'medium' | 'large'
+     * const size = await db.table.get('size');
+     * ```
+     *
+     * - `input` is for `create`, `update` methods.
+     * - `output` is for the data that is loaded from a database and parsed if the column has `parse`.
+     * - `query` is used in `where` and other query methods, it should be compatible with the actual database column type.
+     *
+     * When integrating with a [validation library](/guide/columns-validation-methods), also provide validation schemas:
+     *
+     * ```ts
+     * const sizeSchema = z.union([
+     *   z.literal('small'),
+     *   z.literal('medium'),
+     *   z.literal('large'),
+     * ]);
+     *
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     size: t.text().narrowAllTypes({
+     *       input: sizeSchema,
+     *       output: sizeSchema,
+     *       query: sizeSchema,
+     *     }),
+     *   }));
+     * }
+     *
+     * // size will be typed as 'small' | 'medium' | 'large'
+     * const size = await db.table.get('size');
+     * ```
+     */
+    narrowAllTypes: Schema['narrowAllTypes'];
+    input<T extends {
+        inputSchema: unknown;
+    }, InputSchema extends Schema['type']>(this: T, fn: (schema: T['inputSchema']) => InputSchema): {
+        [K in keyof T]: K extends 'inputSchema' ? InputSchema : T[K];
+    };
+    output<T extends {
+        outputSchema: unknown;
+    }, OutputSchema extends Schema['type']>(this: T, fn: (schema: T['outputSchema']) => OutputSchema): {
+        [K in keyof T]: K extends 'outputSchema' ? OutputSchema : T[K];
+    };
+    query<T extends {
+        querySchema: unknown;
+    }, QuerySchema extends Schema['type']>(this: T, fn: (schema: T['querySchema']) => QuerySchema): {
+        [K in keyof T]: K extends 'querySchema' ? QuerySchema : T[K];
+    };
+    /**
+     * Set a database column name.
+     *
+     * @param name - name of the column in database.
+     */
+    name<T extends PickColumnBaseData>(this: T, name: string): T;
+    /**
+     * Append `select(false)` to a column to exclude it from the default selection.
+     * It won't be selected with `selectAll` or `select('*')` as well.
+     *
+     * ```ts
+     * export class UserTable extends BaseTable {
+     *   readonly table = 'user';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     name: t.string(),
+     *     password: t.string().select(false),
+     *   }));
+     * }
+     *
+     * // only id and name are selected, without password
+     * const user = await db.user.find(123);
+     *
+     * // password is still omitted, even with the wildcard
+     * const same = await db.user.find(123).select('*');
+     *
+     * const comment = await db.comment.find(123).select({
+     *   // password is omitted in the sub-selects as well
+     *   author: (q) => q.author,
+     * });
+     *
+     * // password is omitted here as well
+     * const created = await db.user.create(userData);
+     * ```
+     *
+     * Such a column can only be selected explicitly.
+     *
+     * ```ts
+     * const userWithPassword = await db.user.find(123).select('*', 'password');
+     * ```
+     */
+    select<T extends PickColumnBaseData, Value extends boolean>(this: T, value: Value): ColumnDefaultSelect<T, Value>;
+    /**
+     * Forbid the column to be used in [create](/guide/create-update-delete.html#create-insert) and [update](/guide/create-update-delete.html#update) methods.
+     *
+     * `readOnly` column is still can be set from a [hook](http://localhost:5173/guide/hooks.html#set-values-before-create-or-update).
+     *
+     * `readOnly` column can be used together with a `default`.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     column: t.string().default(() => 'default value'),
+     *     another: t.string().readOnly(),
+     *   }));
+     *
+     *   init(orm: typeof db) {
+     *     this.beforeSave(({ set }) => {
+     *       set({ another: 'value' });
+     *     });
+     *   }
+     * }
+     *
+     * // later in the code
+     * db.table.create({ column: 'value' }); // TS error, runtime error
+     * ```
+     */
+    readOnly<T>(this: T): T & ColumnDataAppReadOnly;
+    /**
+     * Set a column value when creating a record.
+     * This works for [readOnly](#readonly) columns as well.
+     *
+     * If no value or undefined is returned, the hook won't have any effect.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     column: t.string().setOnCreate(() => 'value'),
+     *   }));
+     * }
+     * ```
+     */
+    setOnCreate<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+    /**
+     * Set a column value when updating a record.
+     * This works for [readOnly](#readonly) columns as well.
+     *
+     * If no value or undefined is returned, the hook won't have any effect.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     column: t.string().setOnUpdate(() => 'value'),
+     *   }));
+     * }
+     * ```
+     */
+    setOnUpdate<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+    /**
+     * Set a column value when creating or updating a record.
+     * This works for [readOnly](#readonly) columns as well.
+     *
+     * If no value or undefined is returned, the hook won't have any effect.
+     *
+     * ```ts
+     * export class Table extends BaseTable {
+     *   readonly table = 'table';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     column: t.string().setOnSave(() => 'value'),
+     *   }));
+     * }
+     * ```
+     */
+    setOnSave<T extends QueryColumnInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['inputType'] | void): T;
+}
+
+type Code = string | Codes;
+type Codes = Code[];
+
+type DelayedRelationSelect = {
+    query: QueryBase;
+    value?: {
+        [K: string]: IsQuery;
+    };
+};
+
+interface QueryInternalColumnNameToKey {
+    columnNameToKeyMap?: Map<string, string>;
+}
+
+interface PickQueryDataAliases {
+    aliases?: RecordString;
+}
+interface QueryDataAliases extends PickQueryDataAliases {
+    as?: string;
+    outerAliases?: RecordString;
+}
+
+interface HasCteHooks {
+    cteHooks?: CteHooks;
+}
+interface CteHooks {
+    hasSelect: boolean;
+    tableHooks: CteTableHooks;
+}
+interface CteTableHooks {
+    [K: string]: CteTableHook;
+}
+interface CteTableHook {
+    shape: ColumnsShapeBase;
+    tableHook: TableHook;
+}
+interface TableHook {
+    select?: HookSelect;
+    after?: ((data: unknown, query: any) => unknown | Promise<unknown>)[];
+    afterCommit?: ((data: unknown, query: any) => unknown | Promise<unknown>)[];
+}
+type HookSelect = Map<string, HookSelectValue>;
+interface HookSelectValue {
+    select: string | {
+        sql: string;
+    };
+    as?: string;
+    temp?: string;
+}
+interface HasTableHook {
+    tableHook?: TableHook;
+}
+interface HasHookSelect {
+    hookSelect?: HookSelect;
+}
+
+interface PickQueryDataParsers {
+    defaultParsers?: ColumnsParsers;
+    parsers?: ColumnsParsers;
+    batchParsers?: BatchParsers;
+}
+type ColumnParser = FnUnknownToUnknown;
+interface BatchParser {
+    path: string[];
+    fn: (path: string[], queryResult: {
+        rows: unknown[];
+    }) => MaybePromise<void>;
+}
+type ColumnsParsers = {
+    [K in string | getValueKey]?: ColumnParser;
+};
+type BatchParsers = BatchParser[];
+
+interface QueryDataBase extends QueryDataAliases, PickQueryDataParsers, HasHookSelect {
+    shape: QueryColumnsInit;
+    select?: unknown;
+}
+
+interface SqlCommonOptions extends HasTableHook, HasCteHooks {
+    delayedRelationSelect?: DelayedRelationSelect;
+}
+interface SingleSqlItem {
+    text: string;
+    values?: unknown[];
+}
+interface SingleSql extends SingleSqlItem, SqlCommonOptions {
+}
+interface QueryMetaBase<Scopes extends RecordKeyTrue = RecordKeyTrue> {
+    kind: string;
+    as?: string;
+    subQuery: boolean;
+    hasSelect?: true;
+    hasWhere?: true;
+    defaults: EmptyObject;
+    tsQuery?: string;
+    scopes: Scopes;
+    selectable: SelectableBase;
+    defaultSelect: PropertyKey;
+}
+interface QueryInternalTableDataPrimaryKey {
+    columns: string[];
+    name?: string;
+}
+interface QueryInternalTableDataBase {
+    primaryKey?: QueryInternalTableDataPrimaryKey;
+}
+interface QueryInternalBase extends QueryInternalColumnNameToKey {
+    runtimeDefaultColumns?: string[];
+    transactionStorage: AsyncLocalStorage<TransactionState>;
+    scopes?: RecordUnknown;
+    snakeCase?: boolean;
+    noPrimaryKey: boolean;
+    comment?: string;
+    primaryKeys?: string[];
+    tableData: QueryInternalTableDataBase;
+}
+interface IsQuery {
+    __isQuery: true;
+}
+interface QueryBase extends IsQuery {
+    internal: QueryInternalBase;
+    shape: QueryColumns;
+    q: QueryDataBase;
+    table?: string;
+}
+interface QueryBaseCommon<Scopes extends RecordKeyTrue = RecordKeyTrue> extends QueryBase {
+    meta: QueryMetaBase<Scopes>;
+}
+interface SelectableBase {
+    [K: PropertyKey]: {
+        as: string;
+        column: QueryColumn;
+    };
+}
+type getValueKey = typeof getValueKey;
+declare const getValueKey: unique symbol;
+interface QueryOrExpression<T> {
+    result: {
+        value: QueryColumn<T>;
+    };
+}
+
+interface QueryLogObject {
+    colors: boolean;
+    beforeQuery(sql: SingleSql): unknown;
+    afterQuery(sql: SingleSql, logData: unknown): void;
+    onError(error: Error, sql: SingleSql, logData: unknown): void;
+}
+
+declare class OrchidOrmInternalError extends Error {
+    #private;
+    data?: RecordUnknown | undefined;
+    constructor(query: QueryBase, message?: string, data?: RecordUnknown | undefined);
+    get query(): QueryBase;
+}
+type QueryErrorName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
+declare abstract class QueryError<T extends PickQueryShape = PickQueryShape> extends OrchidOrmInternalError {
+    message: string;
+    name: QueryErrorName;
+    stack: string | undefined;
+    code: string | undefined;
+    detail: string | undefined;
+    severity: string | undefined;
+    hint: string | undefined;
+    position: string | undefined;
+    internalPosition: string | undefined;
+    internalQuery: string | undefined;
+    where: string | undefined;
+    schema: string | undefined;
+    table: string | undefined;
+    column: string | undefined;
+    dataType: string | undefined;
+    constraint: string | undefined;
+    file: string | undefined;
+    line: string | undefined;
+    routine: string | undefined;
+    get isUnique(): boolean;
+    columnsCache?: {
+        [K in keyof T['shape']]?: true;
+    };
+    get columns(): { [K in keyof T["shape"]]?: true | undefined; };
+}
+
+/**
+ * Generic result returning from query methods.
+ */
+interface QueryResultRow {
+    [K: string]: any;
+}
+interface QueryResult<T extends QueryResultRow = any> {
+    rowCount: number;
+    rows: T[];
+    fields: {
+        name: string;
+    }[];
+}
+interface QueryArraysResult<R extends any[] = any[]> {
+    rowCount: number;
+    rows: R[];
+    fields: {
+        name: string;
+    }[];
+}
+interface AdapterConfigBase {
+    databaseURL?: string;
+    /**
+     * This option may be useful in CI when database container has started, CI starts performing next steps,
+     * migrations begin to apply though database may be not fully ready for connections yet.
+     *
+     * Set `connectRetry: true` for the default backoff strategy. It performs 10 attempts starting with 50ms delay and increases delay exponentially according to this formula:
+     *
+     * ```
+     * (factor, defaults to 1.5) ** (currentAttempt - 1) * (delay, defaults to 50)
+     * ```
+     *
+     * So the 2nd attempt will happen in 50ms from start, 3rd attempt in 125ms, 3rd in 237ms, and so on.
+     *
+     * You can customize max attempts to be made, `factor` multiplier and the starting delay by passing:
+     *
+     * ```ts
+     * const options = {
+     *   databaseURL: process.env.DATABASE_URL,
+     *   connectRetry: {
+     *     attempts: 15, // max attempts
+     *     strategy: {
+     *       delay: 100, // initial delay
+     *       factor: 2, // multiplier for the formula above
+     *     }
+     *   }
+     * };
+     *
+     * rakeDb(options, { ... });
+     * ```
+     *
+     * You can pass a custom function to `strategy` to customize delay behavior:
+     *
+     * ```ts
+     * import { setTimeout } from 'timers/promises';
+     *
+     * const options = {
+     *   databaseURL: process.env.DATABASE_URL,
+     *   connectRetry: {
+     *     attempts: 5,
+     *     stragegy(currentAttempt: number, maxAttempts: number) {
+     *       // linear: wait 100ms after 1st attempt, then 200m after 2nd, and so on.
+     *       return setTimeout(currentAttempt * 100);
+     *     },
+     *   },
+     * };
+     * ```
+     */
+    connectRetry?: AdapterConfigConnectRetryParam | true;
+}
+interface AdapterConfigConnectRetryParam {
+    attempts?: number;
+    strategy?: AdapterConfigConnectRetryStrategyParam | AdapterConfigConnectRetryStrategy;
+}
+interface AdapterConfigConnectRetryStrategyParam {
+    delay?: number;
+    factor?: number;
+}
+interface AdapterConfigConnectRetry {
+    attempts: number;
+    strategy: AdapterConfigConnectRetryStrategy;
+}
+interface AdapterConfigConnectRetryStrategy {
+    (attempt: number, attempts: number): Promise<void> | void;
+}
+interface AdapterBase {
+    connectRetryConfig?: AdapterConfigConnectRetry;
+    schema?: string;
+    errorClass: new (...args: any[]) => Error;
+    assignError(to: QueryError, from: Error): void;
+    reconfigure(params: {
+        database?: string;
+        user?: string;
+        password?: string;
+        schema?: string;
+    }): AdapterBase;
+    getDatabase(): string;
+    getUser(): string;
+    getSchema(): string | undefined;
+    getHost(): string;
+    connect?(): Promise<unknown>;
+    query<T extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[]): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(text: string, values?: unknown[]): Promise<QueryArraysResult<R>>;
+    /**
+     * Run a transaction
+     *
+     * @param options - optional transaction parameters
+     * @param cb - callback will be called with a db client with a dedicated connection.
+     */
+    transaction<T>(options: string | undefined, cb: (adapter: AdapterBase) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+interface TransactionState {
+    adapter: AdapterBase;
+    transactionId: number;
+    afterCommit?: TransactionAfterCommitHook[];
+    log?: QueryLogObject;
+    testTransactionCount?: number;
+}
+/**
+ * Element of `afterCommit` transaction array. See {@link TransactionState.afterCommit}.
+ */
+type TransactionAfterCommitHook = unknown[] | QueryBaseCommon | AfterCommitHook[] | AfterCommitStandaloneHook;
+interface AfterCommitHook {
+    (data: unknown[], q: QueryBaseCommon): unknown | Promise<unknown>;
+}
+interface AfterCommitStandaloneHook {
+    (): unknown | Promise<unknown>;
+}
 
 interface CreatePostgresJsDbOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> extends PostgresJsAdapterOptions, DbOptions<SchemaConfig, ColumnTypes> {
 }
-declare const createDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>(options: CreatePostgresJsDbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig<pqb.ColumnTypeBase<pqb.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, pqb.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>(options: CreatePostgresJsDbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 interface PostgresJsAdapterOptions extends postgres.Options<any>, AdapterConfigBase {
     databaseURL?: string;
     schema?: string;
@@ -31,7 +1101,7 @@ declare class PostgresJsAdapter implements AdapterBase {
     arrays<R extends any[] = any[]>(text: string, values?: unknown[]): Promise<QueryArraysResult<R>>;
     transaction<Result>(options: string | undefined, cb: (adapter: AdapterBase) => Promise<Result>): Promise<Result>;
     close(): Promise<void>;
-    assignError(to: QueryError, dbError: Error): void;
+    assignError(to: QueryError, dbError: Error$1): void;
 }
 declare class PostgresJsTransactionAdapter implements AdapterBase {
     adapter: PostgresJsAdapter;
@@ -52,7 +1122,7 @@ declare class PostgresJsTransactionAdapter implements AdapterBase {
     arrays<R extends any[] = any[]>(text: string, values?: unknown[]): Promise<QueryArraysResult<R>>;
     transaction<Result>(_options: string | undefined, cb: (adapter: PostgresJsTransactionAdapter) => Promise<Result>): Promise<Result>;
     close(): Promise<void>;
-    assignError(to: QueryError, from: Error): void;
+    assignError(to: QueryError, from: Error$1): void;
 }
 
 export { type CreatePostgresJsDbOptions, PostgresJsAdapter, type PostgresJsAdapterOptions, PostgresJsTransactionAdapter, createDb };