@remit/drizzle-service 0.0.99 → 0.0.100

package/src/vps-migrations-drift.sqlite.test.ts

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { describe, test } from "node:test";
+import * as entities from "@remit/drizzle-sqlite-schema";
 import {
 	generateSQLiteDrizzleJson,
 	generateSQLiteMigration,
 } from "drizzle-kit/api";
+import { getTableName, is } from "drizzle-orm";
+import { SQLiteTable } from "drizzle-orm/sqlite-core";
 
 /**
  * Every committed SQLite migration set must describe the schema its drizzle
@@ -31,13 +34,14 @@ import {
 
 const REPO_ROOT = new URL("../../../", import.meta.url);
 
-const CONFIGS = [
-	"packages/migrate/drizzle.entities.sqlite.config.ts",
-	"packages/migrate/drizzle.auth.sqlite.config.ts",
-	"packages/migrate/drizzle.meta.sqlite.config.ts",
-];
+const CONFIGS = {
+	app: "packages/migrate/drizzle.app.sqlite.config.ts",
+	mail: "packages/migrate/drizzle.mail.sqlite.config.ts",
+	search: "packages/migrate/drizzle.search.sqlite.config.ts",
+	mcp: "packages/migrate/drizzle.mcp.sqlite.config.ts",
+};
 
-type DrizzleConfig = { schema: string; out: string };
+type DrizzleConfig = { schema: string[]; out: string };
 
 const loadConfig = async (path: string): Promise<DrizzleConfig> =>
 	(
@@ -46,11 +50,38 @@ const loadConfig = async (path: string): Promise<DrizzleConfig> =>
 		}
 	).default;
 
+const loadSchema = async (
+	config: DrizzleConfig,
+): Promise<Record<string, unknown>> =>
+	Object.assign(
+		{},
+		...(await Promise.all(
+			config.schema.map(
+				(path) =>
+					import(new URL(path, REPO_ROOT).href) as Promise<
+						Record<string, unknown>
+					>,
+			),
+		)),
+	);
+
+const tableNames = (schema: Record<string, unknown>): string[] =>
+	Object.values(schema)
+		.filter((value) => is(value, SQLiteTable))
+		.map((table) => getTableName(table as SQLiteTable));
+
+interface Journal {
+	entries: Array<{ idx: number; tag: string }>;
+}
+
+const journalOf = (out: string): Journal =>
+	JSON.parse(
+		readFileSync(new URL(`${out}/meta/_journal.json`, REPO_ROOT), "utf8"),
+	) as Journal;
+
 const latestSnapshot = (out: string): Record<string, unknown> => {
 	const dir = new URL(`${out}/`, REPO_ROOT);
-	const journal = JSON.parse(
-		readFileSync(new URL("meta/_journal.json", dir), "utf8"),
-	) as { entries: Array<{ idx: number }> };
+	const journal = journalOf(out);
 	const idx = Math.max(...journal.entries.map((entry) => entry.idx));
 	return JSON.parse(
 		readFileSync(
@@ -61,12 +92,10 @@ const latestSnapshot = (out: string): Record<string, unknown> => {
 };
 
 describe("committed sqlite migrations", () => {
-	for (const configPath of CONFIGS) {
+	for (const configPath of Object.values(CONFIGS)) {
 		test(`${configPath} — the set matches its schema`, async () => {
 			const config = await loadConfig(configPath);
-			const schema = (await import(
-				new URL(config.schema, REPO_ROOT).href
-			)) as Record<string, unknown>;
+			const schema = await loadSchema(config);
 
 			const drift = await generateSQLiteMigration(
 				latestSnapshot(config.out) as unknown as Parameters<
@@ -83,8 +112,45 @@ describe("committed sqlite migrations", () => {
 		});
 	}
 
+	for (const configPath of Object.values(CONFIGS)) {
+		test(`${configPath} — the journal names every file on disk once, in order`, async () => {
+			const { out } = await loadConfig(configPath);
+			const { entries } = journalOf(out);
+			assert.deepEqual(
+				entries.map((entry) => entry.idx),
+				entries.map((_, index) => index),
+			);
+			assert.deepEqual(
+				entries.map((entry) => `${entry.tag}.sql`).sort(),
+				readdirSync(new URL(`${out}/`, REPO_ROOT))
+					.filter((name) => name.endsWith(".sql"))
+					.sort(),
+			);
+		});
+	}
+
+	// A new TypeSpec entity has to be placed in a database: one that is in
+	// neither set is never migrated anywhere, and one in both is two tables.
+	test("place every generated entity table in exactly one database", async () => {
+		const [app, mail] = await Promise.all(
+			[CONFIGS.app, CONFIGS.mail].map(async (path) =>
+				tableNames(await loadSchema(await loadConfig(path))),
+			),
+		);
+		const placed = [...app, ...mail].sort();
+		assert.deepEqual(placed, [...new Set(placed)]);
+		for (const table of tableNames(entities)) {
+			assert.ok(placed.includes(table), `${table} is in no database`);
+		}
+	});
+
+	test("keep the search set free of drizzle tables", async () => {
+		const config = await loadConfig(CONFIGS.search);
+		assert.deepEqual(tableNames(await loadSchema(config)), []);
+	});
+
 	test("declare mailbox.highest_modseq as text", async () => {
-		const { out } = await loadConfig(CONFIGS[0]);
+		const { out } = await loadConfig(CONFIGS.mail);
 		const snapshot = latestSnapshot(out) as {
 			tables: Record<
 				string,

package/src/account-granted-scopes-migration.sqlite.test.ts

@@ -1,66 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { AccountRepo } from "./repos/i4-account.js";
-import { accountTable } from "./schema.js";
-import {
-	applyMigration,
-	migrationJournal,
-} from "./test-shipped-sqlite-schema.js";
-
-const MIGRATION = "0032_account_granted_scopes";
-
-const atPredecessor = (): Database.Database => {
-	const sqlite = new Database(":memory:");
-	for (const entry of migrationJournal()) {
-		if (entry.tag === MIGRATION) return sqlite;
-		applyMigration(sqlite, entry.tag);
-	}
-	throw new Error(`${MIGRATION} is not in the journal`);
-};
-
-const migrateOnward = (sqlite: Database.Database): void => {
-	const tags = migrationJournal().map((entry) => entry.tag);
-	for (const tag of tags.slice(tags.indexOf(MIGRATION))) {
-		applyMigration(sqlite, tag);
-	}
-};
-
-const insertAccount = (
-	sqlite: Database.Database,
-	accountId: string,
-	authType: string,
-): void => {
-	sqlite
-		.prepare(
-			`INSERT INTO account (
-				account_id, account_config_id, username, email, auth_type,
-				imap_host, imap_port, imap_tls, imap_start_tls, smtp_port,
-				is_active, connection_state, created_at, updated_at
-			) VALUES (?, 'config', 'person', 'person@example.com', ?,
-				'outlook.office365.com', 993, 1, 0, 587, 1,
-				'not_authenticated', 0, 0)`,
-		)
-		.run(accountId, authType);
-};
-
-describe("an account written before granted scopes were recorded", () => {
-	test("a Microsoft account holds the mail grant its consent always asked for", async () => {
-		const sqlite = atPredecessor();
-		insertAccount(sqlite, "microsoft", "oauthMicrosoft");
-		insertAccount(sqlite, "password", "password");
-
-		migrateOnward(sqlite);
-
-		const repo = new AccountRepo(
-			drizzle(sqlite, { schema: { accounts: accountTable } }) as never,
-		);
-		assert.deepEqual((await repo.get("microsoft")).grantedScopes, [
-			"https://outlook.office.com/IMAP.AccessAsUser.All",
-			"https://outlook.office.com/SMTP.Send",
-		]);
-		assert.deepEqual((await repo.get("password")).grantedScopes, []);
-		sqlite.close();
-	});
-});

package/src/account-synced-services-migration.sqlite.test.ts

@@ -1,56 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { AccountService } from "@remit/domain-enums";
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { AccountRepo } from "./repos/i4-account.js";
-import { accountTable } from "./schema.js";
-import {
-	applyMigration,
-	migrationJournal,
-} from "./test-shipped-sqlite-schema.js";
-
-const MIGRATION = "0029_account_synced_services";
-
-const atPredecessor = (): Database.Database => {
-	const sqlite = new Database(":memory:");
-	for (const entry of migrationJournal()) {
-		if (entry.tag === MIGRATION) return sqlite;
-		applyMigration(sqlite, entry.tag);
-	}
-	throw new Error(`${MIGRATION} is not in the journal`);
-};
-
-const migrateOnward = (sqlite: Database.Database): void => {
-	const tags = migrationJournal().map((entry) => entry.tag);
-	for (const tag of tags.slice(tags.indexOf(MIGRATION))) {
-		applyMigration(sqlite, tag);
-	}
-};
-
-describe("an account written before the service selection existed", () => {
-	test("comes out of the migration syncing mail only", async () => {
-		const sqlite = atPredecessor();
-		sqlite
-			.prepare(
-				`INSERT INTO account (
-					account_id, account_config_id, username, email, auth_type,
-					imap_host, imap_port, imap_tls, imap_start_tls, smtp_port,
-					is_active, connection_state, created_at, updated_at
-				) VALUES ('existing', 'config', 'person', 'person@example.com',
-					'password', 'imap.example.com', 993, 1, 0, 587, 1,
-					'not_authenticated', 0, 0)`,
-			)
-			.run();
-
-		migrateOnward(sqlite);
-
-		const repo = new AccountRepo(
-			drizzle(sqlite, { schema: { accounts: accountTable } }) as never,
-		);
-		assert.deepEqual((await repo.get("existing")).syncedServices, [
-			AccountService.Mail,
-		]);
-		sqlite.close();
-	});
-});