updebe 0.1.2 → 0.2.0

package/dist/commands/upgradeHead.js

@@ -4,9 +4,18 @@ exports.runUpgradeHead = runUpgradeHead;
 const database_1 = require("../config/database");
 const connection_1 = require("../db/connection");
 const files_1 = require("../migrations/files");
+const runner_1 = require("../migrations/runner");
 async function runUpgradeHead() {
-    (0, files_1.loadMigrationDefinitions)();
+    const migrations = (0, files_1.loadMigrationDefinitions)();
     const dbConfig = (0, database_1.resolveDatabaseConfig)();
-    await (0, connection_1.testDatabaseConnection)(dbConfig);
+    await (0, connection_1.withDatabaseClient)(dbConfig, async (client) => {
+        try {
+            await (0, runner_1.runUpgradeToHead)(client, dbConfig, migrations);
+        }
+        catch (error) {
+            console.error((0, runner_1.formatMigrationError)(error));
+            throw error;
+        }
+    });
     console.log("Hey! I'm working");
 }

package/dist/db/connection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testDatabaseConnection = testDatabaseConnection;
+exports.withDatabaseClient = withDatabaseClient;
 const pg_1 = require("pg");
 const ANSI_GREEN = "\x1b[32m";
 const ANSI_RED = "\x1b[31m";
@@ -28,3 +29,26 @@ async function testDatabaseConnection(config) {
         await client.end().catch(() => undefined);
     }
 }
+async function withDatabaseClient(config, action) {
+    const client = new pg_1.Client({ connectionString: config.databaseUrl });
+    let connected = false;
+    try {
+        await client.connect();
+        connected = true;
+        console.log(`${ANSI_GREEN}Database connected successfully (schema: ${config.schema})${ANSI_RESET}`);
+        return await action(client);
+    }
+    catch (error) {
+        if (connected) {
+            throw error;
+        }
+        const message = formatSafeError(error);
+        console.error(`${ANSI_RED}Database connection error: ${message}${ANSI_RESET}`);
+        throw new Error("Database connection failed");
+    }
+    finally {
+        if (connected) {
+            await client.end().catch(() => undefined);
+        }
+    }
+}

package/dist/db/migrationState.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureMigrationState = ensureMigrationState;
+exports.getCurrentRevisionId = getCurrentRevisionId;
+exports.setCurrentRevisionId = setCurrentRevisionId;
+const ANSI_GREEN = "\x1b[32m";
+const ANSI_RESET = "\x1b[0m";
+const STATE_KEY = "current";
+const TABLE_NAME = "updebe_migrations";
+function quoteIdentifier(identifier) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+        throw new Error(`Invalid schema name: ${identifier}`);
+    }
+    return `"${identifier}"`;
+}
+function getStateTableReference(schema) {
+    return `${quoteIdentifier(schema)}."${TABLE_NAME}"`;
+}
+async function ensureMigrationState(client, schema) {
+    const quotedSchema = quoteIdentifier(schema);
+    const tableRef = getStateTableReference(schema);
+    await client.query(`CREATE SCHEMA IF NOT EXISTS ${quotedSchema}`);
+    await client.query(`
+    CREATE TABLE IF NOT EXISTS ${tableRef} (
+      singleton_key TEXT PRIMARY KEY,
+      revision_id TEXT NOT NULL,
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `);
+    console.log(`${ANSI_GREEN}Migration state ready at ${schema}.${TABLE_NAME}${ANSI_RESET}`);
+}
+async function getCurrentRevisionId(client, schema) {
+    const tableRef = getStateTableReference(schema);
+    const result = await client.query(`SELECT revision_id FROM ${tableRef} WHERE singleton_key = $1 LIMIT 1`, [STATE_KEY]);
+    if (result.rowCount === 0) {
+        return null;
+    }
+    return result.rows[0].revision_id;
+}
+async function setCurrentRevisionId(client, schema, revisionId) {
+    const tableRef = getStateTableReference(schema);
+    await client.query(`
+      INSERT INTO ${tableRef} (singleton_key, revision_id, updated_at)
+      VALUES ($1, $2, NOW())
+      ON CONFLICT (singleton_key)
+      DO UPDATE SET revision_id = EXCLUDED.revision_id, updated_at = NOW()
+    `, [STATE_KEY, revisionId]);
+}

package/dist/migrations/files.js

@@ -4,47 +4,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMigrationDefinitions = loadMigrationDefinitions;
+exports.loadMigrationModule = loadMigrationModule;
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateMigrationDefinition(migration, filePath) {
-    if (!migration || typeof migration !== "object") {
-        throw new Error(`${filePath}: migration must be an object`);
-    }
-    const revision = migration.revision;
-    if (!revision || typeof revision !== "object") {
+const node_url_1 = require("node:url");
+let tsNodeRegistered = false;
+function extractRevision(content, filePath) {
+    const revisionBlockMatch = content.match(/export\s+const\s+revision\s*=\s*\{([\s\S]*?)\}/m);
+    if (!revisionBlockMatch) {
         throw new Error(`${filePath}: missing required key revision`);
     }
-    const revisionData = revision;
-    if (!isNonEmptyString(revisionData._id)) {
+    const revisionBlock = revisionBlockMatch[1];
+    const idMatch = revisionBlock.match(/\b_id\s*:\s*(["'`])(.*?)\1/m);
+    const revisedIdMatch = revisionBlock.match(/\brevised_id\s*:\s*(["'`])(.*?)\1/m);
+    if (!idMatch) {
         throw new Error(`${filePath}: missing required key revision._id`);
     }
-    if (!isNonEmptyString(revisionData.revised_id)) {
+    if (!revisedIdMatch) {
         throw new Error(`${filePath}: missing required key revision.revised_id`);
     }
+    return {
+        _id: idMatch[2],
+        revised_id: revisedIdMatch[2]
+    };
+}
+function validateMigrationFunctions(content, filePath) {
+    if (!/export\s+(?:async\s+)?function\s+upgrade\s*\(/m.test(content)) {
+        throw new Error(`${filePath}: missing required function upgrade`);
+    }
+    if (!/export\s+(?:async\s+)?function\s+downgrade\s*\(/m.test(content)) {
+        throw new Error(`${filePath}: missing required function downgrade`);
+    }
 }
 function loadMigrationDefinitions(baseDir = process.cwd()) {
-    const migrationsDir = node_path_1.default.join(baseDir, "migrations");
+    const migrationsDir = node_path_1.default.join(baseDir, "updebe", "Migrations");
     if (!node_fs_1.default.existsSync(migrationsDir)) {
         return [];
     }
     const fileNames = node_fs_1.default.readdirSync(migrationsDir)
-        .filter((fileName) => fileName.endsWith(".json"))
+        .filter((fileName) => fileName.endsWith(".ts"))
         .sort();
     return fileNames.map((fileName) => {
-        const relativePath = `migrations/${fileName}`;
+        const relativePath = `updebe/Migrations/${fileName}`;
         const fullPath = node_path_1.default.join(migrationsDir, fileName);
-        let parsedMigration;
+        let content;
         try {
-            const content = node_fs_1.default.readFileSync(fullPath, "utf8");
-            parsedMigration = JSON.parse(content);
+            content = node_fs_1.default.readFileSync(fullPath, "utf8");
         }
         catch {
-            throw new Error(`${relativePath}: invalid JSON`);
+            throw new Error(`${relativePath}: unable to read file`);
         }
-        validateMigrationDefinition(parsedMigration, relativePath);
-        return parsedMigration;
+        const revision = extractRevision(content, relativePath);
+        validateMigrationFunctions(content, relativePath);
+        return {
+            fullPath,
+            filePath: relativePath,
+            revision
+        };
     });
 }
+function ensureTsNodeRuntime() {
+    if (tsNodeRegistered) {
+        return;
+    }
+    const runtimeRequire = (0, node_module_1.createRequire)((0, node_url_1.pathToFileURL)(__filename).href);
+    runtimeRequire("ts-node/register/transpile-only");
+    tsNodeRegistered = true;
+}
+function loadCompiledModule(fullPath) {
+    ensureTsNodeRuntime();
+    const localRequire = (0, node_module_1.createRequire)((0, node_url_1.pathToFileURL)(fullPath).href);
+    const resolvedPath = localRequire.resolve(fullPath);
+    delete localRequire.cache[resolvedPath];
+    return localRequire(resolvedPath);
+}
+function loadMigrationModule(definition) {
+    const rawModule = loadCompiledModule(definition.fullPath);
+    if (typeof rawModule.upgrade !== "function") {
+        throw new Error(`${definition.filePath}: export upgrade must be a function`);
+    }
+    if (typeof rawModule.downgrade !== "function") {
+        throw new Error(`${definition.filePath}: export downgrade must be a function`);
+    }
+    return {
+        ...definition,
+        upgrade: rawModule.upgrade,
+        downgrade: rawModule.downgrade
+    };
+}

package/dist/migrations/runner.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpgradeToHead = runUpgradeToHead;
+exports.formatMigrationError = formatMigrationError;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const migrationState_1 = require("../db/migrationState");
+const files_1 = require("./files");
+const ANSI_GREEN = "\x1b[32m";
+const ANSI_YELLOW = "\x1b[33m";
+const ANSI_RED = "\x1b[31m";
+const ANSI_RESET = "\x1b[0m";
+const INIT_DB_FILE = node_path_1.default.join("updebe", "_init_db.sql");
+function buildPendingMigrations(migrations, currentRevisionId) {
+    const byPreviousRevision = new Map();
+    for (const migration of migrations) {
+        const key = migration.revision.revised_id;
+        const list = byPreviousRevision.get(key) ?? [];
+        list.push(migration);
+        byPreviousRevision.set(key, list);
+    }
+    for (const [key, list] of byPreviousRevision.entries()) {
+        if (list.length > 1) {
+            const files = list.map((item) => item.filePath).join(", ");
+            throw new Error(`Branching migrations detected after '${key}': ${files}`);
+        }
+    }
+    const pending = [];
+    const seen = new Set();
+    let pointer = currentRevisionId ?? "";
+    while (true) {
+        const next = byPreviousRevision.get(pointer)?.[0];
+        if (!next) {
+            break;
+        }
+        if (seen.has(next.revision._id)) {
+            throw new Error(`Cycle detected at revision '${next.revision._id}'`);
+        }
+        pending.push(next);
+        seen.add(next.revision._id);
+        pointer = next.revision._id;
+    }
+    if (currentRevisionId && pending.length === 0) {
+        const isKnownRevision = migrations.some((migration) => migration.revision._id === currentRevisionId);
+        const canContinueFromCurrent = migrations.some((migration) => migration.revision.revised_id === currentRevisionId);
+        if (!isKnownRevision && !canContinueFromCurrent) {
+            throw new Error(`Current revision '${currentRevisionId}' is not present in migration chain`);
+        }
+    }
+    return pending;
+}
+async function applyMigration(client, schema, migration) {
+    const loaded = (0, files_1.loadMigrationModule)(migration);
+    await client.query("BEGIN");
+    try {
+        await loaded.upgrade({
+            query: async (sql, params) => client.query(sql, params)
+        });
+        await (0, migrationState_1.setCurrentRevisionId)(client, schema, loaded.revision._id);
+        await client.query("COMMIT");
+        console.log(`${ANSI_GREEN}Applied migration ${loaded.revision._id}${ANSI_RESET}`);
+    }
+    catch (error) {
+        await client.query("ROLLBACK");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed migration ${loaded.filePath}: ${message}`);
+    }
+}
+function sanitizeInitSql(rawSql) {
+    return rawSql
+        .split(/\r?\n/)
+        .filter((line) => !line.trimStart().startsWith("\\"))
+        .join("\n");
+}
+async function applyInitialSchemaIfPresent(client, baseDir = process.cwd()) {
+    const initFilePath = node_path_1.default.join(baseDir, INIT_DB_FILE);
+    if (!node_fs_1.default.existsSync(initFilePath)) {
+        return;
+    }
+    const rawSql = node_fs_1.default.readFileSync(initFilePath, "utf8");
+    const sanitizedSql = sanitizeInitSql(rawSql).trim();
+    if (!sanitizedSql) {
+        throw new Error(`${INIT_DB_FILE}: file is empty or only contains unsupported psql commands`);
+    }
+    await client.query("BEGIN");
+    try {
+        await client.query(sanitizedSql);
+        await client.query("COMMIT");
+        console.log(`${ANSI_GREEN}Initial schema loaded from ${INIT_DB_FILE}${ANSI_RESET}`);
+    }
+    catch (error) {
+        await client.query("ROLLBACK");
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to apply ${INIT_DB_FILE}: ${message}`);
+    }
+}
+async function runUpgradeToHead(client, config, migrations) {
+    await (0, migrationState_1.ensureMigrationState)(client, config.schema);
+    let currentRevisionId = await (0, migrationState_1.getCurrentRevisionId)(client, config.schema);
+    if (currentRevisionId === null) {
+        await applyInitialSchemaIfPresent(client);
+        currentRevisionId = await (0, migrationState_1.getCurrentRevisionId)(client, config.schema);
+    }
+    const pending = buildPendingMigrations(migrations, currentRevisionId);
+    if (pending.length === 0) {
+        console.log(`${ANSI_YELLOW}No pending migrations. Already at head.${ANSI_RESET}`);
+        return;
+    }
+    console.log(`${ANSI_YELLOW}Applying ${pending.length} migration(s)...${ANSI_RESET}`);
+    for (const migration of pending) {
+        await applyMigration(client, config.schema, migration);
+    }
+    const nextHead = pending[pending.length - 1].revision._id;
+    console.log(`${ANSI_GREEN}Upgrade completed. Current revision: ${nextHead}${ANSI_RESET}`);
+}
+function formatMigrationError(error) {
+    if (error instanceof Error) {
+        return `${ANSI_RED}${error.message}${ANSI_RESET}`;
+    }
+    return `${ANSI_RED}Unknown migration error${ANSI_RESET}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "updebe",
-    "version": "0.1.2",
+    "version": "0.2.0",
     "private": false,
     "description": "Schema migration tool",
     "main": "dist/updebe.js",
@@ -17,12 +17,13 @@
         "updebe": "node dist/updebe.js"
     },
     "dependencies": {
-        "dotenv": "^16.6.1",
-        "pg": "^8.16.3"
+        "dotenv": "^17.4.2",
+        "pg": "^8.23.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^7.0.2"
     },
     "devDependencies": {
         "@types/node": "^24.13.3",
-        "@types/pg": "^8.23.1",
-        "typescript": "^7.0.2"
+        "@types/pg": "^8.23.1"
     }
 }