pipework 0.252.0 → 0.252.1

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

@@ -0,0 +1,57 @@
+import type { ColumnBuilderBaseConfig, ColumnDataType, GeneratedIdentityConfig, IsIdentity } from '../../column-builder.js';
+import { entityKind } from '../../entity.js';
+import type { PgSequenceOptions } from '../sequence.js';
+import { PgColumnBuilder } from './common.js';
+
+export abstract class PgIntColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+> extends PgColumnBuilder<
+	T,
+	{ generatedIdentity: GeneratedIdentityConfig }
+> {
+	static override readonly [entityKind]: string = 'PgIntColumnBaseBuilder';
+
+	generatedAlwaysAsIdentity(
+		sequence?: PgSequenceOptions & { name?: string },
+	): IsIdentity<this, 'always'> {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: 'always',
+				sequenceName: name,
+				sequenceOptions: options,
+			};
+		} else {
+			this.config.generatedIdentity = {
+				type: 'always',
+			};
+		}
+
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+
+		return this as IsIdentity<this, 'always'>;
+	}
+
+	generatedByDefaultAsIdentity(
+		sequence?: PgSequenceOptions & { name?: string },
+	): IsIdentity<this, 'byDefault'> {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: 'byDefault',
+				sequenceName: name,
+				sequenceOptions: options,
+			};
+		} else {
+			this.config.generatedIdentity = {
+				type: 'byDefault',
+			};
+		}
+
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+
+		return this as IsIdentity<this, 'byDefault'>;
+	}
+}

package/src/data/query/pg-core/columns/integer.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 PgIntegerBuilderInitial<TName extends string> = PgIntegerBuilder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgInteger';
+	data: number;
+	driverParam: number | string;
+	enumValues: undefined;
+}>;
+
+export class PgIntegerBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgInteger'>>
+	extends PgIntColumnBaseBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgIntegerBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgInteger');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgInteger<MakeColumnConfig<T, TTableName>> {
+		return new PgInteger<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgInteger<T extends ColumnBaseConfig<'number', 'PgInteger'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgInteger';
+
+	getSQLType(): string {
+		return 'integer';
+	}
+
+	override mapFromDriverValue(value: number | string): number {
+		if (typeof value === 'string') {
+			return Number.parseInt(value);
+		}
+		return value;
+	}
+}
+
+export function integer(): PgIntegerBuilderInitial<''>;
+export function integer<TName extends string>(name: TName): PgIntegerBuilderInitial<TName>;
+export function integer(name?: string) {
+	return new PgIntegerBuilder(name ?? '');
+}

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

@@ -0,0 +1,83 @@
+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 { getColumnNameAndConfig } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+import type { Precision } from './timestamp.js';
+
+export type PgIntervalBuilderInitial<TName extends string> = PgIntervalBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgInterval';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgIntervalBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInterval'>>
+	extends PgColumnBuilder<T, { intervalConfig: IntervalConfig }>
+{
+	static override readonly [entityKind]: string = 'PgIntervalBuilder';
+
+	constructor(
+		name: T['name'],
+		intervalConfig: IntervalConfig,
+	) {
+		super(name, 'string', 'PgInterval');
+		this.config.intervalConfig = intervalConfig;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgInterval<MakeColumnConfig<T, TTableName>> {
+		return new PgInterval<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgInterval<T extends ColumnBaseConfig<'string', 'PgInterval'>>
+	extends PgColumn<T, { intervalConfig: IntervalConfig }>
+{
+	static override readonly [entityKind]: string = 'PgInterval';
+
+	readonly fields: IntervalConfig['fields'] = this.config.intervalConfig.fields;
+	readonly precision: IntervalConfig['precision'] = this.config.intervalConfig.precision;
+
+	getSQLType(): string {
+		const fields = this.fields ? ` ${this.fields}` : '';
+		const precision = this.precision ? `(${this.precision})` : '';
+		return `interval${fields}${precision}`;
+	}
+}
+
+export interface IntervalConfig {
+	fields?:
+		| 'year'
+		| 'month'
+		| 'day'
+		| 'hour'
+		| 'minute'
+		| 'second'
+		| 'year to month'
+		| 'day to hour'
+		| 'day to minute'
+		| 'day to second'
+		| 'hour to minute'
+		| 'hour to second'
+		| 'minute to second';
+	precision?: Precision;
+}
+
+export function interval(): PgIntervalBuilderInitial<''>;
+export function interval(
+	config?: IntervalConfig,
+): PgIntervalBuilderInitial<''>;
+export function interval<TName extends string>(
+	name: TName,
+	config?: IntervalConfig,
+): PgIntervalBuilderInitial<TName>;
+export function interval(a?: string | IntervalConfig, b: IntervalConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<IntervalConfig>(a, b);
+	return new PgIntervalBuilder(name, config);
+}

package/src/data/query/pg-core/columns/json.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 PgJsonBuilderInitial<TName extends string> = PgJsonBuilder<{
+	name: TName;
+	dataType: 'json';
+	columnType: 'PgJson';
+	data: unknown;
+	driverParam: unknown;
+	enumValues: undefined;
+}>;
+
+export class PgJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJson'>> extends PgColumnBuilder<
+	T
+> {
+	static override readonly [entityKind]: string = 'PgJsonBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'json', 'PgJson');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgJson<MakeColumnConfig<T, TTableName>> {
+		return new PgJson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgJson<T extends ColumnBaseConfig<'json', 'PgJson'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgJson';
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgJsonBuilder<T>['config']) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'json';
+	}
+
+	override mapToDriverValue(value: T['data']): string {
+		return JSON.stringify(value);
+	}
+
+	// The driver has already parsed json/jsonb values; parsing again would change a stored string.
+	override mapFromDriverValue(value: T['data']): T['data'] {
+		return value;
+	}
+}
+
+export function json(): PgJsonBuilderInitial<''>;
+export function json<TName extends string>(name: TName): PgJsonBuilderInitial<TName>;
+export function json(name?: string) {
+	return new PgJsonBuilder(name ?? '');
+}

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

@@ -0,0 +1,56 @@
+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 PgJsonbBuilderInitial<TName extends string> = PgJsonbBuilder<{
+	name: TName;
+	dataType: 'json';
+	columnType: 'PgJsonb';
+	data: unknown;
+	driverParam: unknown;
+	enumValues: undefined;
+}>;
+
+export class PgJsonbBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJsonb'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgJsonbBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'json', 'PgJsonb');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgJsonb<MakeColumnConfig<T, TTableName>> {
+		return new PgJsonb<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgJsonb<T extends ColumnBaseConfig<'json', 'PgJsonb'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgJsonb';
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgJsonbBuilder<T>['config']) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'jsonb';
+	}
+
+	override mapToDriverValue(value: T['data']): string {
+		return JSON.stringify(value);
+	}
+
+	// The driver has already parsed json/jsonb values; parsing again would change a stored string.
+	override mapFromDriverValue(value: T['data']): T['data'] {
+		return value;
+	}
+}
+
+export function jsonb(): PgJsonbBuilderInitial<''>;
+export function jsonb<TName extends string>(name: TName): PgJsonbBuilderInitial<TName>;
+export function jsonb(name?: string) {
+	return new PgJsonbBuilder(name ?? '');
+}

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

@@ -0,0 +1,117 @@
+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 PgLineBuilderInitial<TName extends string> = PgLineBuilder<{
+	name: TName;
+	dataType: 'array';
+	columnType: 'PgLine';
+	data: [number, number, number];
+	driverParam: number | string;
+	enumValues: undefined;
+}>;
+
+export class PgLineBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgLine'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgLineBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'array', 'PgLine');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgLineTuple<MakeColumnConfig<T, TTableName>> {
+		return new PgLineTuple<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgLineTuple<T extends ColumnBaseConfig<'array', 'PgLine'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgLine';
+
+	getSQLType(): string {
+		return 'line';
+	}
+
+	override mapFromDriverValue(value: string): [number, number, number] {
+		const [a, b, c] = value.slice(1, -1).split(',');
+		return [Number.parseFloat(a!), Number.parseFloat(b!), Number.parseFloat(c!)];
+	}
+
+	override mapToDriverValue(value: [number, number, number]): string {
+		return `{${value[0]},${value[1]},${value[2]}}`;
+	}
+}
+
+export type PgLineABCBuilderInitial<TName extends string> = PgLineABCBuilder<{
+	name: TName;
+	dataType: 'json';
+	columnType: 'PgLineABC';
+	data: { a: number; b: number; c: number };
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgLineABCBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgLineABC'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgLineABCBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'json', 'PgLineABC');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgLineABC<MakeColumnConfig<T, TTableName>> {
+		return new PgLineABC<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgLineABC<T extends ColumnBaseConfig<'json', 'PgLineABC'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgLineABC';
+
+	getSQLType(): string {
+		return 'line';
+	}
+
+	override mapFromDriverValue(value: string): { a: number; b: number; c: number } {
+		const [a, b, c] = value.slice(1, -1).split(',');
+		return { a: Number.parseFloat(a!), b: Number.parseFloat(b!), c: Number.parseFloat(c!) };
+	}
+
+	override mapToDriverValue(value: { a: number; b: number; c: number }): string {
+		return `{${value.a},${value.b},${value.c}}`;
+	}
+}
+
+export interface PgLineTypeConfig<T extends 'tuple' | 'abc' = 'tuple' | 'abc'> {
+	mode?: T;
+}
+
+export function line(): PgLineBuilderInitial<''>;
+export function line<TMode extends PgLineTypeConfig['mode'] & {}>(
+	config?: PgLineTypeConfig<TMode>,
+): Equal<TMode, 'abc'> extends true ? PgLineABCBuilderInitial<''>
+	: PgLineBuilderInitial<''>;
+export function line<TName extends string, TMode extends PgLineTypeConfig['mode'] & {}>(
+	name: TName,
+	config?: PgLineTypeConfig<TMode>,
+): Equal<TMode, 'abc'> extends true ? PgLineABCBuilderInitial<TName>
+	: PgLineBuilderInitial<TName>;
+export function line(a?: string | PgLineTypeConfig, b?: PgLineTypeConfig) {
+	const { name, config } = getColumnNameAndConfig<PgLineTypeConfig>(a, b);
+	if (!config?.mode || config.mode === 'tuple') {
+		return new PgLineBuilder(name);
+	}
+	return new PgLineABCBuilder(name);
+}

package/src/data/query/pg-core/columns/macaddr.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 PgMacaddrBuilderInitial<TName extends string> = PgMacaddrBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgMacaddr';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgMacaddrBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgMacaddrBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'string', 'PgMacaddr');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgMacaddr<MakeColumnConfig<T, TTableName>> {
+		return new PgMacaddr<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgMacaddr<T extends ColumnBaseConfig<'string', 'PgMacaddr'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgMacaddr';
+
+	getSQLType(): string {
+		return 'macaddr';
+	}
+}
+
+export function macaddr(): PgMacaddrBuilderInitial<''>;
+export function macaddr<TName extends string>(name: TName): PgMacaddrBuilderInitial<TName>;
+export function macaddr(name?: string) {
+	return new PgMacaddrBuilder(name ?? '');
+}

package/src/data/query/pg-core/columns/macaddr8.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 PgMacaddr8BuilderInitial<TName extends string> = PgMacaddr8Builder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgMacaddr8';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgMacaddr8Builder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr8'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgMacaddr8Builder';
+
+	constructor(name: T['name']) {
+		super(name, 'string', 'PgMacaddr8');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgMacaddr8<MakeColumnConfig<T, TTableName>> {
+		return new PgMacaddr8<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgMacaddr8<T extends ColumnBaseConfig<'string', 'PgMacaddr8'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgMacaddr8';
+
+	getSQLType(): string {
+		return 'macaddr8';
+	}
+}
+
+export function macaddr8(): PgMacaddr8BuilderInitial<''>;
+export function macaddr8<TName extends string>(name: TName): PgMacaddr8BuilderInitial<TName>;
+export function macaddr8(name?: string) {
+	return new PgMacaddr8Builder(name ?? '');
+}