@anthonyalayo/drizzle-kit 1.0.2 → 1.0.5

package/tests/indexes/pg.test.ts

@@ -1,245 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,319 +0,0 @@
-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;`);
-});