pipework 0.252.0 → 0.253.0

package/src/data/query/cache/readme.md

@@ -0,0 +1,230 @@
+## Caching with Drizzle
+
+By default, Drizzle does not perform any implicit actions with your queries and mapping. There is no cache under the hood—each query is sent directly to your database, and you can actually see it.
+
+However, there are cases when you might want to implement a simple caching logic for specific queries or even for all queries. With Drizzle's cache option, you can define how and when the cache is used, how you store and retrieve data, and what actions to take when write statements are executed on the database. It's basically similar to `beforeQuery` hooks, that will be invoked before actual query will be executed. Additionally, Drizzle provides predefined logic for caching. Let's take a look at it.
+
+To make cache work you would need to define cache callbacks in drizzle instance or use a predefined ones we have in Drizzle, like a `upstashCache()` that was built together with Upstash team
+
+### Cache overview
+
+**Using upstash cache with drizzle**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache() })
+```
+
+You can also define custom logic for your cache behavior. This is an example of our NodeKV implementation for the Drizzle cache test suites
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: new TestGlobalCache() })
+```
+
+```ts
+import Keyv from 'keyv';
+
+export class TestGlobalCache extends Cache {
+  private globalTtl: number = 1000;
+  // This object will be used to store which query keys were used
+  // for a specific table, so we can later use it for invalidation.
+  private usedTablesPerKey: Record<string, string[]> = {};
+
+  constructor(private kv: Keyv = new Keyv()) {
+    super();
+  }
+
+  // For the strategy, we have two options:
+  // - 'explicit': The cache is used only when .$withCache() is added to a query.
+  // - 'all': All queries are cached globally.
+  // The default behavior is 'explicit'.
+  override strategy(): 'explicit' | 'all' {
+    return 'all';
+  }
+
+  // This function accepts query and parameters that cached into key param,
+  // allowing you to retrieve response values for this query from the cache.
+  override async get(key: string): Promise<any[] | undefined> {
+    const res = await this.kv.get(key) ?? undefined;
+    return res;
+  }
+
+  // This function accepts several options to define how cached data will be stored:
+  // - 'key': A hashed query and parameters.
+  // - 'response': An array of values returned by Drizzle from the database.
+  // - 'tables': An array of tables involved in the select queries. This information is needed for cache invalidation.
+  //
+  // For example, if a query uses the "users" and "posts" tables, you can store this information. Later, when the app executes
+  // any mutation statements on these tables, you can remove the corresponding key from the cache. 
+  // If you're okay with eventual consistency for your queries, you can skip this option.
+  override async put(key: string, response: any, tables: string[], config?: CacheConfig): Promise<void> {
+    await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+    for (const table of tables) {
+      const keys = this.usedTablesPerKey[table];
+      if (keys === undefined) {
+        this.usedTablesPerKey[table] = [key];
+      } else {
+        keys.push(key);
+      }
+    }
+  }
+
+  // This function is called when insert, update, or delete statements are executed. 
+  // You can either skip this step or invalidate queries that used the affected tables.
+  //
+  // The function receives an object with two keys:
+  // - 'tags': Used for queries labeled with a specific tag, allowing you to invalidate by that tag.
+  // - 'tables': The actual tables affected by the insert, update, or delete statements, 
+  //   helping you track which tables have changed since the last cache update.
+  override async onMutate(params: { tags: string | string[], tables: string | string[] | Table<any> | Table<any>[]}): Promise<void> {
+    const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+    const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+    const keysToDelete = new Set<string>();
+
+    for (const table of tablesArray) {
+      const tableName = is(table, Table) ? getTableName(table) : table as string;
+      const keys = this.usedTablesPerKey[tableName] ?? [];
+      for (const key of keys) keysToDelete.add(key);
+    }
+
+    if (keysToDelete.size > 0 || tagsArray.length > 0) {
+      for (const tag of tagsArray) {
+        await this.kv.delete(tag);
+      }
+
+      for (const key of keysToDelete) {
+        await this.kv.delete(key);
+        for (const table of tablesArray) {
+          const tableName = is(table, Table) ? getTableName(table) : table as string;
+          this.usedTablesPerKey[tableName] = [];
+        }
+      }
+    }
+  }
+}
+```
+
+### Cache definition
+
+**Define cache credentials, but no cache will be used globally for all queries**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: '', token: '' }) })
+```
+
+**Define cache credentials, and the cache will be used globally for all queries**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: '', token: '', global: true }) })
+```
+
+**Define cache credentials with custom config values to be used for all queries, unless overridden**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: '', token: '', global: true, config: {} }) })
+```
+
+These are all the possible config values that Drizzle supports with the cache layer
+
+```ts
+export type CacheConfig = {
+  /**
+   * expire time, in seconds (a positive integer)
+   */
+  ex?: number;
+  /**
+   * expire time, in milliseconds (a positive integer).
+   */
+  px?: number;
+  /**
+   * Unix time at which the key will expire, in seconds (a positive integer).
+   */
+  exat?: number;
+  /**
+   * Unix time at which the key will expire, in milliseconds (a positive integer)
+   */
+  pxat?: number;
+  /**
+   * Retain the time to live associated with the key.
+   */
+  keepTtl?: boolean;
+};
+
+```
+
+### Cache usage
+
+Once you've provided all the necessary instructions to the Drizzle database instance, you can now use the cache with Drizzle
+
+**Case 1: Drizzle with global: false option**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: '', token: '' }) })
+```
+
+In this case, the current query won't use the cache
+
+```ts
+const res = await db.select().from(users)
+
+// However, any mutate operation will trigger the onMutate function in the cache
+// and attempt to invalidate queries that used the tables involved in this mutation query.
+await db.insert(users).value({ email: 'cacheman@upstash.com' })
+```
+
+If you want the query to actually use the cache, you need to call `.$withCache()`
+
+```ts
+const res = await db.select().from(users).$withCache()
+```
+
+`.$withCache` has a set of options you can use to manage and config this specific query strategy
+
+```ts
+// rewrite the global config options for this specific query
+.$withCache({ config: {} })
+
+// give a query custom cache key instead of hashing query+params under the hood
+.$withCache({ tag: 'custom_key' })
+
+// disable autoinvalidation for this query, if you are fine with eventual consstnecy for this specific query
+.$withCache({ autoInvalidate: false })
+```
+
+**Case 2: Drizzle with global: true option**
+
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: '', token: '', global: true }) })
+```
+
+In this case, the current query will use the cache
+
+```ts
+const res = await db.select().from(users)
+```
+
+If you want the query to disable cache for some specific query, you need to call `.$withCache(false)`
+
+```ts
+// cache is disabled for this query
+const res = await db.select().from(users).$withCache(false)
+```
+
+You can also use cache instance from a `db` to force invalidate specific tables or tags you've defined previously
+
+```ts
+// Invalidate all queries that use the `users` table. You can do this with the Drizzle instance.
+await db.$cache?.invalidate({ tables: users });
+// or
+await db.$cache?.invalidate({ tables: [users, posts] });
+
+// Invalidate all queries that use the `usersTable`. You can do this by using just the table name.
+await db.$cache?.invalidate({ tables: 'usersTable' });
+// or
+await db.$cache?.invalidate({ tables: ['usersTable' , 'postsTable' ] });
+
+// You can also invalidate custom tags defined in any previously executed select queries.
+await db.$cache?.invalidate({ tags: 'custom_key' });
+// or
+await db.$cache?.invalidate({ tags: ['custom_key', 'custom_key1'] });
+```

package/src/data/query/casing.ts

@@ -0,0 +1,76 @@
+import type { Column } from './column.js';
+import { entityKind } from './entity.js';
+import { Table } from './table.js';
+import type { Casing } from './utils.js';
+
+export function toSnakeCase(input: string) {
+	const words = input
+		.replace(/['\u2019]/g, '')
+		.match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
+
+	return words.map((word) => word.toLowerCase()).join('_');
+}
+
+export function toCamelCase(input: string) {
+	const words = input
+		.replace(/['\u2019]/g, '')
+		.match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
+
+	return words.reduce((acc, word, i) => {
+		const formattedWord = i === 0 ? word.toLowerCase() : `${word[0]!.toUpperCase()}${word.slice(1)}`;
+		return acc + formattedWord;
+	}, '');
+}
+
+function noopCase(input: string) {
+	return input;
+}
+
+export class CasingCache {
+	static readonly [entityKind]: string = 'CasingCache';
+
+	/** @internal */
+	cache: Record<string, string> = {};
+	private cachedTables: Record<string, true> = {};
+	private convert: (input: string) => string;
+
+	constructor(casing?: Casing) {
+		this.convert = casing === 'snake_case'
+			? toSnakeCase
+			: casing === 'camelCase'
+			? toCamelCase
+			: noopCase;
+	}
+
+	getColumnCasing(column: Column): string {
+		if (!column.keyAsName) return column.name;
+
+		const schema = column.table[Table.Symbol.Schema] ?? 'public';
+		const tableName = column.table[Table.Symbol.OriginalName];
+		const key = `${schema}.${tableName}.${column.name}`;
+
+		if (!this.cache[key]) {
+			this.cacheTable(column.table);
+		}
+		return this.cache[key]!;
+	}
+
+	private cacheTable(table: Table) {
+		const schema = table[Table.Symbol.Schema] ?? 'public';
+		const tableName = table[Table.Symbol.OriginalName];
+		const tableKey = `${schema}.${tableName}`;
+
+		if (!this.cachedTables[tableKey]) {
+			for (const column of Object.values(table[Table.Symbol.Columns])) {
+				const columnKey = `${tableKey}.${column.name}`;
+				this.cache[columnKey] = this.convert(column.name);
+			}
+			this.cachedTables[tableKey] = true;
+		}
+	}
+
+	clearCache() {
+		this.cache = {};
+		this.cachedTables = {};
+	}
+}

package/src/data/query/collation.ts

@@ -0,0 +1,11 @@
+/** A collation: one identifier (`'en_US.utf8'`, dots included) or a schema-qualified `[schema, name]`. */
+export type CollationName = string | readonly [schema: string, name: string]
+
+function quoteIdent(name: string): string {
+	return `"${name.replace(/"/g, '""')}"`
+}
+
+/** The collation as SQL text: `"en_US.utf8"` or `"pg_catalog"."C"`. */
+export function quoteCollation(name: CollationName): string {
+	return typeof name === 'string' ? quoteIdent(name) : `${quoteIdent(name[0])}.${quoteIdent(name[1])}`
+}

package/src/data/query/column-builder.ts

@@ -0,0 +1,370 @@
+import { entityKind } from './entity.js';
+import type { Column } from './column.js';
+import type { ExtraConfigColumn, PgColumn, PgSequenceOptions } from './pg-core/index.js';
+import type { SQL } from './sql/sql.js';
+import type { Assume, Simplify } from './utils.js';
+
+export type ColumnDataType =
+	| 'string'
+	| 'number'
+	| 'boolean'
+	| 'array'
+	| 'json'
+	| 'date'
+	| 'bigint'
+	| 'custom'
+	| 'buffer'
+	| 'dateDuration'
+	| 'duration'
+	| 'relDuration'
+	| 'localTime'
+	| 'localDate'
+	| 'localDateTime';
+
+export type Dialect = 'pg' | 'mysql' | 'sqlite' | 'singlestore' | 'common' | 'gel';
+
+export type GeneratedStorageMode = 'virtual' | 'stored';
+
+export type GeneratedType = 'always' | 'byDefault';
+
+export type GeneratedColumnConfig<TDataType> = {
+	as: TDataType | SQL | (() => SQL);
+	type?: GeneratedType;
+	mode?: GeneratedStorageMode;
+};
+
+export type GeneratedIdentityConfig = {
+	sequenceName?: string | undefined;
+	sequenceOptions?: PgSequenceOptions;
+	type: 'always' | 'byDefault';
+};
+
+export interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
+	name: string;
+	dataType: TDataType;
+	columnType: TColumnType;
+	data: unknown;
+	driverParam: unknown;
+	enumValues: string[] | undefined;
+}
+
+export type MakeColumnConfig<
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	TTableName extends string,
+	TData = T extends { $type: infer U } ? U : T['data'],
+> = {
+	name: T['name'];
+	tableName: TTableName;
+	dataType: T['dataType'];
+	columnType: T['columnType'];
+	data: TData;
+	driverParam: T['driverParam'];
+	notNull: T extends { notNull: true } ? true : false;
+	hasDefault: T extends { hasDefault: true } ? true : false;
+	isPrimaryKey: T extends { isPrimaryKey: true } ? true : false;
+	isAutoincrement: T extends { isAutoincrement: true } ? true : false;
+	hasRuntimeDefault: T extends { hasRuntimeDefault: true } ? true : false;
+	enumValues: T['enumValues'];
+	baseColumn: T extends { baseBuilder: infer U extends ColumnBuilderBase } ? BuildColumn<TTableName, U, 'common'>
+		: never;
+	identity: T extends { identity: 'always' } ? 'always' : T extends { identity: 'byDefault' } ? 'byDefault' : undefined;
+	generated: T extends { generated: infer G } ? unknown extends G ? undefined
+		: G extends undefined ? undefined
+		: G
+		: undefined;
+} & {};
+
+export type ColumnBuilderTypeConfig<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	TTypeConfig extends object = object,
+> = Simplify<
+	& {
+		brand: 'ColumnBuilder';
+		name: T['name'];
+		dataType: T['dataType'];
+		columnType: T['columnType'];
+		data: T['data'];
+		driverParam: T['driverParam'];
+		notNull: T extends { notNull: infer U } ? U : boolean;
+		hasDefault: T extends { hasDefault: infer U } ? U : boolean;
+		enumValues: T['enumValues'];
+		identity: T extends { identity: infer U } ? U : unknown;
+		generated: T extends { generated: infer G } ? G extends undefined ? unknown : G : unknown;
+	}
+	& TTypeConfig
+>;
+
+export type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
+	name: string;
+	keyAsName: boolean;
+	notNull: boolean;
+	default: TData | SQL | undefined;
+	defaultFn: (() => TData | SQL) | undefined;
+	onUpdateFn: (() => TData | SQL) | undefined;
+	hasDefault: boolean;
+	primaryKey: boolean;
+	isUnique: boolean;
+	uniqueName: string | undefined;
+	uniqueType: string | undefined;
+	dataType: string;
+	columnType: string;
+	generated: GeneratedColumnConfig<TData> | undefined;
+	generatedIdentity: GeneratedIdentityConfig | undefined;
+	collation?: string | undefined;
+} & TRuntimeConfig;
+
+export interface ColumnBuilderExtraConfig {
+	primaryKeyHasDefault?: boolean;
+}
+
+export type NotNull<T extends ColumnBuilderBase> = T & {
+	_: {
+		notNull: true;
+	};
+};
+
+export type HasDefault<T extends ColumnBuilderBase> = T & {
+	_: {
+		hasDefault: true;
+	};
+};
+
+export type IsPrimaryKey<T extends ColumnBuilderBase> = T & {
+	_: {
+		isPrimaryKey: true;
+	};
+};
+
+export type IsAutoincrement<T extends ColumnBuilderBase> = T & {
+	_: {
+		isAutoincrement: true;
+	};
+};
+
+export type HasRuntimeDefault<T extends ColumnBuilderBase> = T & {
+	_: {
+		hasRuntimeDefault: true;
+	};
+};
+
+export type $Type<T extends ColumnBuilderBase, TType> = T & {
+	_: {
+		$type: TType;
+	};
+};
+
+export type HasGenerated<T extends ColumnBuilderBase, TGenerated extends {} = {}> = T & {
+	_: {
+		hasDefault: true;
+		generated: TGenerated;
+	};
+};
+
+export type IsIdentity<
+	T extends ColumnBuilderBase,
+	TType extends 'always' | 'byDefault',
+> = T & {
+	_: {
+		notNull: true;
+		hasDefault: true;
+		identity: TType;
+	};
+};
+export interface ColumnBuilderBase<
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	TTypeConfig extends object = object,
+> {
+	_: ColumnBuilderTypeConfig<T, TTypeConfig>;
+}
+
+// To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
+export abstract class ColumnBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	TRuntimeConfig extends object = object,
+	TTypeConfig extends object = object,
+	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
+> implements ColumnBuilderBase<T, TTypeConfig> {
+	static readonly [entityKind]: string = 'ColumnBuilder';
+
+	declare _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+
+	protected config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>;
+
+	constructor(name: T['name'], dataType: T['dataType'], columnType: T['columnType']) {
+		this.config = {
+			name,
+			keyAsName: name === '',
+			notNull: false,
+			default: undefined,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: undefined,
+			uniqueType: undefined,
+			dataType,
+			columnType,
+			generated: undefined,
+		} as ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>;
+	}
+
+	/**
+	 * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+	 *
+	 * @example
+	 * ```ts
+	 * const users = pgTable('users', {
+	 * 	id: integer('id').$type<UserId>().primaryKey(),
+	 * 	details: json('details').$type<UserDetails>().notNull(),
+	 * });
+	 * ```
+	 */
+	$type<TType>(): $Type<this, TType> {
+		return this as $Type<this, TType>;
+	}
+
+	/**
+	 * Adds a `not null` clause to the column definition.
+	 *
+	 * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+	 */
+	notNull(): NotNull<this> {
+		this.config.notNull = true;
+		return this as NotNull<this>;
+	}
+
+	/**
+	 * Adds a `default <value>` clause to the column definition.
+	 *
+	 * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+	 *
+	 * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+	 */
+	default(value: (this['_'] extends { $type: infer U } ? U : this['_']['data']) | SQL): HasDefault<this> {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this as HasDefault<this>;
+	}
+
+	/**
+	 * Adds a dynamic default value to the column.
+	 * The function will be called when the row is inserted, and the returned value will be used as the column value.
+	 *
+	 * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	 */
+	$defaultFn(
+		fn: () => (this['_'] extends { $type: infer U } ? U : this['_']['data']) | SQL,
+	): HasRuntimeDefault<HasDefault<this>> {
+		this.config.defaultFn = fn;
+		this.config.hasDefault = true;
+		return this as HasRuntimeDefault<HasDefault<this>>;
+	}
+
+	/**
+	 * Alias for {@link $defaultFn}.
+	 */
+	$default = this.$defaultFn;
+
+	/**
+	 * Adds a dynamic update value to the column.
+	 * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+	 * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+	 *
+	 * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	 */
+	$onUpdateFn(
+		fn: () => (this['_'] extends { $type: infer U } ? U : this['_']['data']) | SQL,
+	): HasDefault<this> {
+		this.config.onUpdateFn = fn;
+		this.config.hasDefault = true;
+		return this as HasDefault<this>;
+	}
+
+	/**
+	 * Alias for {@link $onUpdateFn}.
+	 */
+	$onUpdate = this.$onUpdateFn;
+
+	/**
+	 * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+	 *
+	 * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+	 */
+	primaryKey(): TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<NotNull<this>>>
+		: IsPrimaryKey<NotNull<this>>
+	{
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this as TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<NotNull<this>>>
+			: IsPrimaryKey<NotNull<this>>;
+	}
+
+	abstract generatedAlwaysAs(
+		as: SQL | T['data'] | (() => SQL),
+		config?: Partial<GeneratedColumnConfig<unknown>>,
+	): HasGenerated<this, {
+		type: 'always';
+	}>;
+
+	/** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+	setName(name: string) {
+		if (this.config.name !== '') return;
+		this.config.name = name;
+	}
+}
+
+export type BuildColumn<
+	TTableName extends string,
+	TBuilder extends ColumnBuilderBase,
+	TDialect extends Dialect,
+> = TDialect extends 'pg' ? PgColumn<
+		MakeColumnConfig<TBuilder['_'], TTableName>,
+		{},
+		Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
+	>
+	: TDialect extends 'common' ? Column<
+			MakeColumnConfig<TBuilder['_'], TTableName>,
+			{},
+			Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
+		>
+	: never;
+
+export type BuildIndexColumn<
+	TDialect extends Dialect,
+> = TDialect extends 'pg' ? ExtraConfigColumn
+	: never;
+
+// TODO
+// try to make sql as well + indexRaw
+
+// optional after everything will be working as expected
+// also try to leave only needed methods for extraConfig
+// make an error if I pass .asc() to fk and so on
+
+export type BuildColumns<
+	TTableName extends string,
+	TConfigMap extends Record<string, ColumnBuilderBase>,
+	TDialect extends Dialect,
+> =
+	& {
+		[Key in keyof TConfigMap]: BuildColumn<TTableName, {
+			_:
+				& Omit<TConfigMap[Key]['_'], 'name'>
+				& { name: TConfigMap[Key]['_']['name'] extends '' ? Assume<Key, string> : TConfigMap[Key]['_']['name'] };
+		}, TDialect>;
+	}
+	& {};
+
+export type BuildExtraConfigColumns<
+	_TTableName extends string,
+	TConfigMap extends Record<string, ColumnBuilderBase>,
+	TDialect extends Dialect,
+> =
+	& {
+		[Key in keyof TConfigMap]: BuildIndexColumn<TDialect>;
+	}
+	& {};
+
+export type ChangeColumnTableName<TColumn extends Column, TAlias extends string, TDialect extends Dialect> =
+	TDialect extends 'pg' ? PgColumn<MakeColumnConfig<TColumn['_'], TAlias>>
+		: never;