[sqlite]: push - explain

Author: AleksandrSherman

drizzle-kit/src/cli/commands/push-sqlite.ts

@@ -9,13 +9,13 @@ import { fromDrizzleSchema, prepareFromSchemaFiles } from 'src/dialects/sqlite/d
 import type { JsonStatement } from 'src/dialects/sqlite/statements';
 import type { SQLiteDB } from '../../utils';
 import { prepareFilenames } from '../../utils/utils-node';
+import { highlightSQL } from '../highlighter';
 import { resolver } from '../prompts';
 import { Select } from '../selector-ui';
 import type { EntitiesFilterConfig } from '../validations/cli';
 import type { CasingType } from '../validations/common';
-import { withStyle } from '../validations/outputs';
 import type { SqliteCredentials } from '../validations/sqlite';
-import { ProgressView } from '../views';
+import { explain, ProgressView } from '../views';
 
 export const handle = async (
 	schemaPath: string | string[],
@@ -24,6 +24,7 @@ export const handle = async (
 	filters: EntitiesFilterConfig,
 	force: boolean,
 	casing: CasingType | undefined,
+	explainFlag: boolean,
 ) => {
 	const { connectToSQLite } = await import('../connections');
 	const { introspect: sqliteIntrospect } = await import('./pull-sqlite');
@@ -43,7 +44,7 @@ export const handle = async (
 
 	const { ddl: ddl1 } = await sqliteIntrospect(db, filter, progress);
 
-	const { sqlStatements, statements } = await ddlDiff(
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
 		ddl1,
 		ddl2,
 		resolver<Table>('table'),
@@ -56,40 +57,14 @@ export const handle = async (
 		return;
 	}
 
-	const { hints } = await suggestions(db, statements);
+	const hints = await suggestions(db, statements);
 
-	if (verbose && sqlStatements.length > 0) {
-		console.log();
-		console.log(
-			withStyle.warning('You are about to execute current statements:'),
-		);
-		console.log();
-		console.log(sqlStatements.map((s) => chalk.blue(s)).join('\n'));
-		console.log();
-	}
+	const explainMessage = explain('sqlite', groupedStatements, explainFlag, hints);
 
-	if (!force && sqlStatements.length > 0) {
-		const { data } = await render(
-			new Select(['No, abort', `Yes, I want to execute all statements`]),
-		);
-		if (data?.index === 0) {
-			render(`[${chalk.red('x')}] All changes were aborted`);
-			process.exit(0);
-		}
-	}
+	if (explainMessage) console.log(explainMessage);
+	if (explainFlag) return;
 
 	if (!force && hints.length > 0) {
-		console.log(withStyle.warning('Found data-loss statements:'));
-		console.log(hints.join('\n'));
-		console.log();
-		console.log(
-			chalk.red.bold(
-				'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-			),
-		);
-
-		console.log(chalk.white('Do you still want to push changes?'));
-
 		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
 
 		if (data?.index === 0) {
@@ -98,6 +73,8 @@ export const handle = async (
 		}
 	}
 
+	const lossStatements = hints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
 	if (sqlStatements.length === 0) {
 		render(`\n[${chalk.blue('i')}] No changes detected`);
 	} else {
@@ -108,8 +85,10 @@ export const handle = async (
 			const isD1 = 'driver' in credentials && credentials.driver === 'd1-http';
 			if (!isD1) await db.run('begin');
 			try {
-				for (const dStmnt of sqlStatements) {
-					await db.run(dStmnt);
+				for (const statement of [...lossStatements, ...sqlStatements]) {
+					if (verbose) console.log(highlightSQL(statement));
+
+					await db.run(statement);
 				}
 				if (!isD1) await db.run('commit');
 			} catch (e) {
@@ -127,36 +106,38 @@ export const suggestions = async (
 	connection: SQLiteDB,
 	jsonStatements: JsonStatement[],
 ) => {
-	const statements: string[] = [];
-	const hints = [] as string[];
+	const grouped: { hint: string; statement?: string }[] = [];
 
 	// TODO: generate truncations/recreates ??
 	for (const statement of jsonStatements) {
 		if (statement.type === 'drop_table') {
 			const name = statement.tableName;
 			const res = await connection.query(`select 1 from "${name}" limit 1;`);
 
-			if (res.length > 0) hints.push(`· You're about to delete non-empty '${name}' table`);
+			if (res.length > 0) grouped.push({ hint: `· You're about to delete non-empty '${name}' table` });
 			continue;
 		}
 
 		if (statement.type === 'drop_column') {
 			const { table, name } = statement.column;
 
 			const res = await connection.query(`select 1 from "${table}" limit 1;`);
-			if (res.length > 0) hints.push(`· You're about to delete '${name}' column in a non-empty '${table}' table`);
+			if (res.length > 0) {
+				grouped.push({ hint: `· You're about to delete '${name}' column in a non-empty '${table}' table` });
+			}
 			continue;
 		}
 
 		if (statement.type === 'add_column' && (statement.column.notNull && !statement.column.default)) {
 			const { table, name } = statement.column;
 			const res = await connection.query(`select 1 from "${table}" limit 1`);
 			if (res.length > 0) {
-				hints.push(
-					`· You're about to add not-null '${name}' column without default value to non-empty '${table}' table`,
+				grouped.push(
+					{
+						hint: `· You're about to add not-null '${name}' column without default value to non-empty '${table}' table`,
+						statement: `DELETE FROM "${table}" where true;`,
+					},
 				);
-
-				statements.push(`DELETE FROM "${table}" where true;`);
 			}
 
 			continue;
@@ -170,14 +151,16 @@ export const suggestions = async (
 
 			const res = await connection.query(`select 1 from "${statement.from.name}" limit 1`);
 			if (res.length > 0) {
-				hints.push(
-					`· You're about to drop ${
-						droppedColumns.map((col) => `'${col.name}'`).join(', ')
-					} column(s) in a non-empty '${statement.from.name}' table`,
+				grouped.push(
+					{
+						hint: `· You're about to drop ${
+							droppedColumns.map((col) => `'${col.name}'`).join(', ')
+						} column(s) in a non-empty '${statement.from.name}' table`,
+					},
 				);
 			}
 		}
 	}
 
-	return { statements, hints };
+	return grouped;
 };

drizzle-kit/src/cli/schema.ts

@@ -333,10 +333,10 @@ export const push = command({
 			await handle(schemaPath, verbose, credentials, filters, force, casing, explain);
 		} else if (dialect === 'sqlite') {
 			const { handle: sqlitePush } = await import('./commands/push-sqlite');
-			await sqlitePush(schemaPath, verbose, credentials, filters, force, casing);
+			await sqlitePush(schemaPath, verbose, credentials, filters, force, casing, explain);
 		} else if (dialect === 'turso') {
 			const { handle: libSQLPush } = await import('./commands/push-libsql');
-			await libSQLPush(schemaPath, verbose, credentials, filters, force, casing);
+			await libSQLPush(schemaPath, verbose, credentials, filters, force, casing, explain);
 		} else if (dialect === 'singlestore') {
 			const { handle } = await import('./commands/push-singlestore');
 			await handle(schemaPath, credentials, filters, verbose, force, casing);

drizzle-kit/src/cli/views.ts

@@ -99,15 +99,19 @@ function formatOptionChanges(
 }
 
 export const explain = (
-	dialect: 'mysql' | 'postgres',
-	grouped: { jsonStatement: StatementPostgres; sqlStatements: string[] }[],
+	dialect: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'mssql' | 'common' | 'gel' | 'cockroach',
+	grouped: { jsonStatement: StatementPostgres | StatementSqlite; sqlStatements: string[] }[],
 	explain: boolean,
 	hints: { hint: string; statement?: string }[],
 ) => {
 	const res = [];
 	const explains = [];
 	for (const { jsonStatement, sqlStatements } of grouped) {
-		const res = dialect === 'postgres' ? psqlExplain(jsonStatement as StatementPostgres) : null;
+		const res = dialect === 'postgres'
+			? psqlExplain(jsonStatement as StatementPostgres)
+			: dialect === 'sqlite'
+			? sqliteExplain(jsonStatement as StatementSqlite)
+			: null;
 
 		if (res) {
 			let msg = `┌─── ${res.title}\n`;
@@ -618,27 +622,22 @@ export const sqliteExplain = (
 		}
 
 		if (checkDiffs.length) {
-			let res: string = '';
 			const createdChecks = checkDiffs.filter((it) => it.$diffType === 'create');
 			const droppedChecks = checkDiffs.filter((it) => it.$diffType === 'drop');
 
 			if (createdChecks.length) {
-				res += `| Check constraints added: ${createdChecks.map((it) => `${it.name}`).join(', ')}\n`;
+				blocks.push([`| Check constraints added: ${createdChecks.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
 
-			if (droppedChecks) {
-				res += `| Check constraints dropped: ${droppedChecks.map((it) => `${it.name}`).join(', ')}\n`;
+			if (droppedChecks.length) {
+				blocks.push([`| Check constraints dropped: ${droppedChecks.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
-
-			res += `| It is not possible to create/drop check constraints on existing table\n`;
-			blocks.push([res]);
 		}
 
 		if (checksAlters.length) {
 			blocks.push([
 				`│ Check constraints altered definition:\n`,
 				`│ ${checksAlters.map((it) => `${it.name}: ${it.$left.value} -> ${it.$right.value}`).join(',\n')}\n`,
-				`│ It is not possible to alter definition\n`,
 			]);
 		}
 
@@ -679,49 +678,40 @@ export const sqliteExplain = (
 		}
 
 		if (uniquesDiff.length) {
-			let res: string = '';
-
 			const uniquesCreated = uniquesDiff.filter((it) => it.$diffType === 'create');
 			const uniquesDropped = uniquesDiff.filter((it) => it.$diffType === 'drop');
 			if (uniquesCreated.length) {
-				res += `│ Unique constraints added: ${uniquesCreated.map((it) => `${it.name}`).join(', ')}\n`;
+				blocks.push([`│ Unique constraints added: ${uniquesCreated.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
 			if (uniquesDropped.length) {
-				res += `│ Unique constraints dropped: ${uniquesDropped.map((it) => `${it.name}`).join(', ')}\n`;
+				blocks.push([`│ Unique constraints dropped: ${uniquesDropped.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
-
-			res += `│ It is not possible to create/drop unique constraints on existing table\n`;
-
-			blocks.push([res]);
 		}
 
 		if (pksDiff.length) {
-			let res: string = '';
 			const pksCreated = pksDiff.filter((it) => it.$diffType === 'create');
 			const pksDropped = pksDiff.filter((it) => it.$diffType === 'drop');
 
 			if (pksCreated.length) {
-				res += `│ Primary key constraints added: ${pksCreated.map((it) => `${it.name}`).join(', ')}\n`;
+				blocks.push([`│ Primary key constraints added: ${pksCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (pksDropped.length) {
+				blocks.push([`│ Primary key constraints dropped: ${pksDropped.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
-			if (pksDropped) res += `│ Primary key constraints dropped: ${pksDropped.map((it) => `${it.name}`).join(', ')}\n`;
-
-			res += `│ It is not possible to create/drop primary key constraints on existing table\n`;
-			blocks.push([res]);
 		}
 
 		if (newStoredColumns.length) {
 			blocks.push([
 				`| Stored columns added: ${newStoredColumns.map((it) => `${it.name}`).join(', ')}\n`,
-				`| It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however\n`,
 			]);
 		}
 
 		if (pksAlters.length) {
 			blocks.push([
 				`│ Primary key was altered:\n`,
-				`│ columns: ${
+				`${
 					pksAlters.filter((it) => it.columns).map((it) =>
-						`${it.name}: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
+						`[${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
 					)
 				}\n`,
 			]);
@@ -730,9 +720,9 @@ export const sqliteExplain = (
 		if (uniquesAlters.length) {
 			blocks.push([
 				`│ Unique constraint was altered:\n`,
-				`│ columns: ${
+				`${
 					uniquesAlters.filter((it) => it.columns).map((it) =>
-						`${it.name}, [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
+						`│ name: ${it.name} => columns: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
 					)
 				}\n`,
 			]);
@@ -749,56 +739,49 @@ export const sqliteExplain = (
 			if (columnsAltered) {
 				res += `${
 					columnsAltered.map((it) =>
-						`│ ${it.name} => columns: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]`
+						`│ name: ${it.name} => columns: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]`
 					)
 				}\n`;
 			}
 			if (columnsToAltered) {
 				res += ` ${
 					columnsToAltered.map((it) =>
-						`│ ${it.name} => columnsTo: [${it.columnsTo?.from.join(',')}] -> [${it.columnsTo?.to.join(',')}]`
+						`│ name: ${it.name} => columnsTo: [${it.columnsTo?.from.join(',')}] -> [${it.columnsTo?.to.join(',')}]`
 					)
 				}\n`;
 			}
 			if (tablesToAltered) {
 				res += `${
-					tablesToAltered.map((it) => `│ ${it.name} => tableTo: [${it.tableTo?.from}] -> [${it.tableTo?.to}]`)
+					tablesToAltered.map((it) => `│ name: ${it.name} => tableTo: [${it.tableTo?.from}] -> [${it.tableTo?.to}]`)
 				}\n`;
 			}
 
 			blocks.push([res]);
 		}
 
 		if (fksDiff.length) {
-			let res: string = '';
-
 			const fksCreated = fksDiff.filter((it) => it.$diffType === 'create');
 			const fksDropped = fksDiff.filter((it) => it.$diffType === 'drop');
-			if (fksCreated) res += `| Foreign key constraints added: ${fksCreated.map((it) => `${it.name}`).join(', ')}\n`;
-			if (fksDropped) res += `| Unique constraints dropped: ${fksDropped.map((it) => `${it.name}`).join(', ')}\n`;
-
-			res += `| It is not possible to create/drop foreign key constraints on existing table\n`;
-
-			blocks.push([res]);
+			if (fksCreated.length) {
+				blocks.push([`| Foreign key constraints added: ${fksCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (fksDropped.length) {
+				blocks.push([`| Foreign key constraints dropped: ${fksDropped.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
 		}
 
 		if (indexesDiff.filter((it) => it.isUnique && it.origin === 'auto').length) {
-			let res: string = '';
 			const indexCreated = indexesDiff.filter((it) => it.$diffType === 'create');
 			const indexDropped = indexesDiff.filter((it) => it.$diffType === 'drop');
-			if (indexCreated) res += `| System generated index added: ${indexCreated.map((it) => `${it.name}`).join(', ')}\n`;
-			if (indexDropped) {
-				res += `| System generated index dropped: ${indexDropped.map((it) => `${it.name}`).join(', ')}\n`;
+			if (indexCreated.length) {
+				blocks.push([`| System generated index added: ${indexCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (indexDropped.length) {
+				blocks.push([`| System generated index dropped: ${indexDropped.map((it) => `${it.name}`).join(', ')}\n`]);
 			}
-
-			res += `| It is not possible to drop/create auto generated unique indexes\n`;
-
-			blocks.push([res]);
 		}
 
-		if (blocks.filter((it) => Boolean(it))) {
-			cause += blocks.map((it) => it.join('')).join('|-\n');
-		}
+		cause += blocks.map((it) => it.join('')).join('├─\n');
 	}
 
 	if (st.type === 'recreate_column') {

drizzle-kit/src/dialects/sqlite/diff.ts

@@ -270,6 +270,9 @@ export const ddlDiff = async (
 	for (const it of createdTables) {
 		setOfTablesToRecereate.delete(it.name);
 	}
+	for (const it of deletedTables) {
+		setOfTablesToRecereate.delete(it.name);
+	}
 
 	for (const it of updates) {
 		if (