312 lines
10 KiB
JavaScript
312 lines
10 KiB
JavaScript
import { existsSync, readFileSync, readdirSync } from "node:fs";
|
|
import path from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { pathToFileURL } from "node:url";
|
|
import Database from "better-sqlite3";
|
|
import { databasePathFromUrl } from "./databasePath.mjs";
|
|
|
|
export const GROUP_MIGRATION = "20260807090000_add_material_groups";
|
|
|
|
function tableExists(database, table) {
|
|
return Boolean(
|
|
database
|
|
.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?")
|
|
.get(table)
|
|
);
|
|
}
|
|
|
|
function hasColumn(database, table, column) {
|
|
if (!tableExists(database, table)) return false;
|
|
return database.pragma(`table_info(${table})`).some((item) => item.name === column);
|
|
}
|
|
|
|
function hasForeignKey(database, table, from, target, onDelete) {
|
|
return database
|
|
.pragma(`foreign_key_list(${table})`)
|
|
.some(
|
|
(item) =>
|
|
item.from === from && item.table === target && item.on_delete === onDelete
|
|
);
|
|
}
|
|
|
|
function hasUniqueIndex(database, table, indexName, column) {
|
|
const index = database
|
|
.pragma(`index_list(${table})`)
|
|
.find((item) => item.name === indexName && item.unique === 1);
|
|
if (!index) return false;
|
|
const columns = database.pragma(`index_info(${indexName})`);
|
|
return columns.length === 1 && columns[0].name === column;
|
|
}
|
|
|
|
function schemaSnapshot(database) {
|
|
const tables = database
|
|
.prepare(
|
|
"SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name <> '_prisma_migrations' ORDER BY name"
|
|
)
|
|
.all()
|
|
.map((row) => row.name);
|
|
|
|
return tables.map((table) => ({
|
|
table,
|
|
columns: database.pragma(`table_info(${JSON.stringify(table)})`).map((column) => ({
|
|
name: column.name,
|
|
type: column.type,
|
|
notnull: column.notnull,
|
|
defaultValue: column.dflt_value,
|
|
primaryKey: column.pk,
|
|
})),
|
|
foreignKeys: database
|
|
.pragma(`foreign_key_list(${JSON.stringify(table)})`)
|
|
.map((foreignKey) => ({
|
|
id: foreignKey.id,
|
|
sequence: foreignKey.seq,
|
|
target: foreignKey.table,
|
|
from: foreignKey.from,
|
|
to: foreignKey.to,
|
|
onUpdate: foreignKey.on_update,
|
|
onDelete: foreignKey.on_delete,
|
|
match: foreignKey.match,
|
|
}))
|
|
.sort((left, right) => left.id - right.id || left.sequence - right.sequence),
|
|
indexes: database
|
|
.pragma(`index_list(${JSON.stringify(table)})`)
|
|
.filter((index) => !index.name.startsWith("sqlite_autoindex_"))
|
|
.map((index) => ({
|
|
name: index.name,
|
|
unique: index.unique,
|
|
partial: index.partial,
|
|
columns: database
|
|
.pragma(`index_info(${JSON.stringify(index.name)})`)
|
|
.map((column) => column.name),
|
|
}))
|
|
.sort((left, right) => left.name.localeCompare(right.name)),
|
|
}));
|
|
}
|
|
|
|
function expectedSchemaSnapshot(migrationNames) {
|
|
const database = new Database(":memory:");
|
|
try {
|
|
database.pragma("foreign_keys = ON");
|
|
for (const migrationName of migrationNames) {
|
|
database.exec(
|
|
readFileSync(
|
|
path.join(
|
|
process.cwd(),
|
|
"prisma",
|
|
"migrations",
|
|
migrationName,
|
|
"migration.sql"
|
|
),
|
|
"utf8"
|
|
)
|
|
);
|
|
}
|
|
return schemaSnapshot(database);
|
|
} finally {
|
|
database.close();
|
|
}
|
|
}
|
|
|
|
export function inspectMigrationState(databasePath) {
|
|
if (!existsSync(databasePath)) {
|
|
throw new Error(`Database does not exist: ${databasePath}`);
|
|
}
|
|
const database = new Database(databasePath, { readonly: true, fileMustExist: true });
|
|
try {
|
|
const migrationNames = tableExists(database, "_prisma_migrations")
|
|
? database
|
|
.prepare(
|
|
'SELECT "migration_name" FROM "_prisma_migrations" WHERE "finished_at" IS NOT NULL AND "rolled_back_at" IS NULL'
|
|
)
|
|
.all()
|
|
.map((row) => row.migration_name)
|
|
: [];
|
|
const committedMigrations = readdirSync(
|
|
path.join(process.cwd(), "prisma", "migrations"),
|
|
{ withFileTypes: true }
|
|
)
|
|
.filter((entry) => entry.isDirectory())
|
|
.map((entry) => entry.name)
|
|
.sort();
|
|
const priorMigrations = committedMigrations.filter(
|
|
(name) => name < GROUP_MIGRATION
|
|
);
|
|
const laterMigrations = committedMigrations.filter(
|
|
(name) => name > GROUP_MIGRATION
|
|
);
|
|
|
|
const artifacts = {
|
|
materialGroup: tableExists(database, "MaterialGroup"),
|
|
deckColumn: hasColumn(database, "Deck", "groupId"),
|
|
quizColumn: hasColumn(database, "QuizSet", "groupId"),
|
|
shareColumn: hasColumn(database, "ShareLink", "groupId"),
|
|
deckForeignKey: hasForeignKey(
|
|
database,
|
|
"Deck",
|
|
"groupId",
|
|
"MaterialGroup",
|
|
"SET NULL"
|
|
),
|
|
quizForeignKey: hasForeignKey(
|
|
database,
|
|
"QuizSet",
|
|
"groupId",
|
|
"MaterialGroup",
|
|
"SET NULL"
|
|
),
|
|
shareForeignKey: hasForeignKey(
|
|
database,
|
|
"ShareLink",
|
|
"groupId",
|
|
"MaterialGroup",
|
|
"CASCADE"
|
|
),
|
|
shareUnique: hasUniqueIndex(
|
|
database,
|
|
"ShareLink",
|
|
"ShareLink_groupId_key",
|
|
"groupId"
|
|
),
|
|
};
|
|
const values = Object.values(artifacts);
|
|
const groupArtifactsPresent = values.every(Boolean);
|
|
const groupArtifactsAbsent = values.every((value) => !value);
|
|
const groupMigrationApplied = migrationNames.includes(GROUP_MIGRATION);
|
|
const priorHistoryComplete = priorMigrations.every((name) =>
|
|
migrationNames.includes(name)
|
|
);
|
|
const knownMigrationNames = new Set(committedMigrations);
|
|
const historyHasUnknown = migrationNames.some(
|
|
(name) => !knownMigrationNames.has(name)
|
|
);
|
|
const laterHistoryPresent = laterMigrations.some((name) =>
|
|
migrationNames.includes(name)
|
|
);
|
|
const actualSchema = schemaSnapshot(database);
|
|
const matches = (expected) =>
|
|
JSON.stringify(actualSchema) === JSON.stringify(expected);
|
|
const preGroupSchemaExact = matches(expectedSchemaSnapshot(priorMigrations));
|
|
const adoptedGroupSchemaExact = matches(
|
|
expectedSchemaSnapshot([...priorMigrations, GROUP_MIGRATION])
|
|
);
|
|
const appliedPrefix = committedMigrations.filter((name, index) =>
|
|
committedMigrations.slice(0, index + 1).every((candidate) =>
|
|
migrationNames.includes(candidate)
|
|
)
|
|
);
|
|
const appliedHistoryExact =
|
|
!historyHasUnknown &&
|
|
migrationNames.length === appliedPrefix.length &&
|
|
migrationNames.every((name) => appliedPrefix.includes(name));
|
|
const trackedSchemaExact =
|
|
appliedHistoryExact && matches(expectedSchemaSnapshot(appliedPrefix));
|
|
|
|
let classification = "CONFLICT";
|
|
if (groupMigrationApplied && trackedSchemaExact) classification = "CURRENT";
|
|
else if (
|
|
!groupMigrationApplied &&
|
|
!laterHistoryPresent &&
|
|
priorHistoryComplete &&
|
|
migrationNames.length === priorMigrations.length &&
|
|
groupArtifactsAbsent &&
|
|
preGroupSchemaExact
|
|
) classification = "APPLY";
|
|
else if (
|
|
!groupMigrationApplied &&
|
|
!laterHistoryPresent &&
|
|
priorHistoryComplete &&
|
|
migrationNames.length === priorMigrations.length &&
|
|
groupArtifactsPresent &&
|
|
adoptedGroupSchemaExact
|
|
) classification = "ADOPT";
|
|
|
|
return {
|
|
classification,
|
|
artifacts,
|
|
migrationNames,
|
|
priorHistoryComplete,
|
|
exactSchema: {
|
|
preGroup: preGroupSchemaExact,
|
|
adoptedGroup: adoptedGroupSchemaExact,
|
|
tracked: trackedSchemaExact,
|
|
},
|
|
};
|
|
} finally {
|
|
database.close();
|
|
}
|
|
}
|
|
|
|
function verifyBackup(backupPath, sourcePath) {
|
|
if (!backupPath || !existsSync(backupPath)) {
|
|
throw new Error("--resolve requires an existing verified --backup file");
|
|
}
|
|
if (path.resolve(backupPath) === path.resolve(sourcePath)) {
|
|
throw new Error("--backup must be a separate database file, not the source database");
|
|
}
|
|
const backup = new Database(backupPath, { readonly: true, fileMustExist: true });
|
|
const source = new Database(sourcePath, { readonly: true, fileMustExist: true });
|
|
try {
|
|
if (backup.pragma("integrity_check", { simple: true }) !== "ok") {
|
|
throw new Error("Backup failed SQLite integrity_check");
|
|
}
|
|
if (JSON.stringify(schemaSnapshot(backup)) !== JSON.stringify(schemaSnapshot(source))) {
|
|
throw new Error("Backup schema does not match the source database");
|
|
}
|
|
const sourceCounts = Object.fromEntries(
|
|
schemaSnapshot(source).map(({ table }) => [
|
|
table,
|
|
source.prepare(`SELECT COUNT(*) AS count FROM ${JSON.stringify(table)}`).get().count,
|
|
])
|
|
);
|
|
const backupCounts = Object.fromEntries(
|
|
schemaSnapshot(backup).map(({ table }) => [
|
|
table,
|
|
backup.prepare(`SELECT COUNT(*) AS count FROM ${JSON.stringify(table)}`).get().count,
|
|
])
|
|
);
|
|
if (JSON.stringify(sourceCounts) !== JSON.stringify(backupCounts)) {
|
|
throw new Error("Backup row counts do not match the source database");
|
|
}
|
|
} finally {
|
|
backup.close();
|
|
source.close();
|
|
}
|
|
}
|
|
|
|
function resolveMigration(databaseUrl) {
|
|
const cli = path.join(process.cwd(), "node_modules", "prisma", "build", "index.js");
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
[cli, "migrate", "resolve", "--applied", GROUP_MIGRATION],
|
|
{
|
|
cwd: process.cwd(),
|
|
env: { ...process.env, DATABASE_URL: databaseUrl },
|
|
encoding: "utf8",
|
|
}
|
|
);
|
|
if (result.status !== 0) {
|
|
throw new Error(`Prisma migration resolve failed:\n${result.stdout}\n${result.stderr}`);
|
|
}
|
|
}
|
|
|
|
if (import.meta.url === pathToFileURL(process.argv[1]).href) {
|
|
const databaseUrl = process.env.DATABASE_URL;
|
|
const databasePath = databasePathFromUrl(databaseUrl);
|
|
const state = inspectMigrationState(databasePath);
|
|
console.info(JSON.stringify(state, null, 2));
|
|
|
|
if (process.argv.includes("--resolve")) {
|
|
if (state.classification !== "ADOPT") {
|
|
throw new Error(`Refusing adoption for ${state.classification} database state`);
|
|
}
|
|
const backupIndex = process.argv.indexOf("--backup");
|
|
verifyBackup(
|
|
backupIndex >= 0 ? process.argv[backupIndex + 1] : undefined,
|
|
databasePath
|
|
);
|
|
resolveMigration(databaseUrl);
|
|
console.info(`Marked ${GROUP_MIGRATION} applied after exact-schema preflight.`);
|
|
} else if (state.classification === "CONFLICT") {
|
|
process.exitCode = 2;
|
|
}
|
|
}
|