@anthonyalayo/drizzle-kit 1.0.1 → 1.0.4

package/src/cli/selector-ui.ts

@@ -1,38 +0,0 @@
-import chalk from 'chalk';
-import { Prompt, SelectState } from 'hanji';
-
-export 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);
-	}
-
-	render(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!,
-		};
-	}
-}

package/src/cli/utils.ts

@@ -1,112 +0,0 @@
-import semver from 'semver';
-import { err, warning } from './views';
-
-export const assertExists = (it?: any) => {
-	if (!it) throw new Error();
-};
-
-export const ormVersionGt = async (version: string) => {
-	const { npmVersion } = await import('drizzle-orm/version');
-	if (!semver.gte(npmVersion, version)) {
-		return false;
-	}
-	return true;
-};
-
-export const assertStudioNodeVersion = () => {
-	if (semver.gte(process.version, '18.0.0')) return;
-
-	err('Drizzle Studio requires NodeJS v18 or above');
-	process.exit(1);
-};
-
-export const checkPackage = async (it: string) => {
-	try {
-		await import(it);
-		return true;
-	} catch (e) {
-		return false;
-	}
-};
-
-export const assertPackages = async (...pkgs: string[]) => {
-	try {
-		for (let i = 0; i < pkgs.length; i++) {
-			const it = pkgs[i];
-			await import(it);
-		}
-	} catch (e) {
-		err(
-			`please install required packages: ${
-				pkgs
-					.map((it) => `'${it}'`)
-					.join(' ')
-			}`,
-		);
-		process.exit(1);
-	}
-};
-
-// ex: either pg or postgres are needed
-export const assertEitherPackage = async (
-	...pkgs: string[]
-): Promise<string[]> => {
-	const availables = [] as string[];
-	for (let i = 0; i < pkgs.length; i++) {
-		try {
-			const it = pkgs[i];
-			await import(it);
-			availables.push(it);
-		} catch (e) {}
-	}
-
-	if (availables.length > 0) {
-		return availables;
-	}
-
-	err(
-		`Please install one of those packages are needed: ${
-			pkgs
-				.map((it) => `'${it}'`)
-				.join(' or ')
-		}`,
-	);
-	process.exit(1);
-};
-
-const 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);
-};
-
-export const ormCoreVersions = async () => {
-	try {
-		const { compatibilityVersion, npmVersion } = await import(
-			'drizzle-orm/version'
-		);
-		return { compatibilityVersion, npmVersion };
-	} catch (e) {
-		return {};
-	}
-};

package/src/cli/validations/cli.ts

@@ -1,79 +0,0 @@
-import { array, boolean, intersection, literal, object, string, TypeOf, union } from 'zod';
-import { dialect } from '../../schemaValidator';
-import { casing, casingType, prefix } from './common';
-
-export const cliConfigGenerate = object({
-	dialect: dialect.optional(),
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	config: string().optional(),
-	name: string().optional(),
-	prefix: prefix.optional(),
-	breakpoints: boolean().optional().default(true),
-	custom: boolean().optional().default(false),
-}).strict();
-
-export type CliConfigGenerate = TypeOf<typeof cliConfigGenerate>;
-
-export const pushParams = object({
-	dialect: dialect,
-	casing: casingType.optional(),
-	schema: union([string(), string().array()]),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()])
-		.optional()
-		.default(['public']),
-	extensionsFilters: literal('postgis').array().optional(),
-	verbose: boolean().optional(),
-	strict: boolean().optional(),
-	entities: object({
-		roles: boolean().or(object({
-			provider: string().optional(),
-			include: string().array().optional(),
-			exclude: string().array().optional(),
-		})).optional().default(false),
-	}).optional(),
-}).passthrough();
-
-export type PushParams = TypeOf<typeof pushParams>;
-
-export const pullParams = object({
-	config: string().optional(),
-	dialect: dialect,
-	out: string().optional().default('drizzle'),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()])
-		.optional()
-		.default(['public']),
-	extensionsFilters: literal('postgis').array().optional(),
-	casing,
-	breakpoints: boolean().optional().default(true),
-	migrations: object({
-		prefix: prefix.optional().default('index'),
-	}).optional(),
-	entities: object({
-		roles: boolean().or(object({
-			provider: string().optional(),
-			include: string().array().optional(),
-			exclude: string().array().optional(),
-		})).optional().default(false),
-	}).optional(),
-}).passthrough();
-
-export type Entities = TypeOf<typeof pullParams>['entities'];
-
-export type PullParams = TypeOf<typeof pullParams>;
-
-export const configCheck = object({
-	dialect: dialect.optional(),
-	out: string().optional(),
-});
-
-export const cliConfigCheck = intersection(
-	object({
-		config: string().optional(),
-	}),
-	configCheck,
-);
-
-export type CliCheckConfig = TypeOf<typeof cliConfigCheck>;

package/src/cli/validations/common.ts

@@ -1,193 +0,0 @@
-import chalk from 'chalk';
-import { UnionToIntersection } from 'hono/utils/types';
-import { any, boolean, enum as enum_, literal, object, string, TypeOf, union } from 'zod';
-import { dialect } from '../../schemaValidator';
-import { outputs } from './outputs';
-
-export type Commands =
-	| 'introspect'
-	| 'generate'
-	| 'check'
-	| 'up'
-	| 'drop'
-	| 'push'
-	| 'export';
-
-type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
-type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-type LastTupleElement<TArr extends any[]> = TArr extends [
-	...start: infer _,
-	end: infer Last,
-] ? Last
-	: never;
-
-export type UniqueArrayOfUnion<TUnion, TArray extends TUnion[]> = Exclude<
-	TUnion,
-	TArray[number]
-> extends never ? [TUnion]
-	: [...TArray, Exclude<TUnion, TArray[number]>];
-
-export const assertCollisions = <
-	T extends Record<string, unknown>,
-	TKeys extends (keyof T)[],
-	TRemainingKeys extends Exclude<keyof T, TKeys[number] | 'config'>[],
-	Exhaustive extends TRemainingKeys,
-	UNIQ extends UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
->(
-	command: Commands,
-	options: T,
-	whitelist: Exclude<TKeys, 'config'>,
-	remainingKeys: UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
-): IsUnion<LastTupleElement<UNIQ>> extends false ? 'cli' | 'config' : TKeys => {
-	const { config, ...rest } = options;
-
-	let atLeastOneParam = false;
-	for (const key of Object.keys(rest)) {
-		if (whitelist.includes(key)) continue;
-
-		atLeastOneParam = atLeastOneParam || rest[key] !== undefined;
-	}
-
-	if (!config && atLeastOneParam) {
-		return 'cli' as any;
-	}
-
-	if (!atLeastOneParam) {
-		return 'config' as any;
-	}
-
-	// if config and cli - return error - write a reason
-	console.log(outputs.common.ambiguousParams(command));
-	process.exit(1);
-};
-
-export const sqliteDriversLiterals = [
-	literal('d1-http'),
-	literal('expo'),
-	literal('durable-sqlite'),
-] as const;
-
-export const postgresqlDriversLiterals = [
-	literal('aws-data-api'),
-	literal('pglite'),
-] as const;
-
-export const prefixes = [
-	'index',
-	'timestamp',
-	'supabase',
-	'unix',
-	'none',
-] as const;
-export const prefix = enum_(prefixes);
-export type Prefix = (typeof prefixes)[number];
-
-{
-	const _: Prefix = '' as TypeOf<typeof prefix>;
-}
-
-export const casingTypes = ['snake_case', 'camelCase'] as const;
-export const casingType = enum_(casingTypes);
-export type CasingType = (typeof casingTypes)[number];
-
-export const sqliteDriver = union(sqliteDriversLiterals);
-export const postgresDriver = union(postgresqlDriversLiterals);
-export const driver = union([sqliteDriver, postgresDriver]);
-
-export const configMigrations = object({
-	table: string().optional(),
-	schema: string().optional(),
-	prefix: prefix.optional().default('index'),
-}).optional();
-
-export const configCommonSchema = object({
-	dialect: dialect,
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional(),
-	breakpoints: boolean().optional().default(true),
-	verbose: boolean().optional().default(false),
-	driver: driver.optional(),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	migrations: configMigrations,
-	dbCredentials: any().optional(),
-	casing: casingType.optional(),
-	sql: boolean().default(true),
-}).passthrough();
-
-export const casing = union([literal('camel'), literal('preserve')]).default(
-	'camel',
-);
-
-export const introspectParams = object({
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	introspect: object({
-		casing,
-	}).default({ casing: 'camel' }),
-});
-
-export type IntrospectParams = TypeOf<typeof introspectParams>;
-export type Casing = TypeOf<typeof casing>;
-
-export const configIntrospectCliSchema = object({
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	introspectCasing: union([literal('camel'), literal('preserve')]).default(
-		'camel',
-	),
-});
-
-export const configGenerateSchema = object({
-	schema: union([string(), string().array()]),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
-});
-
-export type GenerateSchema = TypeOf<typeof configGenerateSchema>;
-
-export const configPushSchema = object({
-	dialect: dialect,
-	schema: union([string(), string().array()]),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	verbose: boolean().default(false),
-	strict: boolean().default(false),
-	out: string().optional(),
-});
-
-export type CliConfig = TypeOf<typeof configCommonSchema>;
-export const drivers = ['d1-http', 'expo', 'aws-data-api', 'pglite', 'durable-sqlite'] as const;
-export type Driver = (typeof drivers)[number];
-const _: Driver = '' as TypeOf<typeof driver>;
-
-export const wrapParam = (
-	name: string,
-	param: any | undefined,
-	optional: boolean = false,
-	type?: 'url' | 'secret',
-) => {
-	const check = `[${chalk.green('✓')}]`;
-	const cross = `[${chalk.red('x')}]`;
-	if (typeof param === 'string') {
-		if (param.length === 0) {
-			return `    ${cross} ${name}: ''`;
-		}
-		if (type === 'secret') {
-			return `    ${check} ${name}: '*****'`;
-		} else if (type === 'url') {
-			return `    ${check} ${name}: '${param.replace(/(?<=:\/\/[^:\n]*:)([^@]*)/, '****')}'`;
-		}
-		return `    ${check} ${name}: '${param}'`;
-	}
-	if (optional) {
-		return chalk.gray(`        ${name}?: `);
-	}
-	return `    ${cross} ${name}: ${chalk.gray('undefined')}`;
-};

package/src/cli/validations/libsql.ts

@@ -1,27 +0,0 @@
-import { softAssertUnreachable } from 'src/global';
-import { object, string, TypeOf } from 'zod';
-import { error } from '../views';
-import { wrapParam } from './common';
-
-export const libSQLCredentials = object({
-	url: string().min(1),
-	authToken: string().min(1).optional(),
-});
-
-export type LibSQLCredentials = {
-	url: string;
-	authToken?: string;
-};
-
-const _: LibSQLCredentials = {} as TypeOf<typeof libSQLCredentials>;
-
-export const printConfigConnectionIssues = (
-	options: Record<string, unknown>,
-	command: 'generate' | 'migrate' | 'push' | 'pull' | 'studio',
-) => {
-	let text = `Please provide required params for 'turso' dialect:\n`;
-	console.log(error(text));
-	console.log(wrapParam('url', options.url));
-	console.log(wrapParam('authToken', options.authToken, true, 'secret'));
-	process.exit(1);
-};

package/src/cli/validations/mysql.ts

@@ -1,61 +0,0 @@
-import { boolean, coerce, object, string, TypeOf, union } from 'zod';
-import { error } from '../views';
-import { wrapParam } from './common';
-import { outputs } from './outputs';
-
-export const mysqlCredentials = union([
-	object({
-		host: string().min(1),
-		port: coerce.number().min(1).optional(),
-		user: string().min(1).optional(),
-		password: string().min(1).optional(),
-		database: string().min(1),
-		ssl: union([
-			string(),
-			object({
-				pfx: string().optional(),
-				key: string().optional(),
-				passphrase: string().optional(),
-				cert: string().optional(),
-				ca: union([string(), string().array()]).optional(),
-				crl: union([string(), string().array()]).optional(),
-				ciphers: string().optional(),
-				rejectUnauthorized: boolean().optional(),
-			}),
-		]).optional(),
-	}),
-	object({
-		url: string().min(1),
-	}),
-]);
-
-export type MysqlCredentials = TypeOf<typeof mysqlCredentials>;
-
-export const printCliConnectionIssues = (options: any) => {
-	const { uri, host, database } = options || {};
-
-	if (!uri && (!host || !database)) {
-		console.log(outputs.mysql.connection.required());
-	}
-};
-
-export const printConfigConnectionIssues = (
-	options: Record<string, unknown>,
-) => {
-	if ('url' in options) {
-		let text = `Please provide required params for MySQL driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
-	}
-
-	let text = `Please provide required params for MySQL driver:\n`;
-	console.log(error(text));
-	console.log(wrapParam('host', options.host));
-	console.log(wrapParam('port', options.port, true));
-	console.log(wrapParam('user', options.user, true));
-	console.log(wrapParam('password', options.password, true, 'secret'));
-	console.log(wrapParam('database', options.database));
-	console.log(wrapParam('ssl', options.ssl, true));
-	process.exit(1);
-};

package/src/cli/validations/outputs.ts

@@ -1,91 +0,0 @@
-import chalk from 'chalk';
-import { sqliteDriversLiterals } from './common';
-
-export const withStyle = {
-	error: (str: string) => `${chalk.red(`${chalk.white.bgRed(' Invalid input ')} ${str}`)}`,
-	warning: (str: string) => `${chalk.white.bgGray(' Warning ')} ${str}`,
-	errorWarning: (str: string) => `${chalk.red(`${chalk.white.bgRed(' Warning ')} ${str}`)}`,
-	fullWarning: (str: string) => `${chalk.black.bgYellow(' Warning ')} ${chalk.bold(str)}`,
-	suggestion: (str: string) => `${chalk.white.bgGray(' Suggestion ')} ${str}`,
-	info: (str: string) => `${chalk.grey(str)}`,
-};
-
-export const outputs = {
-	studio: {
-		drivers: (param: string) =>
-			withStyle.error(
-				`"${param}" is not a valid driver. Available drivers: "pg", "mysql2", "better-sqlite", "libsql", "turso". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
-			),
-		noCredentials: () =>
-			withStyle.error(
-				`Please specify a 'dbCredentials' param in config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
-			),
-		noDriver: () =>
-			withStyle.error(
-				`Please specify a 'driver' param in config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
-			),
-		noDialect: () =>
-			withStyle.error(
-				`Please specify 'dialect' param in config, either of 'postgresql', 'mysql', 'sqlite', turso or singlestore`,
-			),
-	},
-	common: {
-		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`,
-				),
-		},
-	},
-};

package/src/cli/validations/postgres.ts

@@ -1,83 +0,0 @@
-import { boolean, coerce, literal, object, string, TypeOf, undefined, union } from 'zod';
-import { error } from '../views';
-import { wrapParam } from './common';
-
-export const postgresCredentials = union([
-	object({
-		driver: undefined(),
-		host: string().min(1),
-		port: coerce.number().min(1).optional(),
-		user: string().min(1).optional(),
-		password: string().min(1).optional(),
-		database: string().min(1),
-		ssl: union([
-			literal('require'),
-			literal('allow'),
-			literal('prefer'),
-			literal('verify-full'),
-			boolean(),
-			object({}).passthrough(),
-		]).optional(),
-	}).transform((o) => {
-		delete o.driver;
-		return o as Omit<typeof o, 'driver'>;
-	}),
-	object({
-		driver: undefined(),
-		url: string().min(1),
-	}).transform<{ url: string }>((o) => {
-		delete o.driver;
-		return o;
-	}),
-	object({
-		driver: literal('aws-data-api'),
-		database: string().min(1),
-		secretArn: string().min(1),
-		resourceArn: string().min(1),
-	}),
-	object({
-		driver: literal('pglite'),
-		url: string().min(1),
-	}),
-]);
-
-export type PostgresCredentials = TypeOf<typeof postgresCredentials>;
-
-export const printConfigConnectionIssues = (
-	options: Record<string, unknown>,
-) => {
-	if (options.driver === 'aws-data-api') {
-		let text = `Please provide required params for AWS Data API driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('database', options.database));
-		console.log(wrapParam('secretArn', options.secretArn, false, 'secret'));
-		console.log(wrapParam('resourceArn', options.resourceArn, false, 'secret'));
-		process.exit(1);
-	}
-
-	if ('url' in options) {
-		let text = `Please provide required params for Postgres driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
-	}
-
-	if ('host' in options || 'database' in options) {
-		let text = `Please provide required params for Postgres driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('host', options.host));
-		console.log(wrapParam('port', options.port, true));
-		console.log(wrapParam('user', options.user, true));
-		console.log(wrapParam('password', options.password, true, 'secret'));
-		console.log(wrapParam('database', options.database));
-		console.log(wrapParam('ssl', options.ssl, true));
-		process.exit(1);
-	}
-
-	console.log(
-		error(
-			`Either connection "url" or "host", "database" are required for PostgreSQL database connection`,
-		),
-	);
-	process.exit(1);
-};