@anthonyalayo/drizzle-kit 1.0.1

package/tests/cli-generate.test.ts

@@ -0,0 +1,259 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { assert, expect, test } from 'vitest';
+import { generate } from '../src/cli/schema';
+
+// good:
+// #1 drizzle-kit generate --dialect=postgresql --schema=schema.ts
+// #2 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out
+// #3 drizzle-kit generate
+// #4 drizzle-kit generate --custom
+// #5 drizzle-kit generate --name=custom
+// #6 drizzle-kit generate --prefix=timestamp
+// #7 drizzle-kit generate --prefix=timestamp --name=custom --custom
+// #8 drizzle-kit generate --config=drizzle1.config.ts
+// #9 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out --prefix=timestamp --name=custom --custom
+
+// errors:
+// #1 drizzle-kit generate --schema=src/schema.ts
+// #2 drizzle-kit generate --dialect=postgresql
+// #3 drizzle-kit generate --dialect=postgresql2
+// #4 drizzle-kit generate --driver=expo
+// #5 drizzle-kit generate --dialect=postgresql --out=out
+// #6 drizzle-kit generate --config=drizzle.config.ts --out=out
+// #7 drizzle-kit generate --config=drizzle.config.ts --schema=schema.ts
+// #8 drizzle-kit generate --config=drizzle.config.ts --dialect=postgresql
+
+test('generate #1', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts',
+	);
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: 'schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+test('generate #2', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts --out=out',
+	);
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: 'schema.ts',
+		out: 'out',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+test('generate #3', async (t) => {
+	const res = await brotest(generate, '');
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// config | pass through custom
+test('generate #4', async (t) => {
+	const res = await brotest(generate, '--custom');
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: true,
+		prefix: 'index',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// config | pass through name
+test('generate #5', async (t) => {
+	const res = await brotest(generate, '--name=custom');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// config | pass through prefix
+test('generate #6', async (t) => {
+	const res = await brotest(generate, '--prefix=timestamp');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		prefix: 'timestamp',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// config | pass through name, prefix and custom
+test('generate #7', async (t) => {
+	const res = await brotest(
+		generate,
+		'--prefix=timestamp --name=custom --custom',
+	);
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: true,
+		prefix: 'timestamp',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// custom config path
+test('generate #8', async (t) => {
+	const res = await brotest(generate, '--config=expo.config.ts');
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		name: undefined,
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: true, // expo driver
+		casing: undefined,
+		driver: 'expo',
+	});
+});
+
+test('generate #9', async (t) => {
+	const res = await brotest(generate, '--config=durable-sqlite.config.ts');
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		name: undefined,
+		custom: false,
+		prefix: 'index',
+		breakpoints: true,
+		schema: './schema.ts',
+		out: 'drizzle',
+		bundle: true, // expo driver
+		casing: undefined,
+		driver: 'durable-sqlite',
+	});
+});
+
+// cli | pass through name, prefix and custom
+test('generate #9', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts --out=out --prefix=timestamp --name=custom --custom',
+	);
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: true,
+		prefix: 'timestamp',
+		breakpoints: true,
+		schema: 'schema.ts',
+		out: 'out',
+		bundle: false,
+		casing: undefined,
+		driver: undefined,
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(generate, '--schema=src/schema.ts');
+	assert.equal(res.type, 'error');
+});
+
+test('err #2', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql');
+	assert.equal(res.type, 'error');
+});
+
+test('err #3', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql2');
+	assert.equal(res.type, 'error');
+});
+
+test('err #4', async (t) => {
+	const res = await brotest(generate, '--driver=expo');
+	assert.equal(res.type, 'error');
+});
+
+test('err #5', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql --out=out');
+	assert.equal(res.type, 'error');
+});
+
+test('err #6', async (t) => {
+	const res = await brotest(generate, '--config=drizzle.config.ts --out=out');
+	assert.equal(res.type, 'error');
+});
+
+test('err #7', async (t) => {
+	const res = await brotest(generate, '--config=drizzle.config.ts --schema=schema.ts');
+	assert.equal(res.type, 'error');
+});
+
+test('err #8', async (t) => {
+	const res = await brotest(generate, '--config=drizzle.config.ts --dialect=postgresql');
+	assert.equal(res.type, 'error');
+});

package/tests/cli-migrate.test.ts

@@ -0,0 +1,103 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { assert, expect, test } from 'vitest';
+import { migrate } from '../src/cli/schema';
+
+// good:
+// #1 drizzle-kit generate
+// #2 drizzle-kit generate --config=turso.config.ts
+// #3 drizzle-kit generate --config=d1http.config.ts
+// #4 drizzle-kit generate --config=postgres.config.ts ## spread connection params
+// #5 drizzle-kit generate --config=drizzle2.config.ts ## custom schema and table for migrations journal
+
+// errors:
+// #1 drizzle-kit generate --config=expo.config.ts
+// TODO: missing required params in config?
+
+test('migrate #1', async (t) => {
+	const res = await brotest(migrate, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+		schema: undefined, // drizzle migrations table schema
+		table: undefined, // drizzle migrations table name
+	});
+});
+
+test('migrate #2', async (t) => {
+	const res = await brotest(migrate, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		out: 'drizzle',
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+		schema: undefined, // drizzle migrations table schema
+		table: undefined, // drizzle migrations table name
+	});
+});
+
+test('migrate #3', async (t) => {
+	const res = await brotest(migrate, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		out: 'drizzle',
+		credentials: {
+			driver: 'd1-http',
+			accountId: 'accid',
+			databaseId: 'dbid',
+			token: 'token',
+		},
+		schema: undefined, // drizzle migrations table schema
+		table: undefined, // drizzle migrations table name
+	});
+});
+
+test('migrate #4', async (t) => {
+	const res = await brotest(migrate, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		schema: undefined, // drizzle migrations table schema
+		table: undefined, // drizzle migrations table name
+	});
+});
+
+// catched a bug
+test('migrate #5', async (t) => {
+	const res = await brotest(migrate, '--config=postgres2.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		schema: 'custom', // drizzle migrations table schema
+		table: 'custom', // drizzle migrations table name
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(migrate, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});

package/tests/cli-push.test.ts

@@ -0,0 +1,126 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { assert, expect, test } from 'vitest';
+import { push } from '../src/cli/schema';
+
+// good:
+// #1 drizzle-kit push
+// #2 drizzle-kit push --config=turso.config.ts
+// #3 drizzle-kit push --config=d1http.config.ts
+// #4 drizzle-kit push --config=postgres.config.ts ## spread connection params
+// #5 drizzle-kit push --config=drizzle2.config.ts ## custom schema and table for migrations journal
+
+// errors:
+// #1 drizzle-kit push --config=expo.config.ts
+// TODO: missing required params in config?
+
+test('push #1', async (t) => {
+	const res = await brotest(push, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+		force: false,
+		schemaPath: './schema.ts',
+		schemasFilter: ['public'],
+		tablesFilter: [],
+		entities: undefined,
+		strict: false,
+		verbose: false,
+		casing: undefined,
+	});
+});
+
+test('push #2', async (t) => {
+	const res = await brotest(push, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+		force: false,
+		schemaPath: './schema.ts',
+		schemasFilter: ['public'],
+		tablesFilter: [],
+		strict: false,
+		verbose: false,
+		casing: undefined,
+	});
+});
+
+test('push #3', async (t) => {
+	const res = await brotest(push, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		credentials: {
+			driver: 'd1-http',
+			accountId: 'accid',
+			databaseId: 'dbid',
+			token: 'token',
+		},
+		force: false,
+		schemaPath: './schema.ts',
+		schemasFilter: ['public'],
+		tablesFilter: [],
+		strict: false,
+		verbose: false,
+		casing: undefined,
+	});
+});
+
+test('push #4', async (t) => {
+	const res = await brotest(push, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		force: false,
+		schemaPath: './schema.ts',
+		schemasFilter: ['public'],
+		tablesFilter: [],
+		entities: undefined,
+		strict: false,
+		verbose: false,
+		casing: undefined,
+	});
+});
+
+// catched a bug
+test('push #5', async (t) => {
+	const res = await brotest(push, '--config=postgres2.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		schemaPath: './schema.ts',
+		schemasFilter: ['public'],
+		tablesFilter: [],
+		strict: false,
+		entities: undefined,
+		force: false,
+		verbose: false,
+		casing: undefined,
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(push, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});

package/tests/common.ts

@@ -0,0 +1,15 @@
+import { test } from 'vitest';
+
+export interface DialectSuite {
+	/**
+	 * 1 statement | create column:
+	 *
+	 * id int primary key autoincrement
+	 */
+	columns1(): Promise<void>;
+}
+
+export const run = (suite: DialectSuite) => {
+	test('add columns #1', suite.columns1);
+};
+// test("add columns #1", suite.columns1)

package/tests/indexes/common.ts

@@ -0,0 +1,21 @@
+import { afterAll, beforeAll, test } from 'vitest';
+
+export interface DialectSuite {
+	simpleIndex(context?: any): Promise<void>;
+	vectorIndex(context?: any): Promise<void>;
+	indexesToBeTriggered(context?: any): Promise<void>;
+}
+
+export const run = (
+	suite: DialectSuite,
+	beforeAllFn?: (context: any) => Promise<void>,
+	afterAllFn?: (context: any) => Promise<void>,
+) => {
+	let context: any = {};
+	beforeAll(beforeAllFn ? () => beforeAllFn(context) : () => {});
+	test('index #1: simple index', () => suite.simpleIndex(context));
+	test('index #2: vector index', () => suite.vectorIndex(context));
+	test('index #3: fields that should be triggered on generate and not triggered on push', () =>
+		suite.indexesToBeTriggered(context));
+	afterAll(afterAllFn ? () => afterAllFn(context) : () => {});
+};