@anthonyalayo/drizzle-kit 1.0.1

package/tests/indexes/pg.test.ts

@@ -0,0 +1,245 @@
+import { sql } from 'drizzle-orm';
+import { index, pgTable, serial, text, vector } from 'drizzle-orm/pg-core';
+import { JsonCreateIndexStatement } from 'src/jsonStatements';
+import { PgSquasher } from 'src/serializer/pgSchema';
+import { diffTestSchemas } from 'tests/schemaDiffer';
+import { expect } from 'vitest';
+import { DialectSuite, run } from './common';
+
+const pgSuite: DialectSuite = {
+	async vectorIndex() {
+		const schema1 = {
+			users: pgTable('users', {
+				id: serial('id').primaryKey(),
+				name: vector('name', { dimensions: 3 }),
+			}),
+		};
+
+		const schema2 = {
+			users: pgTable(
+				'users',
+				{
+					id: serial('id').primaryKey(),
+					embedding: vector('name', { dimensions: 3 }),
+				},
+				(t) => ({
+					indx2: index('vector_embedding_idx')
+						.using('hnsw', t.embedding.op('vector_ip_ops'))
+						.with({ m: 16, ef_construction: 64 }),
+				}),
+			),
+		};
+
+		const { statements, sqlStatements } = await diffTestSchemas(
+			schema1,
+			schema2,
+			[],
+		);
+
+		expect(statements.length).toBe(1);
+		expect(statements[0]).toStrictEqual({
+			schema: '',
+			tableName: 'users',
+			type: 'create_index_pg',
+			data: {
+				columns: [
+					{
+						asc: true,
+						expression: 'name',
+						isExpression: false,
+						nulls: 'last',
+						opclass: 'vector_ip_ops',
+					},
+				],
+				concurrently: false,
+				isUnique: false,
+				method: 'hnsw',
+				name: 'vector_embedding_idx',
+				where: undefined,
+				with: {
+					ef_construction: 64,
+					m: 16,
+				},
+			},
+		});
+		expect(sqlStatements.length).toBe(1);
+		expect(sqlStatements[0]).toBe(
+			`CREATE INDEX "vector_embedding_idx" ON "users" USING hnsw ("name" vector_ip_ops) WITH (m=16,ef_construction=64);`,
+		);
+	},
+
+	async indexesToBeTriggered() {
+		const schema1 = {
+			users: pgTable(
+				'users',
+				{
+					id: serial('id').primaryKey(),
+					name: text('name'),
+				},
+				(t) => ({
+					indx: index('indx').on(t.name.desc()).concurrently(),
+					indx1: index('indx1')
+						.on(t.name.desc())
+						.where(sql`true`),
+					indx2: index('indx2')
+						.on(t.name.op('text_ops'))
+						.where(sql`true`),
+					indx3: index('indx3')
+						.on(sql`lower(name)`)
+						.where(sql`true`),
+				}),
+			),
+		};
+
+		const schema2 = {
+			users: pgTable(
+				'users',
+				{
+					id: serial('id').primaryKey(),
+					name: text('name'),
+				},
+				(t) => ({
+					indx: index('indx').on(t.name.desc()),
+					indx1: index('indx1')
+						.on(t.name.desc())
+						.where(sql`false`),
+					indx2: index('indx2')
+						.on(t.name.op('test'))
+						.where(sql`true`),
+					indx3: index('indx3')
+						.on(sql`lower(${t.id})`)
+						.where(sql`true`),
+					indx4: index('indx4')
+						.on(sql`lower(id)`)
+						.where(sql`true`),
+				}),
+			),
+		};
+
+		const { statements, sqlStatements } = await diffTestSchemas(
+			schema1,
+			schema2,
+			[],
+		);
+
+		expect(sqlStatements).toStrictEqual([
+			'DROP INDEX "indx";',
+			'DROP INDEX "indx1";',
+			'DROP INDEX "indx2";',
+			'DROP INDEX "indx3";',
+			'CREATE INDEX "indx4" ON "users" USING btree (lower(id)) WHERE true;',
+			'CREATE INDEX "indx" ON "users" USING btree ("name" DESC NULLS LAST);',
+			'CREATE INDEX "indx1" ON "users" USING btree ("name" DESC NULLS LAST) WHERE false;',
+			'CREATE INDEX "indx2" ON "users" USING btree ("name" test) WHERE true;',
+			'CREATE INDEX "indx3" ON "users" USING btree (lower("id")) WHERE true;',
+		]);
+	},
+
+	async simpleIndex() {
+		const schema1 = {
+			users: pgTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			}),
+		};
+
+		const schema2 = {
+			users: pgTable(
+				'users',
+				{
+					id: serial('id').primaryKey(),
+					name: text('name'),
+				},
+				(t) => ({
+					indx: index()
+						.on(t.name.desc(), t.id.asc().nullsLast())
+						.with({ fillfactor: 70 })
+						.where(sql`select 1`),
+					indx1: index('indx1')
+						.using('hash', t.name.desc(), sql`${t.name}`)
+						.with({ fillfactor: 70 }),
+				}),
+			),
+		};
+
+		const { statements, sqlStatements } = await diffTestSchemas(
+			schema1,
+			schema2,
+			[],
+		);
+
+		expect(statements.length).toBe(2);
+		expect(statements[0]).toStrictEqual({
+			schema: '',
+			tableName: 'users',
+			type: 'create_index_pg',
+			data: {
+				columns: [
+					{
+						asc: false,
+						expression: 'name',
+						isExpression: false,
+						nulls: 'last',
+						opclass: '',
+					},
+					{
+						asc: true,
+						expression: 'id',
+						isExpression: false,
+						nulls: 'last',
+						opclass: '',
+					},
+				],
+				concurrently: false,
+				isUnique: false,
+				method: 'btree',
+				name: 'users_name_id_index',
+				where: 'select 1',
+				with: {
+					fillfactor: 70,
+				},
+			},
+			// data: 'users_name_id_index;name,false,last,undefined,,id,true,last,undefined;false;false;btree;select 1;{"fillfactor":70}',
+		});
+		expect(statements[1]).toStrictEqual({
+			schema: '',
+			tableName: 'users',
+			type: 'create_index_pg',
+			data: {
+				columns: [
+					{
+						asc: false,
+						expression: 'name',
+						isExpression: false,
+						nulls: 'last',
+						opclass: '',
+					},
+					{
+						asc: true,
+						expression: '"name"',
+						isExpression: true,
+						nulls: 'last',
+						opclass: '',
+					},
+				],
+				concurrently: false,
+				isUnique: false,
+				method: 'hash',
+				name: 'indx1',
+				where: undefined,
+				with: {
+					fillfactor: 70,
+				},
+			},
+		});
+		expect(sqlStatements.length).toBe(2);
+		expect(sqlStatements[0]).toBe(
+			`CREATE INDEX "users_name_id_index" ON "users" USING btree ("name" DESC NULLS LAST,"id") WITH (fillfactor=70) WHERE select 1;`,
+		);
+		expect(sqlStatements[1]).toBe(
+			`CREATE INDEX "indx1" ON "users" USING hash ("name" DESC NULLS LAST,"name") WITH (fillfactor=70);`,
+		);
+	},
+};
+
+run(pgSuite);

package/tests/introspect/libsql.test.ts

@@ -0,0 +1,35 @@
+import { createClient } from '@libsql/client';
+import { sql } from 'drizzle-orm';
+import { int, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
+import fs from 'fs';
+import { introspectLibSQLToFile, introspectMySQLToFile, introspectSQLiteToFile } from 'tests/schemaDiffer';
+import { expect, test } from 'vitest';
+
+if (!fs.existsSync('tests/introspect/libsql')) {
+	fs.mkdirSync('tests/introspect/libsql');
+}
+
+test('view #1', async () => {
+	const turso = createClient({
+		url: ':memory:',
+	});
+
+	const users = sqliteTable('users', { id: int('id') });
+	const testView = sqliteView('some_view', { id: int('id') }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await introspectLibSQLToFile(
+		turso,
+		schema,
+		'view-1',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});

package/tests/introspect/mysql.test.ts

@@ -0,0 +1,319 @@
+import 'dotenv/config';
+import Docker from 'dockerode';
+import { SQL, sql } from 'drizzle-orm';
+import {
+	bigint,
+	char,
+	check,
+	decimal,
+	double,
+	float,
+	int,
+	mediumint,
+	mysqlEnum,
+	mysqlTable,
+	mysqlView,
+	serial,
+	smallint,
+	text,
+	tinyint,
+	varchar,
+} from 'drizzle-orm/mysql-core';
+import * as fs from 'fs';
+import getPort from 'get-port';
+import { Connection, createConnection } from 'mysql2/promise';
+import { introspectMySQLToFile } from 'tests/schemaDiffer';
+import { v4 as uuid } from 'uuid';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+
+let client: Connection;
+let mysqlContainer: Docker.Container;
+
+async function createDockerDB(): Promise<string> {
+	const docker = new Docker();
+	const port = await getPort({ port: 3306 });
+	const image = 'mysql:8';
+
+	const pullStream = await docker.pull(image);
+	await new Promise((resolve, reject) =>
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
+	);
+
+	mysqlContainer = await docker.createContainer({
+		Image: image,
+		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
+		name: `drizzle-integration-tests-${uuid()}`,
+		HostConfig: {
+			AutoRemove: true,
+			PortBindings: {
+				'3306/tcp': [{ HostPort: `${port}` }],
+			},
+		},
+	});
+
+	await mysqlContainer.start();
+
+	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
+}
+
+beforeAll(async () => {
+	const connectionString = process.env.MYSQL_CONNECTION_STRING ?? await createDockerDB();
+
+	const sleep = 1000;
+	let timeLeft = 20000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			client = await createConnection(connectionString);
+			await client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to MySQL');
+		await client?.end().catch(console.error);
+		await mysqlContainer?.stop().catch(console.error);
+		throw lastError;
+	}
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+	await mysqlContainer?.stop().catch(console.error);
+});
+
+beforeEach(async () => {
+	await client.query(`drop database if exists \`drizzle\`;`);
+	await client.query(`create database \`drizzle\`;`);
+	await client.query(`use \`drizzle\`;`);
+});
+
+if (!fs.existsSync('tests/introspect/mysql')) {
+	fs.mkdirSync('tests/introspect/mysql');
+}
+
+test('generated always column: link to another column', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'generated-link-column',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('generated always column virtual: link to another column', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'generated-link-column-virtual',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('Default value of character type column: char', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			sortKey: char('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'default-value-char-column',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('Default value of character type column: varchar', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			sortKey: varchar('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'default-value-varchar-column',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect checks', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: serial('id'),
+			name: varchar('name', { length: 255 }),
+			age: int('age'),
+		}, (table) => ({
+			someCheck: check('some_check', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'introspect-checks',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('view #1', async () => {
+	const users = mysqlTable('users', { id: int('id') });
+	const testView = mysqlView('some_view', { id: int('id') }).as(
+		sql`select \`drizzle\`.\`users\`.\`id\` AS \`id\` from \`drizzle\`.\`users\``,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'view-1',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('view #2', async () => {
+	const users = mysqlTable('some_users', { id: int('id') });
+	const testView = mysqlView('some_view', { id: int('id') }).algorithm('temptable').sqlSecurity('definer').as(
+		sql`SELECT * FROM ${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'view-2',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('handle float type', async () => {
+	const schema = {
+		table: mysqlTable('table', {
+			col1: float(),
+			col2: float({ precision: 2 }),
+			col3: float({ precision: 2, scale: 1 }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'handle-float-type',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('handle unsigned numerical types', async () => {
+	const schema = {
+		table: mysqlTable('table', {
+			col1: int({ unsigned: true }),
+			col2: tinyint({ unsigned: true }),
+			col3: smallint({ unsigned: true }),
+			col4: mediumint({ unsigned: true }),
+			col5: bigint({ mode: 'number', unsigned: true }),
+			col6: float({ unsigned: true }),
+			col7: float({ precision: 2, scale: 1, unsigned: true }),
+			col8: double({ unsigned: true }),
+			col9: double({ precision: 2, scale: 1, unsigned: true }),
+			col10: decimal({ unsigned: true }),
+			col11: decimal({ precision: 2, scale: 1, unsigned: true }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'handle-unsigned-numerical-types',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('instrospect strings with single quotes', async () => {
+	const schema = {
+		columns: mysqlTable('columns', {
+			enum: mysqlEnum('my_enum', ['escape\'s quotes "', 'escape\'s quotes 2 "']).default('escape\'s quotes "'),
+			text: text('text').default('escape\'s quotes " '),
+			varchar: varchar('varchar', { length: 255 }).default('escape\'s quotes " '),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectMySQLToFile(
+		client,
+		schema,
+		'introspect-strings-with-single-quotes',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+
+	await client.query(`drop table columns;`);
+});