@anthonyalayo/drizzle-kit 1.0.1

package/tests/pg-array.test.ts

@@ -0,0 +1,368 @@
+import {
+	bigint,
+	boolean,
+	date,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	serial,
+	text,
+	timestamp,
+	uuid,
+} from 'drizzle-orm/pg-core';
+import { expect, test } from 'vitest';
+import { diffTestSchemas } from './schemaDiffer';
+
+test('array #1: empty array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{}'" },
+	});
+});
+
+test('array #2: integer array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{1,2,3}'" },
+	});
+});
+
+test('array #3: bigint array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: bigint('values', { mode: 'bigint' }).array().default([BigInt(1), BigInt(2), BigInt(3)]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'bigint[]', primaryKey: false, notNull: false, default: "'{1,2,3}'" },
+	});
+});
+
+test('array #4: boolean array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: boolean('values').array().default([true, false, true]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'boolean[]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{true,false,true}'",
+		},
+	});
+});
+
+test('array #5: multi-dimensional array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().array().default([[1, 2], [3, 4]]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'integer[][]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{{1,2},{3,4}}'",
+		},
+	});
+});
+
+test('array #6: date array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: date('values').array().default(['2024-08-06', '2024-08-07']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'date[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"2024-08-06","2024-08-07"}\'',
+		},
+	});
+});
+
+test('array #7: timestamp array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: timestamp('values').array().default([new Date('2024-08-06'), new Date('2024-08-07')]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'timestamp[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"2024-08-06 00:00:00.000","2024-08-07 00:00:00.000"}\'',
+		},
+	});
+});
+
+test('array #8: json array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: json('values').array().default([{ a: 1 }, { b: 2 }]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'json[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"{\\"a\\":1}","{\\"b\\":2}"}\'',
+		},
+	});
+});
+
+test('array #9: text array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: text('values').array().default(['abc', 'def']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'text[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"abc","def"}\'',
+		},
+	});
+});
+
+test('array #10: uuid array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: uuid('values').array().default([
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+				'b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11',
+			]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'uuid[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11","b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11"}\'',
+		},
+	});
+});
+
+test('array #11: enum array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default(['a', 'b', 'c']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'test_enum[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"a","b","c"}\'',
+		},
+	});
+});
+
+test('array #12: enum empty array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default([]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'test_enum[]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{}'",
+		},
+	});
+});

package/tests/pg-checks.test.ts

@@ -0,0 +1,329 @@
+import { sql } from 'drizzle-orm';
+import { check, integer, pgTable, serial, varchar } from 'drizzle-orm/pg-core';
+import { JsonCreateTableStatement } from 'src/jsonStatements';
+import { expect, test } from 'vitest';
+import { diffTestSchemas } from './schemaDiffer';
+
+test('create table with check', async (t) => {
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas({}, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_table',
+		tableName: 'users',
+		schema: '',
+		columns: [
+			{
+				name: 'id',
+				type: 'serial',
+				notNull: true,
+				primaryKey: true,
+			},
+			{
+				name: 'age',
+				type: 'integer',
+				notNull: false,
+				primaryKey: false,
+			},
+		],
+		compositePKs: [],
+		checkConstraints: ['some_check_name;"users"."age" > 21'],
+		compositePkName: '',
+		uniqueConstraints: [],
+		isRLSEnabled: false,
+		policies: [],
+	} as JsonCreateTableStatement);
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
+\t"id" serial PRIMARY KEY NOT NULL,
+\t"age" integer,
+\tCONSTRAINT "some_check_name" CHECK ("users"."age" > 21)
+);\n`);
+});
+
+test('add check contraint to existing table', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_check_constraint',
+		tableName: 'users',
+		schema: '',
+		data: 'some_check_name;"users"."age" > 21',
+	});
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name" CHECK ("users"."age" > 21);`,
+	);
+});
+
+test('drop check contraint in existing table', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'delete_check_constraint',
+		tableName: 'users',
+		schema: '',
+		constraintName: 'some_check_name',
+	});
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
+	);
+});
+
+test('rename check constraint', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('new_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		constraintName: 'some_check_name',
+		schema: '',
+		tableName: 'users',
+		type: 'delete_check_constraint',
+	});
+	expect(statements[1]).toStrictEqual({
+		data: 'new_check_name;"users"."age" > 21',
+		schema: '',
+		tableName: 'users',
+		type: 'create_check_constraint',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("users"."age" > 21);`,
+	);
+});
+
+test('alter check constraint', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check('new_check_name', sql`${table.age} > 10`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		constraintName: 'some_check_name',
+		schema: '',
+		tableName: 'users',
+		type: 'delete_check_constraint',
+	});
+	expect(statements[1]).toStrictEqual({
+		data: 'new_check_name;"users"."age" > 10',
+		schema: '',
+		tableName: 'users',
+		type: 'create_check_constraint',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("users"."age" > 10);`,
+	);
+});
+
+test('alter multiple check constraints', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+			name: varchar('name'),
+		}, (table) => ({
+			checkConstraint1: check('some_check_name_1', sql`${table.age} > 21`),
+			checkConstraint2: check('some_check_name_2', sql`${table.name} != 'Alex'`),
+		})),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+			name: varchar('name'),
+		}, (table) => ({
+			checkConstraint1: check('some_check_name_3', sql`${table.age} > 21`),
+			checkConstraint2: check('some_check_name_4', sql`${table.name} != 'Alex'`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
+	expect(statements.length).toBe(4);
+	expect(statements[0]).toStrictEqual({
+		constraintName: 'some_check_name_1',
+		schema: '',
+		tableName: 'users',
+		type: 'delete_check_constraint',
+	});
+	expect(statements[1]).toStrictEqual({
+		constraintName: 'some_check_name_2',
+		schema: '',
+		tableName: 'users',
+		type: 'delete_check_constraint',
+	});
+	expect(statements[2]).toStrictEqual({
+		data: 'some_check_name_3;"users"."age" > 21',
+		schema: '',
+		tableName: 'users',
+		type: 'create_check_constraint',
+	});
+	expect(statements[3]).toStrictEqual({
+		data: 'some_check_name_4;"users"."name" != \'Alex\'',
+		schema: '',
+		tableName: 'users',
+		type: 'create_check_constraint',
+	});
+
+	expect(sqlStatements.length).toBe(4);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_1";`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_2";`,
+	);
+	expect(sqlStatements[2]).toBe(
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_3" CHECK ("users"."age" > 21);`,
+	);
+	expect(sqlStatements[3]).toBe(
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_4" CHECK ("users"."name" != \'Alex\');`,
+	);
+});
+
+test('create checks with same names', async (t) => {
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+			name: varchar('name'),
+		}, (table) => ({
+			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
+			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
+		})),
+	};
+
+	await expect(diffTestSchemas({}, to, [])).rejects.toThrowError();
+});
+
+test('create unnamed checks', async (t) => {
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			age: integer('age'),
+		}, (table) => ({
+			checkConstraint: check(sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemas({}, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_table',
+		tableName: 'users',
+		schema: '',
+		columns: [
+			{
+				name: 'id',
+				type: 'serial',
+				notNull: true,
+				primaryKey: true,
+			},
+			{
+				name: 'age',
+				type: 'integer',
+				notNull: false,
+				primaryKey: false,
+			},
+		],
+		compositePKs: [],
+		checkConstraints: [';"users"."age" > 21'],
+		compositePkName: '',
+		uniqueConstraints: [],
+		isRLSEnabled: false,
+		policies: [],
+	} as JsonCreateTableStatement);
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
+\t"id" serial PRIMARY KEY NOT NULL,
+\t"age" integer,
+\tCHECK ("users"."age" > 21)
+);\n`);
+});