@anthonyalayo/drizzle-kit 1.0.1 → 1.0.4

package/src/utils.ts

@@ -1,370 +0,0 @@
-import type { RunResult } from 'better-sqlite3';
-import chalk from 'chalk';
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { parse } from 'url';
-import type { NamedWithSchema } from './cli/commands/migrate';
-import { info } from './cli/views';
-import { assertUnreachable, snapshotVersion } from './global';
-import type { Dialect } from './schemaValidator';
-import { backwardCompatibleMysqlSchema } from './serializer/mysqlSchema';
-import { backwardCompatiblePgSchema } from './serializer/pgSchema';
-import { backwardCompatibleSingleStoreSchema } from './serializer/singlestoreSchema';
-import { backwardCompatibleSqliteSchema } from './serializer/sqliteSchema';
-import type { ProxyParams } from './serializer/studio';
-
-export type Proxy = (params: ProxyParams) => Promise<any[]>;
-
-export type SqliteProxy = {
-	proxy: (params: ProxyParams) => Promise<any[] | RunResult>;
-};
-
-export type DB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-};
-
-export type SQLiteDB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-	run(query: string): Promise<void>;
-};
-
-export type LibSQLDB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-	run(query: string): Promise<void>;
-	batchWithPragma?(queries: string[]): Promise<void>;
-};
-
-export const copy = <T>(it: T): T => {
-	return JSON.parse(JSON.stringify(it));
-};
-
-export const objectValues = <T extends object>(obj: T): Array<T[keyof T]> => {
-	return Object.values(obj);
-};
-
-export const assertV1OutFolder = (out: string) => {
-	if (!existsSync(out)) return;
-
-	const oldMigrationFolders = readdirSync(out).filter(
-		(it) => it.length === 14 && /^\d+$/.test(it),
-	);
-
-	if (oldMigrationFolders.length > 0) {
-		console.log(
-			`Your migrations folder format is outdated, please run ${
-				chalk.green.bold(
-					`drizzle-kit up`,
-				)
-			}`,
-		);
-		process.exit(1);
-	}
-};
-
-export type Journal = {
-	version: string;
-	dialect: Dialect;
-	entries: {
-		idx: number;
-		version: string;
-		when: number;
-		tag: string;
-		breakpoints: boolean;
-	}[];
-};
-
-export const dryJournal = (dialect: Dialect): Journal => {
-	return {
-		version: snapshotVersion,
-		dialect,
-		entries: [],
-	};
-};
-
-// export const preparePushFolder = (dialect: Dialect) => {
-//   const out = ".drizzle";
-//   let snapshot: string = "";
-//   if (!existsSync(join(out))) {
-//     mkdirSync(out);
-//     snapshot = JSON.stringify(dryJournal(dialect));
-//   } else {
-//     snapshot = readdirSync(out)[0];
-//   }
-
-//   return { snapshot };
-// };
-
-export const prepareOutFolder = (out: string, dialect: Dialect) => {
-	const meta = join(out, 'meta');
-	const journalPath = join(meta, '_journal.json');
-
-	if (!existsSync(join(out, 'meta'))) {
-		mkdirSync(meta, { recursive: true });
-		writeFileSync(journalPath, JSON.stringify(dryJournal(dialect)));
-	}
-
-	const journal = JSON.parse(readFileSync(journalPath).toString());
-
-	const snapshots = readdirSync(meta)
-		.filter((it) => !it.startsWith('_'))
-		.map((it) => join(meta, it));
-
-	snapshots.sort();
-	return { meta, snapshots, journal };
-};
-
-const 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 };
-	}
-};
-
-export const validateWithReport = (snapshots: string[], dialect: Dialect) => {
-	// ✅ check if drizzle-kit can handle snapshot version
-	// ✅ check if snapshot is of the last version
-	// ✅ check if id of the snapshot is valid
-	// ✅ collect {} of prev id -> snapshotName[], if there's more than one - tell about collision
-	const { validator, version } = validatorForDialect(dialect);
-
-	const result = snapshots.reduce(
-		(accum, it) => {
-			const raw = JSON.parse(readFileSync(`./${it}`).toString());
-
-			accum.rawMap[it] = raw;
-
-			if (raw['version'] && Number(raw['version']) > version) {
-				console.log(
-					info(
-						`${it} snapshot is of unsupported version, please update drizzle-kit`,
-					),
-				);
-				process.exit(0);
-			}
-
-			const result = validator.safeParse(raw);
-			if (!result.success) {
-				accum.malformed.push(it);
-				return accum;
-			}
-
-			const snapshot = result.data;
-			if (snapshot.version !== String(version)) {
-				accum.nonLatest.push(it);
-				return accum;
-			}
-
-			// only if latest version here
-			const idEntry = accum.idsMap[snapshot['prevId']] ?? {
-				parent: it,
-				snapshots: [],
-			};
-			idEntry.snapshots.push(it);
-			accum.idsMap[snapshot['prevId']] = idEntry;
-
-			return accum;
-		},
-		{
-			malformed: [],
-			nonLatest: [],
-			idToNameMap: {},
-			idsMap: {},
-			rawMap: {},
-		} as {
-			malformed: string[];
-			nonLatest: string[];
-			idsMap: Record<string, { parent: string; snapshots: string[] }>;
-			rawMap: Record<string, any>;
-		},
-	);
-
-	return result;
-};
-
-export const prepareMigrationFolder = (
-	outFolder: string = 'drizzle',
-	dialect: Dialect,
-) => {
-	const { snapshots, journal } = prepareOutFolder(outFolder, dialect);
-	const report = validateWithReport(snapshots, dialect);
-	if (report.nonLatest.length > 0) {
-		console.log(
-			report.nonLatest
-				.map((it) => {
-					return `${it}/snapshot.json is not of the latest version`;
-				})
-				.concat(`Run ${chalk.green.bold(`drizzle-kit up`)}`)
-				.join('\n'),
-		);
-		process.exit(0);
-	}
-
-	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')
-		.trim();
-	if (message) {
-		console.log(chalk.red.bold('Error:'), message);
-	}
-
-	const abort = report.malformed.length!! || collisionEntries.length > 0;
-
-	if (abort) {
-		process.exit(0);
-	}
-
-	return { snapshots, journal };
-};
-
-export const prepareMigrationMeta = (
-	schemas: { from: string; to: string }[],
-	tables: { from: NamedWithSchema; to: NamedWithSchema }[],
-	columns: {
-		from: { table: string; schema: string; column: string };
-		to: { table: string; schema: string; column: string };
-	}[],
-) => {
-	const _meta = {
-		schemas: {} as Record<string, string>,
-		tables: {} as Record<string, string>,
-		columns: {} as Record<string, string>,
-	};
-
-	schemas.forEach((it) => {
-		const from = schemaRenameKey(it.from);
-		const to = schemaRenameKey(it.to);
-		_meta.schemas[from] = to;
-	});
-	tables.forEach((it) => {
-		const from = tableRenameKey(it.from);
-		const to = tableRenameKey(it.to);
-		_meta.tables[from] = to;
-	});
-
-	columns.forEach((it) => {
-		const from = columnRenameKey(it.from.table, it.from.schema, it.from.column);
-		const to = columnRenameKey(it.to.table, it.to.schema, it.to.column);
-		_meta.columns[from] = to;
-	});
-
-	return _meta;
-};
-
-export const schemaRenameKey = (it: string) => {
-	return it;
-};
-
-export const tableRenameKey = (it: NamedWithSchema) => {
-	const out = it.schema ? `"${it.schema}"."${it.name}"` : `"${it.name}"`;
-	return out;
-};
-
-export const columnRenameKey = (
-	table: string,
-	schema: string,
-	column: string,
-) => {
-	const out = schema
-		? `"${schema}"."${table}"."${column}"`
-		: `"${table}"."${column}"`;
-	return out;
-};
-
-export const kloudMeta = () => {
-	return {
-		pg: [5],
-		mysql: [] as number[],
-		sqlite: [] as number[],
-	};
-};
-
-export const normaliseSQLiteUrl = (
-	it: string,
-	type: 'libsql' | 'better-sqlite',
-) => {
-	if (type === 'libsql') {
-		if (it.startsWith('file:')) {
-			return it;
-		}
-		try {
-			const url = parse(it);
-			if (url.protocol === null) {
-				return `file:${it}`;
-			}
-			return it;
-		} catch (e) {
-			return `file:${it}`;
-		}
-	}
-
-	if (type === 'better-sqlite') {
-		if (it.startsWith('file:')) {
-			return it.substring(5);
-		}
-
-		return it;
-	}
-
-	assertUnreachable(type);
-};
-
-export const normalisePGliteUrl = (
-	it: string,
-) => {
-	if (it.startsWith('file:')) {
-		return it.substring(5);
-	}
-
-	return it;
-};
-
-export function isPgArrayType(sqlType: string) {
-	return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
-}
-
-export function findAddedAndRemoved(columnNames1: string[], columnNames2: string[]) {
-	const set1 = new Set(columnNames1);
-	const set2 = new Set(columnNames2);
-
-	const addedColumns = columnNames2.filter((it) => !set1.has(it));
-	const removedColumns = columnNames1.filter((it) => !set2.has(it));
-
-	return { addedColumns, removedColumns };
-}
-
-export function escapeSingleQuotes(str: string) {
-	return str.replace(/'/g, "''");
-}
-
-export function unescapeSingleQuotes(str: string, ignoreFirstAndLastChar: boolean) {
-	const regex = ignoreFirstAndLastChar ? /(?<!^)'(?!$)/g : /'/g;
-	return str.replace(/''/g, "'").replace(regex, "\\'");
-}

package/tests/bin.test.ts

@@ -1,58 +0,0 @@
-import chalk from 'chalk';
-import { assert, test } from 'vitest';
-import { analyzeImports, ChainLink } from '../imports-checker/checker';
-
-test('imports-issues', () => {
-	const issues = analyzeImports({
-		basePath: '.',
-		localPaths: ['src'],
-		whiteList: [
-			'@drizzle-team/brocli',
-			'json-diff',
-			'path',
-			'fs',
-			'fs/*',
-			'url',
-			'zod',
-			'node:*',
-			'hono',
-			'glob',
-			'hono/*',
-			'hono/**/*',
-			'@hono/*',
-			'crypto',
-			'hanji',
-			'chalk',
-			'dotenv/config',
-			'camelcase',
-			'semver',
-			'env-paths',
-		],
-		entry: 'src/cli/index.ts',
-		logger: true,
-		ignoreTypes: true,
-	}).issues;
-
-	const chainToString = (chains: ChainLink[]) => {
-		if (chains.length === 0) throw new Error();
-
-		let out = chains[0]!.file + '\n';
-		let indentation = 0;
-		for (let chain of chains) {
-			out += ' '.repeat(indentation)
-				+ '└'
-				+ chain.import
-				+ ` ${chalk.gray(chain.file)}\n`;
-			indentation += 1;
-		}
-		return out;
-	};
-
-	console.log();
-	for (const issue of issues) {
-		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
-		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
-	}
-
-	assert.equal(issues.length, 0);
-});

package/tests/cli/d1http.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'sqlite',
-	driver: 'd1-http',
-	dbCredentials: {
-		accountId: 'accid',
-		databaseId: 'dbid',
-		token: 'token',
-	},
-});

package/tests/cli/drizzle.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'postgresql',
-	dbCredentials: {
-		url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
-	},
-});

package/tests/cli/durable-sqlite.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'sqlite',
-	driver: 'durable-sqlite',
-});

package/tests/cli/expo.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'sqlite',
-	driver: 'expo',
-});

package/tests/cli/postgres.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'postgresql',
-	dbCredentials: {
-		host: '127.0.0.1',
-		port: 5432,
-		user: 'postgresql',
-		password: 'postgres',
-		database: 'db',
-	},
-});

package/tests/cli/postgres2.config.ts

@@ -1,17 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'postgresql',
-	dbCredentials: {
-		host: '127.0.0.1',
-		port: 5432,
-		user: 'postgresql',
-		password: 'postgres',
-		database: 'db',
-	},
-	migrations: {
-		schema: 'custom',
-		table: 'custom',
-	},
-});

package/tests/cli/schema.ts

@@ -1 +0,0 @@
-// mock

package/tests/cli/turso.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from '../../src';
-
-export default defineConfig({
-	schema: './schema.ts',
-	dialect: 'turso',
-	dbCredentials: {
-		url: 'turso.dev',
-		authToken: 'token',
-	},
-});

package/tests/cli-export.test.ts

@@ -1,79 +0,0 @@
-import { test as brotest } from '@drizzle-team/brocli';
-import { assert, expect, test } from 'vitest';
-import { exportRaw } from '../src/cli/schema';
-
-// good:
-// #1 drizzle-kit export --dialect=postgresql --schema=schema.ts
-// #3 drizzle-kit export
-// #3 drizzle-kit export --config=drizzle1.config.ts
-
-// errors:
-// #1 drizzle-kit export --schema=src/schema.ts
-// #2 drizzle-kit export --dialect=postgresql
-// #3 drizzle-kit export --dialect=postgresql2
-// #4 drizzle-kit export --config=drizzle.config.ts --schema=schema.ts
-// #5 drizzle-kit export --config=drizzle.config.ts --dialect=postgresql
-
-test('export #1', async (t) => {
-	const res = await brotest(
-		exportRaw,
-		'--dialect=postgresql --schema=schema.ts',
-	);
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		schema: 'schema.ts',
-		sql: true,
-	});
-});
-
-test('export #2', async (t) => {
-	const res = await brotest(exportRaw, '');
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		schema: './schema.ts',
-		sql: true,
-	});
-});
-
-// custom config path
-test('export #3', async (t) => {
-	const res = await brotest(exportRaw, '--config=expo.config.ts');
-	assert.equal(res.type, 'handler');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		schema: './schema.ts',
-		sql: true,
-	});
-});
-
-// --- errors ---
-test('err #1', async (t) => {
-	const res = await brotest(exportRaw, '--schema=src/schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #2', async (t) => {
-	const res = await brotest(exportRaw, '--dialect=postgresql');
-	assert.equal(res.type, 'error');
-});
-
-test('err #3', async (t) => {
-	const res = await brotest(exportRaw, '--dialect=postgresql2');
-	assert.equal(res.type, 'error');
-});
-
-test('err #4', async (t) => {
-	const res = await brotest(exportRaw, '--config=drizzle.config.ts --schema=schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #5', async (t) => {
-	const res = await brotest(exportRaw, '--config=drizzle.config.ts --dialect=postgresql');
-	assert.equal(res.type, 'error');
-});