updebe 0.1.1 → 0.2.0

package/dist/commands/init.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getCurrentDateStamp() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    return `${year}${month}${day}`;
+}
+function runInit(baseDir = process.cwd()) {
+    const updebeDir = node_path_1.default.join(baseDir, "updebe");
+    const migrationsDir = node_path_1.default.join(updebeDir, "Migrations");
+    const dateStamp = getCurrentDateStamp();
+    const migrationFilePath = node_path_1.default.join(migrationsDir, `${dateStamp}_init.ts`);
+    const configFilePath = node_path_1.default.join(updebeDir, "config.udb");
+    node_fs_1.default.mkdirSync(migrationsDir, { recursive: true });
+    if (!node_fs_1.default.existsSync(configFilePath)) {
+        node_fs_1.default.writeFileSync(configFilePath, "", "utf8");
+    }
+    if (!node_fs_1.default.existsSync(migrationFilePath)) {
+        node_fs_1.default.writeFileSync(migrationFilePath, "export const revision = {\n  _id: \"20260827_init\",\n  revised_id: \"\"\n};\n\nexport async function upgrade(): Promise<void> {\n  // Write upgrade SQL here\n}\n\nexport async function downgrade(): Promise<void> {\n  // Write downgrade SQL here\n}\n", "utf8");
+    }
+}

package/dist/commands/upgradeHead.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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() {
+    const migrations = (0, files_1.loadMigrationDefinitions)();
+    const dbConfig = (0, database_1.resolveDatabaseConfig)();
+    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/config/database.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDatabaseConfig = resolveDatabaseConfig;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const ANSI_GREEN = "\x1b[32m";
+const ANSI_RED = "\x1b[31m";
+const ANSI_RESET = "\x1b[0m";
+function readEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parsePort(rawPort) {
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("Invalid environment variable: PGDB_PORT must be an integer between 1 and 65535");
+    }
+    return port;
+}
+function resolveDatabaseConfig() {
+    try {
+        const schema = readEnv("PGDB_SCHEMA") ?? "public";
+        const databaseUrl = readEnv("DATABASE_URL");
+        if (databaseUrl) {
+            try {
+                new URL(databaseUrl);
+                console.log(`${ANSI_GREEN}Database config resolved from DATABASE_URL (schema: ${schema})${ANSI_RESET}`);
+                return { databaseUrl, schema };
+            }
+            catch {
+                throw new Error("Invalid environment variable: DATABASE_URL must be a valid URL");
+            }
+        }
+        const user = readEnv("PGDB_USER");
+        const host = readEnv("PGDB_HOST");
+        const database = readEnv("PGDB_DATABASE");
+        const password = readEnv("PGDB_PASSWORD");
+        const rawPort = readEnv("PGDB_PORT");
+        const missingVars = [
+            ["PGDB_USER", user],
+            ["PGDB_HOST", host],
+            ["PGDB_DATABASE", database],
+            ["PGDB_PASSWORD", password],
+            ["PGDB_PORT", rawPort]
+        ]
+            .filter(([, value]) => !value)
+            .map(([name]) => name);
+        if (missingVars.length > 0) {
+            throw new Error(`Missing required environment variables: ${missingVars.join(", ")}`);
+        }
+        const port = parsePort(rawPort);
+        const encodedUser = encodeURIComponent(user);
+        const encodedPassword = encodeURIComponent(password);
+        const encodedDatabase = encodeURIComponent(database);
+        const builtDatabaseUrl = `postgresql://${encodedUser}:${encodedPassword}@${host}:${port}/${encodedDatabase}`;
+        console.log(`${ANSI_GREEN}Database config resolved from PGDB_* variables (schema: ${schema})${ANSI_RESET}`);
+        return {
+            databaseUrl: builtDatabaseUrl,
+            schema
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(`${ANSI_RED}Database config error: ${message}${ANSI_RESET}`);
+        throw error;
+    }
+}

package/dist/db/connection.js

@@ -0,0 +1,54 @@
+"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";
+const ANSI_RESET = "\x1b[0m";
+function formatSafeError(error) {
+    if (!(error instanceof Error)) {
+        return "Unknown database error";
+    }
+    // Avoid leaking credentials if a driver error includes connection details.
+    return error.message.replace(/:\/\/[^@\s]+@/g, "://***:***@");
+}
+async function testDatabaseConnection(config) {
+    const client = new pg_1.Client({ connectionString: config.databaseUrl });
+    try {
+        await client.connect();
+        await client.query("SELECT 1");
+        console.log(`${ANSI_GREEN}Database connected successfully (schema: ${config.schema})${ANSI_RESET}`);
+    }
+    catch (error) {
+        const message = formatSafeError(error);
+        console.error(`${ANSI_RED}Database connection error: ${message}${ANSI_RESET}`);
+        throw new Error("Database connection failed");
+    }
+    finally {
+        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

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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"));
+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 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 (!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, "updebe", "Migrations");
+    if (!node_fs_1.default.existsSync(migrationsDir)) {
+        return [];
+    }
+    const fileNames = node_fs_1.default.readdirSync(migrationsDir)
+        .filter((fileName) => fileName.endsWith(".ts"))
+        .sort();
+    return fileNames.map((fileName) => {
+        const relativePath = `updebe/Migrations/${fileName}`;
+        const fullPath = node_path_1.default.join(migrationsDir, fileName);
+        let content;
+        try {
+            content = node_fs_1.default.readFileSync(fullPath, "utf8");
+        }
+        catch {
+            throw new Error(`${relativePath}: unable to read file`);
+        }
+        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/dist/updebe.js

@@ -1,7 +1,23 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("./commands/init");
+const upgradeHead_1 = require("./commands/upgradeHead");
 const command = process.argv[2];
+if (command === "init") {
+    try {
+        (0, init_1.runInit)();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(message);
+        process.exitCode = 1;
+    }
+}
 if (command === "upgrade:head") {
-    console.log("Hey! I'm working");
+    (0, upgradeHead_1.runUpgradeHead)().catch((error) => {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error(message);
+        process.exitCode = 1;
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "updebe",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "private": false,
     "description": "Schema migration tool",
     "main": "dist/updebe.js",
@@ -16,8 +16,14 @@
         "preupdebe": "npm run build",
         "updebe": "node dist/updebe.js"
     },
+    "dependencies": {
+        "dotenv": "^17.4.2",
+        "pg": "^8.23.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^7.0.2"
+    },
     "devDependencies": {
         "@types/node": "^24.13.3",
-        "typescript": "^7.0.2"
+        "@types/pg": "^8.23.1"
     }
 }