Feat: MsSql support

drizzle-kit/package.json

@@ -65,6 +65,7 @@
 		"@types/json-diff": "^1.0.3",
 		"@types/micromatch": "^4.0.9",
 		"@types/minimatch": "^5.1.2",
+		"@types/mssql": "^9.1.4",
 		"@types/node": "^18.11.15",
 		"@types/pg": "^8.10.7",
 		"@types/pluralize": "^0.0.33",
@@ -97,6 +98,7 @@
 		"json-diff": "1.0.6",
 		"micromatch": "^4.0.8",
 		"minimatch": "^7.4.3",
+		"mssql": "^10.0.1",
 		"mysql2": "3.3.3",
 		"node-fetch": "^3.3.2",
 		"ohm-js": "^17.1.0",

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

@@ -5,6 +5,7 @@ import { Minimatch } from 'minimatch';
 import { join } from 'path';
 import { plural, singular } from 'pluralize';
 import { GelSchema } from 'src/serializer/gelSchema';
+import { dryMsSql, MsSqlSchema, squashMssqlScheme } from 'src/serializer/mssqlSchema';
 import { drySingleStore, SingleStoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
 import { assertUnreachable, originUUID } from '../../global';
 import { schemaToTypeScript as gelSchemaToTypeScript } from '../../introspect-gel';
@@ -13,6 +14,7 @@ import { paramNameFor, schemaToTypeScript as postgresSchemaToTypeScript } from '
 import { schemaToTypeScript as singlestoreSchemaToTypeScript } from '../../introspect-singlestore';
 import { schemaToTypeScript as sqliteSchemaToTypeScript } from '../../introspect-sqlite';
 import { fromDatabase as fromGelDatabase } from '../../serializer/gelSerializer';
+import { fromDatabase as fromMssqlDatabase } from '../../serializer/mssqlSerializer';
 import { dryMySql, MySqlSchema, squashMysqlScheme } from '../../serializer/mysqlSchema';
 import { fromDatabase as fromMysqlDatabase } from '../../serializer/mysqlSerializer';
 import { dryPg, type PgSchema, squashPgScheme } from '../../serializer/pgSchema';
@@ -22,6 +24,7 @@ import { drySQLite, type SQLiteSchema, squashSqliteScheme } from '../../serializ
 import { fromDatabase as fromSqliteDatabase } from '../../serializer/sqliteSerializer';
 import {
 	applyLibSQLSnapshotsDiff,
+	applyMssqlSnapshotsDiff,
 	applyMysqlSnapshotsDiff,
 	applyPgSnapshotsDiff,
 	applySingleStoreSnapshotsDiff,
@@ -32,6 +35,7 @@ import { Entities } from '../validations/cli';
 import type { Casing, Prefix } from '../validations/common';
 import { GelCredentials } from '../validations/gel';
 import { LibSQLCredentials } from '../validations/libsql';
+import { MssqlCredentials } from '../validations/mssql';
 import type { MysqlCredentials } from '../validations/mysql';
 import type { PostgresCredentials } from '../validations/postgres';
 import { SingleStoreCredentials } from '../validations/singlestore';
@@ -415,6 +419,117 @@ export const introspectMysql = async (
 	process.exit(0);
 };
 
+// export const introspectMssql = async (
+// 	casing: Casing,
+// 	out: string,
+// 	breakpoints: boolean,
+// 	credentials: MssqlCredentials,
+// 	tablesFilter: string[],
+// 	prefix: Prefix,
+// ) => {
+// 	const { connectToMsSQL } = await import('../connections');
+// 	const { db, database } = await connectToMsSQL(credentials);
+
+// 	const matchers = tablesFilter.map((it) => {
+// 		return new Minimatch(it);
+// 	});
+
+// 	const filter = (tableName: string) => {
+// 		if (matchers.length === 0) return true;
+
+// 		let flags: boolean[] = [];
+
+// 		for (let matcher of matchers) {
+// 			if (matcher.negate) {
+// 				if (!matcher.match(tableName)) {
+// 					flags.push(false);
+// 				}
+// 			}
+
+// 			if (matcher.match(tableName)) {
+// 				flags.push(true);
+// 			}
+// 		}
+
+// 		if (flags.length > 0) {
+// 			return flags.every(Boolean);
+// 		}
+// 		return false;
+// 	};
+
+// 	const progress = new IntrospectProgress();
+// 	const res = await renderWithTask(
+// 		progress,
+// 		fromMssqlDatabase(db, database, filter, (stage, count, status) => {
+// 			progress.update(stage, count, status);
+// 		}),
+// 	);
+
+// 	const schema = { id: originUUID, prevId: '', ...res } as MsSqlSchema;
+// 	const ts = mssqlSchemaToTypeScript(schema, casing);
+// 	const relationsTs = relationsToTypeScript(schema, casing);
+// 	const { internal, ...schemaWithoutInternals } = schema;
+
+// 	const schemaFile = join(out, 'schema.ts');
+// 	writeFileSync(schemaFile, ts.file);
+// 	const relationsFile = join(out, 'relations.ts');
+// 	writeFileSync(relationsFile, relationsTs.file);
+// 	console.log();
+
+// 	const { snapshots, journal } = prepareOutFolder(out, 'mysql');
+
+// 	if (snapshots.length === 0) {
+// 		const { sqlStatements, _meta } = await applyMssqlSnapshotsDiff(
+// 			squashMssqlScheme(dryMsSql),
+// 			squashMssqlScheme(schema),
+// 			tablesResolver,
+// 			columnsResolver,
+// 			mySqlViewsResolver,
+// 			dryMsSql,
+// 			schema,
+// 		);
+
+// 		writeResult({
+// 			cur: schema,
+// 			sqlStatements,
+// 			journal,
+// 			_meta,
+// 			outFolder: out,
+// 			breakpoints,
+// 			type: 'introspect',
+// 			prefixMode: prefix,
+// 		});
+// 	} else {
+// 		render(
+// 			`[${
+// 				chalk.blue(
+// 					'i',
+// 				)
+// 			}] No SQL generated, you already have migrations in project`,
+// 		);
+// 	}
+
+// 	render(
+// 		`[${
+// 			chalk.green(
+// 				'✓',
+// 			)
+// 		}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+// 	);
+// 	render(
+// 		`[${
+// 			chalk.green(
+// 				'✓',
+// 			)
+// 		}] Your relations file is ready ➜ ${
+// 			chalk.bold.underline.blue(
+// 				relationsFile,
+// 			)
+// 		} 🚀`,
+// 	);
+// 	process.exit(0);
+// };
+
 export const introspectSingleStore = async (
 	casing: Casing,
 	out: string,

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

@@ -1,5 +1,7 @@
 import fs from 'fs';
 import {
+	// prepareMsSqlDbPushSnapshot,
+	// prepareMsSqlMigrationSnapshot,
 	prepareMySqlDbPushSnapshot,
 	prepareMySqlMigrationSnapshot,
 	preparePgDbPushSnapshot,
@@ -13,6 +15,7 @@ import {
 import chalk from 'chalk';
 import { render } from 'hanji';
 import path, { join } from 'path';
+import { MsSqlSchema, mssqlSchema, squashMssqlScheme } from 'src/serializer/mssqlSchema';
 import { SingleStoreSchema, singlestoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
 import { TypeOf } from 'zod';
 import type { CommonSchema } from '../../schemaValidator';
@@ -21,6 +24,7 @@ import { PgSchema, pgSchema, Policy, Role, squashPgScheme, View } from '../../se
 import { SQLiteSchema, sqliteSchema, squashSqliteScheme, View as SQLiteView } from '../../serializer/sqliteSchema';
 import {
 	applyLibSQLSnapshotsDiff,
+	applyMssqlSnapshotsDiff,
 	applyMysqlSnapshotsDiff,
 	applyPgSnapshotsDiff,
 	applySingleStoreSnapshotsDiff,
@@ -674,6 +678,7 @@ export const prepareSingleStorePush = async (
 	}
 };
 
+// singlestore
 export const prepareAndMigrateSingleStore = async (config: GenerateConfig) => {
 	const outFolder = config.out;
 	const schemaPath = config.schema;
@@ -799,6 +804,7 @@ export const prepareAndExportMysql = async (config: ExportConfig) => {
 	}
 };
 
+// sqlite
 export const prepareAndMigrateSqlite = async (config: GenerateConfig) => {
 	const outFolder = config.out;
 	const schemaPath = config.schema;
@@ -1054,6 +1060,137 @@ export const prepareLibSQLPush = async (
 	};
 };
 
+// TODO() mssql
+// export const prepareAndExportMssql = async (config: ExportConfig) => {
+// 	const schemaPath = config.schema;
+
+// 	try {
+// 		const { prev, cur, custom } = await prepareMsSqlMigrationSnapshot(
+// 			[],
+// 			schemaPath,
+// 			undefined,
+// 		);
+
+// 		const validatedPrev = mssqlSchema.parse(prev);
+// 		const validatedCur = mssqlSchema.parse(cur);
+
+// 		const squashedPrev = squashMssqlScheme(validatedPrev);
+// 		const squashedCur = squashMssqlScheme(validatedCur);
+
+// 		const { sqlStatements, statements, _meta } = await applyMssqlSnapshotsDiff(
+// 			squashedPrev,
+// 			squashedCur,
+// 			tablesResolver,
+// 			columnsResolver,
+// 			mySqlViewsResolver,
+// 			validatedPrev,
+// 			validatedCur,
+// 		);
+
+// 		console.log(sqlStatements.join('\n'));
+// 	} catch (e) {
+// 		console.error(e);
+// 	}
+// };
+
+// Intersect with prepareAnMigrate
+// export const prepareMsSQLPush = async (
+// 	schemaPath: string | string[],
+// 	snapshot: MsSqlSchema,
+// 	casing: CasingType | undefined,
+// ) => {
+// 	try {
+// 		const { prev, cur } = await prepareMsSqlDbPushSnapshot(
+// 			snapshot,
+// 			schemaPath,
+// 			casing,
+// 		);
+
+// 		const validatedPrev = mssqlSchema.parse(prev);
+// 		const validatedCur = mssqlSchema.parse(cur);
+
+// 		const squashedPrev = squashMssqlScheme(validatedPrev);
+// 		const squashedCur = squashMssqlScheme(validatedCur);
+
+// 		const { sqlStatements, statements } = await applyMssqlSnapshotsDiff(
+// 			squashedPrev,
+// 			squashedCur,
+// 			tablesResolver,
+// 			columnsResolver,
+// 			mySqlViewsResolver,
+// 			validatedPrev,
+// 			validatedCur,
+// 			'push',
+// 		);
+
+// 		return { sqlStatements, statements, validatedCur, validatedPrev };
+// 	} catch (e) {
+// 		console.error(e);
+// 		process.exit(1);
+// 	}
+// };
+
+export const prepareAndMigrateMsSQL = async (config: GenerateConfig) => {
+	const outFolder = config.out;
+	const schemaPath = config.schema;
+	const casing = config.casing;
+
+	try {
+		// TODO: remove
+		// assertV1OutFolder(outFolder);
+
+		// const { snapshots, journal } = prepareMigrationFolder(outFolder, 'mssql');
+		// const { prev, cur, custom } = await prepareMsSqlMigrationSnapshot(
+		// 	snapshots,
+		// 	schemaPath,
+		// 	casing,
+		// );
+
+		// const validatedPrev = mssqlSchema.parse(prev);
+		// const validatedCur = mssqlSchema.parse(cur);
+
+		// if (config.custom) {
+		// 	writeResult({
+		// 		cur: custom,
+		// 		sqlStatements: [],
+		// 		journal,
+		// 		outFolder,
+		// 		name: config.name,
+		// 		breakpoints: config.breakpoints,
+		// 		type: 'custom',
+		// 		prefixMode: config.prefix,
+		// 	});
+		// 	return;
+		// }
+
+		// const squashedPrev = squashMssqlScheme(validatedPrev);
+		// const squashedCur = squashMssqlScheme(validatedCur);
+
+		// const { sqlStatements, statements, _meta } = await applyMssqlSnapshotsDiff(
+		// 	squashedPrev,
+		// 	squashedCur,
+		// 	tablesResolver,
+		// 	columnsResolver,
+		// 	mySqlViewsResolver,
+		// 	validatedPrev,
+		// 	validatedCur,
+		// );
+
+		// writeResult({
+		// 	cur,
+		// 	sqlStatements,
+		// 	journal,
+		// 	_meta,
+		// 	outFolder,
+		// 	name: config.name,
+		// 	breakpoints: config.breakpoints,
+		// 	prefixMode: config.prefix,
+		// });
+	} catch (e) {
+		console.error(e);
+	}
+};
+
 const freeeeeeze = (obj: any) => {
 	Object.freeze(obj);
 	for (let key in obj) {

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

@@ -0,0 +1,53 @@
+import { renderWithTask } from 'hanji';
+import { Minimatch } from 'minimatch';
+import { MsSqlSchema } from 'src/serializer/mssqlSchema';
+import { fromDatabase } from 'src/serializer/mssqlSerializer';
+import { originUUID } from '../../global';
+import type { DB } from '../../utils';
+import { ProgressView } from '../views';
+
+export const mssqlPushIntrospect = async (
+	db: DB,
+	databaseName: string,
+	filters: string[],
+) => {
+	const matchers = filters.map((it) => {
+		return new Minimatch(it);
+	});
+
+	const filter = (tableName: string) => {
+		if (matchers.length === 0) return true;
+
+		let flags: boolean[] = [];
+
+		for (let matcher of matchers) {
+			if (matcher.negate) {
+				if (!matcher.match(tableName)) {
+					flags.push(false);
+				}
+			}
+
+			if (matcher.match(tableName)) {
+				flags.push(true);
+			}
+		}
+
+		if (flags.length > 0) {
+			return flags.every(Boolean);
+		}
+		return false;
+	};
+
+	const progress = new ProgressView(
+		'Pulling schema from database...',
+		'Pulling schema from database...',
+	);
+	const res = await renderWithTask(
+		progress,
+		fromDatabase(db, databaseName, filter),
+	);
+
+	const schema = { id: originUUID, prevId: '', ...res } as MsSqlSchema;
+	const { internal, ...schemaWithoutInternals } = schema;
+	return { schema: schemaWithoutInternals };
+};