CLI Command Architecture

Copyrun([generate, migrate, pull, push, studio, up, check, drop, exportRaw, ...legacy], {
	name: 'drizzle-kit',
	version: version,
});

Copyconst version = async () => {
	const { npmVersion } = await ormCoreVersions();
	const ormVersion = npmVersion ? `drizzle-orm: v${npmVersion}` : '';
	const envVersion = process.env.DRIZZLE_KIT_VERSION;
	const kitVersion = envVersion ? `v${envVersion}` : '--';
	const versions = `drizzle-kit: ${kitVersion}\n${ormVersion}`;
	console.log(chalk.gray(versions), '\n');
};

Copyconst legacyCommand = (name: string, newName: string) => {
	return command({
		name,
		hidden: true,
		handler: () => {
			console.log(
				`This command is deprecated, please use updated '${newName}' command (see https://orm.drizzle.team/kit-docs/upgrade-21#how-to-migrate-to-0210)`,
			);
		},
	});
};
 
const legacy = [
	legacyCommand('generate:pg', 'generate'),
	legacyCommand('generate:mysql', 'generate'),
	legacyCommand('generate:sqlite', 'generate'),
	legacyCommand('push:pg', 'push'),
	legacyCommand('push:mysql', 'push'),
	legacyCommand('push:sqlite', 'push'),
	legacyCommand('introspect:pg', 'introspect'),
	legacyCommand('introspect:mysql', 'introspect'),
	legacyCommand('introspect:sqlite', 'introspect'),
	legacyCommand('up:pg', 'up'),
	legacyCommand('up:mysql', 'up'),
	legacyCommand('up:sqlite', 'up'),
	legacyCommand('check:pg', 'check'),
	legacyCommand('check:mysql', 'check'),
	legacyCommand('check:sqlite', 'check'),
];

Copyconst requiredApiVersion = 10;
export const assertOrmCoreVersion = async () => {
	try {
		const { compatibilityVersion } = await import('drizzle-orm/version');
 
		await import('drizzle-orm/relations');
 
		if (compatibilityVersion && compatibilityVersion === requiredApiVersion) {
			return;
		}
 
		if (!compatibilityVersion || compatibilityVersion < requiredApiVersion) {
			console.log(
				'This version of drizzle-kit requires newer version of drizzle-orm\nPlease update drizzle-orm package to the latest version 👍',
			);
		} else {
			console.log(
				'This version of drizzle-kit is outdated\nPlease update drizzle-kit package to the latest version 👍',
			);
		}
	} catch (e) {
		console.log('Please install latest version of drizzle-orm');
	}
	process.exit(1);
};

Copyexport const assertStudioNodeVersion = () => {
	if (semver.gte(process.version, '18.0.0')) return;
 
	err('Drizzle Studio requires NodeJS v18 or above');
	process.exit(1);
};

Copylet tsxRegistered = false;
const ensureTsxRegistered = () => {
	if (tsxRegistered) return;
 
	const isBun = typeof (globalThis as any).Bun !== 'undefined';
	const isDeno = typeof (globalThis as any).Deno !== 'undefined';
	if (isBun || isDeno) {
		tsxRegistered = true;
		return;
	}
 
	const tsx = require('tsx/cjs/api');
	tsx.register();
	tsxRegistered = true;
};

Copyexport class InMemoryMutex {
	private lockPromise: Promise<void> | null = null;
 
	async withLock<T>(fn: () => Promise<T>): Promise<T> {
		// Wait for any existing lock
		while (this.lockPromise) {
			await this.lockPromise;
		}
 
		let resolveLock: (() => void) | undefined;
		this.lockPromise = new Promise<void>((resolve) => {
			resolveLock = resolve;
		});
 
		try {
			return await fn();
		} finally {
			this.lockPromise = null;
			resolveLock!(); // non-null assertion: TS now knows it's definitely assigned
		}
	}
}

Copyconst assertES5 = async () => {
	try {
		await import('./_es5');
	} catch (e: any) {
		if ('errors' in e && Array.isArray(e.errors) && e.errors.length > 0) {
			const es5Error = (e.errors as any[]).filter((it) => it.text?.includes(`("es5") is not supported yet`)).length > 0;
			if (es5Error) {
				console.log(
					error(
						`Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`,
					),
				);
				process.exit(1);
			}
		}
		console.error(e);
		process.exit(1);
	}
};

Copyexport const prepareCheckParams = async (
	options: {
		config?: string;
		dialect?: Dialect;
		out?: string;
	},
	from: 'cli' | 'config',
): Promise<{ out: string; dialect: Dialect }> => {
	const config = from === 'config'
		? await drizzleConfigFromFile(options.config as string | undefined)
		: options;
 
	if (!config.out || !config.dialect) {
		let text = `Please provide required params for AWS Data API driver:\n`;
		console.log(error(text));
		console.log(wrapParam('database', config.out));
		console.log(wrapParam('secretArn', config.dialect));
		process.exit(1);
	}
	return { out: config.out, dialect: config.dialect };
};

Copyexport const prepareDropParams = async (
	options: {
		config?: string;
		out?: string;
		driver?: Driver;
		dialect?: Dialect;
	},
	from: 'cli' | 'config',
): Promise<{ out: string; bundle: boolean }> => {
	const config = from === 'config'
		? await drizzleConfigFromFile(options.config as string | undefined)
		: options;
 
	if (config.dialect === 'gel') {
		console.log(
			error(
				`You can't use 'drop' command with Gel dialect`,
			),
		);
		process.exit(1);
	}
 
	return { out: config.out || 'drizzle', bundle: config.driver === 'expo' };
};

Copy	ambiguousParams: (command: string) =>
		withStyle.error(
			`You can't use both --config and other cli options for ${command} command`,
		),
	schema: (command: string) => withStyle.error(`"--schema" is a required field for ${command} command`),
},
postgres: {
	connection: {
		required: () =>
			withStyle.error(
				`Either "url" or "host", "database" are required for database connection`,
			),
		awsDataApi: () =>
			withStyle.error(
				"You need to provide 'database', 'secretArn' and 'resourceArn' for Drizzle Kit to connect to AWS Data API",
			),
	},
},
mysql: {
	connection: {
		driver: () => withStyle.error(`Only "mysql2" is available options for "--driver"`),
		required: () =>
			withStyle.error(
				`Either "url" or "host", "database" are required for database connection`,
			),
	},
},
sqlite: {
	connection: {
		driver: () => {
			const listOfDrivers = sqliteDriversLiterals
				.map((it) => `'${it.value}'`)
				.join(', ');
			return withStyle.error(
				`Either ${listOfDrivers} are available options for 'driver' param`,
			);
		},
		url: (driver: string) =>
			withStyle.error(
				`"url" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
			),
		authToken: (driver: string) =>
			withStyle.error(
				`"authToken" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
			),
	},
	introspect: {},
	push: {},
},
singlestore: {
	connection: {
		driver: () => withStyle.error(`Only "mysql2" is available options for "--driver"`),
		required: () =>
			withStyle.error(
				`Either "url" or "host", "database" are required for database connection`,
			),
	},

CopyapplyLibSQLSnapshotsDiff,
applyMysqlSnapshotsDiff,
applyPgSnapshotsDiff,
applySingleStoreSnapshotsDiff,
applySqliteSnapshotsDiff,

Copyexport const schemasResolver = async (
	input: ResolverInput<Table>,
): Promise<ResolverOutput<Table>> => {
	try {
		const { created, deleted, renamed } = await promptSchemasConflict(
			input.created,
			input.deleted,
		);
 
		return { created: created, deleted: deleted, renamed: renamed };
	} catch (e) {
		console.error(e);
		throw e;
	}
};
 
export const tablesResolver = async (
	input: ResolverInput<Table>,
): Promise<ResolverOutputWithMoved<Table>> => {
	try {
		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
			input.created,
			input.deleted,
			'table',
		);
 
		return {
			created: created,
			deleted: deleted,
			moved: moved,
			renamed: renamed,
		};
	} catch (e) {
		console.error(e);
		throw e;
	}
};
 
export const viewsResolver = async (
	input: ResolverInput<View>,
): Promise<ResolverOutputWithMoved<View>> => {
	try {
		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
			input.created,
			input.deleted,
			'view',
		);
 

Copyexport const schemasResolver = async (
	input: ResolverInput<Table>,
): Promise<ResolverOutput<Table>> => {
	try {
		const { created, deleted, renamed } = await promptSchemasConflict(
			input.created,
			input.deleted,
		);
 
		return { created: created, deleted: deleted, renamed: renamed };
	} catch (e) {
		console.error(e);
		throw e;
	}
};
 
export const tablesResolver = async (
	input: ResolverInput<Table>,
): Promise<ResolverOutputWithMoved<Table>> => {
	try {
		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
			input.created,
			input.deleted,
			'table',
		);
 
		return {
			created: created,
			deleted: deleted,
			moved: moved,
			renamed: renamed,
		};
	} catch (e) {
		console.error(e);
		throw e;
	}
};
 
export const viewsResolver = async (
	input: ResolverInput<View>,
): Promise<ResolverOutputWithMoved<View>> => {
	try {
		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
			input.created,
			input.deleted,
			'view',
		);
 
		return {
			created: created,
			deleted: deleted,
			moved: moved,
			renamed: renamed,
		};
	} catch (e) {
		console.error(e);
		throw e;
	}
};
 
export const mySqlViewsResolver = async (
	input: ResolverInput<ViewSquashed & { schema: '' }>,
): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
	try {
		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
			input.created,
			input.deleted,
			'view',
		);
 
		return {
			created: created,
			deleted: deleted,
			moved: moved,
			renamed: renamed,
		};
	} catch (e) {
		console.error(e);
		throw e;
	}

Copyexport const checkHandler = (out: string, dialect: Dialect) => {
	const { snapshots } = prepareOutFolder(out, dialect);
	const report = validateWithReport(snapshots, dialect);

Copyconst validatorForDialect = (dialect: Dialect) => {
	switch (dialect) {
		case 'postgresql':
			return { validator: backwardCompatiblePgSchema, version: 7 };
		case 'sqlite':
			return { validator: backwardCompatibleSqliteSchema, version: 6 };
		case 'turso':
			return { validator: backwardCompatibleSqliteSchema, version: 6 };
		case 'mysql':
			return { validator: backwardCompatibleMysqlSchema, version: 5 };
		case 'singlestore':
			return { validator: backwardCompatibleSingleStoreSchema, version: 1 };
		case 'gel':
			return { validator: backwardCompatibleGelSchema, version: 1 };
	}
};

Copyif (report.nonLatest.length > 0) {
	console.log(
		report.nonLatest
			.map((it) => {
				return `${it} is not of the latest version, please run "drizzle-kit up"`;
			})
			.join('\n'),
	);
	process.exit(1);
}
 
if (report.malformed.length) {
	const message = report.malformed
		.map((it) => {
			return `${it} data is malformed`;
		})
		.join('\n');
	console.log(message);
}
 
const collisionEntries = Object.entries(report.idsMap).filter(
	(it) => it[1].snapshots.length > 1,
);
 
const message = collisionEntries
	.map((it) => {
		const data = it[1];
		return `[${
			data.snapshots.join(
				', ',
			)
		}] are pointing to a parent snapshot: ${data.parent}/snapshot.json which is a collision.`;
	})
	.join('\n');
 
if (message) {
	console.log(message);
}
 
const abort = report.malformed.length!! || collisionEntries.length > 0;
 
if (abort) {
	process.exit(1);
}

Copyconst abort = report.malformed.length!! || collisionEntries.length > 0;
 
if (abort) {
	process.exit(1);
}

Copyconst metaFilePath = join(out, 'meta', '_journal.json');
const journal = JSON.parse(readFileSync(metaFilePath, 'utf-8')) as Journal;
 
if (journal.entries.length === 0) {
	console.log(
		`[${chalk.blue('i')}] no migration entries found in ${metaFilePath}`,
	);
	return;
}

Copyconst result = await render(new DropMigrationView(journal.entries));
if (result.status === 'aborted') return;

Copyexport const upSinglestoreHandler = (out: string) => {};

Copyexport const warning = (msg: string) => {
	render(`[${chalk.yellow('Warning')}] ${msg}`);
};
export const err = (msg: string) => {
	render(`${chalk.bold.red('Error')} ${msg}`);
};
 
export const info = (msg: string, greyMsg: string = ''): string => {
	return `${chalk.blue.bold('Info:')} ${msg} ${greyMsg ? chalk.grey(greyMsg) : ''}`.trim();
};

Copyexport const schema = (schema: CommonSchema): string => {
	type TableEntry = (typeof schema)['tables'][keyof (typeof schema)['tables']];
	const tables = Object.values(schema.tables) as unknown as TableEntry[];
 
	let msg = chalk.bold(`${tables.length} tables\n`);
 
	msg += tables
		.map((t) => {
			const columnsCount = Object.values(t.columns).length;
			const indexesCount = Object.values(t.indexes).length;
			let foreignKeys: number = 0;
			// Singlestore doesn't have foreign keys
			if (schema.dialect !== 'singlestore') {
				// @ts-expect-error
				foreignKeys = Object.values(t.foreignKeys).length;
			}
 
			return `${chalk.bold.blue(t.name)} ${
				chalk.gray(
					`${columnsCount} columns ${indexesCount} indexes ${foreignKeys} fks`,
				)
			}`;
		})
		.join('\n');
 

Copyexport class Select extends Prompt<{ index: number; value: string }> {
	private readonly data: SelectState<{ label: string; value: string }>;
 
	constructor(items: string[]) {
		super();
		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
		this.on('detach', (terminal) => terminal.toggleCursor('show'));
 
		this.data = new SelectState(
			items.map((it) => ({ label: it, value: `${it}-value` })),
		);
		this.data.bind(this);
	}

Copyrender(status: 'idle' | 'submitted' | 'aborted'): string {
	if (status === 'submitted' || status === 'aborted') return '';
 
	let text = ``;
	this.data.items.forEach((it, idx) => {
		text += idx === this.data.selectedIdx
			? `${chalk.green('❯ ' + it.label)}`
			: `  ${it.label}`;
		text += idx != this.data.items.length - 1 ? '\n' : '';
	});
 
	return text;
}
 
result() {
	return {
		index: this.data.selectedIdx,
		value: this.data.items[this.data.selectedIdx]!.value!,
	};
}

Copyexport class ResolveColumnSelect<T extends Named> extends Prompt<
	RenamePropmtItem<T> | T
> {
	private readonly data: SelectState<RenamePropmtItem<T> | T>;
 
	constructor(
		private readonly tableName: string,
		private readonly base: Named,
		data: (RenamePropmtItem<T> | T)[],
	) {
		super();
		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
		this.data = new SelectState(data);
		this.data.bind(this);
	}

Copyexport class MigrateProgress extends TaskView {
	private readonly spinner: Spinner = new Spinner('⣷⣯⣟⡿⢿⣻⣽⣾'.split(''));