pipework 0.252.0 → 0.252.1

package/src/data/query/column.ts

@@ -0,0 +1,150 @@
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderRuntimeConfig,
+	ColumnDataType,
+	GeneratedColumnConfig,
+	GeneratedIdentityConfig,
+} from './column-builder.js';
+import { entityKind } from './entity.js';
+import type { DriverValueMapper, SQL, SQLWrapper } from './sql/sql.js';
+import type { Table } from './table.js';
+import type { Update } from './utils.js';
+
+export interface ColumnBaseConfig<
+	TDataType extends ColumnDataType,
+	TColumnType extends string,
+> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+	tableName: string;
+	notNull: boolean;
+	hasDefault: boolean;
+	isPrimaryKey: boolean;
+	isAutoincrement: boolean;
+	hasRuntimeDefault: boolean;
+}
+
+export type ColumnTypeConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = T & {
+	brand: 'Column';
+	tableName: T['tableName'];
+	name: T['name'];
+	dataType: T['dataType'];
+	columnType: T['columnType'];
+	data: T['data'];
+	driverParam: T['driverParam'];
+	notNull: T['notNull'];
+	hasDefault: T['hasDefault'];
+	isPrimaryKey: T['isPrimaryKey'];
+	isAutoincrement: T['isAutoincrement'];
+	hasRuntimeDefault: T['hasRuntimeDefault'];
+	enumValues: T['enumValues'];
+	baseColumn: T extends { baseColumn: infer U } ? U : unknown;
+	generated: GeneratedColumnConfig<T['data']> | undefined;
+	identity: undefined | 'always' | 'byDefault';
+} & TTypeConfig;
+
+export type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<
+	TData,
+	TRuntimeConfig
+>;
+
+export interface Column<
+	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TRuntimeConfig extends object = object,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTypeConfig extends object = object,
+> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+/*
+	`Column` only accepts a full `ColumnConfig` as its generic.
+	To infer parts of the config, use `AnyColumn` that accepts a partial config.
+	See `GetColumnData` for example usage of inferring.
+*/
+export abstract class Column<
+	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	TRuntimeConfig extends object = object,
+	TTypeConfig extends object = object,
+> implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+	static readonly [entityKind]: string = 'Column';
+
+	declare readonly _: ColumnTypeConfig<T, TTypeConfig>;
+
+	readonly name: string;
+	readonly keyAsName: boolean;
+	readonly primary: boolean;
+	readonly notNull: boolean;
+	readonly default: T['data'] | SQL | undefined;
+	readonly defaultFn: (() => T['data'] | SQL) | undefined;
+	readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
+	readonly hasDefault: boolean;
+	readonly isUnique: boolean;
+	readonly uniqueName: string | undefined;
+	readonly uniqueType: string | undefined;
+	readonly dataType: T['dataType'];
+	readonly columnType: T['columnType'];
+	readonly enumValues: T['enumValues'] = undefined;
+	readonly generated: GeneratedColumnConfig<T['data']> | undefined = undefined;
+	readonly generatedIdentity: GeneratedIdentityConfig | undefined = undefined;
+	readonly collation: string | undefined = undefined;
+
+	protected config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>;
+
+	constructor(
+		readonly table: Table,
+		config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>,
+	) {
+		this.config = config;
+		this.name = config.name;
+		this.keyAsName = config.keyAsName;
+		this.notNull = config.notNull;
+		this.default = config.default;
+		this.defaultFn = config.defaultFn;
+		this.onUpdateFn = config.onUpdateFn;
+		this.hasDefault = config.hasDefault;
+		this.primary = config.primaryKey;
+		this.isUnique = config.isUnique;
+		this.uniqueName = config.uniqueName;
+		this.uniqueType = config.uniqueType;
+		this.dataType = config.dataType as T['dataType'];
+		this.columnType = config.columnType;
+		this.generated = config.generated;
+		this.generatedIdentity = config.generatedIdentity;
+		this.collation = config.collation;
+	}
+
+	abstract getSQLType(): string;
+
+	mapFromDriverValue(value: unknown): unknown {
+		return value;
+	}
+
+	mapToDriverValue(value: unknown): unknown {
+		return value;
+	}
+
+	// ** @internal */
+	shouldDisableInsert(): boolean {
+		return this.config.generated !== undefined && this.config.generated.type !== 'byDefault';
+	}
+}
+
+export type UpdateColConfig<
+	T extends ColumnBaseConfig<ColumnDataType, string>,
+	TUpdate extends Partial<ColumnBaseConfig<ColumnDataType, string>>,
+> = Update<T, TUpdate>;
+
+export type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<
+	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+>;
+
+export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> =
+	// dprint-ignore
+	TInferMode extends 'raw' // Raw mode
+		? TColumn['_']['data'] // Just return the underlying type
+		: TColumn['_']['notNull'] extends true // Query mode
+		? TColumn['_']['data'] // Query mode, not null
+		: TColumn['_']['data'] | null; // Query mode, nullable
+
+export type InferColumnsDataTypes<TColumns extends Record<string, Column>> = {
+	[Key in keyof TColumns]: GetColumnData<TColumns[Key], 'query'>;
+};

package/src/data/query/entity.ts

@@ -0,0 +1,42 @@
+export const entityKind = Symbol.for('drizzle:entityKind');
+export const hasOwnEntityKind = Symbol.for('drizzle:hasOwnEntityKind');
+
+export interface DrizzleEntity {
+	[entityKind]: string;
+}
+
+export type DrizzleEntityClass<T> =
+	& ((abstract new(...args: any[]) => T) | (new(...args: any[]) => T))
+	& DrizzleEntity;
+
+export function is<T extends DrizzleEntityClass<any>>(value: any, type: T): value is InstanceType<T> {
+	if (!value || typeof value !== 'object') {
+		return false;
+	}
+
+	if (value instanceof type) { // eslint-disable-line no-instanceof/no-instanceof
+		return true;
+	}
+
+	if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+		throw new Error(
+			`Class "${
+				type.name ?? '<unknown>'
+			}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`,
+		);
+	}
+
+	let cls = Object.getPrototypeOf(value).constructor;
+	if (cls) {
+		// Traverse the prototype chain to find the entityKind
+		while (cls) {
+			if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+				return true;
+			}
+
+			cls = Object.getPrototypeOf(cls);
+		}
+	}
+
+	return false;
+}

package/src/data/query/errors.ts

@@ -0,0 +1,33 @@
+import { entityKind } from './entity.js';
+
+export class DrizzleError extends Error {
+	static readonly [entityKind]: string = 'DrizzleError';
+
+	constructor({ message, cause }: { message?: string; cause?: unknown }) {
+		super(message);
+		this.name = 'DrizzleError';
+		this.cause = cause;
+	}
+}
+
+export class DrizzleQueryError extends Error {
+	constructor(
+		public query: string,
+		public params: any[],
+		public override cause?: Error,
+	) {
+		super(`Failed query: ${query}\nparams: ${params}`);
+		Error.captureStackTrace(this, DrizzleQueryError);
+
+		// ES2022+: preserves original error on `.cause`
+		if (cause) (this as any).cause = cause;
+	}
+}
+
+export class TransactionRollbackError extends DrizzleError {
+	static override readonly [entityKind]: string = 'TransactionRollbackError';
+
+	constructor() {
+		super({ message: 'Rollback' });
+	}
+}

package/src/data/query/index.ts

@@ -0,0 +1,14 @@
+export * from './alias.js';
+export * from './column-builder.js';
+export * from './column.js';
+export * from './entity.js';
+export * from './errors.js';
+export * from './logger.js';
+export * from './operations.js';
+export * from './query-promise.js';
+export * from './relations.js';
+export * from './sql/index.js';
+export * from './subquery.js';
+export * from './table.js';
+export * from './utils.js';
+export * from './view-common.js';

package/src/data/query/logger.ts

@@ -0,0 +1,47 @@
+import { entityKind } from './entity.js';
+
+export interface Logger {
+	logQuery(query: string, params: unknown[]): void;
+}
+
+export interface LogWriter {
+	write(message: string): void;
+}
+
+export class ConsoleLogWriter implements LogWriter {
+	static readonly [entityKind]: string = 'ConsoleLogWriter';
+
+	write(message: string) {
+		console.log(message);
+	}
+}
+
+export class DefaultLogger implements Logger {
+	static readonly [entityKind]: string = 'DefaultLogger';
+
+	readonly writer: LogWriter;
+
+	constructor(config?: { writer: LogWriter }) {
+		this.writer = config?.writer ?? new ConsoleLogWriter();
+	}
+
+	logQuery(query: string, params: unknown[]): void {
+		const stringifiedParams = params.map((p) => {
+			try {
+				return JSON.stringify(p);
+			} catch {
+				return String(p);
+			}
+		});
+		const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(', ')}]` : '';
+		this.writer.write(`Query: ${query}${paramsStr}`);
+	}
+}
+
+export class NoopLogger implements Logger {
+	static readonly [entityKind]: string = 'NoopLogger';
+
+	logQuery(): void {
+		// noop
+	}
+}

package/src/data/query/operations.ts

@@ -0,0 +1,45 @@
+import type { AnyColumn, Column } from './column.js';
+import type { SQL } from './sql/sql.js';
+import type { Subquery } from './subquery.js';
+import type { Table } from './table.js';
+
+export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+	notNull: true;
+	hasDefault: false;
+}> ? TKey
+	: never;
+
+export type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> =
+	TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+		_: {
+			generated: undefined;
+		};
+	} ? (T extends {
+			_: {
+				identity: undefined;
+			};
+		} ? TKey
+			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
+			: TKey)
+	: never;
+
+// TODO: SQL -> SQLWrapper
+export type SelectedFieldsFlat<TColumn extends Column> = Record<
+	string,
+	TColumn | SQL | SQL.Aliased | Subquery
+>;
+
+export type SelectedFieldsFlatFull<TColumn extends Column> = Record<
+	string,
+	TColumn | SQL | SQL.Aliased
+>;
+
+export type SelectedFields<TColumn extends Column, TTable extends Table> = Record<
+	string,
+	SelectedFieldsFlat<TColumn>[string] | TTable | SelectedFieldsFlat<TColumn>
+>;
+
+export type SelectedFieldsOrdered<TColumn extends Column> = {
+	path: string[];
+	field: TColumn | SQL | SQL.Aliased | Subquery;
+}[];

package/src/data/query/pg-core/alias.ts

@@ -0,0 +1,12 @@
+import { TableAliasProxyHandler } from '../alias.js';
+import type { BuildAliasTable } from './query-builders/select.types.js';
+
+import type { PgTable } from './table.js';
+import type { PgViewBase } from './view-base.js';
+
+export function alias<TTable extends PgTable | PgViewBase, TAlias extends string>(
+	table: TTable,
+	alias: TAlias,
+): BuildAliasTable<TTable, TAlias> {
+	return new Proxy(table, new TableAliasProxyHandler(alias, false)) as any;
+}

package/src/data/query/pg-core/checks.ts

@@ -0,0 +1,32 @@
+import { entityKind } from '../entity.js';
+import type { SQL } from '../sql/index.js';
+import type { PgTable } from './table.js';
+
+export class CheckBuilder {
+	static readonly [entityKind]: string = 'PgCheckBuilder';
+
+	protected brand!: 'PgConstraintBuilder';
+
+	constructor(public name: string, public value: SQL) {}
+
+	/** @internal */
+	build(table: PgTable): Check {
+		return new Check(table, this);
+	}
+}
+
+export class Check {
+	static readonly [entityKind]: string = 'PgCheck';
+
+	readonly name: string;
+	readonly value: SQL;
+
+	constructor(public table: PgTable, builder: CheckBuilder) {
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+}
+
+export function check(name: string, value: SQL): CheckBuilder {
+	return new CheckBuilder(name, value);
+}

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

@@ -0,0 +1,71 @@
+import { bigint } from './bigint.js';
+import { bigserial } from './bigserial.js';
+import { boolean } from './boolean.js';
+import { char } from './char.js';
+import { cidr } from './cidr.js';
+import { customType } from './custom.js';
+import { date } from './date.js';
+import { doublePrecision } from './double-precision.js';
+import { inet } from './inet.js';
+import { integer } from './integer.js';
+import { interval } from './interval.js';
+import { json } from './json.js';
+import { jsonb } from './jsonb.js';
+import { line } from './line.js';
+import { macaddr } from './macaddr.js';
+import { macaddr8 } from './macaddr8.js';
+import { numeric } from './numeric.js';
+import { point } from './point.js';
+import { geometry } from './postgis_extension/geometry.js';
+import { real } from './real.js';
+import { serial } from './serial.js';
+import { smallint } from './smallint.js';
+import { smallserial } from './smallserial.js';
+import { text } from './text.js';
+import { time } from './time.js';
+import { timestamp } from './timestamp.js';
+import { uuid } from './uuid.js';
+import { varchar } from './varchar.js';
+import { bit } from './vector_extension/bit.js';
+import { halfvec } from './vector_extension/halfvec.js';
+import { sparsevec } from './vector_extension/sparsevec.js';
+import { vector } from './vector_extension/vector.js';
+
+export function getPgColumnBuilders() {
+	return {
+		bigint,
+		bigserial,
+		boolean,
+		char,
+		cidr,
+		customType,
+		date,
+		doublePrecision,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		geometry,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		bit,
+		halfvec,
+		sparsevec,
+		vector,
+	};
+}
+
+export type PgColumnsBuilders = ReturnType<typeof getPgColumnBuilders>;

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

@@ -0,0 +1,110 @@
+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 } from './common.js';
+import { PgIntColumnBaseBuilder } from './int.common.js';
+
+export type PgBigInt53BuilderInitial<TName extends string> = PgBigInt53Builder<{
+	name: TName;
+	dataType: 'number';
+	columnType: 'PgBigInt53';
+	data: number;
+	driverParam: number | string;
+	enumValues: undefined;
+}>;
+
+export class PgBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigInt53'>>
+	extends PgIntColumnBaseBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgBigInt53Builder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgBigInt53');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgBigInt53<MakeColumnConfig<T, TTableName>> {
+		return new PgBigInt53<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgBigInt53<T extends ColumnBaseConfig<'number', 'PgBigInt53'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgBigInt53';
+
+	getSQLType(): string {
+		return 'bigint';
+	}
+
+	override mapFromDriverValue(value: number | string): number {
+		if (typeof value === 'number') {
+			return value;
+		}
+		return Number(value);
+	}
+}
+
+export type PgBigInt64BuilderInitial<TName extends string> = PgBigInt64Builder<{
+	name: TName;
+	dataType: 'bigint';
+	columnType: 'PgBigInt64';
+	data: bigint;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigInt64'>>
+	extends PgIntColumnBaseBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgBigInt64Builder';
+
+	constructor(name: T['name']) {
+		super(name, 'bigint', 'PgBigInt64');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgBigInt64<MakeColumnConfig<T, TTableName>> {
+		return new PgBigInt64<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgBigInt64<T extends ColumnBaseConfig<'bigint', 'PgBigInt64'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgBigInt64';
+
+	getSQLType(): string {
+		return 'bigint';
+	}
+
+	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
+	override mapFromDriverValue(value: string): bigint {
+		return BigInt(value);
+	}
+}
+
+export interface PgBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+	mode: T;
+}
+
+export function bigint<TMode extends PgBigIntConfig['mode']>(
+	config: PgBigIntConfig<TMode>,
+): TMode extends 'number' ? PgBigInt53BuilderInitial<''> : PgBigInt64BuilderInitial<''>;
+export function bigint<TName extends string, TMode extends PgBigIntConfig['mode']>(
+	name: TName,
+	config: PgBigIntConfig<TMode>,
+): TMode extends 'number' ? PgBigInt53BuilderInitial<TName> : PgBigInt64BuilderInitial<TName>;
+export function bigint(a: string | PgBigIntConfig, b?: PgBigIntConfig) {
+	const { name, config } = getColumnNameAndConfig<PgBigIntConfig>(a, b);
+	if (config.mode === 'number') {
+		return new PgBigInt53Builder(name);
+	}
+	return new PgBigInt64Builder(name);
+}

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

@@ -0,0 +1,128 @@
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderRuntimeConfig,
+	HasDefault,
+	MakeColumnConfig,
+	NotNull,
+} from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { getColumnNameAndConfig } from '../../utils.js';
+import type { AnyPgTable } from '../table.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgBigSerial53BuilderInitial<TName extends string> = NotNull<
+	HasDefault<
+		PgBigSerial53Builder<{
+			name: TName;
+			dataType: 'number';
+			columnType: 'PgBigSerial53';
+			data: number;
+			driverParam: number;
+			enumValues: undefined;
+		}>
+	>
+>;
+
+export class PgBigSerial53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigSerial53'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgBigSerial53Builder';
+
+	constructor(name: string) {
+		super(name, 'number', 'PgBigSerial53');
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgBigSerial53<MakeColumnConfig<T, TTableName>> {
+		return new PgBigSerial53<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgBigSerial53<T extends ColumnBaseConfig<'number', 'PgBigSerial53'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgBigSerial53';
+
+	getSQLType(): string {
+		return 'bigserial';
+	}
+
+	override mapFromDriverValue(value: number): number {
+		if (typeof value === 'number') {
+			return value;
+		}
+		return Number(value);
+	}
+}
+
+export type PgBigSerial64BuilderInitial<TName extends string> = NotNull<
+	HasDefault<
+		PgBigSerial64Builder<{
+			name: TName;
+			dataType: 'bigint';
+			columnType: 'PgBigSerial64';
+			data: bigint;
+			driverParam: string;
+			enumValues: undefined;
+		}>
+	>
+>;
+
+export class PgBigSerial64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigSerial64'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgBigSerial64Builder';
+
+	constructor(name: string) {
+		super(name, 'bigint', 'PgBigSerial64');
+		this.config.hasDefault = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgBigSerial64<MakeColumnConfig<T, TTableName>> {
+		return new PgBigSerial64<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgBigSerial64<T extends ColumnBaseConfig<'bigint', 'PgBigSerial64'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgBigSerial64';
+
+	getSQLType(): string {
+		return 'bigserial';
+	}
+
+	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
+	override mapFromDriverValue(value: string): bigint {
+		return BigInt(value);
+	}
+}
+
+export interface PgBigSerialConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+	mode: T;
+}
+
+export function bigserial<TMode extends PgBigSerialConfig['mode']>(
+	config: PgBigSerialConfig<TMode>,
+): TMode extends 'number' ? PgBigSerial53BuilderInitial<''> : PgBigSerial64BuilderInitial<''>;
+export function bigserial<TName extends string, TMode extends PgBigSerialConfig['mode']>(
+	name: TName,
+	config: PgBigSerialConfig<TMode>,
+): TMode extends 'number' ? PgBigSerial53BuilderInitial<TName> : PgBigSerial64BuilderInitial<TName>;
+export function bigserial(a: string | PgBigSerialConfig, b?: PgBigSerialConfig) {
+	const { name, config } = getColumnNameAndConfig<PgBigSerialConfig>(a, b);
+	if (config.mode === 'number') {
+		return new PgBigSerial53Builder(name);
+	}
+	return new PgBigSerial64Builder(name);
+}