peta-migrate 0.1.1 → 0.2.1

package/dist/snapshot-DopEB8mx.mjs

@@ -0,0 +1,550 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Migrator } from "kysely/migration";
+//#region src/checksum.ts
+/**
+* Compute SHA-256 hex digest of a file's content.
+*/
+function computeChecksum(filePath) {
+	const content = readFileSync(filePath, "utf-8");
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Load the checksum store from the migrations directory.
+*/
+function loadChecksums(migrationsDir) {
+	const filePath = resolve(migrationsDir, ".checksums.json");
+	if (!existsSync(filePath)) return {};
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/**
+* Save checksums to the migrations directory.
+*/
+function saveChecksums(migrationsDir, store) {
+	writeFileSync(resolve(migrationsDir, ".checksums.json"), JSON.stringify(store, null, 2));
+}
+/**
+* Verify a migration file's checksum against the stored value.
+* Returns true if match or no stored checksum exists.
+*/
+function verifyChecksum(migrationsDir, name, filePath) {
+	const stored = loadChecksums(migrationsDir)[name];
+	if (!stored) return true;
+	return stored === computeChecksum(filePath);
+}
+//#endregion
+//#region src/config.ts
+function defineConfig(config) {
+	return config;
+}
+async function loadConfig() {
+	const candidates = [
+		"peta.config.ts",
+		"peta.config.js",
+		"peta.config.mjs"
+	];
+	let mod = null;
+	for (const file of candidates) try {
+		mod = await import(resolve(process.cwd(), file));
+		break;
+	} catch {}
+	if (!mod) throw new Error("No peta.config.ts found. Create one in your project root.");
+	const config = mod.default ?? mod;
+	return {
+		migrationsDir: config.migrationsDir,
+		models: config.models,
+		getKysely: config.getKysely
+	};
+}
+async function loadMigrationFiles(dir) {
+	const { readdirSync } = await import("node:fs");
+	const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+	const migrations = [];
+	for (const file of files) {
+		const mod = await import(resolve(dir, file));
+		if (mod.up) migrations.push({
+			name: file.replace(/\.(ts|js)$/, ""),
+			up: mod.up,
+			down: mod.down ?? (async () => {})
+		});
+	}
+	return migrations;
+}
+/**
+* Load model definitions from glob patterns.
+* Dynamically imports each matched file and collects ModelDefinition exports.
+* Models are keyed by their `.name` property.
+*/
+async function loadModels(patterns) {
+	const modelMap = /* @__PURE__ */ new Map();
+	const patternList = Array.isArray(patterns) ? patterns : [patterns];
+	const cwd = process.cwd();
+	for (const raw of patternList) {
+		let pattern = raw;
+		if (!pattern.startsWith("/")) pattern = resolve(cwd, pattern);
+		const glob = new Bun.Glob(pattern);
+		const files = Array.from(glob.scanSync(cwd));
+		for (const file of files) {
+			const fullPath = resolve(cwd, file);
+			try {
+				const mod = await import(fullPath);
+				for (const value of Object.values(mod)) if (isModelDefinition(value)) {
+					if (!modelMap.has(value.name)) modelMap.set(value.name, value);
+				}
+			} catch (err) {
+				console.warn(`⚠ Failed to load model file "${fullPath}":`, err.message);
+			}
+		}
+	}
+	return modelMap;
+}
+function isModelDefinition(value) {
+	if (value === null || value === void 0) return false;
+	const obj = value;
+	return typeof obj.table === "string" && obj.columns !== void 0 && typeof obj.columns === "object";
+}
+//#endregion
+//#region src/differ.ts
+/**
+* Compare two SchemaSnapshots and produce a list of SchemaDiff operations.
+* Compares `prev` (old) vs `next` (new) to generate a migration plan.
+*/
+function diffSnapshots(prev, next) {
+	const diffs = [];
+	const prevTables = new Map(prev.tables.map((t) => [t.name, t]));
+	const nextTables = new Map(next.tables.map((t) => [t.name, t]));
+	for (const [name] of prevTables) if (!nextTables.has(name)) diffs.push({
+		type: "dropTable",
+		table: name
+	});
+	for (const [name, table] of nextTables) if (!prevTables.has(name)) diffs.push({
+		type: "createTable",
+		table: name,
+		details: {
+			columns: table.columns,
+			indexes: table.indexes
+		}
+	});
+	for (const [name, nextTable] of nextTables) {
+		const prevTable = prevTables.get(name);
+		if (!prevTable) continue;
+		const tableDiffs = diffTable(prevTable, nextTable);
+		diffs.push(...tableDiffs);
+	}
+	return diffs;
+}
+function diffTable(prev, next) {
+	const diffs = [];
+	const prevColumns = new Map(prev.columns.map((c) => [c.name, c]));
+	const nextColumns = new Map(next.columns.map((c) => [c.name, c]));
+	for (const [name] of prevColumns) if (!nextColumns.has(name)) diffs.push({
+		type: "dropColumn",
+		table: prev.name,
+		column: name
+	});
+	for (const [name, col] of nextColumns) if (!prevColumns.has(name)) diffs.push({
+		type: "addColumn",
+		table: prev.name,
+		column: name,
+		details: { ...col }
+	});
+	for (const [name, nextCol] of nextColumns) {
+		const prevCol = prevColumns.get(name);
+		if (!prevCol) continue;
+		if (columnsDiffer(prevCol, nextCol)) diffs.push({
+			type: "alterColumn",
+			table: prev.name,
+			column: name,
+			details: {
+				from: prevCol,
+				to: nextCol
+			}
+		});
+	}
+	const prevIndexes = new Map(prev.indexes.map((i) => [i.name, i]));
+	const nextIndexes = new Map(next.indexes.map((i) => [i.name, i]));
+	for (const [name] of prevIndexes) if (!nextIndexes.has(name)) diffs.push({
+		type: "dropIndex",
+		table: prev.name,
+		details: { indexName: name }
+	});
+	for (const [name, idx] of nextIndexes) if (!prevIndexes.has(name)) diffs.push({
+		type: "addIndex",
+		table: prev.name,
+		details: {
+			indexName: name,
+			columns: idx.columns,
+			unique: idx.unique
+		}
+	});
+	return diffs;
+}
+function columnsDiffer(a, b) {
+	if (a.type !== b.type) return true;
+	if (a.isNullable !== b.isNullable) return true;
+	if (a.isPrimaryKey !== b.isPrimaryKey) return true;
+	if (a.isUnique !== b.isUnique) return true;
+	if (JSON.stringify(a.defaultValue) !== JSON.stringify(b.defaultValue)) return true;
+	if (JSON.stringify(a.references) !== JSON.stringify(b.references)) return true;
+	return false;
+}
+//#endregion
+//#region src/generator.ts
+function createMigrationGenerator() {
+	function generateInitialMigration(models, _options = {}) {
+		const parts = [];
+		const indexParts = [];
+		const warnings = [];
+		const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
+		for (const [, modelDef] of models) {
+			const table = modelDef.table;
+			if (!table) continue;
+			parts.push(generateCreateTable(table, modelDef.columns));
+			for (const [colName, col] of Object.entries(modelDef.columns)) if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) indexParts.push(generateCreateIndex(table, colName));
+			for (const [, rel] of Object.entries(modelDef.relations ?? {})) if (rel.type === "manyToMany") {
+				const through = rel.throughTable;
+				if (through && !registeredTables.has(through)) warnings.push(`// ⚠ Detected ManyToMany "${modelDef.name}" references table "${through}" but no model is registered for it.\n//   Add a model to include the pivot table.`);
+			}
+		}
+		const upBody = [...parts, ...indexParts].join("\n\n");
+		const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`).join("\n");
+		return `import type { Kysely } from "kysely"\nimport { sql } from "kysely"\n\nexport async function up(db: Kysely<any>): Promise<void> {\n${warnings.length > 0 ? `  // Warnings:\n${warnings.join("\n")}\n\n` : ""}${upBody}\n}\n\nexport async function down(db: Kysely<any>): Promise<void> {\n${downTables}\n}\n`;
+	}
+	function generateMigrationFromDiff(diffs, _options = {}) {
+		const upParts = [];
+		const downParts = [];
+		const warnings = [];
+		for (const diff of diffs) switch (diff.type) {
+			case "createTable": {
+				const cols = diff.details?.columns ?? [];
+				const indexes = diff.details?.indexes ?? [];
+				upParts.push(generateCreateTableFromSchema(diff.table, cols));
+				for (const idx of indexes) upParts.push(generateCreateIndexFromSchema(diff.table, idx.name, idx.columns));
+				downParts.push(`  await db.schema.dropTable("${diff.table}").ifExists().execute()`);
+				break;
+			}
+			case "dropTable":
+				upParts.push(`  await db.schema.dropTable("${diff.table}").ifExists().execute()`);
+				downParts.push(`  // ⚠ Cannot auto-restore dropped table "${diff.table}" — manual recovery needed`);
+				warnings.push(`// ⚠ Dropped table "${diff.table}". The down() function cannot restore it.`);
+				break;
+			case "addColumn": {
+				const col = diff.details;
+				upParts.push(`  await db.schema.alterTable("${diff.table}").addColumn("${col.name}", "${col.type}"${columnCallbackFromSchema(col)}).execute()`);
+				downParts.push(`  await db.schema.alterTable("${diff.table}").dropColumn("${col.name}").execute()`);
+				break;
+			}
+			case "dropColumn":
+				upParts.push(`  await db.schema.alterTable("${diff.table}").dropColumn("${diff.column}").execute()`);
+				downParts.push(`  // ⚠ Cannot auto-restore dropped column "${diff.table}.${diff.column}" — manual recovery needed`);
+				warnings.push(`// ⚠ Dropped column "${diff.table}.${diff.column}". The down() function cannot restore it.`);
+				break;
+			case "alterColumn": {
+				const details = diff.details;
+				upParts.push(`  // ⚠ ALTER COLUMN "${diff.table}.${diff.column}" — manual review recommended`);
+				if (details) {
+					upParts.push(`  //   from: ${details.from.type} → to: ${details.to.type}`);
+					upParts.push(`  //   nullable: ${details.from.isNullable} → ${details.to.isNullable}`);
+				}
+				upParts.push(`  await db.schema.alterTable("${diff.table}").alterColumn("${diff.column}", (col) => col.setDataType("${details?.to.type ?? "text"}")).execute()`);
+				warnings.push(`// ⚠ ALTER COLUMN "${diff.table}.${diff.column}". Down migration is not auto-generated.`);
+				break;
+			}
+			case "addIndex": {
+				const idxDetails = diff.details;
+				const idxName = idxDetails?.indexName ?? `${diff.table}_${diff.column ?? "idx"}_index`;
+				const idxCols = idxDetails?.columns ?? (diff.column ? [diff.column] : []);
+				upParts.push(generateCreateIndexFromSchema(diff.table, idxName, idxCols));
+				downParts.push(`  await db.schema.dropIndex("${idxName}").ifExists().execute()`);
+				break;
+			}
+			case "dropIndex": {
+				const idxName = diff.details?.indexName ?? `${diff.table}_idx`;
+				upParts.push(`  await db.schema.dropIndex("${idxName}").ifExists().execute()`);
+				downParts.push(`  // ⚠ Cannot auto-restore dropped index "${idxName}" — manual recovery needed`);
+				warnings.push(`// ⚠ Dropped index "${idxName}". The down() function cannot restore it.`);
+				break;
+			}
+		}
+		const upBody = upParts.join("\n\n");
+		const downBody = downParts.join("\n\n");
+		return `import type { Kysely } from "kysely"\nimport { sql } from "kysely"\n\nexport async function up(db: Kysely<any>): Promise<void> {\n${warnings.length > 0 ? `  // Warnings:\n${warnings.join("\n")}\n\n` : ""}${upBody}\n}\n\nexport async function down(db: Kysely<any>): Promise<void> {\n${downBody}\n}\n`;
+	}
+	return {
+		generateInitialMigration,
+		generateMigrationFromDiff
+	};
+}
+function generateCreateTable(table, columns) {
+	const lines = [`  await db.schema.createTable("${table}").ifNotExists()`];
+	for (const [name, col] of Object.entries(columns)) lines.push(`    .addColumn("${name}", "${mapType(col)}"${columnCallback(col)})`);
+	lines.push("    .execute()");
+	return lines.join("\n");
+}
+function generateCreateTableFromSchema(table, columns) {
+	const lines = [`  await db.schema.createTable("${table}").ifNotExists()`];
+	for (const col of columns) {
+		const ref = col.references ? `, (c) => c.references("${col.references.table}.${col.references.column}")` : "";
+		const extras = [];
+		if (col.isPrimaryKey) extras.push("primaryKey()");
+		if (!col.isNullable && !col.isPrimaryKey) extras.push("notNull()");
+		if (col.isUnique && !col.isPrimaryKey) extras.push("unique()");
+		if (col.defaultValue !== void 0 && col.defaultValue !== null) extras.push(`defaultTo(${JSON.stringify(col.defaultValue)})`);
+		const cb = extras.length > 0 ? `, (c) => c.${extras.join(".")}${ref ? `.${ref.slice(5)}` : ""}` : ref;
+		lines.push(`    .addColumn("${col.name}", "${col.type}"${cb})`);
+	}
+	lines.push("    .execute()");
+	return lines.join("\n");
+}
+function generateCreateIndex(table, column) {
+	return [
+		`  await db.schema.createIndex("${table}_${column}_index")`,
+		`    .on("${table}")`,
+		`    .column("${column}")`,
+		"    .execute()"
+	].join("\n");
+}
+function generateCreateIndexFromSchema(table, indexName, columns) {
+	const lines = [`  await db.schema.createIndex("${indexName}").on("${table}")`];
+	for (const col of columns) lines.push(`    .column("${col}")`);
+	lines.push("    .execute()");
+	return lines.join("\n");
+}
+function columnCallback(col) {
+	const calls = [];
+	if (col.isPrimaryKey) {
+		if (col.dataType === "integer") calls.push("autoIncrement()");
+		calls.push("primaryKey()");
+	}
+	if (!col.isNullable && !col.isPrimaryKey) calls.push("notNull()");
+	const dv = col.defaultValue;
+	if (dv !== void 0 && typeof dv !== "function") calls.push(`defaultTo(${JSON.stringify(dv)})`);
+	if (col.isUnique && !col.isPrimaryKey) calls.push("unique()");
+	const refConstraint = col.constraints.find((c) => c.type === "references");
+	if (refConstraint?.args[0]) {
+		const targetTable = (typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0])?.table;
+		const targetColumns = refConstraint.args[1];
+		if (typeof targetTable === "string" && targetTable && targetColumns?.length) calls.push(`references("${targetTable}.${targetColumns[0]}")`);
+	}
+	return calls.length === 0 ? "" : `, (c) => c.${calls.join(".")}`;
+}
+function columnCallbackFromSchema(col) {
+	const calls = [];
+	if (col.isPrimaryKey) calls.push("primaryKey()");
+	if (!col.isNullable && !col.isPrimaryKey) calls.push("notNull()");
+	if (col.defaultValue !== void 0 && col.defaultValue !== null && typeof col.defaultValue !== "function") calls.push(`defaultTo(${JSON.stringify(col.defaultValue)})`);
+	if (col.isUnique && !col.isPrimaryKey) calls.push("unique()");
+	if (col.references) calls.push(`references("${col.references.table}.${col.references.column}")`);
+	return calls.length === 0 ? "" : `, (c) => c.${calls.join(".")}`;
+}
+function mapType(col) {
+	switch (col.dataType) {
+		case "integer":
+		case "smallint":
+		case "bigint":
+		case "text":
+		case "boolean":
+		case "timestamp":
+		case "date":
+		case "float":
+		case "double":
+		case "uuid": return col.dataType;
+		case "string": {
+			const max = col.args[0];
+			return max != null ? `varchar(${max})` : "varchar";
+		}
+		case "json":
+		case "jsonb": return "json";
+		case "decimal": {
+			const p = col.args[0];
+			const s = col.args[1];
+			return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
+		}
+		case "enum": return "text";
+		default: return col.dataType;
+	}
+}
+//#endregion
+//#region src/runner.ts
+function createMigrationRunner(db, table = "_peta_migrations") {
+	/**
+	* Create a Kysely MigrationProvider from our MigrationFile[].
+	*/
+	function createProvider(files) {
+		return { async getMigrations() {
+			const result = {};
+			for (const f of files.sort(byName)) result[f.name] = {
+				up: f.up,
+				down: f.down
+			};
+			return result;
+		} };
+	}
+	/**
+	* Build a Migrator instance with the given migration files.
+	*/
+	function buildMigrator(files) {
+		return new Migrator({
+			db,
+			provider: createProvider(files),
+			migrationTableName: table,
+			migrationLockTableName: `${table}_lock`
+		});
+	}
+	/**
+	* Query the migration tracking table directly.
+	* Kysely's Migrator stores with column "name" and "timestamp".
+	*/
+	async function queryCompleted() {
+		try {
+			return (await db.selectFrom(table).select(["name", "timestamp"]).orderBy("name", "asc").execute()).map((r) => ({
+				name: String(r.name),
+				appliedAt: String(r.timestamp)
+			}));
+		} catch {
+			return [];
+		}
+	}
+	async function ensureTable() {
+		const result = await buildMigrator([]).migrateUp();
+		if (result.error) {
+			const msg = result.error.message ?? "";
+			if (!msg.includes("no migrations") && !msg.includes("no pending")) throw result.error;
+		}
+	}
+	async function getCompleted() {
+		return queryCompleted();
+	}
+	async function up(migrations) {
+		const result = await buildMigrator(migrations).migrateToLatest();
+		if (result.error) throw result.error;
+	}
+	async function down(migrations) {
+		const result = await buildMigrator(migrations).migrateDown();
+		if (result.error) throw result.error;
+	}
+	async function status(migrations) {
+		const completed = await queryCompleted();
+		const completedNames = new Set(completed.map((r) => r.name));
+		return {
+			completed,
+			pending: migrations.filter((m) => !completedNames.has(m.name)).sort(byName)
+		};
+	}
+	return {
+		ensureTable,
+		getCompleted,
+		up,
+		down,
+		status
+	};
+}
+function byName(a, b) {
+	return a.name.localeCompare(b.name);
+}
+//#endregion
+//#region src/snapshot.ts
+/**
+* Extract a SchemaSnapshot from a map of model definitions.
+*/
+function createSnapshot(models) {
+	const tables = [];
+	for (const [, model] of models) {
+		if (!model.table) continue;
+		const columns = [];
+		const indexes = [];
+		for (const [name, col] of Object.entries(model.columns)) {
+			columns.push(columnToSchema(name, col));
+			if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) indexes.push({
+				name: `${model.table}_${name}_index`,
+				columns: [name]
+			});
+		}
+		tables.push({
+			name: model.table,
+			columns,
+			indexes
+		});
+	}
+	return {
+		version: 1,
+		tables
+	};
+}
+function columnToSchema(name, col) {
+	const refConstraint = col.constraints.find((c) => c.type === "references");
+	let references;
+	if (refConstraint?.args[0]) {
+		const targetTable = (typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0])?.table;
+		const targetColumns = refConstraint.args[1];
+		if (typeof targetTable === "string" && targetTable && targetColumns?.length) {
+			const first = targetColumns[0];
+			if (first) references = {
+				table: targetTable,
+				column: first
+			};
+		}
+	}
+	return {
+		name,
+		type: mapSnapshotType(col),
+		isNullable: col.isNullable ?? false,
+		isPrimaryKey: col.isPrimaryKey ?? false,
+		isUnique: col.isUnique ?? false,
+		defaultValue: col.defaultValue,
+		references
+	};
+}
+function mapSnapshotType(col) {
+	switch (col.dataType) {
+		case "integer":
+		case "smallint":
+		case "bigint":
+		case "text":
+		case "boolean":
+		case "timestamp":
+		case "date":
+		case "float":
+		case "double":
+		case "uuid": return col.dataType;
+		case "string": {
+			const max = col.args[0];
+			return max != null ? `varchar(${max})` : "varchar";
+		}
+		case "json":
+		case "jsonb": return "json";
+		case "decimal": {
+			const p = col.args[0];
+			const s = col.args[1];
+			return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
+		}
+		case "enum": return "text";
+		default: return col.dataType;
+	}
+}
+/**
+* Load snapshot from a JSON file path.
+*/
+async function loadSnapshot(filePath) {
+	try {
+		const { readFileSync } = await import("node:fs");
+		const data = readFileSync(filePath, "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+/**
+* Save snapshot to a JSON file path.
+*/
+async function saveSnapshot(filePath, snapshot) {
+	const { writeFileSync } = await import("node:fs");
+	writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
+}
+//#endregion
+export { createMigrationGenerator as a, loadConfig as c, computeChecksum as d, loadChecksums as f, createMigrationRunner as i, loadMigrationFiles as l, verifyChecksum as m, loadSnapshot as n, diffSnapshots as o, saveChecksums as p, saveSnapshot as r, defineConfig as s, createSnapshot as t, loadModels as u };

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "peta-migrate",
   "type": "module",
-  "version": "0.1.1",
+  "private": false,
+  "version": "0.2.1",
   "description": "Migration tools for peta-orm",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zfadhli/peta-stack.git"
   },
-  "module": "src/index.ts",
+  "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "exports": {
@@ -32,15 +33,22 @@
   },
   "peerDependencies": {
     "kysely": "^0.29.2",
+    "peta-orm": "workspace:*",
     "typescript": "^6.0.0"
   },
   "devDependencies": {
+    "@libsql/client": "^0.8.0",
+    "@libsql/kysely-libsql": "^0.4.1",
     "@types/bun": "^1.3.14",
-    "tsdown": "^0.22.2"
+    "kysely": "^0.29.2",
+    "peta-orm": "workspace:*",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.0"
   },
   "scripts": {
     "build": "tsdown",
-    "prepublish": "bun run build",
-    "typecheck": "bun x tsc --noEmit"
+    "prepublishOnly": "bun run build",
+    "typecheck": "bun x tsc --noEmit",
+    "test": "bun test"
   }
 }