pqb 0.70.0 → 0.71.1

package/dist/internal.d.ts

@@ -668,7 +668,7 @@ interface ColumnSchemaGetterTableClass$1 {
 }
 interface ColumnTypeSchemaArg$1 {
   __schemaType: unknown;
-  nullable<T extends Column$1.Pick.ForNullable>(this: T): Column$1.Modifiers.Nullable<T, unknown, unknown, unknown>;
+  nullable: unknown;
   encode: unknown;
   parse: unknown;
   parseNull: unknown;
@@ -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;
     }
@@ -943,7 +969,7 @@ interface NumberColumnData$1 extends BaseNumberData$1, Column$1.Data {
   identity?: TableData$1.Identity;
 }
 interface SerialColumnData$1 extends NumberColumnData$1 {
-  default: Expression$1;
+  default: true;
 }
 declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig$1, SchemaType extends Schema['__schemaType']> extends Column$1 {
   __schema: Schema;
@@ -988,27 +1014,26 @@ declare class DecimalColumn$1<Schema extends ColumnSchemaConfig$1> extends Numbe
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
   toSQL(): string;
 }
-type IdentityColumn<T extends Column$1.Pick.Data> = Column$1.Modifiers.Default<T, Expression$1>;
 declare class SmallIntColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): Column$1.Modifiers.HasDefault<T>;
 }
 declare class IntegerColumn$1<Schema extends ColumnSchemaConfig$1> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): Column$1.Modifiers.HasDefault<T>;
 }
 declare class BigIntColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberAsStringBaseColumn<Schema, string | number | bigint> {
   dataType: "int8";
   querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
-  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): IdentityColumn<T>;
+  identity<T extends Column$1.Pick.Data>(this: T, options?: TableData$1.Identity): Column$1.Modifiers.HasDefault<T>;
 }
 declare class RealColumn$1<Schema extends ColumnSchemaConfig$1> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
   dataType: "float4";
@@ -1203,6 +1228,7 @@ declare class JSONTextColumn$1<T, Schema extends ColumnTypeSchemaArg$1, InputSch
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 interface DefaultSchemaConfig$1 extends ColumnSchemaConfig$1<Column$1> {
+  nullable<T extends Column$1.Pick.ForNullable>(this: T): Column$1.Modifiers.Nullable<T>;
   parse<T extends Column$1.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column$1.Modifiers.Parse<T, unknown, Output>;
   parseNull<T extends Column$1.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column$1.Modifiers.ParseNull<T, unknown, Output>;
   encode<T extends Column$1.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column$1.Modifiers.Encode<T, unknown, Input>;
@@ -1599,7 +1625,7 @@ declare class UUIDColumn$1<Schema extends ColumnSchemaConfig$1> extends Column$1
   T & {
     data: {
       primaryKey: Name;
-      default: RawSqlBase$1;
+      default: true;
     };
   };
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
@@ -1651,8 +1677,8 @@ declare class BooleanColumn$1<Schema extends ColumnSchemaConfig$1> extends Colum
   toCode(ctx: ColumnToCodeCtx$1, key: string): Code$1;
 }
 interface Timestamps$1<T extends Column$1.Pick.Data> {
-  createdAt: Column$1.Modifiers.Default<T, RawSqlBase$1>;
-  updatedAt: Column$1.Modifiers.Default<T, RawSqlBase$1>;
+  createdAt: Column$1.Modifiers.HasDefault<T>;
+  updatedAt: Column$1.Modifiers.HasDefault<T>;
 }
 interface TimestampHelpers {
   /**
@@ -1734,7 +1760,7 @@ interface DefaultColumnTypes$1<SchemaConfig extends ColumnSchemaConfig$1> extend
   decimal: SchemaConfig['decimal'];
   real: SchemaConfig['real'];
   doublePrecision: SchemaConfig['doublePrecision'];
-  identity(options?: TableData$1.Identity): IdentityColumn<ReturnType<SchemaConfig['integer']>>;
+  identity(options?: TableData$1.Identity): Column$1.Modifiers.HasDefault<ReturnType<SchemaConfig['integer']>>;
   smallSerial: SchemaConfig['smallSerial'];
   serial: SchemaConfig['serial'];
   bigSerial: SchemaConfig['bigSerial'];
@@ -7247,7 +7273,8 @@ declare namespace Column$1 {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column.Pick.ForNullable, 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' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
+    export type Nullable<T extends Column.Pick.ForNullable> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends '__queryType' ? T['__queryType'] | null : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
+    export type NullableWithSchema<T extends Column.Pick.ForNullable, 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' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
     export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
     export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
     interface DataNullable {
@@ -7263,8 +7290,7 @@ declare namespace Column$1 {
     export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
     export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
     export type ParseNull<T extends Column.Pick.ForParseNull, NullSchema, NullType> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? Exclude<T['__outputType'], null> | NullType : T['__outputType'] : K extends '__nullType' ? NullType : K extends 'outputSchema' ? null extends T['__type'] ? T['outputSchema'] | NullSchema : T['outputSchema'] : K extends 'nullSchema' ? NullSchema : T[K] };
-    type DefaultData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'default' ? Value extends null ? never : Value : K extends 'optional' ? true : T[K] };
-    export type Default<T extends Column.Pick.Data, Value> = { [K in keyof T]: K extends 'data' ? DefaultData<T['data'], Value> : T[K] };
+    export type HasDefault<T extends Column.Pick.Data> = T & Column.Data.Default;
     type DefaultSelectData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K] };
     export type DefaultSelect<T extends Column.Pick.Data, Value extends boolean> = { [K in keyof T]: K extends 'data' ? DefaultSelectData<T['data'], Value> : T[K] };
     export interface IsAppReadOnly {
@@ -7364,6 +7390,7 @@ declare namespace Column$1 {
     interface TableParamInstance {
       schema?: string;
       table: string;
+      nameInDb?: string;
       columns: PickQueryShape$1;
     }
     interface TableParam {
@@ -7455,6 +7482,12 @@ declare namespace Column$1 {
     skipValueToArray?: boolean;
   }
   export namespace Data {
+    interface Default {
+      data: {
+        default: true;
+        optional: true;
+      };
+    }
     interface Check {
       sql: RawSqlBase$1;
       name?: string;
@@ -7525,13 +7558,13 @@ declare abstract class Column$1 {
    *
    * @param value - default value or a function returning a value
    */
-  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase$1 | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
+  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase$1 | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.HasDefault<T>;
   /**
    * 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 Column.Pick.Data>(this: T): Column.Modifiers.Default<T, RawSqlBase$1>;
+  hasDefault<T extends Column.Pick.Data>(this: T): Column.Modifiers.HasDefault<T>;
   /**
    * Set a database-level validation check to a column. `check` accepts a raw SQL.
    *
@@ -8224,7 +8257,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.
    *
@@ -8347,6 +8380,7 @@ interface QueryData$1 extends QueryDataAliases, PickQueryDataParsers, HasHookSel
   type: QueryType;
   adapter: Adapter$1;
   selectShape: ColumnsShape$1;
+  nameInDb?: string;
   handleResult: HandleResult;
   catch?: boolean;
   returnType: QueryReturnType$1;

package/package.json

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