pipework 0.252.0 → 0.253.0

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

@@ -0,0 +1,25 @@
+import type { PgColumn } from './columns/index.js';
+import { bindIfParam } from '../sql/expressions/index.js';
+import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '../sql/sql.js';
+import { sql } from '../sql/sql.js';
+
+export * from '../sql/expressions/index.js';
+
+export function concat(column: PgColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
+	return sql`${column} || ${bindIfParam(value, column)}`;
+}
+
+export function substring(
+	column: PgColumn | SQL.Aliased,
+	{ from, for: _for }: { from?: number | Placeholder | SQLWrapper; for?: number | Placeholder | SQLWrapper },
+): SQL {
+	const chunks: SQLChunk[] = [sql`substring(`, column];
+	if (from !== undefined) {
+		chunks.push(sql` from `, bindIfParam(from, column));
+	}
+	if (_for !== undefined) {
+		chunks.push(sql` for `, bindIfParam(_for, column));
+	}
+	chunks.push(sql`)`);
+	return sql.join(chunks);
+}

package/src/data/query/pg-core/foreign-keys.ts

@@ -0,0 +1,130 @@
+import { entityKind } from '../entity.js';
+import { TableName } from '../table.utils.js';
+import type { AnyPgColumn, PgColumn } from './columns/index.js';
+import type { PgTable } from './table.js';
+
+export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+
+export type Reference = () => {
+	readonly name?: string | undefined;
+	readonly columns: PgColumn[];
+	readonly foreignTable: PgTable;
+	readonly foreignColumns: PgColumn[];
+};
+
+export class ForeignKeyBuilder {
+	static readonly [entityKind]: string = 'PgForeignKeyBuilder';
+
+	/** @internal */
+	reference: Reference;
+
+	/** @internal */
+	_onUpdate: UpdateDeleteAction | undefined = 'no action';
+
+	/** @internal */
+	_onDelete: UpdateDeleteAction | undefined = 'no action';
+
+	/** @internal */
+	_onDeleteColumns: string[] | undefined;
+
+	constructor(
+		config: () => {
+			name?: string | undefined;
+			columns: PgColumn[];
+			foreignColumns: PgColumn[];
+		},
+		actions?: {
+			onUpdate?: UpdateDeleteAction;
+			onDelete?: UpdateDeleteAction;
+		} | undefined,
+	) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as PgTable, foreignColumns };
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+
+	onUpdate(action: UpdateDeleteAction): this {
+		this._onUpdate = action === undefined ? 'no action' : action;
+		return this;
+	}
+
+	onDelete(action: UpdateDeleteAction): this {
+		this._onDelete = action === undefined ? 'no action' : action;
+		return this;
+	}
+
+	/** Database column names an ON DELETE SET NULL / SET DEFAULT applies to (Postgres 15+). */
+	onDeleteColumns(columns: string[] | undefined): this {
+		this._onDeleteColumns = columns;
+		return this;
+	}
+
+	/** @internal */
+	build(table: PgTable): ForeignKey {
+		return new ForeignKey(table, this);
+	}
+}
+
+export type AnyForeignKeyBuilder = ForeignKeyBuilder;
+
+export class ForeignKey {
+	static readonly [entityKind]: string = 'PgForeignKey';
+
+	readonly reference: Reference;
+	readonly onUpdate: UpdateDeleteAction | undefined;
+	readonly onDelete: UpdateDeleteAction | undefined;
+	readonly onDeleteColumns: string[] | undefined;
+
+	constructor(readonly table: PgTable, builder: ForeignKeyBuilder) {
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+		this.onDeleteColumns = builder._onDeleteColumns;
+	}
+
+	getName(): string {
+		const { name, columns, foreignColumns } = this.reference();
+		const columnNames = columns.map((column) => column.name);
+		const foreignColumnNames = foreignColumns.map((column) => column.name);
+		const chunks = [
+			this.table[TableName],
+			...columnNames,
+			foreignColumns[0]!.table[TableName],
+			...foreignColumnNames,
+		];
+		return name ?? `${chunks.join('_')}_fk`;
+	}
+}
+
+type ColumnsWithTable<
+	TTableName extends string,
+	TColumns extends PgColumn[],
+> = { [Key in keyof TColumns]: AnyPgColumn<{ tableName: TTableName }> };
+
+export function foreignKey<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends [AnyPgColumn<{ tableName: TTableName }>, ...AnyPgColumn<{ tableName: TTableName }>[]],
+>(
+	config: {
+		name?: string;
+		columns: TColumns;
+		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+	},
+): ForeignKeyBuilder {
+	function mappedConfig() {
+		const { name, columns, foreignColumns } = config;
+		return {
+			name,
+			columns,
+			foreignColumns,
+		};
+	}
+
+	return new ForeignKeyBuilder(mappedConfig);
+}

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

@@ -0,0 +1,21 @@
+export * from './alias.js';
+export * from './checks.js';
+export * from './columns/index.js';
+export * from './db.js';
+export * from './dialect.js';
+export * from './foreign-keys.js';
+export * from './indexes.js';
+export * from './policies.js';
+export * from './primary-keys.js';
+export * from './query-builders/index.js';
+export * from './roles.js';
+export * from './schema.js';
+export * from './sequence.js';
+export * from './session.js';
+export * from './subquery.js';
+export * from './table.js';
+export * from './unique-constraint.js';
+export * from './utils.js';
+export * from './utils/index.js';
+export * from './view-common.js';
+export * from './view.js';

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

@@ -0,0 +1,276 @@
+import { SQL } from '../sql/sql.js';
+
+import { entityKind, is } from '../entity.js';
+import type { ExtraConfigColumn, PgColumn } from './columns/index.js';
+import { IndexedColumn } from './columns/index.js';
+import type { PgTable } from './table.js';
+
+interface IndexConfig {
+	name?: string | undefined;
+
+	columns: Partial<IndexedColumn | SQL>[];
+
+	/**
+	 * If true, the index will be created as `create unique index` instead of `create index`.
+	 */
+	unique: boolean;
+
+	/**
+	 * If true, the index will be created as `create index concurrently` instead of `create index`.
+	 */
+	concurrently?: boolean;
+
+	/**
+	 * If true, NULLs in the indexed columns compare equal (`NULLS NOT DISTINCT`, PG 15+). Unique indexes only.
+	 */
+	nullsNotDistinct?: boolean;
+
+	/**
+	 * If true, the index will be created as `create index ... on only <table>` instead of `create index ... on <table>`.
+	 */
+	only: boolean;
+
+	/**
+	 * Covering columns (`INCLUDE (...)`, PG 11+): stored in the index, not part of its key.
+	 */
+	include?: string[];
+
+	/**
+	 * Condition for partial index.
+	 */
+	where?: SQL;
+
+	/**
+	 * The optional WITH clause specifies storage parameters for the index
+	 */
+	with?: Record<string, any>;
+
+	/**
+	 * The optional WITH clause method for the index
+	 */
+	method?: 'btree' | string;
+}
+
+export type IndexColumn = PgColumn;
+
+export type PgIndexMethod = 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat' | (string & {});
+
+export type PgIndexOpClass =
+	| 'abstime_ops'
+	| 'access_method'
+	| 'anyarray_eq'
+	| 'anyarray_ge'
+	| 'anyarray_gt'
+	| 'anyarray_le'
+	| 'anyarray_lt'
+	| 'anyarray_ne'
+	| 'bigint_ops'
+	| 'bit_ops'
+	| 'bool_ops'
+	| 'box_ops'
+	| 'bpchar_ops'
+	| 'char_ops'
+	| 'cidr_ops'
+	| 'cstring_ops'
+	| 'date_ops'
+	| 'float_ops'
+	| 'int2_ops'
+	| 'int4_ops'
+	| 'int8_ops'
+	| 'interval_ops'
+	| 'jsonb_ops'
+	| 'macaddr_ops'
+	| 'name_ops'
+	| 'numeric_ops'
+	| 'oid_ops'
+	| 'oidint4_ops'
+	| 'oidint8_ops'
+	| 'oidname_ops'
+	| 'oidvector_ops'
+	| 'point_ops'
+	| 'polygon_ops'
+	| 'range_ops'
+	| 'record_eq'
+	| 'record_ge'
+	| 'record_gt'
+	| 'record_le'
+	| 'record_lt'
+	| 'record_ne'
+	| 'text_ops'
+	| 'time_ops'
+	| 'timestamp_ops'
+	| 'timestamptz_ops'
+	| 'timetz_ops'
+	| 'uuid_ops'
+	| 'varbit_ops'
+	| 'varchar_ops'
+	// pg_vector types
+	| 'xml_ops'
+	| 'vector_l2_ops'
+	| 'vector_ip_ops'
+	| 'vector_cosine_ops'
+	| 'vector_l1_ops'
+	| 'bit_hamming_ops'
+	| 'bit_jaccard_ops'
+	| 'halfvec_l2_ops'
+	| 'sparsevec_l2_op'
+	| (string & {});
+
+export class IndexBuilderOn {
+	static readonly [entityKind]: string = 'PgIndexBuilderOn';
+
+	constructor(private unique: boolean, private name?: string) {}
+
+	on(...columns: [Partial<ExtraConfigColumn> | SQL, ...Partial<ExtraConfigColumn | SQL>[]]): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+				it = it as ExtraConfigColumn;
+				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
+				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+				return clonedIndexedColumn;
+			}),
+			this.unique,
+			false,
+			this.name,
+		);
+	}
+
+	onOnly(...columns: [Partial<ExtraConfigColumn | SQL>, ...Partial<ExtraConfigColumn | SQL>[]]): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+				const col = it as ExtraConfigColumn;
+				const clonedIndexedColumn = new IndexedColumn(col.name, !!col.keyAsName, col.columnType!, col.indexConfig!);
+				col.indexConfig = col.defaultConfig;
+				return clonedIndexedColumn;
+			}),
+			this.unique,
+			true,
+			this.name,
+		);
+	}
+
+	/**
+	 * Specify what index method to use. Choices are `btree`, `hash`, `gist`, `spgist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
+	 *
+	 * If you have the `pg_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
+	 *
+	 * **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
+	 *
+	 * @param method The name of the index method to be used
+	 * @param columns
+	 * @returns
+	 */
+	using(
+		method: PgIndexMethod,
+		...columns: [Partial<ExtraConfigColumn | SQL>, ...Partial<ExtraConfigColumn | SQL>[]]
+	): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+				it = it as ExtraConfigColumn;
+				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
+				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+				return clonedIndexedColumn;
+			}),
+			this.unique,
+			true,
+			this.name,
+			method,
+		);
+	}
+}
+
+export interface AnyIndexBuilder {
+	build(table: PgTable): Index;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface IndexBuilder extends AnyIndexBuilder {}
+
+export class IndexBuilder implements AnyIndexBuilder {
+	static readonly [entityKind]: string = 'PgIndexBuilder';
+
+	/** @internal */
+	config: IndexConfig;
+
+	constructor(
+		columns: Partial<IndexedColumn | SQL>[],
+		unique: boolean,
+		only: boolean,
+		name?: string,
+		method: string = 'btree',
+	) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			only,
+			method,
+		};
+	}
+
+	concurrently(): this {
+		this.config.concurrently = true;
+		return this;
+	}
+
+	nullsNotDistinct(): this {
+		if (!this.config.unique) {
+			throw new Error(
+				`[pipework] Index "${this.config.name ?? '(unnamed)'}" is not unique: NULLS NOT DISTINCT needs uniqueIndex.`,
+			);
+		}
+		this.config.nullsNotDistinct = true;
+		return this;
+	}
+
+	with(obj: Record<string, any>): this {
+		this.config.with = obj;
+		return this;
+	}
+
+	include(...columns: Partial<ExtraConfigColumn>[]): this {
+		this.config.include = columns.map((c) => c.name as string);
+		return this;
+	}
+
+	where(condition: SQL): this {
+		this.config.where = condition;
+		return this;
+	}
+
+	/** @internal */
+	build(table: PgTable): Index {
+		return new Index(this.config, table);
+	}
+}
+
+export class Index {
+	static readonly [entityKind]: string = 'PgIndex';
+
+	readonly config: IndexConfig & { table: PgTable };
+
+	constructor(config: IndexConfig, table: PgTable) {
+		this.config = { ...config, table };
+	}
+}
+
+export type GetColumnsTableName<TColumns> = TColumns extends PgColumn ? TColumns['_']['name']
+	: TColumns extends PgColumn[] ? TColumns[number]['_']['name']
+	: never;
+
+export function index(name?: string): IndexBuilderOn {
+	return new IndexBuilderOn(false, name);
+}
+
+export function uniqueIndex(name?: string): IndexBuilderOn {
+	return new IndexBuilderOn(true, name);
+}

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

@@ -0,0 +1,56 @@
+import { entityKind } from '../entity.js';
+import type { SQL } from '../sql/sql.js';
+import type { PgRole } from './roles.js';
+import type { PgTable } from './table.js';
+
+export type PgPolicyToOption =
+	| 'public'
+	| 'current_role'
+	| 'current_user'
+	| 'session_user'
+	| (string & {})
+	| PgPolicyToOption[]
+	| PgRole;
+
+export interface PgPolicyConfig {
+	as?: 'permissive' | 'restrictive' | undefined;
+	for?: 'all' | 'select' | 'insert' | 'update' | 'delete' | undefined;
+	to?: PgPolicyToOption | undefined;
+	using?: SQL | undefined;
+	withCheck?: SQL | undefined;
+}
+
+export class PgPolicy implements PgPolicyConfig {
+	static readonly [entityKind]: string = 'PgPolicy';
+
+	readonly as: PgPolicyConfig['as'];
+	readonly for: PgPolicyConfig['for'];
+	readonly to: PgPolicyConfig['to'];
+	readonly using: PgPolicyConfig['using'];
+	readonly withCheck: PgPolicyConfig['withCheck'];
+
+	/** @internal */
+	_linkedTable?: PgTable;
+
+	constructor(
+		readonly name: string,
+		config?: PgPolicyConfig,
+	) {
+		if (config) {
+			this.as = config.as;
+			this.for = config.for;
+			this.to = config.to;
+			this.using = config.using;
+			this.withCheck = config.withCheck;
+		}
+	}
+
+	link(table: PgTable): this {
+		this._linkedTable = table;
+		return this;
+	}
+}
+
+export function pgPolicy(name: string, config?: PgPolicyConfig) {
+	return new PgPolicy(name, config);
+}

package/src/data/query/pg-core/primary-keys.ts

@@ -0,0 +1,62 @@
+import { entityKind } from '../entity.js';
+import type { AnyPgColumn, PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
+
+export function primaryKey<
+	TTableName extends string,
+	TColumn extends AnyPgColumn<{ tableName: TTableName }>,
+	TColumns extends readonly AnyPgColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: readonly [TColumn, ...TColumns] }): PrimaryKeyBuilder;
+/**
+ * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
+ * @param columns
+ */
+export function primaryKey<
+	TTableName extends string,
+	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
+>(...columns: TColumns): PrimaryKeyBuilder;
+export function primaryKey(...config: any) {
+	if (config[0].columns) {
+		return new PrimaryKeyBuilder([...config[0].columns], config[0].name);
+	}
+	return new PrimaryKeyBuilder(config);
+}
+
+export class PrimaryKeyBuilder {
+	static readonly [entityKind]: string = 'PgPrimaryKeyBuilder';
+
+	/** @internal */
+	columns: PgColumn[];
+
+	/** @internal */
+	name?: string | undefined;
+
+	constructor(
+		columns: PgColumn[],
+		name?: string,
+	) {
+		this.columns = columns;
+		this.name = name;
+	}
+
+	/** @internal */
+	build(table: PgTable): PrimaryKey {
+		return new PrimaryKey(table, this.columns, this.name);
+	}
+}
+
+export class PrimaryKey {
+	static readonly [entityKind]: string = 'PgPrimaryKey';
+
+	readonly columns: AnyPgColumn<{}>[];
+	readonly name?: string | undefined;
+
+	constructor(readonly table: PgTable, columns: AnyPgColumn<{}>[], name?: string) {
+		this.columns = columns;
+		this.name = name;
+	}
+
+	getName(): string {
+		return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+	}
+}

package/src/data/query/pg-core/query-builders/count.ts

@@ -0,0 +1,86 @@
+import { entityKind } from '../../entity.js';
+import { SQL, sql, type SQLWrapper } from '../../sql/sql.js';
+import type { NeonAuthToken } from '../../utils.js';
+import type { PgSession } from '../session.js';
+import type { PgTable } from '../table.js';
+
+export class PgCountBuilder<
+	TSession extends PgSession<any, any, any>,
+> extends SQL<number> implements Promise<number>, SQLWrapper {
+	private sql: SQL<number>;
+	private token?: NeonAuthToken | undefined;
+
+	static override readonly [entityKind] = 'PgCountBuilder';
+	[Symbol.toStringTag] = 'PgCountBuilder';
+
+	private session: TSession;
+
+	private static buildEmbeddedCount(
+		source: PgTable | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	): SQL<number> {
+		return sql<number>`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
+	}
+
+	private static buildCount(
+		source: PgTable | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	): SQL<number> {
+		return sql<number>`select count(*) as count from ${source}${sql.raw(' where ').if(filters)}${filters};`;
+	}
+
+	constructor(
+		readonly params: {
+			source: PgTable | SQL | SQLWrapper;
+			filters?: SQL<unknown> | undefined;
+			session: TSession;
+		},
+	) {
+		super(PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
+
+		this.mapWith(Number);
+
+		this.session = params.session;
+
+		this.sql = PgCountBuilder.buildCount(
+			params.source,
+			params.filters,
+		);
+	}
+
+	/** @intrnal */
+	setToken(token?: NeonAuthToken) {
+		this.token = token;
+		return this;
+	}
+
+	then<TResult1 = number, TResult2 = never>(
+		onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined,
+		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined,
+	): Promise<TResult1 | TResult2> {
+		return Promise.resolve(this.session.count(this.sql, this.token))
+			.then(
+				onfulfilled,
+				onrejected,
+			);
+	}
+
+	catch(
+		onRejected?: ((reason: any) => any) | null | undefined,
+	): Promise<number> {
+		return this.then(undefined, onRejected);
+	}
+
+	finally(onFinally?: (() => void) | null | undefined): Promise<number> {
+		return this.then(
+			(value) => {
+				onFinally?.();
+				return value;
+			},
+			(reason) => {
+				onFinally?.();
+				throw reason;
+			},
+		);
+	}
+}