durcno 1.0.0-alpha.0

package/dist/src/migration/ddl.mjs

@@ -0,0 +1,1084 @@
+import { snapshotExprToSQL } from "../constraints/check.mjs";
+import { CustomStatement, DDLStatement } from "./statement.mjs";
+//#region src/migration/ddl.ts
+/**
+* Builds a quoted relation name from schema and name.
+* Examples:
+* - schema="public", name="users" -> "public"."users"
+*/
+function buildRelation(schema, name) {
+	return `"${schema}"."${name}"`;
+}
+/**
+* DDL statement that creates a new PostgreSQL schema.
+*
+* Generates: `CREATE SCHEMA <name>;`
+*
+* @remarks
+* Schemas are not tracked in the migration snapshot.
+*
+* @example
+* ```typescript
+* ddl.createSchema('analytics');
+* // CREATE SCHEMA analytics;
+* ```
+*/
+var CreateSchemaStatement = class extends DDLStatement {
+	type = "createSchema";
+	/**
+	* @param schema - The name of the schema to create.
+	*/
+	constructor(schema) {
+		super();
+		this.schema = schema;
+	}
+	toSQL() {
+		return `CREATE SCHEMA ${this.schema};`;
+	}
+	/** Schemas are not tracked in snapshot, so this is a no-op. */
+	applyToSnapshot(_snapshot) {}
+};
+/**
+* DDL statement that drops an existing PostgreSQL schema.
+*
+* Generates: `DROP SCHEMA <name>;`
+*
+* @remarks
+* Schemas are not tracked in the migration snapshot.
+*
+* @example
+* ```typescript
+* ddl.dropSchema('analytics');
+* // DROP SCHEMA analytics;
+* ```
+*/
+var DropSchemaStatement = class extends DDLStatement {
+	type = "dropSchema";
+	/**
+	* @param schema - The name of the schema to drop.
+	*/
+	constructor(schema) {
+		super();
+		this.schema = schema;
+	}
+	toSQL() {
+		return `DROP SCHEMA ${this.schema};`;
+	}
+	/** Schemas are not tracked in snapshot, so this is a no-op. */
+	applyToSnapshot(_snapshot) {}
+};
+/**
+* DDL statement that creates a new PostgreSQL enum type.
+*
+* Generates: `CREATE TYPE "schema"."name" AS ENUM('val1', 'val2', ...);`
+*
+* @example
+* ```typescript
+* ddl.createEnum('public', 'user_type', ['admin', 'user', 'guest']);
+* // CREATE TYPE "public"."user_type" AS ENUM('admin', 'user', 'guest');
+* ```
+*/
+var CreateEnumStatement = class extends DDLStatement {
+	type = "createEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The name of the enum type to create.
+	* @param values - Ordered list of allowed enum values.
+	*/
+	constructor(schema, name, values) {
+		super();
+		this.schema = schema;
+		this.name = name;
+		this.values = values;
+	}
+	toSQL() {
+		return `CREATE TYPE ${buildRelation(this.schema, this.name)} AS ENUM(${this.values.map((v) => `'${v}'`).join(", ")});`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		snapshot.enums[key] = {
+			schema: this.schema,
+			name: this.name,
+			values: [...this.values]
+		};
+	}
+};
+/**
+* DDL statement that adds a value to an existing PostgreSQL enum type.
+*
+* Generates: `ALTER TYPE "schema"."name" ADD VALUE IF NOT EXISTS 'value' [AFTER|BEFORE 'ref'];`
+*
+* @remarks
+* PostgreSQL does not support removing values from an enum.
+* Values can only be added, optionally positioned relative to an existing value.
+*
+* @example
+* ```typescript
+* // Append a value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator');
+*
+* // Insert after a specific value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator', { after: 'admin' });
+*
+* // Insert before a specific value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator', { before: 'user' });
+* ```
+*/
+var AlterEnumAddValueStatement = class extends DDLStatement {
+	type = "alterEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The enum type name.
+	* @param value - The new value to add.
+	* @param position - Optional positioning: `{ after: 'val' }` or `{ before: 'val' }`.
+	*/
+	constructor(schema, name, value, position) {
+		super();
+		this.schema = schema;
+		this.name = name;
+		this.value = value;
+		this.position = position;
+	}
+	toSQL() {
+		let sql = `ALTER TYPE ${buildRelation(this.schema, this.name)} ADD VALUE IF NOT EXISTS '${this.value}'`;
+		if (this.position?.after) sql += ` AFTER '${this.position.after}'`;
+		else if (this.position?.before) sql += ` BEFORE '${this.position.before}'`;
+		return `${sql};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		const enm = snapshot.enums[key];
+		if (!enm) return;
+		if (this.position?.after) {
+			const afterIdx = enm.values.indexOf(this.position.after);
+			if (afterIdx !== -1) {
+				enm.values.splice(afterIdx + 1, 0, this.value);
+				return;
+			}
+		} else if (this.position?.before) {
+			const beforeIdx = enm.values.indexOf(this.position.before);
+			if (beforeIdx !== -1) {
+				enm.values.splice(beforeIdx, 0, this.value);
+				return;
+			}
+		}
+		enm.values.push(this.value);
+	}
+};
+/**
+* DDL statement that drops an existing PostgreSQL enum type.
+*
+* Generates: `DROP TYPE "schema"."name";`
+*
+* @example
+* ```typescript
+* ddl.dropEnum('public', 'user_type');
+* // DROP TYPE "public"."user_type";
+* ```
+*/
+var DropEnumStatement = class extends DDLStatement {
+	type = "dropEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The enum type name to drop.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	toSQL() {
+		return `DROP TYPE ${buildRelation(this.schema, this.name)};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		delete snapshot.enums[key];
+	}
+};
+/**
+* DDL statement that creates a new PostgreSQL sequence.
+*
+* Generates: `CREATE SEQUENCE "schema"."name" [START WITH n] [INCREMENT BY n] ...;`
+*
+* @example
+* ```typescript
+* ddl.createSequence('public', 'order_seq', {
+*   startWith: 1000,
+*   increment: 1,
+*   cache: 10,
+* });
+* // CREATE SEQUENCE "public"."order_seq" START WITH 1000 INCREMENT BY 1 CACHE 10;
+* ```
+*/
+var CreateSequenceStatement = class extends DDLStatement {
+	type = "createSequence";
+	/**
+	* @param schema - The schema the sequence belongs to.
+	* @param name - The sequence name.
+	* @param options - Optional sequence configuration.
+	*/
+	constructor(schema, name, options = {}) {
+		super();
+		this.schema = schema;
+		this.name = name;
+		this.options = options;
+	}
+	toSQL() {
+		let sql = `CREATE SEQUENCE ${buildRelation(this.schema, this.name)}`;
+		if (this.options.startWith !== void 0) sql += ` START WITH ${this.options.startWith}`;
+		if (this.options.increment !== void 0) sql += ` INCREMENT BY ${this.options.increment}`;
+		if (this.options.minValue !== void 0) sql += ` MINVALUE ${this.options.minValue}`;
+		if (this.options.maxValue !== void 0) sql += ` MAXVALUE ${this.options.maxValue}`;
+		if (this.options.cycle) sql += " CYCLE";
+		if (this.options.cache !== void 0) sql += ` CACHE ${this.options.cache}`;
+		return `${sql};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		snapshot.sequences[key] = {
+			schema: this.schema,
+			name: this.name,
+			startWith: this.options.startWith,
+			increment: this.options.increment,
+			minValue: this.options.minValue,
+			maxValue: this.options.maxValue,
+			cycle: this.options.cycle,
+			cache: this.options.cache
+		};
+	}
+};
+/**
+* DDL statement that drops an existing PostgreSQL sequence.
+*
+* Generates: `DROP SEQUENCE "schema"."name";`
+*
+* @example
+* ```typescript
+* ddl.dropSequence('public', 'order_seq');
+* // DROP SEQUENCE "public"."order_seq";
+* ```
+*/
+var DropSequenceStatement = class extends DDLStatement {
+	type = "dropSequence";
+	/**
+	* @param schema - The schema the sequence belongs to.
+	* @param name - The sequence name to drop.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	toSQL() {
+		return `DROP SEQUENCE ${buildRelation(this.schema, this.name)};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		delete snapshot.sequences[key];
+	}
+};
+/**
+* Generates a SQL column definition string from column metadata.
+* Used by both CREATE TABLE and ALTER TABLE statements.
+*/
+function toColumnDef(name, type, options = {}) {
+	let def = `"${name}" ${type}`;
+	if (options.primaryKey) def += " PRIMARY KEY";
+	if (options.references) {
+		const refTable = `"${options.references.schema}"."${options.references.table}"`;
+		def += ` REFERENCES ${refTable}(${options.references.column}) ON DELETE ${options.references.onDelete}`;
+	}
+	if (options.unique) def += " UNIQUE";
+	if (options.notNull) def += " NOT NULL";
+	if (options.default !== void 0) def += ` DEFAULT ${options.default}`;
+	if (options.generated) def += ` GENERATED ${options.generated} AS ${options.as}`;
+	return def;
+}
+/**
+* Chainable builder that constructs a `CREATE TABLE` DDL statement.
+*
+* Use {@link ddl.createTable} to obtain an instance, then chain
+* `.column()`, `.check()`, `.uniqueConstraint()`, and `.primaryKeyConstraint()`.
+*
+* @example
+* ```typescript
+* ddl.createTable('public', 'users')
+*   .column('id', 'serial', { primaryKey: true })
+*   .column('name', 'varchar(255)', { notNull: true })
+*   .column('email', 'varchar(255)', { notNull: true, unique: true })
+*   .check('name_length', { column: 'name', op: '>', value: 0 })
+*   .uniqueConstraint('users_name_email_unique', ['name', 'email']);
+* ```
+*/
+var CreateTableBuilder = class extends DDLStatement {
+	type = "createTable";
+	columns = [];
+	checks = [];
+	_uniqueConstraints = [];
+	_primaryKeyConstraint;
+	/**
+	* @param schema - The PostgreSQL schema to create the table in.
+	* @param name - The table name.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	/**
+	* Add a column to the table.
+	*
+	* @param colName - Column name.
+	* @param type - SQL type (e.g. `"varchar(255)"`, `"integer"`, `"serial"`).
+	* @param options - Column options (constraints, default, references, etc.).
+	* @returns `this` for chaining.
+	*/
+	column(colName, type, options = {}) {
+		this.columns.push({
+			name: colName,
+			type,
+			options
+		});
+		return this;
+	}
+	/**
+	* Add a CHECK constraint to the table.
+	*
+	* @param chkName - Constraint name.
+	* @param expr - The check expression.
+	* @returns `this` for chaining.
+	*/
+	check(chkName, expr) {
+		this.checks.push({
+			name: chkName,
+			expr
+		});
+		return this;
+	}
+	/**
+	* Add a table-level UNIQUE constraint spanning one or more columns.
+	*
+	* @param ucName - Constraint name.
+	* @param columns - Column names that form the unique key.
+	* @returns `this` for chaining.
+	*/
+	uniqueConstraint(ucName, columns) {
+		this._uniqueConstraints.push({
+			name: ucName,
+			columns
+		});
+		return this;
+	}
+	/**
+	* Add a composite PRIMARY KEY constraint.
+	*
+	* @param pkName - Constraint name.
+	* @param columns - Column names that form the primary key.
+	* @returns `this` for chaining.
+	*/
+	primaryKeyConstraint(pkName, columns) {
+		this._primaryKeyConstraint = {
+			name: pkName,
+			columns
+		};
+		return this;
+	}
+	toSQL() {
+		const relation = buildRelation(this.schema, this.name);
+		const entries = [];
+		for (const col of this.columns) entries.push(`  ${toColumnDef(col.name, col.type, col.options)}`);
+		for (const chk of this.checks) entries.push(`  CONSTRAINT ${chk.name} CHECK (${snapshotExprToSQL(chk.expr)})`);
+		for (const uc of this._uniqueConstraints) {
+			const cols = uc.columns.map((c) => `"${c}"`).join(", ");
+			entries.push(`  CONSTRAINT ${uc.name} UNIQUE (${cols})`);
+		}
+		if (this._primaryKeyConstraint) {
+			const pk = this._primaryKeyConstraint;
+			const cols = pk.columns.map((c) => `"${c}"`).join(", ");
+			entries.push(`  CONSTRAINT ${pk.name} PRIMARY KEY (${cols})`);
+		}
+		return `CREATE TABLE ${relation} (\n${entries.join(",\n")}\n);`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		const columns = {};
+		for (const col of this.columns) {
+			const colSnapshot = { type: col.type };
+			if (col.options.notNull) colSnapshot.notNull = true;
+			if (col.options.primaryKey) colSnapshot.primaryKey = true;
+			if (col.options.unique) colSnapshot.unique = true;
+			if (col.options.default !== void 0) colSnapshot.default = col.options.default;
+			if (col.options.generated) colSnapshot.generated = col.options.generated;
+			if (col.options.as) colSnapshot.as = col.options.as;
+			if (col.options.references) colSnapshot.references = {
+				schema: col.options.references.schema,
+				table: col.options.references.table,
+				column: col.options.references.column,
+				onDelete: col.options.references.onDelete
+			};
+			columns[col.name] = colSnapshot;
+		}
+		const tableKey = `${this.schema}.${this.name}`;
+		const checks = {};
+		for (const chk of this.checks) checks[chk.name] = {
+			name: chk.name,
+			table: tableKey,
+			expr: chk.expr
+		};
+		const uniqueConstraints = {};
+		for (const uc of this._uniqueConstraints) uniqueConstraints[uc.name] = {
+			name: uc.name,
+			table: tableKey,
+			columns: [...uc.columns]
+		};
+		let primaryKeyConstraint;
+		if (this._primaryKeyConstraint) primaryKeyConstraint = {
+			name: this._primaryKeyConstraint.name,
+			table: tableKey,
+			columns: [...this._primaryKeyConstraint.columns]
+		};
+		snapshot.tables[key] = {
+			schema: this.schema,
+			name: this.name,
+			columns,
+			indexes: {},
+			checkConstraints: checks,
+			uniqueConstraints,
+			primaryKeyConstraint
+		};
+	}
+};
+/**
+* DDL statement that drops an existing table.
+*
+* Generates: `DROP TABLE "schema"."name";`
+*
+* @example
+* ```typescript
+* ddl.dropTable('public', 'users');
+* // DROP TABLE "public"."users";
+* ```
+*/
+var DropTableStatement = class extends DDLStatement {
+	type = "dropTable";
+	/**
+	* @param schema - The schema of the table.
+	* @param name - The table name to drop.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	toSQL() {
+		return `DROP TABLE ${buildRelation(this.schema, this.name)};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		delete snapshot.tables[key];
+	}
+};
+/**
+* DDL statement that renames an existing table.
+*
+* Generates: `ALTER TABLE "schema"."oldName" RENAME TO "newName";`
+*
+* @example
+* ```typescript
+* ddl.renameTable('public', 'users', 'accounts');
+* // ALTER TABLE "public"."users" RENAME TO "accounts";
+* ```
+*/
+var RenameTableStatement = class extends DDLStatement {
+	type = "renameTable";
+	/**
+	* @param schema - The schema of the table.
+	* @param oldName - The current table name.
+	* @param newName - The new table name.
+	*/
+	constructor(schema, oldName, newName) {
+		super();
+		this.schema = schema;
+		this.oldName = oldName;
+		this.newName = newName;
+	}
+	toSQL() {
+		return `ALTER TABLE ${buildRelation(this.schema, this.oldName)} RENAME TO "${this.newName}";`;
+	}
+	applyToSnapshot(snapshot) {
+		const oldKey = `${this.schema}.${this.oldName}`;
+		const newKey = `${this.schema}.${this.newName}`;
+		const table = snapshot.tables[oldKey];
+		if (!table) return;
+		table.name = this.newName;
+		snapshot.tables[newKey] = table;
+		delete snapshot.tables[oldKey];
+	}
+};
+/**
+* Chainable builder that constructs `ALTER TABLE` DDL statements.
+*
+* Supports adding/dropping columns, changing types, toggling constraints,
+* and managing defaults. Each chained method appends an action that produces
+* a separate `ALTER TABLE ... ;` SQL statement when {@link toSQL} is called.
+*
+* Use {@link ddl.alterTable} to obtain an instance.
+*
+* @example
+* ```typescript
+* ddl.alterTable('public', 'users')
+*   .addColumn('age', 'integer', { notNull: true, default: '0' })
+*   .dropColumn('legacy_field')
+*   .setNotNull('email')
+*   .addUniqueConstraint('users_email_unique', ['email']);
+* ```
+*/
+var AlterTableBuilder = class extends DDLStatement {
+	type = "alterTable";
+	actions = [];
+	/**
+	* @param schema - The schema of the table to alter.
+	* @param name - The table name.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	/**
+	* Add a new column to the table.
+	*
+	* @param name - Column name.
+	* @param type - SQL type (e.g. `"varchar(255)"`).
+	* @param options - Column constraints and options.
+	* @returns `this` for chaining.
+	*/
+	addColumn(name, type, options = {}) {
+		this.actions.push({
+			type: "addColumn",
+			name,
+			colType: type,
+			options
+		});
+		return this;
+	}
+	/**
+	* Drop a column from the table.
+	*
+	* @param name - The column name to drop.
+	* @returns `this` for chaining.
+	*/
+	dropColumn(name) {
+		this.actions.push({
+			type: "dropColumn",
+			name
+		});
+		return this;
+	}
+	/**
+	* Rename a column.
+	*
+	* @param oldName - The current column name.
+	* @param newName - The new column name.
+	* @returns `this` for chaining.
+	*/
+	renameColumn(oldName, newName) {
+		this.actions.push({
+			type: "renameColumn",
+			oldName,
+			newName
+		});
+		return this;
+	}
+	/**
+	* Change the type of an existing column.
+	*
+	* @param name - The column name.
+	* @param newType - The new SQL type.
+	* @returns `this` for chaining.
+	*/
+	alterColumnType(name, newType) {
+		this.actions.push({
+			type: "alterColumnType",
+			name,
+			newType
+		});
+		return this;
+	}
+	/**
+	* Add a column-level UNIQUE constraint.
+	*
+	* @param column - The column name.
+	* @returns `this` for chaining.
+	*/
+	addUnique(column) {
+		this.actions.push({
+			type: "addUnique",
+			column
+		});
+		return this;
+	}
+	/**
+	* Drop a named constraint (UNIQUE, CHECK, or PRIMARY KEY).
+	*
+	* @param name - The constraint name.
+	* @returns `this` for chaining.
+	*/
+	dropConstraint(name) {
+		this.actions.push({
+			type: "dropConstraint",
+			name
+		});
+		return this;
+	}
+	/**
+	* Set `NOT NULL` on a column.
+	*
+	* @param column - The column name.
+	* @returns `this` for chaining.
+	*/
+	setNotNull(column) {
+		this.actions.push({
+			type: "setNotNull",
+			column
+		});
+		return this;
+	}
+	/**
+	* Drop `NOT NULL` from a column, making it nullable.
+	*
+	* @param column - The column name.
+	* @returns `this` for chaining.
+	*/
+	dropNotNull(column) {
+		this.actions.push({
+			type: "dropNotNull",
+			column
+		});
+		return this;
+	}
+	/**
+	* Set or change the DEFAULT value for a column.
+	*
+	* @param column - The column name.
+	* @param defaultValue - The new default value as a raw SQL expression.
+	* @returns `this` for chaining.
+	*/
+	setDefault(column, defaultValue) {
+		this.actions.push({
+			type: "setDefault",
+			column,
+			defaultValue
+		});
+		return this;
+	}
+	/**
+	* Drop the DEFAULT value from a column.
+	*
+	* @param column - The column name.
+	* @returns `this` for chaining.
+	*/
+	dropDefault(column) {
+		this.actions.push({
+			type: "dropDefault",
+			column
+		});
+		return this;
+	}
+	/**
+	* Add a CHECK constraint to the table.
+	*
+	* @param name - Constraint name.
+	* @param expr - The check expression.
+	* @returns `this` for chaining.
+	*/
+	addCheck(name, expr) {
+		this.actions.push({
+			type: "addCheck",
+			name,
+			expr
+		});
+		return this;
+	}
+	/**
+	* Add a table-level UNIQUE constraint spanning one or more columns.
+	*
+	* @param name - Constraint name.
+	* @param columns - Column names that form the unique key.
+	* @returns `this` for chaining.
+	*/
+	addUniqueConstraint(name, columns) {
+		this.actions.push({
+			type: "addUniqueConstraint",
+			name,
+			columns
+		});
+		return this;
+	}
+	/**
+	* Add a composite PRIMARY KEY constraint.
+	*
+	* @param name - Constraint name.
+	* @param columns - Column names that form the primary key.
+	* @returns `this` for chaining.
+	*/
+	addPrimaryKeyConstraint(name, columns) {
+		this.actions.push({
+			type: "addPrimaryKeyConstraint",
+			name,
+			columns
+		});
+		return this;
+	}
+	toSQL() {
+		const relation = buildRelation(this.schema, this.name);
+		const statements = [];
+		for (const action of this.actions) switch (action.type) {
+			case "addColumn":
+				statements.push(`ALTER TABLE ${relation} ADD COLUMN ${toColumnDef(action.name, action.colType, action.options)};`);
+				break;
+			case "dropColumn":
+				statements.push(`ALTER TABLE ${relation} DROP COLUMN "${action.name}";`);
+				break;
+			case "renameColumn":
+				statements.push(`ALTER TABLE ${relation} RENAME COLUMN "${action.oldName}" TO "${action.newName}";`);
+				break;
+			case "alterColumnType":
+				statements.push(`ALTER TABLE ${relation} ALTER COLUMN "${action.name}" TYPE ${action.newType};`);
+				break;
+			case "addUnique":
+				statements.push(`ALTER TABLE ${relation} ADD UNIQUE (${action.column});`);
+				break;
+			case "dropConstraint":
+				statements.push(`ALTER TABLE ${relation} DROP CONSTRAINT ${action.name};`);
+				break;
+			case "setNotNull":
+				statements.push(`ALTER TABLE ${relation} ALTER COLUMN "${action.column}" SET NOT NULL;`);
+				break;
+			case "dropNotNull":
+				statements.push(`ALTER TABLE ${relation} ALTER COLUMN "${action.column}" DROP NOT NULL;`);
+				break;
+			case "setDefault":
+				statements.push(`ALTER TABLE ${relation} ALTER COLUMN "${action.column}" SET DEFAULT '${action.defaultValue}';`);
+				break;
+			case "dropDefault":
+				statements.push(`ALTER TABLE ${relation} ALTER COLUMN "${action.column}" DROP DEFAULT;`);
+				break;
+			case "addCheck":
+				statements.push(`ALTER TABLE ${relation} ADD CONSTRAINT ${action.name} CHECK (${snapshotExprToSQL(action.expr)});`);
+				break;
+			case "addUniqueConstraint": {
+				const cols = action.columns.map((c) => `"${c}"`).join(", ");
+				statements.push(`ALTER TABLE ${relation} ADD CONSTRAINT ${action.name} UNIQUE (${cols});`);
+				break;
+			}
+			case "addPrimaryKeyConstraint": {
+				const cols = action.columns.map((c) => `"${c}"`).join(", ");
+				statements.push(`ALTER TABLE ${relation} ADD CONSTRAINT ${action.name} PRIMARY KEY (${cols});`);
+				break;
+			}
+		}
+		return statements.join("\n");
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		const table = snapshot.tables[key];
+		if (!table) return;
+		for (const action of this.actions) switch (action.type) {
+			case "addColumn": {
+				const colSnapshot = { type: action.colType };
+				if (action.options.notNull) colSnapshot.notNull = true;
+				if (action.options.primaryKey) colSnapshot.primaryKey = true;
+				if (action.options.unique) colSnapshot.unique = true;
+				if (action.options.default !== void 0) colSnapshot.default = action.options.default;
+				if (action.options.generated) colSnapshot.generated = action.options.generated;
+				if (action.options.as) colSnapshot.as = action.options.as;
+				if (action.options.references) colSnapshot.references = {
+					schema: action.options.references.schema,
+					table: action.options.references.table,
+					column: action.options.references.column,
+					onDelete: action.options.references.onDelete
+				};
+				table.columns[action.name] = colSnapshot;
+				break;
+			}
+			case "dropColumn":
+				delete table.columns[action.name];
+				break;
+			case "renameColumn": {
+				const col = table.columns[action.oldName];
+				if (col) {
+					table.columns[action.newName] = col;
+					delete table.columns[action.oldName];
+				}
+				break;
+			}
+			case "alterColumnType":
+				if (table.columns[action.name]) table.columns[action.name].type = action.newType;
+				break;
+			case "addUnique":
+				if (table.columns[action.column]) table.columns[action.column].unique = true;
+				break;
+			case "dropConstraint":
+				if (action.name.endsWith("_key")) {
+					const colName = action.name.replace(`${this.name}_`, "").replace("_key", "");
+					if (table.columns[colName]) delete table.columns[colName].unique;
+				}
+				delete table.checkConstraints[action.name];
+				if (table.uniqueConstraints) delete table.uniqueConstraints[action.name];
+				if (table.primaryKeyConstraint && table.primaryKeyConstraint.name === action.name) delete table.primaryKeyConstraint;
+				break;
+			case "setNotNull":
+				if (table.columns[action.column]) table.columns[action.column].notNull = true;
+				break;
+			case "dropNotNull":
+				if (table.columns[action.column]) delete table.columns[action.column].notNull;
+				break;
+			case "setDefault":
+				if (table.columns[action.column]) table.columns[action.column].default = action.defaultValue;
+				break;
+			case "dropDefault":
+				if (table.columns[action.column]) delete table.columns[action.column].default;
+				break;
+			case "addCheck": {
+				const tableKey = `${this.schema}.${this.name}`;
+				table.checkConstraints[action.name] = {
+					name: action.name,
+					table: tableKey,
+					expr: action.expr
+				};
+				break;
+			}
+			case "addUniqueConstraint": {
+				const tableKey = `${this.schema}.${this.name}`;
+				if (!table.uniqueConstraints) table.uniqueConstraints = {};
+				table.uniqueConstraints[action.name] = {
+					name: action.name,
+					table: tableKey,
+					columns: [...action.columns]
+				};
+				break;
+			}
+			case "addPrimaryKeyConstraint": {
+				const tableKey = `${this.schema}.${this.name}`;
+				table.primaryKeyConstraint = {
+					name: action.name,
+					table: tableKey,
+					columns: [...action.columns]
+				};
+				break;
+			}
+		}
+	}
+};
+/**
+* Chainable builder that constructs a `CREATE INDEX` DDL statement.
+*
+* Use {@link ddl.createIndex} to obtain an instance, then chain `.on()`,
+* and optionally `.using()` and `.unique()`.
+*
+* @example
+* ```typescript
+* ddl.createIndex('idx_users_email')
+*   .on('public', 'users', ['email'])
+*   .using('btree')
+*   .unique();
+* // CREATE UNIQUE INDEX idx_users_email ON "public"."users" USING btree ("email");
+* ```
+*/
+var CreateIndexBuilder = class extends DDLStatement {
+	type = "createIndex";
+	tableSchema = "";
+	tableName = "";
+	indexType = "btree";
+	indexColumns = [];
+	isUnique = false;
+	isConcurrent = false;
+	/**
+	* @param indexName - The name of the index to create.
+	*/
+	constructor(indexName) {
+		super();
+		this.indexName = indexName;
+	}
+	/**
+	* Build the index concurrently, without locking writes on the table.
+	*
+	* Generates: `CREATE INDEX CONCURRENTLY ...`
+	*
+	* @remarks
+	* Concurrent index creation cannot run inside a transaction.
+	* Set `transaction: false` in your migration options when using this.
+	*
+	* @returns `this` for chaining.
+	*/
+	concurrently() {
+		this.isConcurrent = true;
+		return this;
+	}
+	/**
+	* Specify the table and columns this index is created on.
+	*
+	* @param schema - The table's schema.
+	* @param table - The table name.
+	* @param columns - Optional array of column names to index.
+	* @returns `this` for chaining.
+	*/
+	on(schema, table, columns) {
+		this.tableSchema = schema;
+		this.tableName = table;
+		if (columns) this.indexColumns = columns;
+		return this;
+	}
+	/**
+	* Specify the index method.
+	*
+	* @param type - The index type (`"btree"`, `"hash"`, `"gin"`, `"gist"`, etc.).
+	* @param columns - Optional array of column names to index.
+	* @returns `this` for chaining.
+	*/
+	using(type, columns) {
+		this.indexType = type;
+		if (columns) this.indexColumns = columns;
+		return this;
+	}
+	/**
+	* Make this a unique index.
+	*
+	* @returns `this` for chaining.
+	*/
+	unique() {
+		this.isUnique = true;
+		return this;
+	}
+	toSQL() {
+		const tableRelation = buildRelation(this.tableSchema, this.tableName);
+		const columns = this.indexColumns.map((c) => `"${c}"`).join(", ");
+		return `CREATE${this.isUnique ? " UNIQUE" : ""} INDEX${this.isConcurrent ? " CONCURRENTLY" : ""} ${this.indexName} ON ${tableRelation} USING ${this.indexType} (${columns});`;
+	}
+	applyToSnapshot(snapshot) {
+		const tableKey = `${this.tableSchema}.${this.tableName}`;
+		const table = snapshot.tables[tableKey];
+		if (!table) return;
+		table.indexes[this.indexName] = {
+			name: this.indexName,
+			table: tableKey,
+			columns: [...this.indexColumns],
+			type: this.indexType,
+			unique: this.isUnique
+		};
+	}
+};
+/**
+* DDL statement builder that drops an existing index.
+*
+* Generates: `DROP INDEX [CONCURRENTLY] <name>;`
+*
+* @example
+* ```typescript
+* ddl.dropIndex('idx_users_email');
+* // DROP INDEX idx_users_email;
+*
+* ddl.dropIndex('idx_users_email').concurrently();
+* // DROP INDEX CONCURRENTLY idx_users_email;
+* ```
+*/
+var DropIndexStatement = class extends DDLStatement {
+	type = "dropIndex";
+	isConcurrent = false;
+	/**
+	* @param indexName - The name of the index to drop.
+	*/
+	constructor(indexName) {
+		super();
+		this.indexName = indexName;
+	}
+	/**
+	* Drop the index concurrently, without locking writes on the table.
+	*
+	* Generates: `DROP INDEX CONCURRENTLY ...`
+	*
+	* @remarks
+	* Concurrent index drops cannot run inside a transaction.
+	* Set `transaction: false` in your migration options when using this.
+	*
+	* @returns `this` for chaining.
+	*/
+	concurrently() {
+		this.isConcurrent = true;
+		return this;
+	}
+	toSQL() {
+		return `DROP INDEX${this.isConcurrent ? " CONCURRENTLY" : ""} ${this.indexName};`;
+	}
+	applyToSnapshot(snapshot) {
+		for (const table of Object.values(snapshot.tables)) if (table.indexes[this.indexName]) {
+			delete table.indexes[this.indexName];
+			break;
+		}
+	}
+};
+/**
+* The main DDL builder entry point.
+*
+* Provides factory methods for all supported DDL operations.
+* Import from `durcno/migration` and use in migration files.
+*
+* @example
+* ```typescript
+* import { ddl, type DDLStatement } from 'durcno/migration';
+*
+* export const statements: DDLStatement[] = [
+*   ddl.createEnum('public', 'user_type', ['admin', 'user']),
+*   ddl.createTable('public', 'users')
+*     .column('id', 'serial', { primaryKey: true })
+*     .column('name', 'varchar(255)', { notNull: true }),
+* ];
+* ```
+*/
+const ddl = {
+	createSchema(name) {
+		return new CreateSchemaStatement(name);
+	},
+	dropSchema(name) {
+		return new DropSchemaStatement(name);
+	},
+	createEnum(schema, name, values) {
+		return new CreateEnumStatement(schema, name, values);
+	},
+	alterEnumAddValue(schema, name, value, position) {
+		return new AlterEnumAddValueStatement(schema, name, value, position);
+	},
+	dropEnum(schema, name) {
+		return new DropEnumStatement(schema, name);
+	},
+	createSequence(schema, name, options) {
+		return new CreateSequenceStatement(schema, name, options);
+	},
+	dropSequence(schema, name) {
+		return new DropSequenceStatement(schema, name);
+	},
+	createTable(schema, name) {
+		return new CreateTableBuilder(schema, name);
+	},
+	dropTable(schema, name) {
+		return new DropTableStatement(schema, name);
+	},
+	renameTable(schema, oldName, newName) {
+		return new RenameTableStatement(schema, oldName, newName);
+	},
+	alterTable(schema, name) {
+		return new AlterTableBuilder(schema, name);
+	},
+	createIndex(name) {
+		return new CreateIndexBuilder(name);
+	},
+	dropIndex(name) {
+		return new DropIndexStatement(name);
+	},
+	custom(sql) {
+		return new CustomStatement(sql);
+	}
+};
+//#endregion
+export { ddl };