Refactor Study Desk application structure
This commit is contained in:
parent
faaccf8a7e
commit
089439ed90
145 changed files with 8087 additions and 3412 deletions
312
scripts/migration-preflight.mjs
Normal file
312
scripts/migration-preflight.mjs
Normal file
|
|
@ -0,0 +1,312 @@
|
|||
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;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue