aiex-cli 0.0.0

package/dist/core/schema-sqlite/migrate-helper.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/core/schema-sqlite/migrate-helper.mjs

@@ -0,0 +1,190 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs/promises";
+import Database from "better-sqlite3";
+import * as esbuild from "esbuild";
+
+//#region src/core/schema-sqlite/migrate-helper.ts
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const { generateSQLiteDrizzleJson, generateSQLiteMigration } = require("drizzle-kit/api");
+const EMPTY_SNAPSHOT = {
+	version: "6",
+	dialect: "sqlite",
+	tables: {},
+	views: {},
+	enums: {},
+	_meta: {
+		tables: {},
+		columns: {}
+	},
+	internal: { indexes: {} },
+	id: "00000000-0000-0000-0000-000000000000",
+	prevId: "00000000-0000-0000-0000-000000000000"
+};
+async function loadSchemaExports(schemaPath) {
+	let cliDir;
+	try {
+		const pkgPath = require.resolve("aiex-cli/package.json");
+		cliDir = path.dirname(pkgPath);
+	} catch {
+		cliDir = path.dirname(path.dirname(path.dirname(path.dirname(__dirname))));
+	}
+	const result = await esbuild.build({
+		entryPoints: [schemaPath],
+		bundle: true,
+		platform: "node",
+		format: "cjs",
+		write: false,
+		nodePaths: [path.join(cliDir, "node_modules")]
+	});
+	const tempPath = schemaPath.replace(".ts", ".__bundled__.cjs");
+	await fs.writeFile(tempPath, result.outputFiles[0].text);
+	try {
+		const exports = require(tempPath);
+		await fs.unlink(tempPath);
+		return exports;
+	} catch (e) {
+		await fs.unlink(tempPath).catch(() => {});
+		throw e;
+	}
+}
+async function loadPrevSnapshot(migrationsPath) {
+	const metaPath = path.join(migrationsPath, "meta", "_journal.json");
+	try {
+		const journal = JSON.parse(await fs.readFile(metaPath, "utf-8"));
+		if (!journal.entries?.length) return null;
+		const latestEntry = journal.entries[journal.entries.length - 1];
+		const snapshotPath = path.join(migrationsPath, "meta", `${latestEntry.tag}_snapshot.json`);
+		return JSON.parse(await fs.readFile(snapshotPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+async function saveSnapshot(migrationsPath, snapshot) {
+	const metaPath = path.join(migrationsPath, "meta");
+	await fs.mkdir(metaPath, { recursive: true });
+	const journalPath = path.join(metaPath, "_journal.json");
+	let journal;
+	try {
+		journal = JSON.parse(await fs.readFile(journalPath, "utf-8"));
+	} catch {
+		journal = {
+			version: "6",
+			dialect: "sqlite",
+			entries: []
+		};
+	}
+	const idx = journal.entries.length + 1;
+	const tag = `${String(idx).padStart(4, "0")}_${snapshot.id.replace(/-/g, "_").substring(0, 8)}`;
+	const snapshotPath = path.join(metaPath, `${tag}_snapshot.json`);
+	await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2));
+	journal.entries.push({
+		idx,
+		version: snapshot.id,
+		when: Date.now(),
+		tag,
+		breakpoints: true
+	});
+	await fs.writeFile(journalPath, JSON.stringify(journal, null, 2));
+	return tag;
+}
+async function saveMigrationFile(migrationsPath, tag, sqlStatements) {
+	await fs.mkdir(migrationsPath, { recursive: true });
+	const sqlPath = path.join(migrationsPath, `${tag}.sql`);
+	const sqlContent = sqlStatements.join("\n--> statement-breakpoint\n");
+	await fs.writeFile(sqlPath, sqlContent);
+	return sqlPath;
+}
+function applyMigrationWithTransaction(dbPath, sqlStatements) {
+	const db = new Database(dbPath);
+	const transaction = db.transaction(() => {
+		for (const sql of sqlStatements) db.exec(sql);
+	});
+	try {
+		transaction();
+	} finally {
+		db.close();
+	}
+}
+const LOCK_FILE = ".migrate.lock";
+async function acquireLock(aiexDir) {
+	const lockPath = path.join(aiexDir, LOCK_FILE);
+	await fs.mkdir(aiexDir, { recursive: true });
+	try {
+		const fd = await fs.open(lockPath, "wx");
+		await fd.write(`${process.pid}\n${Date.now()}`);
+		await fd.close();
+	} catch (e) {
+		if (e.code === "EEXIST") try {
+			const [pidStr, timestampStr] = (await fs.readFile(lockPath, "utf-8")).split("\n");
+			const lockPid = Number.parseInt(pidStr, 10);
+			const lockTime = Number.parseInt(timestampStr, 10);
+			const lockAge = Date.now() - lockTime;
+			if (lockAge > 3e5) {
+				await fs.unlink(lockPath);
+				return acquireLock(aiexDir);
+			}
+			throw new Error(`Migration is already running (PID ${lockPid}, started ${Math.round(lockAge / 1e3)}s ago). Wait for it to complete or remove ${lockPath} if stale.`);
+		} catch {
+			await fs.unlink(lockPath).catch(() => {});
+			return acquireLock(aiexDir);
+		}
+		throw e;
+	}
+}
+async function releaseLock(aiexDir) {
+	const lockPath = path.join(aiexDir, LOCK_FILE);
+	await fs.unlink(lockPath).catch(() => {});
+}
+async function main() {
+	const args = process.argv.slice(2);
+	const schemaPath = args[0];
+	const migrationsPath = args[1];
+	const dbPath = args[2];
+	if (!schemaPath || !migrationsPath || !dbPath) {
+		console.error("Usage: migrate-helper.ts <schemaPath> <migrationsPath> <dbPath>");
+		process.exit(1);
+	}
+	try {
+		const aiexDir = path.dirname(path.dirname(migrationsPath));
+		await acquireLock(aiexDir);
+		try {
+			const exports = await loadSchemaExports(schemaPath);
+			const prevSnapshot = await loadPrevSnapshot(migrationsPath);
+			const currentSnapshot = await generateSQLiteDrizzleJson(exports, prevSnapshot?.id);
+			const sqlStatements = await generateSQLiteMigration(prevSnapshot || EMPTY_SNAPSHOT, currentSnapshot);
+			if (sqlStatements.length === 0) {
+				console.log(JSON.stringify({
+					success: true,
+					changes: 0
+				}));
+				return;
+			}
+			applyMigrationWithTransaction(dbPath, sqlStatements);
+			const tag = await saveSnapshot(migrationsPath, currentSnapshot);
+			await saveMigrationFile(migrationsPath, tag, sqlStatements);
+			console.log(JSON.stringify({
+				success: true,
+				changes: sqlStatements.length,
+				tag
+			}));
+		} finally {
+			await releaseLock(aiexDir);
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(JSON.stringify({
+			success: false,
+			error: message
+		}));
+		process.exit(1);
+	}
+}
+main();
+
+//#endregion
+export {  };