@anthonyalayo/drizzle-kit 1.0.1

package/tests/libsql-views.test.ts

@@ -0,0 +1,218 @@
+import { sql } from 'drizzle-orm';
+import { int, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
+import { expect, test } from 'vitest';
+import { diffTestSchemasLibSQL } from './schemaDiffer';
+
+test('create view', async () => {
+	const users = sqliteTable('users', { id: int('id').default(1) });
+	const view = sqliteView('view').as((qb) => qb.select().from(users));
+	const to = {
+		users: users,
+		testView: view,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL({}, to, []);
+
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		type: 'sqlite_create_table',
+		tableName: 'users',
+		columns: [{
+			autoincrement: false,
+			default: 1,
+			name: 'id',
+			type: 'integer',
+			primaryKey: false,
+			notNull: false,
+		}],
+		compositePKs: [],
+		uniqueConstraints: [],
+		referenceData: [],
+		checkConstraints: [],
+	});
+	expect(statements[1]).toStrictEqual({
+		type: 'sqlite_create_view',
+		name: 'view',
+		definition: 'select "id" from "users"',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
+\t\`id\` integer DEFAULT 1
+);\n`);
+	expect(sqlStatements[1]).toBe(`CREATE VIEW \`view\` AS select "id" from "users";`);
+});
+
+test('drop view', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		name: 'view',
+		type: 'drop_view',
+	});
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		`DROP VIEW \`view\`;`,
+	);
+});
+
+test('alter view', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users WHERE users.id = 1`),
+	};
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
+
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		name: 'view',
+		type: 'drop_view',
+	});
+	expect(statements[1]).toStrictEqual({
+		name: 'view',
+		type: 'sqlite_create_view',
+		definition: 'SELECT * FROM users WHERE users.id = 1',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(
+		`DROP VIEW \`view\`;`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`CREATE VIEW \`view\` AS SELECT * FROM users WHERE users.id = 1;`,
+	);
+});
+
+test('create view with existing flag', async () => {
+	const view = sqliteView('view', {}).existing();
+	const to = {
+		testView: view,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL({}, to, []);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('drop view with existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('rename view with existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).existing(),
+	};
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('rename view and drop existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
+
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		name: 'view',
+		type: 'drop_view',
+	});
+	expect(statements[1]).toStrictEqual({
+		type: 'sqlite_create_view',
+		name: 'new_view',
+		definition: 'SELECT * FROM users',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe('DROP VIEW `view`;');
+	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users;`);
+});
+
+test('rename view and alter ".as"', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users WHERE 1=1`),
+	};
+	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
+
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		name: 'view',
+		type: 'drop_view',
+	});
+	expect(statements[1]).toStrictEqual({
+		type: 'sqlite_create_view',
+		name: 'new_view',
+		definition: 'SELECT * FROM users WHERE 1=1',
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe('DROP VIEW `view`;');
+	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users WHERE 1=1;`);
+});

package/tests/migrate/libsq-schema.ts

@@ -0,0 +1,6 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+	id: integer('id').primaryKey().notNull(),
+	name: text('name').notNull(),
+});

package/tests/migrate/libsql-migrate.test.ts

@@ -0,0 +1,58 @@
+import { createClient } from '@libsql/client';
+import { connectToLibSQL } from 'src/cli/connections';
+import { expect, test } from 'vitest';
+
+test('validate migrate function', async () => {
+	const credentials = {
+		url: ':memory:',
+	};
+	const { migrate, query } = await connectToLibSQL(credentials);
+
+	await migrate({ migrationsFolder: 'tests/migrate/migrations' });
+
+	const res = await query(`PRAGMA table_info("users");`);
+
+	expect(res).toStrictEqual([{
+		cid: 0,
+		name: 'id',
+		type: 'INTEGER',
+		notnull: 0,
+		dflt_value: null,
+		pk: 0,
+	}, {
+		cid: 1,
+		name: 'name',
+		type: 'INTEGER',
+		notnull: 1,
+		dflt_value: null,
+		pk: 0,
+	}]);
+});
+
+// test('validate migrate function', async () => {
+// 	const credentials = {
+// 		url: '',
+// 		authToken: '',
+// 	};
+// 	const { migrate, query } = await connectToLibSQL(credentials);
+
+// 	await migrate({ migrationsFolder: 'tests/migrate/migrations' });
+
+// 	const res = await query(`PRAGMA table_info("users");`);
+
+// 	expect(res).toStrictEqual([{
+// 		cid: 0,
+// 		name: 'id',
+// 		type: 'INTEGER',
+// 		notnull: 0,
+// 		dflt_value: null,
+// 		pk: 0,
+// 	}, {
+// 		cid: 1,
+// 		name: 'name',
+// 		type: 'INTEGER',
+// 		notnull: 1,
+// 		dflt_value: null,
+// 		pk: 0,
+// 	}]);
+// });

package/tests/migrate/migrations/0000_little_blizzard.sql

@@ -0,0 +1,4 @@
+CREATE TABLE `users` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`name` text NOT NULL
+);

package/tests/migrate/migrations/0001_nebulous_storm.sql

@@ -0,0 +1,10 @@
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_users` (
+	`id` integer,
+	`name` integer NOT NULL
+);
+--> statement-breakpoint
+INSERT INTO `__new_users`("id", "name") SELECT "id", "name" FROM `users`;--> statement-breakpoint
+DROP TABLE `users`;--> statement-breakpoint
+ALTER TABLE `__new_users` RENAME TO `users`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;

package/tests/migrate/migrations/meta/0000_snapshot.json

@@ -0,0 +1,40 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "2bd46776-9e41-4a6c-b617-5c600bb176f2",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/tests/migrate/migrations/meta/0001_snapshot.json

@@ -0,0 +1,40 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "6c0ec455-42fd-47fd-a22c-4bb4551e1358",
+  "prevId": "2bd46776-9e41-4a6c-b617-5c600bb176f2",
+  "tables": {
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/tests/migrate/migrations/meta/_journal.json

@@ -0,0 +1,20 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1725358702427,
+      "tag": "0000_little_blizzard",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1725358713033,
+      "tag": "0001_nebulous_storm",
+      "breakpoints": true
+    }
+  ]
+}

package/tests/mysql-checks.test.ts

@@ -0,0 +1,291 @@
+import { sql } from 'drizzle-orm';
+import { check, int, mysqlTable, serial, varchar } from 'drizzle-orm/mysql-core';
+import { expect, test } from 'vitest';
+import { diffTestSchemasMysql } from './schemaDiffer';
+
+test('create table with check', async (t) => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemasMysql({}, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_table',
+		tableName: 'users',
+		columns: [
+			{
+				name: 'id',
+				type: 'serial',
+				notNull: true,
+				primaryKey: false,
+				autoincrement: true,
+			},
+			{
+				name: 'age',
+				type: 'int',
+				notNull: false,
+				primaryKey: false,
+				autoincrement: false,
+			},
+		],
+		compositePKs: [
+			'users_id;id',
+		],
+		checkConstraints: ['some_check_name;\`users\`.\`age\` > 21'],
+		compositePkName: 'users_id',
+		uniqueConstraints: [],
+		schema: undefined,
+		internals: {
+			tables: {},
+			indexes: {},
+		},
+	});
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
+\t\`id\` serial AUTO_INCREMENT NOT NULL,
+\t\`age\` int,
+\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`),
+\tCONSTRAINT \`some_check_name\` CHECK(\`users\`.\`age\` > 21)
+);\n`);
+});
+
+test('add check contraint to existing table', async (t) => {
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_check_constraint',
+		tableName: 'users',
+		data: 'some_check_name;\`users\`.\`age\` > 21',
+		schema: '',
+	});
+
+	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 to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemasMysql(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: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('new_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemasMysql(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: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
+		})),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => ({
+			checkConstraint: check('new_check_name', sql`${table.age} > 10`),
+		})),
+	};
+
+	const { sqlStatements, statements } = await diffTestSchemasMysql(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: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+			name: varchar('name', { length: 255 }),
+		}, (table) => ({
+			checkConstraint1: check('some_check_name_1', sql`${table.age} > 21`),
+			checkConstraint2: check('some_check_name_2', sql`${table.name} != 'Alex'`),
+		})),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+			name: varchar('name', { length: 255 }),
+		}, (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 diffTestSchemasMysql(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: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+			name: varchar('name', { length: 255 }),
+		}, (table) => ({
+			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
+			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
+		})),
+	};
+
+	await expect(diffTestSchemasMysql({}, to, [])).rejects.toThrowError();
+});