@erfanium/drizzle-orm 0.1.0 → 1.0.1

package/pg-core/columns/common.d.ts

@@ -1,69 +1,277 @@
-import type { ColumnBuilderBase, ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnBuilderRuntimeConfig, ColumnDataType, HasGenerated } from "../../column-builder.js";
-import { ColumnBuilder } from "../../column-builder.js";
-import type { ColumnBaseConfig } from "../../column.js";
-import { Column } from "../../column.js";
-import { entityKind } from "../../entity.js";
-import type { Simplify, Update } from "../../utils.js";
-import type { UpdateDeleteAction } from "../foreign-keys.js";
-import type { AnyPgTable, PgTable } from "../table.js";
-import type { SQL } from "../../sql/sql.js";
-import type { PgIndexOpClass } from "../indexes.js";
+import type { ColumnType, GeneratedColumnConfig, GeneratedIdentityConfig } from '../../column-builder.js';
+import { Column } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { UpdateDeleteAction } from '../foreign-keys.js';
+import type { PgTable } from '../table.js';
+import type { SQL } from '../../sql/sql.js';
+import type { Update } from '../../utils.js';
+import type { PgIndexOpClass } from '../indexes.js';
+export type PgArrayDimension = 0 | 1 | 2 | 3 | 4 | 5;
+type PgArrayDimensionString = '[]' | '[][]' | '[][][]' | '[][][][]' | '[][][][][]';
+type ArrayDimensionStringToNumber<T extends PgArrayDimensionString> = T extends '[]' ? 1 : T extends '[][]' ? 2 : T extends '[][][]' ? 3 : T extends '[][][][]' ? 4 : T extends '[][][][][]' ? 5 : never;
+export interface PgColumnBuilderConfig {
+    dataType: ColumnType;
+    data: unknown;
+    driverParam: unknown;
+    notNull?: boolean;
+    hasDefault?: boolean;
+    isPrimaryKey?: boolean;
+    isAutoincrement?: boolean;
+    hasRuntimeDefault?: boolean;
+    enumValues?: string[];
+    identity?: 'always' | 'byDefault';
+    generated?: unknown;
+    dimensions?: PgArrayDimension;
+    $type?: unknown;
+}
+export interface PgColumnBuilderRuntimeConfig<TData> {
+    name: string;
+    keyAsName: boolean;
+    notNull: boolean;
+    default: TData | SQL | undefined;
+    defaultFn: (() => TData | SQL) | undefined;
+    onUpdateFn: (() => TData | SQL) | undefined;
+    hasDefault: boolean;
+    primaryKey: boolean;
+    isUnique: boolean;
+    uniqueName: string | undefined;
+    uniqueType: string | undefined;
+    dataType: string;
+    columnType: string;
+    generated: GeneratedColumnConfig<TData> | undefined;
+    generatedIdentity: GeneratedIdentityConfig | undefined;
+    dimensions?: PgArrayDimension;
+}
+export interface PgColumnBaseConfig<out TDataType extends ColumnType = ColumnType> {
+    name: string;
+    dataType: TDataType;
+    tableName: string;
+    notNull: boolean;
+    hasDefault: boolean;
+    isPrimaryKey: boolean;
+    isAutoincrement: boolean;
+    hasRuntimeDefault: boolean;
+    data: unknown;
+    driverParam: unknown;
+    enumValues: string[] | undefined;
+    generated: unknown;
+    identity: undefined | 'always' | 'byDefault';
+}
+type WrapArray<T, N extends number> = N extends 1 ? T[] : N extends 2 ? T[][] : N extends 3 ? T[][][] : N extends 4 ? T[][][][] : N extends 5 ? T[][][][][] : T;
+export type SetNotNull<T> = T & {
+    readonly _: {
+        notNull: true;
+    };
+};
+export type SetHasDefault<T> = T & {
+    readonly _: {
+        hasDefault: true;
+    };
+};
+export type SetIsPrimaryKey<T> = T & {
+    readonly _: {
+        isPrimaryKey: true;
+        notNull: true;
+    };
+};
+export type SetHasRuntimeDefault<T> = T & {
+    readonly _: {
+        hasRuntimeDefault: true;
+        hasDefault: true;
+    };
+};
+export type Set$Type<T, TType> = T & {
+    readonly _: {
+        $type: TType;
+    };
+};
+export type SetHasGenerated<T> = T & {
+    readonly _: {
+        hasDefault: true;
+        generated: true;
+    };
+};
+export type SetDimensions<T, TDim extends PgArrayDimension> = T & {
+    readonly _: {
+        dimensions: TDim;
+    };
+};
+export type SetIdentity<T, TType extends 'always' | 'byDefault'> = T & {
+    readonly _: {
+        notNull: true;
+        hasDefault: true;
+        identity: TType;
+    };
+};
+export type HasIdentity<T, TType extends 'always' | 'byDefault'> = SetIdentity<T, TType>;
+type GetBaseData<T> = T extends {
+    $type: infer U;
+} ? U : T extends {
+    data: infer D;
+} ? D : unknown;
+export type ResolvePgColumnConfig<out T extends PgColumnBuilderConfig, out TTableName extends string, out TData = T['dimensions'] extends 1 | 2 | 3 | 4 | 5 ? WrapArray<GetBaseData<T>, T['dimensions']> : GetBaseData<T>> = {
+    name: string;
+    tableName: TTableName;
+    dataType: T['dataType'];
+    data: TData;
+    driverParam: T['dimensions'] extends 1 | 2 | 3 | 4 | 5 ? WrapArray<T['driverParam'], T['dimensions']> | string : T['driverParam'];
+    notNull: T['notNull'] extends true ? true : false;
+    hasDefault: T['hasDefault'] extends true ? true : false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: T extends {
+        enumValues: infer E extends string[];
+    } ? E : undefined;
+    identity: T['identity'] extends 'always' | 'byDefault' ? T['identity'] : undefined;
+    generated: T['generated'] extends true ? true : undefined;
+} & {};
+export interface AnyPgColumnBuilder {
+    readonly _: PgColumnBuilderConfig;
+}
+export type PgBuildColumn<TTableName extends string, TBuilder extends AnyPgColumnBuilder, TBuiltConfig extends PgColumnBaseConfig<ColumnType> = ResolvePgColumnConfig<TBuilder['_'], TTableName>> = PgColumn<ColumnType, TBuiltConfig, {}>;
+export type PgBuildColumns<out TTableName extends string, out TConfigMap extends Record<string, AnyPgColumnBuilder>> = {
+    [Key in keyof TConfigMap]: PgBuildColumn<TTableName, TConfigMap[Key]>;
+} & {};
+export type PgBuildExtraConfigColumns<out TConfigMap extends Record<string, AnyPgColumnBuilder>> = {
+    [Key in keyof TConfigMap]: ExtraConfigColumn;
+} & {};
+export type PgColumns = Record<string, PgColumn>;
 export interface ReferenceConfig {
     ref: () => PgColumn;
-    actions: {
+    config: {
+        name?: string;
         onUpdate?: UpdateDeleteAction;
         onDelete?: UpdateDeleteAction;
     };
 }
-export interface PgColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> extends ColumnBuilderBase<T, TTypeConfig & {
-    dialect: 'pg';
-}> {
-}
-export declare abstract class PgColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & {
-    dialect: 'pg';
-}, TExtraConfig> implements PgColumnBuilderBase<T, TTypeConfig> {
-    private foreignKeyConfigs;
+export declare abstract class PgColumnBuilder<out T extends PgColumnBuilderConfig = PgColumnBuilderConfig, out TRuntimeConfig extends object = object> {
     static readonly [entityKind]: string;
-    array<TSize extends number | undefined = undefined>(size?: TSize): PgArrayBuilder<{
-        name: T['name'];
-        dataType: 'array';
-        columnType: 'PgArray';
-        data: T['data'][];
-        driverParam: T['driverParam'][] | string;
-        enumValues: T['enumValues'];
-        size: TSize;
-        baseBuilder: T;
-    } & (T extends {
-        notNull: true;
-    } ? {
-        notNull: true;
-    } : {}) & (T extends {
-        hasDefault: true;
-    } ? {
-        hasDefault: true;
-    } : {}), T>;
-    references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;
+    readonly _: T;
+    private foreignKeyConfigs;
+    protected config: PgColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
+    constructor(name: string, dataType: ColumnType, columnType: string);
+    /**
+     * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+     *
+     * @example
+     * ```ts
+     * const users = pgTable('users', {
+     * 	id: integer('id').$type<UserId>().primaryKey(),
+     * 	details: json('details').$type<UserDetails>().notNull(),
+     * });
+     * ```
+     */
+    $type<TType>(): Set$Type<this, TType>;
+    /**
+     * Adds a `not null` clause to the column definition.
+     *
+     * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+     */
+    notNull(): SetNotNull<this>;
+    /**
+     * Adds a `default <value>` clause to the column definition.
+     *
+     * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+     *
+     * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+     */
+    default(value: (this['_'] extends {
+        dimensions: 1 | 2 | 3 | 4 | 5;
+    } ? WrapArray<this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data'], this['_']['dimensions']> : this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data']) | SQL): SetHasDefault<this>;
+    /**
+     * Adds a dynamic default value to the column.
+     * The function will be called when the row is inserted, and the returned value will be used as the column value.
+     *
+     * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+     */
+    $defaultFn(fn: () => (this['_'] extends {
+        dimensions: 1 | 2 | 3 | 4 | 5;
+    } ? WrapArray<this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data'], this['_']['dimensions']> : this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data']) | SQL): SetHasRuntimeDefault<this>;
+    /**
+     * Alias for {@link $defaultFn}.
+     */
+    $default: (fn: () => (this["_"] extends {
+        dimensions: 1 | 2 | 3 | 4 | 5;
+    } ? WrapArray<this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"], this["_"]["dimensions"]> : this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]) | SQL) => SetHasRuntimeDefault<this>;
+    /**
+     * Adds a dynamic update value to the column.
+     * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+     * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+     *
+     * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+     */
+    $onUpdateFn(fn: () => (this['_'] extends {
+        dimensions: 1 | 2 | 3 | 4 | 5;
+    } ? WrapArray<this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data'], this['_']['dimensions']> : this['_'] extends {
+        $type: infer U;
+    } ? U : this['_']['data']) | SQL): SetHasDefault<this>;
+    /**
+     * Alias for {@link $onUpdateFn}.
+     */
+    $onUpdate: (fn: () => (this["_"] extends {
+        dimensions: 1 | 2 | 3 | 4 | 5;
+    } ? WrapArray<this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"], this["_"]["dimensions"]> : this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]) | SQL) => SetHasDefault<this>;
+    /**
+     * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+     *
+     * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+     */
+    primaryKey(): SetIsPrimaryKey<this>;
+    /**
+     * Makes this column a PostgreSQL array column.
+     *
+     * @example
+     * ```ts
+     * const t = pgTable('t', {
+     *   // 1D array: number[]
+     *   tags: integer().array(),
+     *   // Or explicitly: integer().array('[]')
+     *   // 2D array: number[][]
+     *   matrix: integer().array('[][]'),
+     * });
+     * ```
+     */
+    array(): SetDimensions<this, 1>;
+    array<TDim extends PgArrayDimensionString>(dimensions: TDim): SetDimensions<this, ArrayDimensionStringToNumber<TDim>>;
+    references(ref: ReferenceConfig['ref'], config?: ReferenceConfig['config']): this;
     unique(name?: string, config?: {
         nulls: 'distinct' | 'not distinct';
     }): this;
-    generatedAlwaysAs(as: SQL | T['data'] | (() => SQL)): HasGenerated<this, {
-        type: 'always';
-    }>;
+    generatedAlwaysAs(as: SQL | (() => SQL)): SetHasGenerated<this>;
 }
-export declare abstract class PgColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
-    dialect: 'pg';
-}> {
-    readonly table: PgTable;
+export declare abstract class PgColumn<out TColumnType extends ColumnType = any, out T extends PgColumnBaseConfig<TColumnType> = PgColumnBaseConfig<TColumnType>, out TRuntimeConfig extends object = {}> extends Column<T, TRuntimeConfig> {
     static readonly [entityKind]: string;
-    constructor(table: PgTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+    readonly dimensions: PgArrayDimension;
+    constructor(table: PgTable, config: PgColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig);
 }
 export type IndexedExtraConfigType = {
     order?: 'asc' | 'desc';
     nulls?: 'first' | 'last';
     opClass?: string;
 };
-export declare class ExtraConfigColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>> extends PgColumn<T, IndexedExtraConfigType> {
+export declare class ExtraConfigColumn<out T extends PgColumnBaseConfig<ColumnType> = PgColumnBaseConfig<ColumnType>> extends PgColumn<ColumnType, T, IndexedExtraConfigType> {
     static readonly [entityKind]: string;
+    /** @itnernal */
+    readonly codec: undefined;
     getSQLType(): string;
     indexConfig: IndexedExtraConfigType;
     defaultConfig: IndexedExtraConfigType;
@@ -104,46 +312,11 @@ export declare class ExtraConfigColumn<T extends ColumnBaseConfig<ColumnDataType
 }
 export declare class IndexedColumn {
     static readonly [entityKind]: string;
-    constructor(name: string | undefined, keyAsName: boolean, type: string, indexConfig: IndexedExtraConfigType);
-    name: string | undefined;
+    constructor(name: string, keyAsName: boolean, type: string, indexConfig: IndexedExtraConfigType);
+    name: string;
     keyAsName: boolean;
     type: string;
     indexConfig: IndexedExtraConfigType;
 }
-export type AnyPgColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = PgColumn<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;
-export type PgArrayColumnBuilderBaseConfig = ColumnBuilderBaseConfig<'array', 'PgArray'> & {
-    size: number | undefined;
-    baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-};
-export declare class PgArrayBuilder<T extends PgArrayColumnBuilderBaseConfig, TBase extends ColumnBuilderBaseConfig<ColumnDataType, string> | PgArrayColumnBuilderBaseConfig> extends PgColumnBuilder<T, {
-    baseBuilder: TBase extends PgArrayColumnBuilderBaseConfig ? PgArrayBuilder<TBase, TBase extends {
-        baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any>;
-    } ? TBaseBuilder : never> : PgColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-    size: T['size'];
-}, {
-    baseBuilder: TBase extends PgArrayColumnBuilderBaseConfig ? PgArrayBuilder<TBase, TBase extends {
-        baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any>;
-    } ? TBaseBuilder : never> : PgColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-    size: T['size'];
-}> {
-    static readonly [entityKind] = "PgArrayBuilder";
-    constructor(name: string, baseBuilder: PgArrayBuilder<T, TBase>['config']['baseBuilder'], size: T['size']);
-}
-export declare class PgArray<T extends ColumnBaseConfig<'array', 'PgArray'> & {
-    size: number | undefined;
-    baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-}, TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>> extends PgColumn<T, {}, {
-    size: T['size'];
-    baseBuilder: T['baseBuilder'];
-}> {
-    readonly baseColumn: PgColumn;
-    readonly range?: [number | undefined, number | undefined] | undefined;
-    readonly size: T['size'];
-    static readonly [entityKind]: string;
-    constructor(table: AnyPgTable<{
-        name: T['tableName'];
-    }>, config: PgArrayBuilder<T, TBase>['config'], baseColumn: PgColumn, range?: [number | undefined, number | undefined] | undefined);
-    getSQLType(): string;
-    mapFromDriverValue(value: unknown[] | string): T['data'];
-    mapToDriverValue(value: unknown[], isNestedArray?: boolean): unknown[] | string;
-}
+export type AnyPgColumn<TPartial extends Partial<PgColumnBaseConfig<ColumnType>> = {}> = PgColumn<any, Required<Update<PgColumnBaseConfig<ColumnType>, TPartial>>>;
+export {};