@anthonyalayo/drizzle-kit 1.0.1

package/.gitignore

@@ -0,0 +1,25 @@
+/*
+**/.DS_Store
+
+!src
+!imports-checker
+!tests
+!vitest.config.ts
+!README.md
+!CONTRIBUTING.md
+!schema.ts
+
+!.eslint
+!.gitignore
+!package.json
+!tsconfig.json
+!tsconfig.cli-types.json
+!tsconfig.build.json
+!pnpm-lock.yaml
+!.github
+!build.ts
+!build.dev.ts
+
+tests/test.ts
+
+!patches

package/README.md

@@ -0,0 +1,79 @@
+## Drizzle Kit
+
+Drizzle Kit is a CLI migrator tool for Drizzle ORM. It is probably the one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like deletions and renames by prompting user input.
+<https://github.com/drizzle-team/drizzle-kit-mirror> - is a mirror repository for issues.
+
+## Documentation
+
+Check the full documentation on [the website](https://orm.drizzle.team/kit-docs/overview).
+
+### How it works
+
+Drizzle Kit traverses a schema module and generates a snapshot to compare with the previous version, if there is one.
+Based on the difference, it will generate all needed SQL migrations. If there are any cases that can't be resolved automatically, such as renames, it will prompt the user for input.
+
+For example, for this schema module:
+
+```typescript
+// src/db/schema.ts
+
+import { integer, pgTable, serial, text, varchar } from "drizzle-orm/pg-core";
+
+const users = pgTable("users", {
+    id: serial("id").primaryKey(),
+    fullName: varchar("full_name", { length: 256 }),
+  }, (table) => ({
+    nameIdx: index("name_idx", table.fullName),
+  })
+);
+
+export const authOtp = pgTable("auth_otp", {
+  id: serial("id").primaryKey(),
+  phone: varchar("phone", { length: 256 }),
+  userId: integer("user_id").references(() => users.id),
+});
+```
+
+It will generate:
+
+```SQL
+CREATE TABLE IF NOT EXISTS auth_otp (
+ "id" SERIAL PRIMARY KEY,
+ "phone" character varying(256),
+ "user_id" INT
+);
+
+CREATE TABLE IF NOT EXISTS users (
+ "id" SERIAL PRIMARY KEY,
+ "full_name" character varying(256)
+);
+
+DO $$ BEGIN
+ ALTER TABLE auth_otp ADD CONSTRAINT auth_otp_user_id_fkey FOREIGN KEY ("user_id") REFERENCES users(id);
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+
+CREATE INDEX IF NOT EXISTS users_full_name_index ON users (full_name);
+```
+
+### Installation & configuration
+
+```shell
+npm install -D drizzle-kit
+```
+
+Running with CLI options:
+
+```jsonc
+// package.json
+{
+ "scripts": {
+  "generate": "drizzle-kit generate --out migrations-folder --schema src/db/schema.ts"
+ }
+}
+```
+
+```shell
+npm run generate
+```

package/build.dev.ts

@@ -0,0 +1,51 @@
+import * as esbuild from 'esbuild';
+import { cpSync } from 'node:fs';
+
+const driversPackages = [
+	// postgres drivers
+	'pg',
+	'postgres',
+	'@vercel/postgres',
+	'@neondatabase/serverless',
+	//  mysql drivers
+	'mysql2',
+	'@planetscale/database',
+	// sqlite drivers
+	'@libsql/client',
+	'better-sqlite3',
+];
+
+esbuild.buildSync({
+	entryPoints: ['./src/utils.ts'],
+	bundle: true,
+	outfile: 'dist/utils.js',
+	format: 'cjs',
+	target: 'node16',
+	platform: 'node',
+	external: ['drizzle-orm', 'esbuild', ...driversPackages],
+	banner: {
+		js: `#!/usr/bin/env -S node --loader @esbuild-kit/esm-loader --no-warnings`,
+	},
+});
+
+esbuild.buildSync({
+	entryPoints: ['./src/cli/index.ts'],
+	bundle: true,
+	outfile: 'dist/index.cjs',
+	format: 'cjs',
+	target: 'node16',
+	platform: 'node',
+	external: [
+		'commander',
+		'json-diff',
+		'glob',
+		'esbuild',
+		'drizzle-orm',
+		...driversPackages,
+	],
+	banner: {
+		js: `#!/usr/bin/env -S node --loader ./dist/loader.mjs --no-warnings`,
+	},
+});
+
+cpSync('./src/loader.mjs', 'dist/loader.mjs');

package/build.ts

@@ -0,0 +1,112 @@
+/// <reference types="bun-types" />
+import * as esbuild from 'esbuild';
+import { readFileSync, writeFileSync } from 'node:fs';
+import * as tsup from 'tsup';
+import pkg from './package.json';
+
+const driversPackages = [
+	// postgres drivers
+	'pg',
+	'postgres',
+	'@vercel/postgres',
+	'@neondatabase/serverless',
+	'@electric-sql/pglite',
+	//  mysql drivers
+	'mysql2',
+	'@planetscale/database',
+	// sqlite drivers
+	'@libsql/client',
+	'better-sqlite3',
+	'bun:sqlite',
+];
+
+esbuild.buildSync({
+	entryPoints: ['./src/utils.ts'],
+	bundle: true,
+	outfile: 'dist/utils.js',
+	format: 'cjs',
+	target: 'node16',
+	platform: 'node',
+	external: [
+		'commander',
+		'json-diff',
+		'glob',
+		'esbuild',
+		'drizzle-orm',
+		...driversPackages,
+	],
+	banner: {
+		js: `#!/usr/bin/env node`,
+	},
+});
+
+esbuild.buildSync({
+	entryPoints: ['./src/utils.ts'],
+	bundle: true,
+	outfile: 'dist/utils.mjs',
+	format: 'esm',
+	target: 'node16',
+	platform: 'node',
+	external: [
+		'commander',
+		'json-diff',
+		'glob',
+		'esbuild',
+		'drizzle-orm',
+		...driversPackages,
+	],
+	banner: {
+		js: `#!/usr/bin/env node`,
+	},
+});
+
+esbuild.buildSync({
+	entryPoints: ['./src/cli/index.ts'],
+	bundle: true,
+	outfile: 'dist/bin.cjs',
+	format: 'cjs',
+	target: 'node16',
+	platform: 'node',
+	define: {
+		'process.env.DRIZZLE_KIT_VERSION': `"${pkg.version}"`,
+	},
+	external: [
+		'esbuild',
+		'drizzle-orm',
+		...driversPackages,
+	],
+	banner: {
+		js: `#!/usr/bin/env node`,
+	},
+});
+
+const main = async () => {
+	await tsup.build({
+		entryPoints: ['./src/index.ts', './src/api.ts'],
+		outDir: './dist',
+		external: ['bun:sqlite'],
+		splitting: false,
+		dts: true,
+		format: ['cjs', 'esm'],
+		outExtension: (ctx) => {
+			if (ctx.format === 'cjs') {
+				return {
+					dts: '.d.ts',
+					js: '.js',
+				};
+			}
+			return {
+				dts: '.d.mts',
+				js: '.mjs',
+			};
+		},
+	});
+
+	const apiCjs = readFileSync('./dist/api.js', 'utf8').replace(/await import\(/g, 'require(');
+	writeFileSync('./dist/api.js', apiCjs);
+};
+
+main().catch((e) => {
+	console.error(e);
+	process.exit(1);
+});

package/imports-checker/analyze.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from 'fs';
+import type { Node } from 'ohm-js';
+import JSImports from './grammar/grammar.ohm-bundle';
+
+export type CollectionItem = {
+	type: 'data' | 'types';
+	source: string;
+};
+
+function recursiveRun(...args: Node[]): boolean {
+	for (const arg of args) {
+		if (
+			arg.ctorName === 'Rest'
+			|| arg.ctorName === 'comment'
+			|| arg.ctorName === 'stringLiteral'
+		) {
+			continue;
+		}
+
+		if (
+			arg.ctorName === 'ImportExpr_From'
+			|| arg.ctorName === 'ImportExpr_NoFrom'
+		) {
+			arg['analyze']();
+
+			continue;
+		}
+
+		if (arg.isTerminal()) continue;
+
+		for (const c of arg.children) {
+			if (!recursiveRun(c)) return false;
+		}
+	}
+
+	return true;
+}
+function init(collection: CollectionItem[]) {
+	const semantics = JSImports.createSemantics();
+
+	semantics.addOperation('analyze', {
+		JSImports(arg0, arg1) {
+			recursiveRun(arg0, arg1);
+		},
+
+		ImportExpr_From(kImport, importInner, kFrom, importSource) {
+			const ruleName = importInner.children[0]!.ctorName;
+			const importType = ruleName === 'ImportInner_Type' || ruleName === 'ImportInner_Types'
+				? 'types'
+				: 'data';
+
+			collection.push({
+				source: importSource.children[1]!.sourceString!,
+				type: importType,
+			});
+		},
+
+		ImportExpr_NoFrom(kImport, importSource) {
+			collection.push({
+				source: importSource.children[1]!.sourceString!,
+				type: 'data',
+			});
+		},
+	});
+
+	return semantics;
+}
+
+export function analyze(path: string) {
+	const file = readFileSync(path).toString();
+	const match = JSImports.match(file, 'JSImports');
+
+	if (match.failed()) throw new Error(`Failed to parse file: ${path}`);
+	const collection: CollectionItem[] = [];
+
+	init(collection)(match)['analyze']();
+	return collection;
+}

package/imports-checker/checker.ts

@@ -0,0 +1,296 @@
+import fs from 'fs';
+import m from 'micromatch';
+import { dirname, join as joinPath, relative, resolve as resolvePath } from 'path';
+import { analyze } from './analyze';
+
+type External = {
+	file: string;
+	import: string;
+	type: 'data' | 'types';
+};
+
+export type Issue = {
+	file: string;
+	imports: IssueImport[];
+	accessChains: ChainLink[][];
+};
+
+export type IssueImport = {
+	name: string;
+	type: 'data' | 'types';
+};
+
+export type ChainLink = {
+	file: string;
+	import: string;
+};
+
+type ListMode = 'whitelist' | 'blacklist';
+
+class ImportAnalyzer {
+	private localImportRegex = /^(\.?\.?\/|\.\.?$)/;
+	private importedFileFormatRegex = /^.*\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|json)$/i;
+
+	private visited: Set<string> = new Set<string>();
+
+	private externals: External[] = [];
+	private accessChains: Record<string, ChainLink[][]> = {};
+
+	constructor(
+		private basePath: string,
+		private entry: string,
+		private listMode: ListMode,
+		private readonly wantedList: string[],
+		private localPaths: string[],
+		private logger?: boolean,
+		private ignoreTypes?: boolean,
+	) {}
+
+	private isDirectory = (path: string) => {
+		try {
+			return fs.lstatSync(path).isDirectory();
+		} catch (e) {
+			return false;
+		}
+	};
+
+	private isFile = (path: string) => {
+		try {
+			return fs.lstatSync(path).isFile();
+		} catch (e) {
+			return false;
+		}
+	};
+
+	private localizePath = (path: string) => relative(resolvePath(this.basePath), resolvePath(path));
+
+	private isCustomLocal = (importTarget: string) =>
+		!!this.localPaths.find(
+			(l) =>
+				importTarget === l
+				|| importTarget.startsWith(l.endsWith('/') ? l : `${l}/`),
+		);
+	private isLocal = (importTarget: string) =>
+		this.localImportRegex.test(importTarget)
+		|| this.isCustomLocal(importTarget);
+	private isTsFormat = (path: string) => this.importedFileFormatRegex.test(path);
+
+	private resolveCustomLocalPath = (
+		absoluteBase: string,
+		base: string,
+		target: string,
+	): string => {
+		return joinPath(absoluteBase, target);
+	};
+
+	private resolveTargetFile = (path: string): string => {
+		if (this.isFile(path)) return path;
+
+		const formats = [
+			'.ts',
+			'.mts',
+			'.cts',
+			'.tsx',
+			'.js',
+			'.mjs',
+			'.cjs',
+			'.jsx',
+		];
+
+		for (const format of formats) {
+			const indexPath = joinPath(path, `/index${format}`);
+			if (this.isFile(indexPath)) return indexPath;
+
+			const formatFilePath = `${path}${format}`;
+			if (this.isFile(formatFilePath)) return formatFilePath;
+		}
+
+		return path;
+	};
+
+	private resolveTargetPath = (
+		absoluteBase: string,
+		base: string,
+		target: string,
+	): string => {
+		if (this.isCustomLocal(target)) {
+			return this.resolveTargetFile(
+				this.resolveCustomLocalPath(absoluteBase, base, target),
+			);
+		}
+
+		const dir = this.isDirectory(base) ? base : dirname(base);
+		const joined = joinPath(dir, target);
+
+		return this.resolveTargetFile(joined);
+	};
+
+	private _analyzeImports = (
+		target: string = this.entry,
+		basePath: string = this.basePath,
+		accessChain: ChainLink[] = [],
+	) => {
+		if (this.visited.has(target)) return;
+
+		const locals: string[] = [];
+
+		try {
+			if (this.logger) console.log(`${this.localizePath(target)}`);
+
+			const imports = analyze(target);
+
+			for (const { source: i, type } of imports) {
+				if (this.ignoreTypes && type === 'types') continue;
+
+				if (this.isLocal(i)) {
+					locals.push(i);
+
+					continue;
+				}
+
+				this.externals.push({
+					file: this.localizePath(target),
+					import: i,
+					type: type,
+				});
+			}
+		} catch (e) {
+			throw e;
+		} finally {
+			this.visited.add(target);
+		}
+
+		for (const local of locals) {
+			const transformedTarget = this.resolveTargetPath(basePath, target, local);
+
+			const localChain = [
+				...accessChain,
+				{
+					file: this.localizePath(target),
+					import: local,
+				},
+			];
+
+			const localized = this.localizePath(transformedTarget);
+
+			if (this.accessChains[localized]) {
+				this.accessChains[localized].push(localChain);
+			} else this.accessChains[localized] = [localChain];
+
+			if (this.isTsFormat(transformedTarget)) {
+				this._analyzeImports(transformedTarget, basePath, localChain);
+			} else {
+				throw new Error(`unrecognized: ${localized}`);
+			}
+		}
+	};
+
+	public analyzeImports = () => {
+		const entryLocalized = this.localizePath(this.entry);
+		if (!this.accessChains[entryLocalized]) {
+			this.accessChains[entryLocalized] = [[]];
+		}
+
+		this._analyzeImports();
+
+		const rawIssues = this.listMode === 'whitelist'
+			? this.externals.filter((e) => !m([e.import], this.wantedList).length)
+			: this.externals.filter((e) => m([e.import], this.wantedList).length);
+
+		const issueMap: Record<string, Issue> = {};
+		for (const { file, import: i, type } of rawIssues) {
+			if (issueMap[file]) {
+				issueMap[file].imports.push({
+					name: i,
+					type,
+				});
+
+				continue;
+			}
+
+			issueMap[file] = {
+				file,
+				imports: [
+					{
+						name: i,
+						type,
+					},
+				],
+				accessChains: this.accessChains[file]!,
+			};
+		}
+
+		return {
+			issues: Object.entries(issueMap).map(([file, data]) => {
+				for (const chain of data.accessChains) {
+					chain.push({
+						file,
+						import: '',
+					});
+				}
+
+				return data;
+			}),
+			accessChains: this.accessChains,
+		};
+	};
+}
+
+export type CustomLocalPathResolver = (
+	basePath: string,
+	path: string,
+	target: string,
+) => string;
+
+export type AnalyzeImportsConfig =
+	& {
+		basePath: string;
+		entry: string;
+		logger?: boolean;
+		ignoreTypes?: boolean;
+		localPaths?: string[];
+	}
+	& (
+		| {
+			blackList: string[];
+		}
+		| {
+			whiteList: string[];
+		}
+	);
+
+type AnyAnalyzeImportsConfig = {
+	basePath: string;
+	entry: string;
+	blackList?: string[];
+	whiteList?: string[];
+	logger?: boolean;
+	ignoreTypes?: boolean;
+	localPaths?: string[];
+};
+
+export function analyzeImports(cfg: AnalyzeImportsConfig) {
+	const {
+		basePath,
+		blackList,
+		whiteList,
+		entry,
+		localPaths: localImports,
+		ignoreTypes,
+		logger,
+	} = cfg as AnyAnalyzeImportsConfig;
+	const mode = whiteList ? 'whitelist' : 'blacklist';
+	const wantedList = blackList ?? whiteList!;
+
+	const analyzer = new ImportAnalyzer(
+		joinPath(basePath),
+		joinPath(entry),
+		mode,
+		wantedList,
+		localImports ?? [],
+		logger,
+		ignoreTypes,
+	);
+
+	return analyzer.analyzeImports();
+}