pipework 0.252.0 → 0.252.1

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

@@ -0,0 +1,227 @@
+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, PgColumnBuilder } from './common.js';
+
+export type PgNumericBuilderInitial<TName extends string> = PgNumericBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgNumeric';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgNumericBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgNumeric'>> extends PgColumnBuilder<
+	T,
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
+	static override readonly [entityKind]: string = 'PgNumericBuilder';
+
+	constructor(name: T['name'], precision?: number, scale?: number) {
+		super(name, 'string', 'PgNumeric');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgNumeric<MakeColumnConfig<T, TTableName>> {
+		return new PgNumeric<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgNumeric<T extends ColumnBaseConfig<'string', 'PgNumeric'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgNumeric';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericBuilder<T>['config']) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue(value: unknown): string {
+		if (typeof value === 'string') return value;
+
+		return String(value);
+	}
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision}, ${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export type PgNumericNumberBuilderInitial<TName extends string> = PgNumericNumberBuilder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgNumericNumber';
+	data: number;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgNumericNumberBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgNumericNumber'>>
+	extends PgColumnBuilder<
+		T,
+		{
+			precision: number | undefined;
+			scale: number | undefined;
+		}
+	>
+{
+	static override readonly [entityKind]: string = 'PgNumericNumberBuilder';
+
+	constructor(name: T['name'], precision?: number, scale?: number) {
+		super(name, 'number', 'PgNumericNumber');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgNumericNumber<MakeColumnConfig<T, TTableName>> {
+		return new PgNumericNumber<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgNumericNumber<T extends ColumnBaseConfig<'number', 'PgNumericNumber'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgNumericNumber';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericNumberBuilder<T>['config']) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue(value: unknown): number {
+		if (typeof value === 'number') return value;
+
+		return Number(value);
+	}
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision}, ${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export type PgNumericBigIntBuilderInitial<TName extends string> = PgNumericBigIntBuilder<{
+	name: TName;
+	dataType: 'bigint';
+	columnType: 'PgNumericBigInt';
+	data: bigint;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgNumericBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'PgNumericBigInt'>>
+	extends PgColumnBuilder<
+		T,
+		{
+			precision: number | undefined;
+			scale: number | undefined;
+		}
+	>
+{
+	static override readonly [entityKind]: string = 'PgNumericBigIntBuilder';
+
+	constructor(name: T['name'], precision?: number, scale?: number) {
+		super(name, 'bigint', 'PgNumericBigInt');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgNumericBigInt<MakeColumnConfig<T, TTableName>> {
+		return new PgNumericBigInt<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgNumericBigInt<T extends ColumnBaseConfig<'bigint', 'PgNumericBigInt'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgNumericBigInt';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericBigIntBuilder<T>['config']) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue = BigInt;
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision}, ${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export type PgNumericConfig<T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint'> =
+	| { precision: number; scale?: number; mode?: T }
+	| { precision?: number; scale: number; mode?: T }
+	| { precision?: number; scale?: number; mode: T };
+
+export function numeric<TMode extends 'string' | 'number' | 'bigint'>(
+	config?: PgNumericConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilderInitial<''>
+	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilderInitial<''>
+	: PgNumericBuilderInitial<''>;
+export function numeric<TName extends string, TMode extends 'string' | 'number' | 'bigint'>(
+	name: TName,
+	config?: PgNumericConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilderInitial<TName>
+	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilderInitial<TName>
+	: PgNumericBuilderInitial<TName>;
+export function numeric(a?: string | PgNumericConfig, b?: PgNumericConfig) {
+	const { name, config } = getColumnNameAndConfig<PgNumericConfig>(a, b);
+	const mode = config?.mode;
+	return mode === 'number'
+		? new PgNumericNumberBuilder(name, config?.precision, config?.scale)
+		: mode === 'bigint'
+		? new PgNumericBigIntBuilder(name, config?.precision, config?.scale)
+		: new PgNumericBuilder(name, config?.precision, config?.scale);
+}
+
+export const decimal = numeric;

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

@@ -0,0 +1,127 @@
+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, PgColumnBuilder } from './common.js';
+
+export type PgPointTupleBuilderInitial<TName extends string> = PgPointTupleBuilder<{
+	name: TName;
+	dataType: 'array';
+	columnType: 'PgPointTuple';
+	data: [number, number];
+	driverParam: number | string;
+	enumValues: undefined;
+}>;
+
+export class PgPointTupleBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgPointTuple'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgPointTupleBuilder';
+
+	constructor(name: string) {
+		super(name, 'array', 'PgPointTuple');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgPointTuple<MakeColumnConfig<T, TTableName>> {
+		return new PgPointTuple<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgPointTuple<T extends ColumnBaseConfig<'array', 'PgPointTuple'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgPointTuple';
+
+	getSQLType(): string {
+		return 'point';
+	}
+
+	override mapFromDriverValue(value: string | { x: number; y: number }): [number, number] {
+		if (typeof value === 'string') {
+			const [x, y] = value.slice(1, -1).split(',');
+			return [Number.parseFloat(x!), Number.parseFloat(y!)];
+		}
+		return [value.x, value.y];
+	}
+
+	override mapToDriverValue(value: [number, number]): string {
+		return `(${value[0]},${value[1]})`;
+	}
+}
+
+export type PgPointObjectBuilderInitial<TName extends string> = PgPointObjectBuilder<{
+	name: TName;
+	dataType: 'json';
+	columnType: 'PgPointObject';
+	data: { x: number; y: number };
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgPointObjectBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgPointObject'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgPointObjectBuilder';
+
+	constructor(name: string) {
+		super(name, 'json', 'PgPointObject');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgPointObject<MakeColumnConfig<T, TTableName>> {
+		return new PgPointObject<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgPointObject<T extends ColumnBaseConfig<'json', 'PgPointObject'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgPointObject';
+
+	getSQLType(): string {
+		return 'point';
+	}
+
+	override mapFromDriverValue(value: string | { x: number; y: number }): { x: number; y: number } {
+		if (typeof value === 'string') {
+			const [x, y] = value.slice(1, -1).split(',');
+			return { x: Number.parseFloat(x!), y: Number.parseFloat(y!) };
+		}
+		return value;
+	}
+
+	override mapToDriverValue(value: { x: number; y: number }): string {
+		return `(${value.x},${value.y})`;
+	}
+}
+
+export interface PgPointConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
+	mode?: T;
+}
+
+export function point(): PgPointTupleBuilderInitial<''>;
+export function point<TMode extends PgPointConfig['mode'] & {}>(
+	config?: PgPointConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilderInitial<''>
+	: PgPointTupleBuilderInitial<''>;
+export function point<TName extends string, TMode extends PgPointConfig['mode'] & {}>(
+	name: TName,
+	config?: PgPointConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilderInitial<TName>
+	: PgPointTupleBuilderInitial<TName>;
+export function point(a?: string | PgPointConfig, b?: PgPointConfig) {
+	const { name, config } = getColumnNameAndConfig<PgPointConfig>(a, b);
+	if (!config?.mode || config.mode === 'tuple') {
+		return new PgPointTupleBuilder(name);
+	}
+	return new PgPointObjectBuilder(name);
+}

package/src/data/query/pg-core/columns/postgis_extension/geometry.ts

@@ -0,0 +1,119 @@
+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, PgColumnBuilder } from '../common.js';
+import { parseEWKB } from './utils.js';
+
+export type PgGeometryBuilderInitial<TName extends string> = PgGeometryBuilder<{
+	name: TName;
+	dataType: 'array';
+	columnType: 'PgGeometry';
+	data: [number, number];
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgGeometryBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgGeometry'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgGeometryBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'array', 'PgGeometry');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgGeometry<MakeColumnConfig<T, TTableName>> {
+		return new PgGeometry<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgGeometry<T extends ColumnBaseConfig<'array', 'PgGeometry'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgGeometry';
+
+	getSQLType(): string {
+		return 'geometry(point)';
+	}
+
+	override mapFromDriverValue(value: string): [number, number] {
+		return parseEWKB(value);
+	}
+
+	override mapToDriverValue(value: [number, number]): string {
+		return `point(${value[0]} ${value[1]})`;
+	}
+}
+
+export type PgGeometryObjectBuilderInitial<TName extends string> = PgGeometryObjectBuilder<{
+	name: TName;
+	dataType: 'json';
+	columnType: 'PgGeometryObject';
+	data: { x: number; y: number };
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgGeometryObjectBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgGeometryObject'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgGeometryObjectBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'json', 'PgGeometryObject');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgGeometryObject<MakeColumnConfig<T, TTableName>> {
+		return new PgGeometryObject<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgGeometryObject<T extends ColumnBaseConfig<'json', 'PgGeometryObject'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgGeometryObject';
+
+	getSQLType(): string {
+		return 'geometry(point)';
+	}
+
+	override mapFromDriverValue(value: string): { x: number; y: number } {
+		const parsed = parseEWKB(value);
+		return { x: parsed[0], y: parsed[1] };
+	}
+
+	override mapToDriverValue(value: { x: number; y: number }): string {
+		return `point(${value.x} ${value.y})`;
+	}
+}
+
+export interface PgGeometryConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
+	mode?: T;
+	type?: 'point' | (string & {});
+	srid?: number;
+}
+
+export function geometry(): PgGeometryBuilderInitial<''>;
+export function geometry<TMode extends PgGeometryConfig['mode'] & {}>(
+	config?: PgGeometryConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilderInitial<''> : PgGeometryBuilderInitial<''>;
+export function geometry<TName extends string, TMode extends PgGeometryConfig['mode'] & {}>(
+	name: TName,
+	config?: PgGeometryConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilderInitial<TName> : PgGeometryBuilderInitial<TName>;
+export function geometry(a?: string | PgGeometryConfig, b?: PgGeometryConfig) {
+	const { name, config } = getColumnNameAndConfig<PgGeometryConfig>(a, b);
+	if (!config?.mode || config.mode === 'tuple') {
+		return new PgGeometryBuilder(name);
+	}
+	return new PgGeometryObjectBuilder(name);
+}

package/src/data/query/pg-core/columns/postgis_extension/utils.ts

@@ -0,0 +1,47 @@
+function hexToBytes(hex: string): Uint8Array {
+	const bytes: number[] = [];
+	for (let c = 0; c < hex.length; c += 2) {
+		bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+	}
+	return new Uint8Array(bytes);
+}
+
+function bytesToFloat64(bytes: Uint8Array, offset: number): number {
+	const buffer = new ArrayBuffer(8);
+	const view = new DataView(buffer);
+	for (let i = 0; i < 8; i++) {
+		view.setUint8(i, bytes[offset + i]!);
+	}
+	return view.getFloat64(0, true);
+}
+
+export function parseEWKB(hex: string): [number, number] {
+	const bytes = hexToBytes(hex);
+
+	let offset = 0;
+
+	// Byte order: 1 is little-endian, 0 is big-endian
+	const byteOrder = bytes[offset];
+	offset += 1;
+
+	const view = new DataView(bytes.buffer);
+	const geomType = view.getUint32(offset, byteOrder === 1);
+	offset += 4;
+
+	let _srid: number | undefined;
+	if (geomType & 0x20000000) { // SRID flag
+		_srid = view.getUint32(offset, byteOrder === 1);
+		offset += 4;
+	}
+
+	if ((geomType & 0xFFFF) === 1) {
+		const x = bytesToFloat64(bytes, offset);
+		offset += 8;
+		const y = bytesToFloat64(bytes, offset);
+		offset += 8;
+
+		return [x, y];
+	}
+
+	throw new Error('Unsupported geometry type');
+}

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

@@ -0,0 +1,58 @@
+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 PgRealBuilderInitial<TName extends string> = PgRealBuilder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgReal';
+	data: number;
+	driverParam: string | number;
+	enumValues: undefined;
+}>;
+
+export class PgRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgReal'>> extends PgColumnBuilder<
+	T,
+	{ length: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'PgRealBuilder';
+
+	constructor(name: T['name'], length?: number) {
+		super(name, 'number', 'PgReal');
+		this.config.length = length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgReal<MakeColumnConfig<T, TTableName>> {
+		return new PgReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgReal<T extends ColumnBaseConfig<'number', 'PgReal'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgReal';
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgRealBuilder<T>['config']) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'real';
+	}
+
+	override mapFromDriverValue = (value: string | number): number => {
+		if (typeof value === 'string') {
+			return Number.parseFloat(value);
+		}
+		return value;
+	};
+}
+
+export function real(): PgRealBuilderInitial<''>;
+export function real<TName extends string>(name: TName): PgRealBuilderInitial<TName>;
+export function real(name?: string) {
+	return new PgRealBuilder(name ?? '');
+}

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

@@ -0,0 +1,55 @@
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderRuntimeConfig,
+	HasDefault,
+	MakeColumnConfig,
+	NotNull,
+} 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 PgSerialBuilderInitial<TName extends string> = NotNull<
+	HasDefault<
+		PgSerialBuilder<{
+			name: TName;
+			dataType: 'number';
+			columnType: 'PgSerial';
+			data: number;
+			driverParam: number;
+			enumValues: undefined;
+		}>
+	>
+>;
+
+export class PgSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSerial'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgSerialBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgSerial');
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgSerial<MakeColumnConfig<T, TTableName>> {
+		return new PgSerial<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgSerial<T extends ColumnBaseConfig<'number', 'PgSerial'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgSerial';
+
+	getSQLType(): string {
+		return 'serial';
+	}
+}
+
+export function serial(): PgSerialBuilderInitial<''>;
+export function serial<TName extends string>(name: TName): PgSerialBuilderInitial<TName>;
+export function serial(name?: string) {
+	return new PgSerialBuilder(name ?? '');
+}

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

@@ -0,0 +1,53 @@
+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 } from './common.js';
+import { PgIntColumnBaseBuilder } from './int.common.js';
+
+export type PgSmallIntBuilderInitial<TName extends string> = PgSmallIntBuilder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgSmallInt';
+	data: number;
+	driverParam: number | string;
+	enumValues: undefined;
+}>;
+
+export class PgSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallInt'>>
+	extends PgIntColumnBaseBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgSmallIntBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgSmallInt');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgSmallInt<MakeColumnConfig<T, TTableName>> {
+		return new PgSmallInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgSmallInt<T extends ColumnBaseConfig<'number', 'PgSmallInt'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgSmallInt';
+
+	getSQLType(): string {
+		return 'smallint';
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'string') {
+			return Number(value);
+		}
+		return value;
+	};
+}
+
+export function smallint(): PgSmallIntBuilderInitial<''>;
+export function smallint<TName extends string>(name: TName): PgSmallIntBuilderInitial<TName>;
+export function smallint(name?: string) {
+	return new PgSmallIntBuilder(name ?? '');
+}