[PG] Add Support For Domains and Check Constraints On Columns

.gitignore

@@ -1,5 +1,6 @@
 node_modules
 .vscode
+.idea
 dist
 dist.new
 *.tsbuildinfo
@@ -12,4 +13,4 @@ dist-dts
 rollup.config-*.mjs
 *.log
 .DS_Store
-drizzle-seed/src/dev
+drizzle-seed/src/dev

drizzle-kit/src/api.ts

@@ -5,6 +5,7 @@ import { PgDatabase } from 'drizzle-orm/pg-core';
 import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
 import {
 	columnsResolver,
+	domainsResolver,
 	enumsResolver,
 	indPolicyResolver,
 	mySqlViewsResolver,
@@ -57,6 +58,7 @@ export const generateDrizzleJson = (
 
 	const snapshot = generatePgSnapshot(
 		prepared.tables,
+		prepared.domains,
 		prepared.enums,
 		prepared.schemas,
 		prepared.sequences,
@@ -91,6 +93,7 @@ export const generateMigration = async (
 		squashedPrev,
 		squashedCur,
 		schemasResolver,
+		domainsResolver,
 		enumsResolver,
 		sequencesResolver,
 		policyResolver,
@@ -144,6 +147,7 @@ export const pushSchema = async (
 		squashedPrev,
 		squashedCur,
 		schemasResolver,
+		domainsResolver,
 		enumsResolver,
 		sequencesResolver,
 		policyResolver,

drizzle-kit/src/cli/commands/introspect.ts

@@ -35,6 +35,7 @@ import type { SqliteCredentials } from '../validations/sqlite';
 import { IntrospectProgress } from '../views';
 import {
 	columnsResolver,
+	domainsResolver,
 	enumsResolver,
 	indPolicyResolver,
 	mySqlViewsResolver,
@@ -121,6 +122,7 @@ export const introspectPostgres = async (
 			squashPgScheme(dryPg),
 			squashPgScheme(schema),
 			schemasResolver,
+			domainsResolver,
 			enumsResolver,
 			sequencesResolver,
 			policyResolver,
@@ -485,7 +487,7 @@ export const introspectSqlite = async (
 			chalk.green(
 				'✓',
 			)
-		}] You relations file is ready ➜ ${
+		}] Your relations file is ready ➜ ${
 			chalk.bold.underline.blue(
 				relationsFile,
 			)

drizzle-kit/src/cli/commands/migrate.ts

@@ -28,6 +28,7 @@ import {
 	Column,
 	ColumnsResolverInput,
 	ColumnsResolverOutput,
+	Domain,
 	Enum,
 	PolicyResolverInput,
 	PolicyResolverOutput,
@@ -260,6 +261,28 @@ export const indPolicyResolver = async (
 	};
 };
 
+export const domainsResolver = async (
+	input: ResolverInput<Domain>,
+): Promise<ResolverOutputWithMoved<Domain>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'domain',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
 export const enumsResolver = async (
 	input: ResolverInput<Enum>,
 ): Promise<ResolverOutputWithMoved<Enum>> => {
@@ -342,6 +365,7 @@ export const prepareAndMigratePg = async (config: GenerateConfig) => {
 			squashedPrev,
 			squashedCur,
 			schemasResolver,
+			domainsResolver,
 			enumsResolver,
 			sequencesResolver,
 			policyResolver,
@@ -388,6 +412,7 @@ export const prepareAndExportPg = async (config: ExportConfig) => {
 			squashedPrev,
 			squashedCur,
 			schemasResolver,
+			domainsResolver,
 			enumsResolver,
 			sequencesResolver,
 			policyResolver,
@@ -420,6 +445,7 @@ export const preparePgPush = async (
 		squashedPrev,
 		squashedCur,
 		schemasResolver,
+		domainsResolver,
 		enumsResolver,
 		sequencesResolver,
 		policyResolver,
@@ -1205,7 +1231,7 @@ export const promptNamedConflict = async <T extends Named>(
 export const promptNamedWithSchemasConflict = async <T extends NamedWithSchema>(
 	newItems: T[],
 	missingItems: T[],
-	entity: 'table' | 'enum' | 'sequence' | 'view',
+	entity: 'table' | 'domain' | 'enum' | 'sequence' | 'view',
 ): Promise<{
 	created: T[];
 	renamed: { from: T; to: T }[];

drizzle-kit/src/cli/commands/pgUp.ts

@@ -9,6 +9,7 @@ import {
 	pgSchemaV5,
 	PgSchemaV6,
 	pgSchemaV6,
+	PgSchemaV7,
 	Table,
 	TableV5,
 } from '../../serializer/pgSchema';
@@ -72,8 +73,7 @@ export const updateUpToV6 = (json: Record<string, any>): PgSchemaV6 => {
 	};
 };
 
-// Changed index format stored in snapshot for PostgreSQL in 0.22.0
-export const updateUpToV7 = (json: Record<string, any>): PgSchema => {
+export const updateUpToV7 = (json: Record<string, any>): PgSchemaV7 => {
 	const schema = pgSchemaV6.parse(json);
 	const tables = Object.fromEntries(
 		Object.entries(schema.tables).map((it) => {
@@ -109,6 +109,44 @@ export const updateUpToV7 = (json: Record<string, any>): PgSchema => {
 	};
 };
 
+// Changed index format stored in snapshot for PostgreSQL in 0.22.0
+export const updateUpToV8 = (json: Record<string, any>): PgSchema => {
+	const schema = pgSchemaV6.parse(json);
+	const tables = Object.fromEntries(
+		Object.entries(schema.tables).map((it) => {
+			const table = it[1];
+			const mappedIndexes = Object.fromEntries(
+				Object.entries(table.indexes).map((idx) => {
+					const { columns, ...rest } = idx[1];
+					const mappedColumns = columns.map<Index['columns'][number]>((it) => {
+						return {
+							expression: it,
+							isExpression: false,
+							asc: true,
+							nulls: 'last',
+							opClass: undefined,
+						};
+					});
+					return [idx[0], { columns: mappedColumns, with: {}, ...rest }];
+				}),
+			);
+			return [it[0], { ...table, indexes: mappedIndexes, policies: {}, isRLSEnabled: false, checkConstraints: {} }];
+		}),
+	);
+
+	return {
+		...schema,
+		version: '8',
+		dialect: 'postgresql',
+		domains: {},
+		sequences: {},
+		tables: tables,
+		policies: {},
+		views: {},
+		roles: {},
+	};
+};
+
 // major migration with of folder structure, etc...
 export const upPgHandlerV4toV5 = (obj: PgSchemaV4): PgSchemaV5 => {
 	const mappedTables: Record<string, TableV5> = {};

drizzle-kit/src/cli/views.ts

@@ -243,7 +243,7 @@ export class ResolveSelect<T extends NamedWithSchema> extends Prompt<
 	constructor(
 		private readonly base: T,
 		data: (RenamePropmtItem<T> | T)[],
-		private readonly entityType: 'table' | 'enum' | 'sequence' | 'view' | 'role',
+		private readonly entityType: 'table' | 'domain' | 'enum' | 'sequence' | 'view' | 'role',
 	) {
 		super();
 		this.on('attach', (terminal) => terminal.toggleCursor('hide'));

drizzle-kit/src/global.ts

@@ -1,5 +1,5 @@
 export const originUUID = '00000000-0000-0000-0000-000000000000';
-export const snapshotVersion = '7';
+export const snapshotVersion = '8';
 
 export function assertUnreachable(x: never | undefined): never {
 	throw new Error("Didn't expect to get here");

drizzle-kit/src/jsonDiffer.js

@@ -215,6 +215,7 @@ export function applyJsonDiff(json1, json2) {
 	const difference = JSON.parse(JSON.stringify(rawDiff || {}));
 	difference.schemas = difference.schemas || {};
 	difference.tables = difference.tables || {};
+	difference.domains = difference.domains || {};
 	difference.enums = difference.enums || {};
 	difference.sequences = difference.sequences || {};
 	difference.roles = difference.roles || {};
@@ -271,6 +272,16 @@ export function applyJsonDiff(json1, json2) {
 		}
 	}
 
+	const domainsEntries = Object.entries(difference.domains);
+	const alteredDomains = domainsEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
+		.map((it) => {
+			const domainEntry = json1.domains[it[0]];
+			if (!domainEntry) return;
+			const { name, schema, baseType, notNull, defaultValue, checkConstraints } = domainEntry;
+			return { name, schema, baseType, notNull, defaultValue, checkConstraints };
+		}).filter(Boolean);
+
 	const enumsEntries = Object.entries(difference.enums);
 	const alteredEnums = enumsEntries
 		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
@@ -402,6 +413,7 @@ export function applyJsonDiff(json1, json2) {
 
 	return {
 		alteredTablesWithColumns,
+		alteredDomains,
 		alteredEnums,
 		alteredSequences,
 		alteredRoles,

drizzle-kit/src/jsonStatements.ts

@@ -4,6 +4,7 @@ import { warning } from './cli/views';
 import { CommonSquashedSchema } from './schemaValidator';
 import { MySqlKitInternals, MySqlSchema, MySqlSquasher, View as MySqlView } from './serializer/mysqlSchema';
 import {
+	CheckConstraint,
 	Index,
 	MatViewWithOption,
 	PgSchema,
@@ -21,7 +22,7 @@ import {
 	SQLiteSquasher,
 	View as SqliteView,
 } from './serializer/sqliteSchema';
-import { AlteredColumn, Column, Sequence, Table } from './snapshotsDiffer';
+import { AlteredColumn, Column, Domain, Sequence, Table } from './snapshotsDiffer';
 
 export interface JsonSqliteCreateTableStatement {
 	type: 'sqlite_create_table';
@@ -96,6 +97,43 @@ export interface JsonRenameTableStatement {
 	tableNameTo: string;
 }
 
+// Types for Domain-related JSON statements
+export type JsonDomainStatement =
+	| JsonCreateDomainStatement
+	| JsonDropDomainStatement
+	| JsonAlterDomainStatement;
+
+export interface JsonCreateDomainStatement {
+	type: 'create_domain';
+	name: string;
+	schema: string;
+	notNull?: boolean;
+	defaultValue?: string;
+	baseType: string;
+	checkConstraints?: string[];
+}
+
+export interface JsonDropDomainStatement {
+	type: 'drop_domain';
+	name: string;
+	schema: string;
+}
+
+export interface JsonAlterDomainStatement {
+	type: 'alter_domain';
+	action:
+		| 'add_constraint'
+		| 'drop_constraint'
+		| 'set_not_null'
+		| 'drop_not_null'
+		| 'set_default'
+		| 'drop_default';
+	name: string;
+	schema: string;
+	defaultValue?: string;
+	checkConstraints?: string[];
+}
+
 export interface JsonCreateEnumStatement {
 	type: 'create_type_enum';
 	name: string;
@@ -866,7 +904,10 @@ export type JsonStatement =
 	| JsonIndRenamePolicyStatement
 	| JsonDropIndPolicyStatement
 	| JsonCreateIndPolicyStatement
-	| JsonAlterIndPolicyStatement;
+	| JsonAlterIndPolicyStatement
+	| JsonCreateDomainStatement
+	| JsonDropDomainStatement
+	| JsonAlterDomainStatement;
 
 export const preparePgCreateTableJson = (
 	table: Table,
@@ -1006,6 +1047,46 @@ export const prepareRenameTableJson = (
 	};
 };
 
+// Helper function to create domain statements
+export const prepareDomainJson = (
+	domain: Domain,
+	type: 'create' | 'alter' | 'drop',
+	action?: JsonAlterDomainStatement['action'],
+): JsonDomainStatement => {
+	let checkConstraints;
+	if (domain.checkConstraints) {
+		checkConstraints = Object.values(domain.checkConstraints);
+	}
+
+	if (type === 'create') {
+		return {
+			type: 'create_domain',
+			name: domain.name,
+			schema: domain.schema,
+			notNull: domain.notNull,
+			defaultValue: domain.defaultValue,
+			baseType: domain.baseType,
+			checkConstraints,
+		};
+	} else if (type === 'drop') {
+		return {
+			type: 'drop_domain',
+			name: domain.name,
+			schema: domain.schema,
+		};
+	}
+
+	// For alter actions
+	return {
+		type: 'alter_domain',
+		action: action!,
+		name: domain.name,
+		schema: domain.schema,
+		defaultValue: domain.defaultValue,
+		checkConstraints,
+	};
+};
+
 export const prepareCreateEnumJson = (
 	name: string,
 	schema: string,

drizzle-kit/src/serializer/index.ts

@@ -35,11 +35,23 @@ export const serializePg = async (
 	const { prepareFromPgImports } = await import('./pgImports');
 	const { generatePgSnapshot } = await import('./pgSerializer');
 
-	const { tables, enums, schemas, sequences, views, matViews, roles, policies } = await prepareFromPgImports(
+	const { tables, domains, enums, schemas, sequences, views, matViews, roles, policies } = await prepareFromPgImports(
 		filenames,
 	);
 
-	return generatePgSnapshot(tables, enums, schemas, sequences, roles, policies, views, matViews, casing, schemaFilter);
+	return generatePgSnapshot(
+		tables,
+		domains,
+		enums,
+		schemas,
+		sequences,
+		roles,
+		policies,
+		views,
+		matViews,
+		casing,
+		schemaFilter,
+	);
 };
 
 export const serializeSQLite = async (