orchid-orm 1.78.12 → 1.78.13

package/dist/migrations/index.mjs

@@ -1,140 +1,26 @@
-import { astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, getTableFactoryConfig, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCommands, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile } from "rake-db";
+import { RakeDbError, astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, getTableFactoryConfig, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCommands, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile } from "rake-db";
 import { ArrayColumn, DomainColumn, EnumColumn, RawSql, UnknownColumn, VirtualColumn, addCode, codeToString, colors, columnsShapeToCode, constraintToCode, deepCompare, emptyArray, emptyObject, excludeToCode, exhaustive, getColumnBaseType, getDriverErrorCode, getForeignKeyTableInstance, getFreeSetAlias, getImportPath, getQuerySchema, getSupportedDefaultPrivileges, indexToCode, pathToLog, pluralize, primaryKeyInnerToCode, queryToSql, quoteObjectKey, raw, rawSqlToSql, singleQuote, sqlToRawSql, toArray, toCamelCase, toPascalCase, toSnakeCase } from "pqb/internal";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import fs from "node:fs/promises";
 export * from "rake-db";
-const viewDataToSql = (viewData, viewName) => {
-	return sqlToRawSql(viewDataToQuerySql(viewData, viewName));
-};
-const viewDataToQuerySql = (viewData, viewName) => {
-	if (viewData.query) return queryToSql(viewData.query);
-	if (viewData.sql !== void 0) return rawSqlToSql(viewData.sql);
-	throw new Error(`Either sql or query is required for view ${viewName}`);
-};
-const compareSqlExpressions = async (expressions, adapter) => {
-	if (!expressions.length) return;
-	let id = 1;
-	for (const { source, compare, handle } of expressions) {
-		const viewName = `orchidTmpView${id++}`;
-		const values = [];
-		const combinedQueries = [
-			`CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(({ inDb, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map((s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`).join(", ")}`).join(", ")}${source ? ` FROM ${source}` : ""})`,
-			`SELECT pg_get_viewdef('${viewName}') v`,
-			`DROP VIEW ${viewName}`
-		].join("; ");
-		const query = () => adapter.query(combinedQueries, values);
-		const result = await (adapter.isInTransaction() ? adapter.savepoint(viewName, void 0, query) : query()).then((res) => res[1], async (err) => {
-			if (typeof err === "object" && getDriverErrorCode(err) !== "42704") throw err;
-		});
-		if (!result) {
-			handle();
-			return;
-		}
-		handle(compareSqlExpressionResult(result.rows[0].v, compare[0].inCode));
-	}
-};
-const compareViewsExpressions = async (adapter, compare) => {
-	if (!compare.length) return;
-	const queries = [];
-	let id = 1;
-	compare.forEach(({ inCode, ast }, i) => {
-		const viewName = `orchidTmpView${id++}ForViews`;
-		queries.push({ batch: [
-			`SAVEPOINT "${viewName}S"`,
-			`CREATE TEMPORARY${"recursive" in ast.options && ast.options.recursive ? " RECURSIVE" : ""} VIEW "${viewName}" (${ast.options.columns?.map((column) => `"${column}"`).join(", ")}) AS (${inCode})`,
-			`SELECT ${i} i, '${viewName}' v, pg_get_viewdef('"${viewName}"') sql`,
-			`DROP VIEW "${viewName}"`,
-			`RELEASE SAVEPOINT "${viewName}S"`
-		] });
-	});
-	let results;
-	try {
-		const sql = queries.flatMap((q) => q.batch).join(";");
-		const query = () => adapter.query(sql, []);
-		results = await (adapter.isInTransaction() ? adapter.savepoint("orchidOrmGeneratorViews", void 0, query) : query());
-	} catch {
-		results = (await Promise.all(queries.map(async ({ batch: queries }, i) => {
-			const sql = queries.join(";");
-			const query = () => adapter.query(sql, []);
-			return await (adapter.isInTransaction() ? adapter.savepoint(`orchidOrmGeneratorViews${i}`, void 0, query) : query()).catch((err) => {
-				if (typeof err === "object") {
-					const code = getDriverErrorCode(err);
-					if (code === "42703" || code === "42704" || code === "42P01") return [];
-				}
-				throw err;
-			});
-		}))).flat();
-	}
-	const handled = /* @__PURE__ */ new Set();
-	for (const result of results) for (const row of result.rows) if ("sql" in row) {
-		const { i, v } = row;
-		const cmp = compare[i];
-		const hasQuote = !!cmp.inDb.match(/\w*WITH RECURSIVE "/);
-		if (row.sql.replaceAll(hasQuote ? v : `"${v}"`, cmp.ast.name) !== cmp.inDb) cmp.onNotEqual();
-		handled.add(i);
-	}
-	compare.forEach((cmp, i) => {
-		if (!handled.has(i)) cmp.onNotEqual();
-	});
-};
-const compareSqlExpressionResult = (resultSql, inCode) => {
-	let pos = 7;
-	const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
-	let match;
-	let inDb = "";
-	let codeI = 0;
-	const matches = inCode.map(() => true);
-	while (match = rgx.exec(resultSql)) {
-		const sql = resultSql.slice(pos, rgx.lastIndex - match[0].length).trim();
-		if (match[1].split("-").length === 2) {
-			inDb = sql;
-			codeI = 0;
-		} else {
-			if (inDb !== sql && !(inDb.startsWith("(") && inDb.endsWith(")") && inDb.slice(1, -1) === sql) && !(sql.startsWith("(") && sql.endsWith(")") && sql.slice(1, -1) === inDb)) matches[codeI] = false;
-			codeI++;
-		}
-		pos = rgx.lastIndex;
-	}
-	const firstMatching = matches.indexOf(true);
-	return firstMatching === -1 ? void 0 : firstMatching;
-};
-const promptCreateOrRename = (kind, name, drop, verifying) => {
-	if (verifying) throw new AbortSignal();
-	let hintPos = name.length + 4;
-	for (const from of drop) {
-		const value = from.length + 8 + name.length;
-		if (value > hintPos) hintPos = value;
-	}
-	let max = 0;
-	const add = name.length + 3;
-	for (const name of drop) if (name.length + add > max) max = name.length + add;
-	const renameMessage = `rename ${kind}`;
-	return promptSelect({
-		message: `Create or rename ${colors.blueBold(name)} ${kind} from another ${kind}?`,
-		options: [`${colors.greenBold("+")} ${name}  ${colors.pale(`create ${kind}`.padStart(hintPos + renameMessage.length - name.length - 4, " "))}`, ...drop.map((d) => `${colors.yellowBold("~")} ${d} ${colors.yellowBold("=>")} ${name}  ${colors.pale(renameMessage.padStart(hintPos + renameMessage.length - d.length - name.length - 8, " "))}`)]
-	});
-};
-const checkForColumnAddOrDrop = (shape, key) => {
-	const item = shape[key];
-	if (item) return item && (Array.isArray(item) || item.type === "add" || item.type === "drop");
-	for (const k in shape) {
-		const item = shape[k];
-		if (Array.isArray(item) ? item.some((item) => (item.type === "add" || item.type === "drop") && item.item.data.name === key) : (item.type === "add" || item.type === "drop") && item.item.data.name === key) return true;
-	}
-	return false;
-};
-const processSchemas = async (ast, dbStructure, { codeItems: { schemas }, verifying, internal: { generatorIgnore }, currentSchema }) => {
+const processSchemas = async (ast, dbStructure, { codeItems: { schemas }, internal: { generatorIgnore }, currentSchema }, { decider }) => {
 	const createSchemas = [];
 	const dropSchemas = [];
 	for (const schema of schemas) if (!dbStructure.schemas.includes(schema)) createSchemas.push(schema);
 	for (const schema of dbStructure.schemas) if (!schemas.has(schema) && schema !== "public" && schema !== currentSchema && !generatorIgnore?.schemas?.includes(schema)) dropSchemas.push(schema);
 	for (const schema of createSchemas) {
 		if (dropSchemas.length) {
-			const i = await promptCreateOrRename("schema", schema, dropSchemas, verifying);
-			if (i) {
-				const from = dropSchemas[i - 1];
-				dropSchemas.splice(i - 1, 1);
+			const from = await decider.createOrRename({
+				kind: "schema",
+				target: { name: schema },
+				candidates: dropSchemas,
+				candidateSource: (x) => ({ name: x }),
+				name: schema,
+				candidateName: (x) => x
+			});
+			if (from) {
+				dropSchemas.splice(dropSchemas.indexOf(from), 1);
 				const views = dbStructure.views || [];
 				renameSchemaInStructures(dbStructure.tables, from, schema);
 				renameSchemaInStructures(views, from, schema);
@@ -206,12 +92,12 @@ const processExtensions = (ast, dbStructure, { currentSchema, internal: { extens
 		...ext
 	})));
 };
-const processColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, verifying) => {
+const processColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, decisionCtx) => {
 	const { dbTable } = changeTableData;
 	const dbColumns = Object.fromEntries(dbTable.columns.map((column) => [column.name, column]));
 	const { columnsToAdd, columnsToDrop, columnsToChange } = groupColumns(structureToAstCtx, dbStructure, domainsMap, dbColumns, changeTableData);
-	await addOrRenameColumns(config, dbStructure, changeTableData, columnsToAdd, columnsToDrop, columnsToChange, verifying);
-	await changeColumns(adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying);
+	await addOrRenameColumns(config, dbStructure, changeTableData, columnsToAdd, columnsToDrop, columnsToChange, decisionCtx);
+	await changeColumns(adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, decisionCtx);
 	dropColumns(changeTableData, columnsToDrop);
 };
 const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, changeTableData) => {
@@ -251,14 +137,21 @@ const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, cha
 		columnsToChange
 	};
 };
-const addOrRenameColumns = async (config, dbStructure, { dbTableData, schema, changeTableAst: { name: tableName, shape } }, columnsToAdd, columnsToDrop, columnsToChange, verifying) => {
+const addOrRenameColumns = async (config, dbStructure, changeTableData, columnsToAdd, columnsToDrop, columnsToChange, decisionCtx) => {
+	const { dbTableData, schema, changeTableAst: { name: tableName, shape } } = changeTableData;
 	for (const { key, column } of columnsToAdd) {
 		if (columnsToDrop.length) {
 			const codeName = column.data.name ?? key;
-			const i = await promptCreateOrRename("column", codeName, columnsToDrop.map((x) => x.key), verifying);
-			if (i) {
-				const drop = columnsToDrop[i - 1];
-				columnsToDrop.splice(i - 1, 1);
+			const drop = await decisionCtx.decider.createOrRename({
+				kind: "column",
+				target: codeColumnTarget(changeTableData, codeName),
+				candidates: columnsToDrop,
+				candidateSource: (x) => dbColumnSource(decisionCtx, changeTableData, x.column.data.name ?? x.key),
+				name: codeName,
+				candidateName: (x) => x.key
+			});
+			if (drop) {
+				columnsToDrop.splice(columnsToDrop.indexOf(drop), 1);
 				const from = drop.column.data.name ?? drop.key;
 				columnsToChange.set(from, {
 					key,
@@ -289,11 +182,11 @@ const dropColumns = ({ changeTableAst: { shape } }, columnsToDrop) => {
 		item: column
 	};
 };
-const changeColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying) => {
+const changeColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, decisionCtx) => {
 	for (const [key, { key: codeKey, dbName, column: codeColumn }] of columnsToChange) {
 		const dbColumnStructure = dbColumns[dbName];
 		const dbColumn = instantiateDbColumn(structureToAstCtx, dbStructure, domainsMap, dbColumnStructure);
-		const action = await compareColumns(adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, verifying, key, dbName, dbColumn, codeColumn);
+		const action = await compareColumns(adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, decisionCtx, key, dbName, codeColumn.data.name ?? codeKey, dbColumn, codeColumn);
 		if (action === "change") changeColumn(changeTableData, key, dbName, dbColumn, codeColumn);
 		else if (action === "recreate") changeTableData.changeTableAst.shape[key] = [{
 			type: "drop",
@@ -311,7 +204,7 @@ const changeColumns = async (adapter, config, structureToAstCtx, dbStructure, do
 		}
 	}
 };
-const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, verifying, key, dbName, dbColumn, codeColumn) => {
+const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSql, changeTableData, typeCastsCache, decisionCtx, key, dbName, codeName, dbColumn, codeColumn) => {
 	const maybeArrayDbColumn = dbColumn;
 	const maybeArrayCodeColumn = codeColumn;
 	if (dbColumn instanceof ArrayColumn && codeColumn instanceof ArrayColumn) {
@@ -326,11 +219,13 @@ const compareColumns = async (adapter, domainsMap, ast, currentSchema, compareSq
 		const codeBaseType = getColumnBaseType(codeColumn, domainsMap, codeType);
 		if (!typeCasts.get(dbBaseType)?.has(codeBaseType)) {
 			if (!(dbColumn instanceof EnumColumn) || !(codeColumn instanceof EnumColumn) || !deepCompare(dbColumn.options, codeColumn.options)) {
-				if (verifying) throw new AbortSignal();
-				const tableName = concatSchemaAndName(changeTableData.changeTableAst);
-				if (await promptSelect({
-					message: `Cannot cast type of ${tableName}'s column ${key} from ${dbType} to ${codeType}`,
-					options: [`${colors.yellowBold(`-/+`)} recreate the column, existing data will be ${colors.red("lost")}`, `write migration manually`]
+				if (!await decisionCtx.decider.recreateColumn({
+					source: dbColumnSource(decisionCtx, changeTableData, dbName),
+					target: codeColumnTarget(changeTableData, codeName),
+					tableName: concatSchemaAndName(changeTableData.changeTableAst),
+					columnName: key,
+					fromType: dbType,
+					toType: codeType
 				})) throw new AbortSignal();
 				dbColumn.data.name = codeColumn.data.name;
 				return "recreate";
@@ -445,6 +340,19 @@ const changeColumn = (changeTableData, key, dbName, dbColumn, codeColumn) => {
 		to: { column: simpleCodeColumn }
 	};
 };
+const dbColumnSource = (decisionCtx, { dbTable }, name) => {
+	const { schema, name: table } = decisionCtx.dbSource(dbTable);
+	return {
+		schema,
+		table,
+		name
+	};
+};
+const codeColumnTarget = ({ schema, changeTableAst }, name) => ({
+	schema,
+	table: changeTableAst.name,
+	name
+});
 const getColumnDbType = (column, currentSchema) => {
 	if (column instanceof EnumColumn) {
 		const [schema = currentSchema, name] = getSchemaAndTableFromName(currentSchema, column.enumName);
@@ -464,6 +372,110 @@ const getColumnDbType = (column, currentSchema) => {
 const renameColumn = (columns, from, to) => {
 	for (let i = 0; i < columns.length; i++) if (columns[i] === from) columns[i] = to;
 };
+const viewDataToSql = (viewData, viewName) => {
+	return sqlToRawSql(viewDataToQuerySql(viewData, viewName));
+};
+const viewDataToQuerySql = (viewData, viewName) => {
+	if (viewData.query) return queryToSql(viewData.query);
+	if (viewData.sql !== void 0) return rawSqlToSql(viewData.sql);
+	throw new Error(`Either sql or query is required for view ${viewName}`);
+};
+const compareSqlExpressions = async (expressions, adapter) => {
+	if (!expressions.length) return;
+	let id = 1;
+	for (const { source, compare, handle } of expressions) {
+		const viewName = `orchidTmpView${id++}`;
+		const values = [];
+		const combinedQueries = [
+			`CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(({ inDb, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map((s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`).join(", ")}`).join(", ")}${source ? ` FROM ${source}` : ""})`,
+			`SELECT pg_get_viewdef('${viewName}') v`,
+			`DROP VIEW ${viewName}`
+		].join("; ");
+		const query = () => adapter.query(combinedQueries, values);
+		const result = await (adapter.isInTransaction() ? adapter.savepoint(viewName, void 0, query) : query()).then((res) => res[1], async (err) => {
+			if (typeof err === "object" && getDriverErrorCode(err) !== "42704") throw err;
+		});
+		if (!result) {
+			handle();
+			return;
+		}
+		handle(compareSqlExpressionResult(result.rows[0].v, compare[0].inCode));
+	}
+};
+const compareViewsExpressions = async (adapter, compare) => {
+	if (!compare.length) return;
+	const queries = [];
+	let id = 1;
+	compare.forEach(({ inCode, ast }, i) => {
+		const viewName = `orchidTmpView${id++}ForViews`;
+		queries.push({ batch: [
+			`SAVEPOINT "${viewName}S"`,
+			`CREATE TEMPORARY${"recursive" in ast.options && ast.options.recursive ? " RECURSIVE" : ""} VIEW "${viewName}" (${ast.options.columns?.map((column) => `"${column}"`).join(", ")}) AS (${inCode})`,
+			`SELECT ${i} i, '${viewName}' v, pg_get_viewdef('"${viewName}"') sql`,
+			`DROP VIEW "${viewName}"`,
+			`RELEASE SAVEPOINT "${viewName}S"`
+		] });
+	});
+	let results;
+	try {
+		const sql = queries.flatMap((q) => q.batch).join(";");
+		const query = () => adapter.query(sql, []);
+		results = await (adapter.isInTransaction() ? adapter.savepoint("orchidOrmGeneratorViews", void 0, query) : query());
+	} catch {
+		results = (await Promise.all(queries.map(async ({ batch: queries }, i) => {
+			const sql = queries.join(";");
+			const query = () => adapter.query(sql, []);
+			return await (adapter.isInTransaction() ? adapter.savepoint(`orchidOrmGeneratorViews${i}`, void 0, query) : query()).catch((err) => {
+				if (typeof err === "object") {
+					const code = getDriverErrorCode(err);
+					if (code === "42703" || code === "42704" || code === "42P01") return [];
+				}
+				throw err;
+			});
+		}))).flat();
+	}
+	const handled = /* @__PURE__ */ new Set();
+	for (const result of results) for (const row of result.rows) if ("sql" in row) {
+		const { i, v } = row;
+		const cmp = compare[i];
+		const hasQuote = !!cmp.inDb.match(/\w*WITH RECURSIVE "/);
+		if (row.sql.replaceAll(hasQuote ? v : `"${v}"`, cmp.ast.name) !== cmp.inDb) cmp.onNotEqual();
+		handled.add(i);
+	}
+	compare.forEach((cmp, i) => {
+		if (!handled.has(i)) cmp.onNotEqual();
+	});
+};
+const compareSqlExpressionResult = (resultSql, inCode) => {
+	let pos = 7;
+	const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
+	let match;
+	let inDb = "";
+	let codeI = 0;
+	const matches = inCode.map(() => true);
+	while (match = rgx.exec(resultSql)) {
+		const sql = resultSql.slice(pos, rgx.lastIndex - match[0].length).trim();
+		if (match[1].split("-").length === 2) {
+			inDb = sql;
+			codeI = 0;
+		} else {
+			if (inDb !== sql && !(inDb.startsWith("(") && inDb.endsWith(")") && inDb.slice(1, -1) === sql) && !(sql.startsWith("(") && sql.endsWith(")") && sql.slice(1, -1) === inDb)) matches[codeI] = false;
+			codeI++;
+		}
+		pos = rgx.lastIndex;
+	}
+	const firstMatching = matches.indexOf(true);
+	return firstMatching === -1 ? void 0 : firstMatching;
+};
+const checkForColumnAddOrDrop = (shape, key) => {
+	const item = shape[key];
+	if (item) return item && (Array.isArray(item) || item.type === "add" || item.type === "drop");
+	for (const k in shape) {
+		const item = shape[k];
+		if (Array.isArray(item) ? item.some((item) => (item.type === "add" || item.type === "drop") && item.item.data.name === key) : (item.type === "add" || item.type === "drop") && item.item.data.name === key) return true;
+	}
+	return false;
+};
 const processDomains = async (ast, adapter, domainsMap, dbStructure, { codeItems: { domains }, structureToAstCtx, currentSchema, internal: { generatorIgnore } }, pendingDbTypes) => {
 	const codeDomains = [];
 	if (domains) for (const { schemaName, name, column } of domains) codeDomains.push(makeComparableDomain(currentSchema, schemaName, name, column));
@@ -594,7 +606,7 @@ const createAst = (codeDomain) => ({
 	name: codeDomain.name,
 	baseType: codeDomain.column
 });
-const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSchema, verifying, internal: { generatorIgnore } }, pendingDbTypes) => {
+const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSchema, internal: { generatorIgnore } }, decisionCtx, pendingDbTypes) => {
 	const createEnums = [];
 	const dropEnums = [];
 	for (const [, codeEnum] of enums) {
@@ -605,7 +617,7 @@ const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSch
 		if (generatorIgnore?.schemas?.includes(dbEnum.schemaName) || generatorIgnore?.enums?.includes(dbEnum.name)) continue;
 		const codeEnum = enums.get(`${dbEnum.schemaName}.${dbEnum.name}`);
 		if (codeEnum) {
-			await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, verifying);
+			await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, decisionCtx, currentSchema);
 			continue;
 		}
 		const i = createEnums.findIndex((x) => x.name === dbEnum.name);
@@ -624,17 +636,26 @@ const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSch
 				to: dbEnum.name
 			});
 			pendingDbTypes.add(toSchema, dbEnum.name);
-			await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, verifying);
+			await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, decisionCtx, currentSchema);
 			continue;
 		}
 		dropEnums.push(dbEnum);
 	}
 	for (const codeEnum of createEnums) {
 		if (dropEnums.length) {
-			const i = await promptCreateOrRename("enum", codeEnum.name, dropEnums.map((x) => x.name), verifying);
-			if (i) {
-				const dbEnum = dropEnums[i - 1];
-				dropEnums.splice(i - 1, 1);
+			const dbEnum = await decisionCtx.decider.createOrRename({
+				kind: "enum",
+				target: {
+					schema: codeEnum.schema ?? currentSchema,
+					name: codeEnum.name
+				},
+				candidates: dropEnums,
+				candidateSource: (x) => decisionCtx.dbSource(x),
+				name: codeEnum.name,
+				candidateName: (x) => x.name
+			});
+			if (dbEnum) {
+				dropEnums.splice(dropEnums.indexOf(dbEnum), 1);
 				const fromSchema = dbEnum.schemaName;
 				const from = dbEnum.name;
 				const toSchema = codeEnum.schema ?? currentSchema;
@@ -650,7 +671,7 @@ const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSch
 					to
 				});
 				pendingDbTypes.add(toSchema, to);
-				await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, verifying);
+				await changeEnum(ast, dbEnum, codeEnum, pendingDbTypes, decisionCtx, currentSchema);
 				continue;
 			}
 		}
@@ -669,7 +690,7 @@ const processEnums = async (ast, dbStructure, { codeItems: { enums }, currentSch
 		values: dbEnum.values
 	});
 };
-const changeEnum = async (ast, dbEnum, codeEnum, pendingDbTypes, verifying) => {
+const changeEnum = async (ast, dbEnum, codeEnum, pendingDbTypes, decisionCtx, currentSchema) => {
 	const { values: dbValues } = dbEnum;
 	const { values: codeValues, schema, name } = codeEnum;
 	const addValues = codeValues.filter((value) => !dbValues.includes(value));
@@ -699,7 +720,14 @@ const changeEnum = async (ast, dbEnum, codeEnum, pendingDbTypes, verifying) => {
 			return;
 		}
 	} else if (!dropValues.length) return;
-	const enumValueChanges = await promptEnumValueChanges(name, dbValues, codeValues, addValues, dropValues, verifying);
+	const enumValueChanges = await resolveEnumValueChanges({
+		source: decisionCtx.dbSource(dbEnum),
+		target: {
+			schema: schema ?? currentSchema,
+			name
+		},
+		enumName: name
+	}, dbValues, codeValues, addValues, dropValues, decisionCtx.decider);
 	if (enumValueChanges) {
 		let changed = false;
 		if (Object.keys(enumValueChanges.renamedValues).length) {
@@ -735,19 +763,18 @@ const changeEnum = async (ast, dbEnum, codeEnum, pendingDbTypes, verifying) => {
 	});
 	pendingDbTypes.add(schema, name);
 };
-const promptEnumValueChanges = async (enumName, dbValues, codeValues, addValues, dropValues, verifying) => {
+const resolveEnumValueChanges = async (enumQuestion, dbValues, codeValues, addValues, dropValues, decider) => {
 	if (!addValues.length || !dropValues.length) return;
 	const renamedValues = {};
 	const remainingDropValues = [...dropValues];
 	for (const value of addValues) if (remainingDropValues.length) {
-		if (verifying) throw new AbortSignal();
-		const i = await promptSelect({
-			message: `Add or rename ${colors.blueBold(value)} enum value in ${colors.blueBold(enumName)}?`,
-			options: [`${colors.greenBold("+")} ${value}  ${colors.pale("add enum value")}`, ...remainingDropValues.map((dropValue) => `${colors.yellowBold("~")} ${dropValue} ${colors.yellowBold("=>")} ${value}  ${colors.pale("rename enum value")}`)]
+		const dropValue = await decider.addOrRenameEnumValue({
+			...enumQuestion,
+			value,
+			candidates: remainingDropValues
 		});
-		if (i) {
-			const dropValue = remainingDropValues[i - 1];
-			remainingDropValues.splice(i - 1, 1);
+		if (dropValue !== void 0) {
+			remainingDropValues.splice(remainingDropValues.indexOf(dropValue), 1);
 			renamedValues[dropValue] = value;
 		}
 	}
@@ -1721,7 +1748,7 @@ const isSameStringArray = (a, b) => {
 	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 	return true;
 };
-const processTables = async (ast, domainsMap, adapter, dbStructure, config, { structureToAstCtx, codeItems: { tables }, currentSchema, internal: { generatorIgnore }, verifying }, pendingDbTypes) => {
+const processTables = async (ast, domainsMap, adapter, dbStructure, config, { structureToAstCtx, codeItems: { tables }, currentSchema, internal: { generatorIgnore } }, decisionCtx, pendingDbTypes) => {
 	const createTables = collectCreateTables(tables, dbStructure, currentSchema);
 	const compareSql = {
 		values: [],
@@ -1730,8 +1757,8 @@ const processTables = async (ast, domainsMap, adapter, dbStructure, config, { st
 	const expressions = [];
 	const { changeTables, changeTableSchemas, dropTables, tableShapes } = collectChangeAndDropTables(adapter, config, tables, dbStructure, currentSchema, createTables, generatorIgnore);
 	applyChangeTableSchemas(changeTableSchemas, currentSchema, ast);
-	await applyCreateOrRenameTables(dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, verifying);
-	await applyChangeTables(adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, verifying, pendingDbTypes);
+	await applyCreateOrRenameTables(dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, decisionCtx);
+	await applyChangeTables(adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, decisionCtx, pendingDbTypes);
 	processForeignKeys(config, ast, changeTables, currentSchema, tableShapes);
 	await Promise.all([applyCompareSql(compareSql, adapter), compareSqlExpressions(expressions, adapter)]);
 	await processTableRls(adapter, ast, dbStructure, tables, currentSchema, generatorIgnore);
@@ -1807,12 +1834,12 @@ const applyChangeTableSchemas = (changeTableSchemas, currentSchema, ast) => {
 		});
 	}
 };
-const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, verifying, pendingDbTypes) => {
+const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, decisionCtx, pendingDbTypes) => {
 	const compareExpressions = [];
 	const typeCastsCache = {};
 	for (const changeTableData of changeTables) {
 		compareExpressions.length = 0;
-		await processTableChange(adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, verifying);
+		await processTableChange(adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, decisionCtx);
 		if (compareExpressions.length) {
 			const { codeTable } = changeTableData;
 			const names = [];
@@ -1859,13 +1886,22 @@ const applyCompareSql = async (compareSql, adapter) => {
 		for (let i = 0; i < results.length; i++) if (!results[i]) compareSql.expressions[i].change();
 	}
 };
-const applyCreateOrRenameTables = async (dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, verifying) => {
+const applyCreateOrRenameTables = async (dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, decisionCtx) => {
 	for (const codeTable of createTables) {
 		if (dropTables.length) {
-			const i = await promptCreateOrRename("table", codeTable.table, dropTables.map((x) => x.name), verifying);
-			if (i) {
-				const dbTable = dropTables[i - 1];
-				dropTables.splice(i - 1, 1);
+			const dbTable = await decisionCtx.decider.createOrRename({
+				kind: "table",
+				target: {
+					schema: codeTable.q.schema ?? currentSchema,
+					name: codeTable.table
+				},
+				candidates: dropTables,
+				candidateSource: (x) => decisionCtx.dbSource(x),
+				name: codeTable.table,
+				candidateName: (x) => x.name
+			});
+			if (dbTable) {
+				dropTables.splice(dropTables.indexOf(dbTable), 1);
 				ast.push({
 					type: "renameType",
 					kind: "TABLE",
@@ -1935,8 +1971,8 @@ const makeTableShape = (table) => {
 	}
 	return shape;
 };
-const processTableChange = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, verifying) => {
-	await processColumns(adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, verifying);
+const processTableChange = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, decisionCtx) => {
+	await processColumns(adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, decisionCtx);
 	processPrimaryKey(config, changeTableData);
 	processIndexesAndExcludes(config, changeTableData, ast, compareExpressions);
 	processChecks(ast, changeTableData, compareExpressions);
@@ -1957,7 +1993,7 @@ const defaults = {
 	connLimit: -1,
 	bypassRls: false
 };
-const processRoles = async (ast, dbStructure, { verifying, internal: { roles } }) => {
+const processRoles = async (ast, dbStructure, { internal: { roles } }, { decider }) => {
 	if (!dbStructure.roles || !roles) return;
 	const codeRoles = roles.map((role) => {
 		const { defaultPrivileges: _, ...roleWithoutPrivileges } = role;
@@ -1986,10 +2022,16 @@ const processRoles = async (ast, dbStructure, { verifying, internal: { roles } }
 	for (const codeRole of codeRoles) {
 		if (found.has(codeRole.name)) continue;
 		if (dropRoles.length) {
-			const i = await promptCreateOrRename("table", codeRole.name, dropRoles.map((x) => x.name), verifying);
-			if (i) {
-				const dbRole = dropRoles[i - 1];
-				dropRoles.splice(i - 1, 1);
+			const dbRole = await decider.createOrRename({
+				kind: "role",
+				target: { name: codeRole.name },
+				candidates: dropRoles,
+				candidateSource: (x) => ({ name: x.name }),
+				name: codeRole.name,
+				candidateName: (x) => x.name
+			});
+			if (dbRole) {
+				dropRoles.splice(dropRoles.indexOf(dbRole), 1);
 				ast.push(makeRenameOrChangeAst(dbRole, codeRole));
 				continue;
 			}
@@ -2785,6 +2827,74 @@ const normalizedViewName = (view, currentSchema) => {
 	return view.schemaName === currentSchema ? view.name : `${view.schemaName}.${view.name}`;
 };
 /**
+* Creates `MigrationDecisionCtx` for the `decider`, remembering the identities
+* of tables and enums in `dbStructure`, so it must be called for every
+* introspection before the generators change it.
+*/
+const makeMigrationDecisionCtx = (decider, dbStructure) => {
+	const sources = /* @__PURE__ */ new WeakMap();
+	for (const item of [...dbStructure.tables, ...dbStructure.enums]) sources.set(item, {
+		schema: item.schemaName,
+		name: item.name
+	});
+	return {
+		decider,
+		dbSource(item) {
+			const source = sources.get(item);
+			if (!source) throw new Error(`${item.schemaName}.${item.name} is missing in the introspected structure`);
+			return source;
+		}
+	};
+};
+/**
+* Decider that asks the user in the terminal.
+*/
+const interactiveDecider = {
+	async createOrRename({ kind, name, candidates, candidateName }) {
+		const names = candidates.map(candidateName);
+		let hintPos = name.length + 4;
+		for (const from of names) {
+			const value = from.length + 8 + name.length;
+			if (value > hintPos) hintPos = value;
+		}
+		const renameMessage = `rename ${kind}`;
+		const i = await promptSelect({
+			message: `Create or rename ${colors.blueBold(name)} ${kind} from another ${kind}?`,
+			options: [`${colors.greenBold("+")} ${name}  ${colors.pale(`create ${kind}`.padStart(hintPos + renameMessage.length - name.length - 4, " "))}`, ...names.map((d) => `${colors.yellowBold("~")} ${d} ${colors.yellowBold("=>")} ${name}  ${colors.pale(renameMessage.padStart(hintPos + renameMessage.length - d.length - name.length - 8, " "))}`)]
+		});
+		return i ? candidates[i - 1] : void 0;
+	},
+	async addOrRenameEnumValue({ enumName, value, candidates }) {
+		const i = await promptSelect({
+			message: `Add or rename ${colors.blueBold(value)} enum value in ${colors.blueBold(enumName)}?`,
+			options: [`${colors.greenBold("+")} ${value}  ${colors.pale("add enum value")}`, ...candidates.map((dropValue) => `${colors.yellowBold("~")} ${dropValue} ${colors.yellowBold("=>")} ${value}  ${colors.pale("rename enum value")}`)]
+		});
+		return i ? candidates[i - 1] : void 0;
+	},
+	async recreateColumn({ tableName, columnName, fromType, toType }) {
+		return !await promptSelect({
+			message: `Cannot cast type of ${tableName}'s column ${columnName} from ${fromType} to ${toType}`,
+			options: [`${colors.yellowBold(`-/+`)} recreate the column, existing data will be ${colors.red("lost")}`, `write migration manually`]
+		});
+	}
+};
+/**
+* Decider for re-generating a migration after applying it: any remaining
+* question means the migration did not bring the database to the code state,
+* so it aborts instead of asking.
+*/
+const verifyingDecider = {
+	createOrRename() {
+		throw new AbortSignal();
+	},
+	addOrRenameEnumValue() {
+		throw new AbortSignal();
+	},
+	recreateColumn() {
+		throw new AbortSignal();
+	}
+};
+/**
 * This is needed to compare SQLs of table expressions.
 * Need to exclude table columns of pending types, such as enums or domains,
 * that aren't created yet from the SQL comparison.
@@ -2800,16 +2910,17 @@ var PendingDbTypes = class {
 };
 const composeMigration = async (adapter, config, ast, dbStructure, params) => {
 	const { structureToAstCtx, currentSchema } = params;
-	await processRoles(ast, dbStructure, params);
+	const decisionCtx = makeMigrationDecisionCtx(params.decider, dbStructure);
+	await processRoles(ast, dbStructure, params, decisionCtx);
 	processDefaultPrivileges(ast, dbStructure, params);
 	processGrants(ast, dbStructure, params);
 	const domainsMap = makeDomainsMap(structureToAstCtx, dbStructure);
-	await processSchemas(ast, dbStructure, params);
+	await processSchemas(ast, dbStructure, params, decisionCtx);
 	processExtensions(ast, dbStructure, params);
 	const pendingDbTypes = new PendingDbTypes();
 	await processDomains(ast, adapter, domainsMap, dbStructure, params, pendingDbTypes);
-	await processEnums(ast, dbStructure, params, pendingDbTypes);
-	await processTables(ast, domainsMap, adapter, dbStructure, config, params, pendingDbTypes);
+	await processEnums(ast, dbStructure, params, decisionCtx, pendingDbTypes);
+	await processTables(ast, domainsMap, adapter, dbStructure, config, params, decisionCtx, pendingDbTypes);
 	await processViews(ast, adapter, dbStructure, params);
 	await processMaterializedViews(ast, adapter, dbStructure, params);
 	return astToMigration(currentSchema, config, ast);
@@ -2834,9 +2945,11 @@ const verifyMigration = async (adapter, config, migrationCode, generateMigration
 				roles,
 				...structureParams
 			});
-			generateMigrationParams.verifying = true;
 			try {
-				code = await composeMigration(trx, config, [], dbStructure, generateMigrationParams);
+				code = await composeMigration(trx, config, [], dbStructure, {
+					...generateMigrationParams,
+					decider: verifyingDecider
+				});
 			} catch (err) {
 				if (err instanceof AbortSignal) {
 					code = false;
@@ -2851,6 +2964,222 @@ const verifyMigration = async (adapter, config, migrationCode, generateMigration
 	}
 	return code;
 };
+const pathLengths = {
+	schema: 1,
+	role: 1,
+	enum: 2,
+	table: 2,
+	column: 3,
+	"enum-value": 3
+};
+/**
+* Parses arguments of the generate command, separating the flags that answer
+* the generator questions from the positional arguments.
+*/
+const parseGenerateArgs = (args) => {
+	const positional = [];
+	let nonInteractive = false;
+	const answers = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--non-interactive") {
+			nonInteractive = true;
+			continue;
+		}
+		if (arg === "--transaction") {
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--transaction=")) continue;
+		if (!arg.startsWith("--")) {
+			positional.push(arg);
+			continue;
+		}
+		const match = arg.match(/^--(rename|create|recreate)(?:=(.*))?$/s);
+		if (!match) throw new RakeDbError(`Unknown flag ${arg}`);
+		const action = match[1];
+		const value = match[2] ?? args[++i];
+		if (value === void 0) throw new RakeDbError(`--${action} requires a value`);
+		answers.push(parseAnswer(action, value));
+	}
+	checkConflictingAnswers(answers);
+	return {
+		positional,
+		nonInteractive,
+		answers
+	};
+};
+const parseAnswer = (action, value) => {
+	const flag = `--${action} ${value}`;
+	const invalid = (reason) => new RakeDbError(`Invalid ${flag}: ${reason}`);
+	const colon = value.indexOf(":");
+	const kind = value.slice(0, colon);
+	if (colon === -1 || !Object.hasOwn(pathLengths, kind)) throw invalid(`expected one of ${Object.keys(pathLengths).join(", ")} followed by a colon`);
+	if (action === "recreate" && kind !== "column") throw invalid("only a column can be recreated");
+	const length = pathLengths[kind];
+	const readPath = (start) => {
+		const { path, end } = parsePath(value, start, invalid);
+		if (path.length !== length) throw invalid(`${kind} must be given by ${length} dot-separated name${length === 1 ? "" : "s"}`);
+		return {
+			path,
+			end
+		};
+	};
+	const first = readPath(colon + 1);
+	if (action === "create") {
+		if (first.end !== value.length) throw invalid("unexpected text after the name");
+		return {
+			flag,
+			action,
+			kind,
+			target: first.path
+		};
+	}
+	if (value[first.end] !== "=") throw invalid("expected the old name and the new name separated by \"=\"");
+	const second = readPath(first.end + 1);
+	if (second.end !== value.length) throw invalid("unexpected text after the name");
+	return {
+		flag,
+		action,
+		kind,
+		source: first.path,
+		target: second.path
+	};
+};
+const parsePath = (value, start, invalid) => {
+	const path = [];
+	let i = start;
+	for (;;) {
+		let segment = "";
+		if (value[i] === "\"") {
+			for (i++;; i++) {
+				if (i === value.length) throw invalid("unterminated quoted name");
+				if (value[i] === "\"") {
+					if (value[i + 1] !== "\"") break;
+					i++;
+				}
+				segment += value[i];
+			}
+			i++;
+		} else {
+			while (i < value.length && !".=\"".includes(value[i])) segment += value[i++];
+			if (!segment) throw invalid("expected a name");
+		}
+		path.push(segment);
+		if (value[i] !== ".") return {
+			path,
+			end: i
+		};
+		i++;
+	}
+};
+const answerGroup = (answer) => answer.action === "recreate" ? "recreate" : "createOrRename";
+const answerKey = (group, kind, path) => `${group} ${kind}:${formatPath(path)}`;
+const checkConflictingAnswers = (answers) => {
+	const targets = /* @__PURE__ */ new Map();
+	const sources = /* @__PURE__ */ new Map();
+	for (const answer of answers) {
+		const group = answerGroup(answer);
+		const conflict = (other) => new RakeDbError(`${answer.flag} conflicts with ${other.flag}`);
+		const targetKey = answerKey(group, answer.kind, answer.target);
+		const sameTarget = targets.get(targetKey);
+		if (sameTarget) throw conflict(sameTarget);
+		targets.set(targetKey, answer);
+		if (answer.action !== "create") {
+			const sourceKey = answerKey(group, answer.kind, answer.source);
+			const sameSource = sources.get(sourceKey);
+			if (sameSource) throw conflict(sameSource);
+			sources.set(sourceKey, answer);
+		}
+	}
+};
+/**
+* Formats database names as they are given in the answer flags:
+* separated by dots, quoting the names that cannot be read otherwise.
+*/
+const formatPath = (path) => path.map((name) => /^[^\s."=]+$/.test(name) ? name : `"${name.replaceAll("\"", "\"\"")}"`).join(".");
+const itemPath = ({ schema, table, name }) => [
+	...schema === void 0 ? [] : [schema],
+	...table === void 0 ? [] : [table],
+	name
+];
+const samePath = (a, b) => a.length === b.length && a.every((name, i) => name === b[i]);
+/**
+* Creates an `AnswersDecider` for the `answers`.
+* Without the `ask` decider, a question without an answer is collected,
+* and the generation goes on as if the item was created or recreated,
+* so that the following questions are collected as well.
+*/
+const makeAnswersDecider = (answers, ask) => {
+	const answerMap = /* @__PURE__ */ new Map();
+	for (const answer of answers) answerMap.set(answerKey(answerGroup(answer), answer.kind, answer.target), answer);
+	const used = /* @__PURE__ */ new Set();
+	const takeAnswer = (group, kind, target) => {
+		const answer = answerMap.get(answerKey(group, kind, target));
+		if (answer) used.add(answer);
+		return answer;
+	};
+	const errors = [];
+	const questions = [];
+	const addQuestion = (question, options) => {
+		questions.push([question, ...options.map((option) => `  ${option}`)].join("\n"));
+	};
+	const findCandidate = (answer, kind, target, candidates, candidatePath) => {
+		const candidate = candidates.find((candidate) => samePath(candidatePath(candidate), answer.source));
+		if (candidate === void 0) errors.push(`${answer.flag}: ${formatPath(answer.source)} is not among the ${kind}s that can be renamed to ${formatPath(target)}: ${candidates.map((candidate) => formatPath(candidatePath(candidate))).join(", ")}`);
+		return candidate;
+	};
+	return {
+		async createOrRename(question) {
+			const { kind, candidates, candidateSource } = question;
+			const target = itemPath(question.target);
+			const candidatePath = (candidate) => itemPath(candidateSource(candidate));
+			const answer = takeAnswer("createOrRename", kind, target);
+			if (answer) return answer.action === "rename" ? findCandidate(answer, kind, target, candidates, candidatePath) : void 0;
+			if (ask) return ask.createOrRename(question);
+			addQuestion(`Create or rename ${kind} ${formatPath(target)}?`, [formatFlag("create", kind, target), ...candidates.map((candidate) => formatFlag("rename", kind, candidatePath(candidate), target))]);
+		},
+		async addOrRenameEnumValue(question) {
+			const { value, candidates } = question;
+			const kind = "enum-value";
+			const target = [...itemPath(question.target), value];
+			const source = itemPath(question.source);
+			const candidatePath = (candidate) => [...source, candidate];
+			const answer = takeAnswer("createOrRename", kind, target);
+			if (answer) return answer.action === "rename" ? findCandidate(answer, kind, target, candidates, candidatePath) : void 0;
+			if (ask) return ask.addOrRenameEnumValue(question);
+			addQuestion(`Add or rename enum value ${formatPath(target)}?`, [formatFlag("create", kind, target), ...candidates.map((candidate) => formatFlag("rename", kind, candidatePath(candidate), target))]);
+		},
+		async recreateColumn(question) {
+			const kind = "column";
+			const source = itemPath(question.source);
+			const target = itemPath(question.target);
+			const answer = takeAnswer("recreate", kind, target);
+			if (answer && answer.action === "recreate") {
+				if (!samePath(source, answer.source)) errors.push(`${answer.flag}: the column to recreate is ${formatPath(source)}`);
+				return true;
+			}
+			if (ask) return ask.recreateColumn(question);
+			addQuestion(`Cannot cast column ${formatPath(source)} from ${question.fromType} to ${question.toType}. Recreate it (existing data will be lost), or write the migration manually?`, [formatFlag("recreate", kind, source, target)]);
+			return true;
+		},
+		problems() {
+			const sections = [];
+			if (errors.length) sections.push(errors.join("\n"));
+			if (questions.length) sections.push("Run the command again with one of the suggested flags for each question, keeping the answer flags given before:", ...questions, "More questions may come up after these are answered.");
+			else {
+				const unused = answers.filter((answer) => answer.action === "rename" && !used.has(answer));
+				if (unused.length) sections.push(`These renames do not match any question:\n${unused.map((answer) => answer.flag).join("\n")}`);
+			}
+			return sections.length ? `Cannot generate the migration.\n\n${sections.join("\n\n")}` : void 0;
+		}
+	};
+};
+const formatFlag = (action, kind, path, target) => {
+	const value = `${kind}:${formatPath(path)}${target ? `=${formatPath(target)}` : ""}`;
+	return `--${action} ${shellQuote(value)}`;
+};
+const shellQuote = (value) => /^[\w.:=@%+,/-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
 const report = (ast, config, currentSchema) => {
 	if (!config.logger) return;
 	const code = [];
@@ -3140,12 +3469,14 @@ const generate = async (adapters, config, args, afterPull) => {
 	if (!dbPath || !getTableFactoryConfig(config)) throw invalidConfig(config);
 	if (!adapters.length) throw new Error(`Database options must not be empty`);
 	if (!dbPath.endsWith(".ts")) dbPath += ".ts";
-	let migrationName = args[0] ?? "generated";
+	const { positional, nonInteractive, answers } = parseGenerateArgs(args);
+	let migrationName = positional[0] ?? "generated";
 	let up;
 	if (migrationName === "up") {
 		up = true;
 		migrationName = "generated";
-	} else up = args[1] === "up";
+	} else up = positional[1] === "up";
+	const decider = makeAnswersDecider(answers, nonInteractive || !process.stdin.isTTY ? void 0 : interactiveDecider);
 	if (afterPull) adapters = [afterPull.adapter];
 	const db = await getDbFromConfig(config, dbPath);
 	const { columnTypes, internal } = db.$qb;
@@ -3170,7 +3501,8 @@ const generate = async (adapters, config, args, afterPull) => {
 			...internal,
 			generatorIgnore,
 			grants: effectiveGrants
-		}
+		},
+		decider
 	};
 	const ast = [];
 	let migrationCode;
@@ -3183,6 +3515,11 @@ const generate = async (adapters, config, args, afterPull) => {
 		}
 		throw err;
 	}
+	const problems = decider.problems();
+	if (problems) {
+		if (!afterPull) await closeAdapters(adapters);
+		throw new RakeDbError(problems);
+	}
 	if (migrationCode && !afterPull) {
 		const result = await verifyMigration(adapter, config, migrationCode, generateMigrationParams, rolesDbStructureParam, structureParams);
 		if (result !== void 0) throw new Error(`Failed to verify generated migration: some of database changes were not applied properly. This is a bug, please open an issue, attach the following migration code:\n${migrationCode}${result === false ? "" : `\nAfter applying:\n${result}`}`);
@@ -3908,7 +4245,11 @@ const patchRakeDb$1 = () => {
 			"no arguments": "\"generated\" is a default file name",
 			"migration-name": "set migration file name",
 			up: "auto-apply migration",
-			"migration-name up": "with a custom name and apply it"
+			"migration-name up": "with a custom name and apply it",
+			"--non-interactive": "report unanswered questions instead of asking",
+			"--rename kind:old=new": "answer to rename an item",
+			"--create kind:name": "answer to create an item",
+			"--recreate column:old=new": "answer to recreate a column, losing data"
 		},
 		helpAfter: "reset"
 	};