pipework 0.252.0 → 0.252.1

package/src/data/query/pg-core/columns/custom.ts

@@ -0,0 +1,232 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import type { SQL } from '../../sql/sql.js';
+import { type Equal, getColumnNameAndConfig } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
+	& {
+		name: TName;
+		dataType: 'custom';
+		columnType: 'PgCustomColumn';
+		data: T['data'];
+		driverParam: T['driverData'];
+		enumValues: undefined;
+	}
+	& (T['notNull'] extends true ? { notNull: true } : {})
+	& (T['default'] extends true ? { hasDefault: true } : {});
+
+export interface PgCustomColumnInnerConfig {
+	customTypeValues: CustomTypeValues;
+}
+
+export class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'PgCustomColumn'>>
+	extends PgColumnBuilder<
+		T,
+		{
+			fieldConfig: CustomTypeValues['config'];
+			customTypeParams: CustomTypeParams<any>;
+		},
+		{
+			pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+		}
+	>
+{
+	static override readonly [entityKind]: string = 'PgCustomColumnBuilder';
+
+	constructor(
+		name: T['name'],
+		fieldConfig: CustomTypeValues['config'],
+		customTypeParams: CustomTypeParams<any>,
+	) {
+		super(name, 'custom', 'PgCustomColumn');
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+
+	/** @internal */
+	build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgCustomColumn<MakeColumnConfig<T, TTableName>> {
+		return new PgCustomColumn<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgCustomColumn<T extends ColumnBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgCustomColumn';
+
+	private sqlName: string;
+	private mapTo?: ((value: T['data']) => T['driverParam']) | undefined;
+	private mapFrom?: ((value: T['driverParam']) => T['data']) | undefined;
+
+	constructor(
+		table: AnyPgTable<{ name: T['tableName'] }>,
+		config: PgCustomColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+	}
+
+	getSQLType(): string {
+		return this.sqlName;
+	}
+
+	override mapFromDriverValue(value: T['driverParam']): T['data'] {
+		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	}
+
+	override mapToDriverValue(value: T['data']): T['driverParam'] {
+		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	}
+}
+
+export type CustomTypeValues = {
+	/**
+	 * Required type for custom column, that will infer proper type model
+	 *
+	 * Examples:
+	 *
+	 * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+	 *
+	 * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+	 */
+	data: unknown;
+
+	/**
+	 * Type helper, that represents what type database driver is accepting for specific database data type
+	 */
+	driverData?: unknown;
+
+	/**
+	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
+	 */
+	config?: Record<string, any>;
+
+	/**
+	 * Whether the config argument should be required or not
+	 * @default false
+	 */
+	configRequired?: boolean;
+
+	/**
+	 * If your custom data type should be notNull by default you can use `notNull: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	notNull?: boolean;
+
+	/**
+	 * If your custom data type has default you can use `default: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	default?: boolean;
+};
+
+export interface CustomTypeParams<T extends CustomTypeValues> {
+	/**
+	 * Database data type string representation, that is used for migrations
+	 * @example
+	 * ```
+	 * `jsonb`, `text`
+	 * ```
+	 *
+	 * If database data type needs additional params you can use them from `config` param
+	 * @example
+	 * ```
+	 * `varchar(256)`, `numeric(2,3)`
+	 * ```
+	 *
+	 * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+	 *
+	 * @example
+	 * Usage example
+	 * ```
+	 *   dataType() {
+	 *     return 'boolean';
+	 *   },
+	 * ```
+	 * Or
+	 * ```
+	 *   dataType(config) {
+	 * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+	 * 	 }
+	 * ```
+	 */
+	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+
+	/**
+	 * Optional mapping function, between user input and driver
+	 * @example
+	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
+	 * ```
+	 * toDriver(value: TData): string {
+	 * 	 return JSON.stringify(value);
+	 * }
+	 * ```
+	 */
+	toDriver?: (value: T['data']) => T['driverData'] | SQL;
+
+	/**
+	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+	 * @example
+	 * For example, when using timestamp we need to map string Date representation to JS Date
+	 * ```
+	 * fromDriver(value: string): Date {
+	 * 	return new Date(value);
+	 * },
+	 * ```
+	 */
+	fromDriver?: (value: T['driverData']) => T['data'];
+}
+
+/**
+ * Custom pg database data type generator
+ */
+export function customType<T extends CustomTypeValues = CustomTypeValues>(
+	customTypeParams: CustomTypeParams<T>,
+): Equal<T['configRequired'], true> extends true ? {
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig: TConfig,
+		): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
+		<TName extends string>(
+			dbName: TName,
+			fieldConfig: T['config'],
+		): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+	}
+	: {
+		(): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig?: TConfig,
+		): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
+		<TName extends string>(
+			dbName: TName,
+			fieldConfig?: T['config'],
+		): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+	}
+{
+	return <TName extends string>(
+		a?: TName | T['config'],
+		b?: T['config'],
+	): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
+		return new PgCustomColumnBuilder(name as ConvertCustomConfig<TName, T>['name'], config, customTypeParams);
+	};
+}

package/src/data/query/pg-core/columns/date.common.ts

@@ -0,0 +1,15 @@
+import type { ColumnBuilderBaseConfig, ColumnDataType } from '../../column-builder.js';
+import { entityKind } from '../../entity.js';
+import { sql } from '../../sql/sql.js';
+import { PgColumnBuilder } from './common.js';
+
+export abstract class PgDateColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	TRuntimeConfig extends object = object,
+> extends PgColumnBuilder<T, TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'PgDateColumnBaseBuilder';
+
+	defaultNow() {
+		return this.default(sql`now()`);
+	}
+}

package/src/data/query/pg-core/columns/date.ts

@@ -0,0 +1,112 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { type Equal, getColumnNameAndConfig } from '../../utils.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
+
+export type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
+	name: TName;
+	dataType: 'date';
+	columnType: 'PgDate';
+	data: Date;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgDate'>> extends PgDateColumnBaseBuilder<T> {
+	static override readonly [entityKind]: string = 'PgDateBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'date', 'PgDate');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgDate<MakeColumnConfig<T, TTableName>> {
+		return new PgDate<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgDate<T extends ColumnBaseConfig<'date', 'PgDate'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgDate';
+
+	getSQLType(): string {
+		return 'date';
+	}
+
+	override mapFromDriverValue(value: string | Date): Date {
+		if (typeof value === 'string') return new Date(value);
+
+		return value;
+	}
+
+	override mapToDriverValue(value: Date): string {
+		return value.toISOString();
+	}
+}
+
+export type PgDateStringBuilderInitial<TName extends string> = PgDateStringBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgDateString';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgDateString'>>
+	extends PgDateColumnBaseBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgDateStringBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'string', 'PgDateString');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgDateString<MakeColumnConfig<T, TTableName>> {
+		return new PgDateString<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgDateString<T extends ColumnBaseConfig<'string', 'PgDateString'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgDateString';
+
+	getSQLType(): string {
+		return 'date';
+	}
+
+	override mapFromDriverValue(value: Date | string): string {
+		if (typeof value === 'string') return value;
+
+		return value.toISOString().slice(0, -14);
+	}
+}
+
+export interface PgDateConfig<T extends 'date' | 'string' = 'date' | 'string'> {
+	mode: T;
+}
+
+export function date(): PgDateStringBuilderInitial<''>;
+export function date<TMode extends PgDateConfig['mode'] & {}>(
+	config?: PgDateConfig<TMode>,
+): Equal<TMode, 'date'> extends true ? PgDateBuilderInitial<''> : PgDateStringBuilderInitial<''>;
+export function date<TName extends string, TMode extends PgDateConfig['mode'] & {}>(
+	name: TName,
+	config?: PgDateConfig<TMode>,
+): Equal<TMode, 'date'> extends true ? PgDateBuilderInitial<TName> : PgDateStringBuilderInitial<TName>;
+export function date(a?: string | PgDateConfig, b?: PgDateConfig) {
+	const { name, config } = getColumnNameAndConfig<PgDateConfig>(a, b);
+	if (config?.mode === 'date') {
+		return new PgDateBuilder(name);
+	}
+	return new PgDateStringBuilder(name);
+}

package/src/data/query/pg-core/columns/double-precision.ts

@@ -0,0 +1,55 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgDoublePrecision';
+	data: number;
+	driverParam: string | number;
+	enumValues: undefined;
+}>;
+
+export class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgDoublePrecision'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgDoublePrecisionBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgDoublePrecision');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgDoublePrecision<MakeColumnConfig<T, TTableName>> {
+		return new PgDoublePrecision<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgDoublePrecision<T extends ColumnBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgDoublePrecision';
+
+	getSQLType(): string {
+		return 'double precision';
+	}
+
+	override mapFromDriverValue(value: string | number): number {
+		if (typeof value === 'string') {
+			return Number.parseFloat(value);
+		}
+		return value;
+	}
+}
+
+export function doublePrecision(): PgDoublePrecisionBuilderInitial<''>;
+export function doublePrecision<TName extends string>(name: TName): PgDoublePrecisionBuilderInitial<TName>;
+export function doublePrecision(name?: string) {
+	return new PgDoublePrecisionBuilder(name ?? '');
+}

package/src/data/query/pg-core/columns/enum.ts

@@ -0,0 +1,201 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import type { NonArray, Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+// Enum as ts enum
+
+export type PgEnumObjectColumnBuilderInitial<TName extends string, TValues extends object> = PgEnumObjectColumnBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgEnumObjectColumn';
+	data: TValues[keyof TValues];
+	enumValues: string[];
+	driverParam: string;
+}>;
+
+export interface PgEnumObject<TValues extends object> {
+	(): PgEnumObjectColumnBuilderInitial<'', TValues>;
+	<TName extends string>(name: TName): PgEnumObjectColumnBuilderInitial<TName, TValues>;
+	<TName extends string>(name?: TName): PgEnumObjectColumnBuilderInitial<TName, TValues>;
+
+	readonly enumName: string;
+	readonly enumValues: string[];
+	readonly schema: string | undefined;
+	/** @internal */
+	[isPgEnumSym]: true;
+}
+
+export class PgEnumObjectColumnBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'PgEnumObjectColumn'> & { enumValues: string[] },
+> extends PgColumnBuilder<T, { enum: PgEnumObject<any> }> {
+	static override readonly [entityKind]: string = 'PgEnumObjectColumnBuilder';
+
+	constructor(name: T['name'], enumInstance: PgEnumObject<any>) {
+		super(name, 'string', 'PgEnumObjectColumn');
+		this.config.enum = enumInstance;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgEnumObjectColumn<MakeColumnConfig<T, TTableName>> {
+		return new PgEnumObjectColumn<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgEnumObjectColumn<T extends ColumnBaseConfig<'string', 'PgEnumObjectColumn'> & { enumValues: object }>
+	extends PgColumn<T, { enum: PgEnumObject<object> }>
+{
+	static override readonly [entityKind]: string = 'PgEnumObjectColumn';
+
+	readonly enum;
+	override readonly enumValues = this.config.enum.enumValues;
+
+	constructor(
+		table: AnyPgTable<{ name: T['tableName'] }>,
+		config: PgEnumObjectColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+
+	getSQLType(): string {
+		return this.enum.enumName;
+	}
+}
+
+// Enum as string union
+
+export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> =
+	PgEnumColumnBuilder<{
+		name: TName;
+		dataType: 'string';
+		columnType: 'PgEnumColumn';
+		data: TValues[number];
+		enumValues: TValues;
+		driverParam: string;
+	}>;
+
+const isPgEnumSym = Symbol.for('drizzle:isPgEnum');
+export interface PgEnum<TValues extends [string, ...string[]]> {
+	(): PgEnumColumnBuilderInitial<'', TValues>;
+	<TName extends string>(name: TName): PgEnumColumnBuilderInitial<TName, TValues>;
+	<TName extends string>(name?: TName): PgEnumColumnBuilderInitial<TName, TValues>;
+
+	readonly enumName: string;
+	readonly enumValues: TValues;
+	readonly schema: string | undefined;
+	/** @internal */
+	[isPgEnumSym]: true;
+}
+
+export function isPgEnum(obj: unknown): obj is PgEnum<[string, ...string[]]> {
+	return !!obj && typeof obj === 'function' && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+
+export class PgEnumColumnBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'PgEnumColumn'> & { enumValues: [string, ...string[]] },
+> extends PgColumnBuilder<T, { enum: PgEnum<T['enumValues']> }> {
+	static override readonly [entityKind]: string = 'PgEnumColumnBuilder';
+
+	constructor(name: T['name'], enumInstance: PgEnum<T['enumValues']>) {
+		super(name, 'string', 'PgEnumColumn');
+		this.config.enum = enumInstance;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgEnumColumn<MakeColumnConfig<T, TTableName>> {
+		return new PgEnumColumn<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgEnumColumn<T extends ColumnBaseConfig<'string', 'PgEnumColumn'> & { enumValues: [string, ...string[]] }>
+	extends PgColumn<T, { enum: PgEnum<T['enumValues']> }>
+{
+	static override readonly [entityKind]: string = 'PgEnumColumn';
+
+	readonly enum = this.config.enum;
+	override readonly enumValues = this.config.enum.enumValues;
+
+	constructor(
+		table: AnyPgTable<{ name: T['tableName'] }>,
+		config: PgEnumColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+
+	getSQLType(): string {
+		return this.enum.enumName;
+	}
+}
+
+export function pgEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
+	enumName: string,
+	values: T | Writable<T>,
+): PgEnum<Writable<T>>;
+
+export function pgEnum<E extends Record<string, string>>(
+	enumName: string,
+	enumObj: NonArray<E>,
+): PgEnumObject<E>;
+
+export function pgEnum(
+	enumName: any,
+	input: any,
+): any {
+	return Array.isArray(input)
+		? pgEnumWithSchema(enumName, [...input] as [string, ...string[]], undefined)
+		: pgEnumObjectWithSchema(enumName, input, undefined);
+}
+
+/** @internal */
+export function pgEnumWithSchema<U extends string, T extends Readonly<[U, ...U[]]>>(
+	enumName: string,
+	values: T | Writable<T>,
+	schema?: string,
+): PgEnum<Writable<T>> {
+	const enumInstance: PgEnum<Writable<T>> = Object.assign(
+		<TName extends string>(name?: TName): PgEnumColumnBuilderInitial<TName, Writable<T>> =>
+			new PgEnumColumnBuilder(name ?? '' as TName, enumInstance),
+		{
+			enumName,
+			enumValues: values,
+			schema,
+			[isPgEnumSym]: true,
+		} as const,
+	);
+
+	return enumInstance;
+}
+
+/** @internal */
+export function pgEnumObjectWithSchema<T extends object>(
+	enumName: string,
+	values: T,
+	schema?: string,
+): PgEnumObject<T> {
+	const enumInstance: PgEnumObject<T> = Object.assign(
+		<TName extends string>(name?: TName): PgEnumObjectColumnBuilderInitial<TName, T> =>
+			new PgEnumObjectColumnBuilder(name ?? '' as TName, enumInstance),
+		{
+			enumName,
+			enumValues: Object.values(values),
+			schema,
+			[isPgEnumSym]: true,
+		} as const,
+	);
+
+	return enumInstance;
+}

package/src/data/query/pg-core/columns/index.ts

@@ -0,0 +1,35 @@
+export * from './bigint.js';
+export * from './bigserial.js';
+export * from './boolean.js';
+export * from './char.js';
+export * from './cidr.js';
+export * from './common.js';
+export * from './custom.js';
+export * from './date.js';
+export * from './double-precision.js';
+export * from './enum.js';
+export * from './inet.js';
+export * from './int.common.js';
+export * from './integer.js';
+export * from './interval.js';
+export * from './json.js';
+export * from './jsonb.js';
+export * from './line.js';
+export * from './macaddr.js';
+export * from './macaddr8.js';
+export * from './numeric.js';
+export * from './point.js';
+export * from './postgis_extension/geometry.js';
+export * from './real.js';
+export * from './serial.js';
+export * from './smallint.js';
+export * from './smallserial.js';
+export * from './text.js';
+export * from './time.js';
+export * from './timestamp.js';
+export * from './uuid.js';
+export * from './varchar.js';
+export * from './vector_extension/bit.js';
+export * from './vector_extension/halfvec.js';
+export * from './vector_extension/sparsevec.js';
+export * from './vector_extension/vector.js';

package/src/data/query/pg-core/columns/inet.ts

@@ -0,0 +1,43 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgInetBuilderInitial<TName extends string> = PgInetBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgInet';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgInetBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInet'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgInetBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'string', 'PgInet');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgInet<MakeColumnConfig<T, TTableName>> {
+		return new PgInet<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgInet<T extends ColumnBaseConfig<'string', 'PgInet'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgInet';
+
+	getSQLType(): string {
+		return 'inet';
+	}
+}
+
+export function inet(): PgInetBuilderInitial<''>;
+export function inet<TName extends string>(name: TName): PgInetBuilderInitial<TName>;
+export function inet(name?: string) {
+	return new PgInetBuilder(name ?? '');
+}