stepwise-migrations 1.0.24 → 1.0.27

package/README.md

@@ -62,7 +62,7 @@ There are three types of migrations:
 ## Usage
 
 ```text
-Usage: stepwise-migrations [command] [options]
+Usage: stepwise-migrations <command> [options]
 
 Commands:
   migrate
@@ -79,15 +79,18 @@ Commands:
     Drop all tables, schema and stepwise_migration_events table
   get-applied-script
     Get the script for the last applied migration
+  baseline
+    Without applying any migrations, set the migration table state to a specific version
 
 Options:
   --connection <connection>  The connection string to use to connect to the database
-  --schema <schema>          The schema to use for the migrations
+  --schema <schema>          The schema to use for the migrations (default: public)
   --path <path>              The path to the migrations directory
   --ssl true/false           Whether to use SSL for the connection (default: false)
   --napply                   Number of up migrations to apply (default: all)
   --nundo                    Number of undo migrations to apply (default: 1)
-  --filename                 The filename to get the script for (default: last applied migration)
+  --filename                 (get-applied-script) The filename to get the script for (default: last applied migration)
+  --filename                 (baseline) The filename to baseline (default: last unapplied versioned migration)
 
 Example:
   npx stepwise-migrations migrate \
@@ -371,4 +374,32 @@ Dropping the tables, schema and migration history table... done!
 
 </details>
 
+### Baseline
+
+Without applying any migrations, set the migration table state to a specific version.
+
+Command:
+
+```bash
+npx stepwise-migrations baseline \
+  --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydb \
+  --schema=myschema \
+  --path=./test/migrations-template/
+```
+
+<details>
+
+<summary>Example output</summary>
+
+```text
+Creating schema myschema... done!
+Creating stepwise_migration_events table... done!
+Baselining v1_first.sql... done!
+Baselining v2_second.sql... done!
+Baselining v3_third.sql... done!
+All done! (Shadow)-applied 3 migrations to baseline to v3_third.sql
+```
+
+</details>
+
 [comment]: <> (End of examples)

package/dist/src/commands.js

@@ -8,21 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAppliedScriptCommand = exports.auditCommand = exports.undoCommand = exports.dropCommand = exports.validateCommand = exports.statusCommand = exports.infoCommand = exports.migrateCommand = void 0;
+exports.baselineCommand = exports.getAppliedScriptCommand = exports.auditCommand = exports.undoCommand = exports.dropCommand = exports.validateCommand = exports.statusCommand = exports.infoCommand = exports.migrateCommand = exports.ensureTableInitialised = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
 const db_1 = require("./db");
 const state_1 = require("./state");
 const utils_1 = require("./utils");
-const migrateCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema, napply, filePath } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const ensureTableInitialised = (client) => __awaiter(void 0, void 0, void 0, function* () {
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     if (!schemaExists) {
-        yield (0, db_1.dbCreateSchema)(client, schema);
+        yield client.dbCreateSchema();
     }
     if (!tableExists) {
-        yield (0, db_1.dbCreateEventsTable)(client, schema);
+        yield client.dbCreateEventsTable();
     }
-    const state = yield (0, state_1.loadState)(client, schema, filePath);
+});
+exports.ensureTableInitialised = ensureTableInitialised;
+const migrateCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { napply, filePath } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    yield (0, exports.ensureTableInitialised)(client);
+    const state = yield (0, state_1.loadState)(client, filePath);
     (0, utils_1.abortIfErrors)(state);
     if (state.files.unappliedVersionedFiles.length === 0 &&
         state.files.unappliedRepeatableFiles.length === 0) {
@@ -34,15 +43,16 @@ const migrateCommand = (client, argv) => __awaiter(void 0, void 0, void 0, funct
         ...state.files.unappliedRepeatableFiles,
     ].slice(0, napply);
     for (const migration of migrationsToApply) {
-        yield (0, db_1.applyMigration)(client, schema, migration);
+        yield client.dbApplyMigration(migration);
     }
     console.log(`All done! Applied ${migrationsToApply.length} migration${migrationsToApply.length === 1 ? "" : "s"}`);
-    (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(yield (0, state_1.loadState)(client, schema, filePath));
+    (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(yield (0, state_1.loadState)(client, filePath));
 });
 exports.migrateCommand = migrateCommand;
-const infoCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema, filePath } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const infoCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     if (!schemaExists) {
         console.log("Schema does not exist");
     }
@@ -50,13 +60,14 @@ const infoCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function
         console.log("Migration table has not been initialised. Run migrate to begin.");
     }
     if (schemaExists && tableExists) {
-        (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(yield (0, state_1.loadState)(client, schema, filePath));
+        (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(yield (0, state_1.loadState)(client, filePath));
     }
 });
 exports.infoCommand = infoCommand;
-const statusCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema, filePath } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const statusCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     if (!schemaExists) {
         console.log("Schema does not exist");
     }
@@ -64,15 +75,16 @@ const statusCommand = (client, argv) => __awaiter(void 0, void 0, void 0, functi
         console.log("Migration table has not been initialised. Run migrate to begin.");
     }
     if (schemaExists && tableExists) {
-        (0, utils_1.printMigrationHistory)(yield (0, state_1.loadState)(client, schema, filePath));
+        (0, utils_1.printMigrationHistory)(yield (0, state_1.loadState)(client, filePath));
     }
 });
 exports.statusCommand = statusCommand;
-const validateCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const validateCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
-    const state = yield (0, state_1.loadState)(client, schema, argv.path);
+    const state = yield (0, state_1.loadState)(client, filePath);
     if (schemaExists && tableExists) {
         (0, utils_1.abortIfErrors)(state);
     }
@@ -80,16 +92,18 @@ const validateCommand = (client, argv) => __awaiter(void 0, void 0, void 0, func
     (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(state);
 });
 exports.validateCommand = validateCommand;
-const dropCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema } = (0, utils_1.parseArgs)(argv);
+const dropCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema } = args;
+    const client = yield (0, db_1.dbConnect)(args);
     process.stdout.write(`Dropping the tables, schema and migration history table... `);
-    yield (0, db_1.dbDropAll)(client, schema);
+    yield client.dbDropAll();
     console.log(`done!`);
 });
 exports.dropCommand = dropCommand;
-const undoCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema, nundo, filePath } = (0, utils_1.parseArgs)(argv);
-    const state = yield (0, state_1.loadState)(client, schema, filePath);
+const undoCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath, nundo } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    const state = yield (0, state_1.loadState)(client, filePath);
     (0, utils_1.abortIfErrors)(state);
     const reversedAppliedVersionedMigrations = state.current.appliedVersionedMigrations.slice().reverse();
     const undosToApplyAll = reversedAppliedVersionedMigrations.map((migration) => state.files.undoFiles.find((file) => file.filename === (0, state_1.getUndoFilename)(migration.filename)));
@@ -99,17 +113,18 @@ const undoCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function
         process.exit(1);
     }
     for (const { filename, script } of undosToApply) {
-        yield (0, db_1.applyUndoMigration)(client, schema, filename, script);
+        yield client.dbApplyUndoMigration(filename, script);
     }
     console.log(`All done! Performed ${undosToApply.length} undo migration${undosToApply.length === 1 ? "" : "s"}`);
     (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(state);
 });
 exports.undoCommand = undoCommand;
-const auditCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const auditCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
-    const state = yield (0, state_1.loadState)(client, schema, argv.path);
+    const state = yield (0, state_1.loadState)(client, filePath);
     console.log("Event history:");
     console.table(state.events.map((row) => ({
         id: row.id,
@@ -120,17 +135,44 @@ const auditCommand = (client, argv) => __awaiter(void 0, void 0, void 0, functio
     })));
 });
 exports.auditCommand = auditCommand;
-const getAppliedScriptCommand = (client, argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const { schema } = (0, utils_1.parseArgs)(argv);
-    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client, schema);
+const getAppliedScriptCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath, filename } = args;
+    node_assert_1.default.ok(filename, "filename is required for this command");
+    const client = yield (0, db_1.dbConnect)(args);
+    const { schemaExists, tableExists } = yield (0, utils_1.checkSchemaAndTable)(client);
     (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
-    const state = yield (0, state_1.loadState)(client, schema, argv.path);
-    const script = yield (0, db_1.dbGetAppliedScript)(state, argv.filename);
+    const state = yield (0, state_1.loadState)(client, filePath);
+    const script = yield client.dbGetAppliedScript(state, filename);
     if (script) {
         console.log(script);
     }
     else {
-        console.error(`Script for ${argv.filename} not found, use the audit command to check all applied migrations`);
+        console.error(`Script for ${filename} not found, use the audit command to check all applied migrations`);
     }
 });
 exports.getAppliedScriptCommand = getAppliedScriptCommand;
+const baselineCommand = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { connection, schema, filePath, filename: argvFilename } = args;
+    const client = yield (0, db_1.dbConnect)(args);
+    yield (0, exports.ensureTableInitialised)(client);
+    const state = yield (0, state_1.loadState)(client, filePath);
+    if (state.files.unappliedVersionedFiles.length === 0) {
+        console.error("Error: No unapplied versioned migrations, aborting.");
+        process.exit(1);
+    }
+    const filename = argvFilename !== null && argvFilename !== void 0 ? argvFilename : state.files.unappliedVersionedFiles[state.files.unappliedVersionedFiles.length - 1].filename;
+    if (!state.files.unappliedVersionedFiles.find((file) => file.filename === filename)) {
+        console.error(`Error: '${filename}' is not an unapplied versioned migration, aborting.`);
+        process.exit(1);
+    }
+    let appliedCount = 0;
+    for (const file of state.files.unappliedVersionedFiles) {
+        yield client.dbBaseline(file);
+        appliedCount++;
+        if (file.filename === filename) {
+            break;
+        }
+    }
+    console.log(`All done! (Shadow)-applied ${appliedCount} migrations to baseline to ${filename}`);
+});
+exports.baselineCommand = baselineCommand;

package/dist/src/db/index.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbConnect = void 0;
+const pg = __importStar(require("./pg"));
+const dbConnect = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    if (args.connection.startsWith("postgresql://")) {
+        return yield pg._dbConnect(args);
+    }
+    // else if (connection.startsWith("mysql://")) {
+    //   const client = await mysql._dbConnect(argv);
+    //   return {
+    //     type: "mysql",
+    //     client,
+    //     ...mysql,
+    //   };
+    // }
+    throw new Error("Invalid database connection string");
+});
+exports.dbConnect = dbConnect;

package/dist/src/db/pg.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._dbConnect = void 0;
+const pg_1 = __importStar(require("pg"));
+const types_1 = require("../types");
+pg_1.default.types.setTypeParser(1114, function (stringValue) {
+    return stringValue; //1114 for time without timezone type
+});
+pg_1.default.types.setTypeParser(1082, function (stringValue) {
+    return stringValue; //1082 for date type
+});
+const _dbConnect = (_a) => __awaiter(void 0, [_a], void 0, function* ({ ssl, connection, schema }) {
+    const pool = new pg_1.Pool({
+        connectionString: connection,
+        ssl: ssl === "true",
+    });
+    let client;
+    try {
+        client = yield pool.connect();
+        yield client.query("SELECT 1");
+    }
+    catch (error) {
+        console.error("Failed to connect to the database", error);
+        process.exit(1);
+    }
+    const dbSchemaExists = () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield client.query(`SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = '${schema}')`);
+        return result.rows[0].exists;
+    });
+    const dbTableExists = () => __awaiter(void 0, void 0, void 0, function* () {
+        const tableExistsResult = yield client.query(`SELECT EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'stepwise_migration_events' and schemaname = '${schema}')`);
+        return tableExistsResult.rows[0].exists;
+    });
+    const dbDropAll = () => __awaiter(void 0, void 0, void 0, function* () {
+        yield client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
+    });
+    const dbCreateSchema = () => __awaiter(void 0, void 0, void 0, function* () {
+        process.stdout.write(`Creating schema ${schema}... `);
+        yield client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+        console.log(`done!`);
+    });
+    const dbEventHistory = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const eventQuery = yield client.query(`SELECT * FROM ${schema}.stepwise_migration_events`);
+            return eventQuery.rows.map((row) => types_1.EventRow.parse(row));
+        }
+        catch (error) {
+            console.error("Error fetching event history", error);
+            process.exit(1);
+        }
+    });
+    const dbCreateEventsTable = () => __awaiter(void 0, void 0, void 0, function* () {
+        process.stdout.write(`Creating stepwise_migration_events table... `);
+        yield client.query(`
+  CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migration_events (
+    id SERIAL PRIMARY KEY,
+    type TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    script TEXT NOT NULL,
+    applied_by TEXT NOT NULL DEFAULT current_user,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );
+      `);
+        console.log(`done!`);
+    });
+    const dbGetAppliedScript = (state, filename) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        return (_a = state.current.appliedVersionedMigrations
+            .concat(state.current.appliedRepeatableMigrations)
+            .find((file) => file.filename === filename)) === null || _a === void 0 ? void 0 : _a.script;
+    });
+    const dbApplyMigration = (migration) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            process.stdout.write(`Applying ${migration.type} migration ${migration.filename}... `);
+            yield client.query("BEGIN");
+            yield client.query(`SET search_path TO ${schema};
+      ${migration.script.toString()}`);
+            yield client.query(`INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`, [migration.type, migration.filename, migration.script]);
+            yield client.query("COMMIT");
+            console.log(`done!`);
+        }
+        catch (error) {
+            try {
+                yield client.query("ROLLBACK");
+            }
+            catch (error) {
+                console.error("Error rolling back transaction", error);
+            }
+            console.error("Error applying migration", error);
+            process.exit(1);
+        }
+    });
+    const dbBaseline = (migration) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            process.stdout.write(`Baselining ${migration.filename}... `);
+            yield client.query("BEGIN");
+            yield client.query(`INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`, [migration.type, migration.filename, migration.script]);
+            yield client.query("COMMIT");
+            console.log(`done!`);
+        }
+        catch (error) {
+            try {
+                yield client.query("ROLLBACK");
+            }
+            catch (error) {
+                console.error("Error rolling back transaction", error);
+            }
+            console.error("Error baselining migration", error);
+            process.exit(1);
+        }
+    });
+    const dbApplyUndoMigration = (filename, script) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            process.stdout.write(`Applying undo migration ${filename}... `);
+            yield client.query("BEGIN");
+            yield client.query(`SET search_path TO ${schema};
+      ${script.toString()}`);
+            yield client.query(`INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`, ["undo", filename, script]);
+            yield client.query("COMMIT");
+            console.log(`done!`);
+        }
+        catch (error) {
+            try {
+                yield client.query("ROLLBACK");
+            }
+            catch (error) {
+                console.error("Error rolling back transaction", error);
+            }
+            console.error("Error applying undo migration", error);
+            process.exit(1);
+        }
+    });
+    return {
+        type: "pg",
+        schema,
+        dbSchemaExists,
+        dbTableExists,
+        dbDropAll,
+        dbCreateSchema,
+        dbEventHistory,
+        dbCreateEventsTable,
+        dbGetAppliedScript,
+        dbApplyMigration,
+        dbBaseline,
+        dbApplyUndoMigration,
+    };
+});
+exports._dbConnect = _dbConnect;

package/dist/src/index.js

@@ -14,44 +14,123 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
 const commands_1 = require("./commands");
-const db_1 = require("./db");
 const utils_1 = require("./utils");
 const main = () => __awaiter(void 0, void 0, void 0, function* () {
-    const argv = (0, yargs_1.default)(process.argv.slice(2)).argv;
-    (0, utils_1.validateArgs)(argv);
-    const command = argv._[0];
-    const client = yield (0, db_1.dbConnect)(argv);
+    const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+        .command("migrate", "Migrate the database to the latest version", (yargs) => {
+        return yargs.options({
+            napply: {
+                type: "number",
+                describe: "Number of migrations to apply, defaults to all",
+            },
+        });
+    })
+        .command("validate", "Validate the migration files and the stepwise_migration_events table")
+        .command("info", "Show information about the current state of the migrations in the database and in the migration files")
+        .command("status", "Only show the status of the migrations in the database, not the migration files")
+        .command("undo", "Rollback the database to the previous version", (yargs) => {
+        return yargs.options({
+            nundo: {
+                type: "number",
+                describe: "Number of migrations to undo, defaults to 1",
+            },
+        });
+    })
+        .command("get-applied-script", "Get the script for the last applied migration", (yargs) => {
+        return yargs.options({
+            filename: {
+                type: "string",
+                describe: "The filename to get the script for",
+            },
+        });
+    })
+        .command("drop", "Drop the tables, schema and migration history table")
+        .command("baseline", "Without applying any migrations, set the migration table state to a specific version", (yargs) => {
+        return yargs.options({
+            filename: {
+                type: "string",
+                describe: "The filename to baseline to",
+                default: null,
+            },
+        });
+    })
+        .options({
+        connection: {
+            type: "string",
+            demandOption: true,
+            alias: "c",
+            describe: "The connection string to use to connect to the database",
+        },
+        schema: {
+            type: "string",
+            default: "public",
+            alias: "s",
+            describe: "The schema to use for the migrations",
+        },
+        ssl: {
+            type: "boolean",
+            default: false,
+            describe: "Whether to use SSL for the connection",
+        },
+        path: {
+            type: "string",
+            default: "./",
+            alias: "p",
+            describe: "The path to the migrations directory",
+        },
+    })
+        .example([
+        [
+            `npx stepwise-migrations migrate \\
+      --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \\
+      --schema=myschema \\
+      --path=./test/migrations-template/`,
+            "Migrate the database to the latest version",
+        ],
+    ])
+        .wrap(yargs_1.default.terminalWidth())
+        .demandCommand(1)
+        .recommendCommands()
+        .strict()
+        .help()
+        .version(false)
+        .parse();
+    const args = (0, utils_1.parseArgs)(argv);
+    const command = args.command;
     if (command === "migrate") {
-        yield (0, commands_1.migrateCommand)(client, argv);
+        yield (0, commands_1.migrateCommand)(args);
     }
     else if (command === "info") {
-        yield (0, commands_1.infoCommand)(client, argv);
+        yield (0, commands_1.infoCommand)(args);
     }
     else if (command === "status") {
-        yield (0, commands_1.statusCommand)(client, argv);
+        yield (0, commands_1.statusCommand)(args);
     }
     else if (command === "validate") {
-        yield (0, commands_1.validateCommand)(client, argv);
+        yield (0, commands_1.validateCommand)(args);
     }
     else if (command === "drop") {
-        yield (0, commands_1.dropCommand)(client, argv);
+        yield (0, commands_1.dropCommand)(args);
     }
     else if (command === "undo") {
-        yield (0, commands_1.undoCommand)(client, argv);
+        yield (0, commands_1.undoCommand)(args);
     }
     else if (command === "audit") {
-        yield (0, commands_1.auditCommand)(client, argv);
+        yield (0, commands_1.auditCommand)(args);
     }
     else if (command === "get-applied-script") {
-        yield (0, commands_1.getAppliedScriptCommand)(client, argv);
+        yield (0, commands_1.getAppliedScriptCommand)(args);
+    }
+    else if (command === "baseline") {
+        yield (0, commands_1.baselineCommand)(args);
     }
     else {
         console.error(`Invalid command: ${command}`);
         console.log(utils_1.usage);
         process.exit(1);
     }
-    client.release();
     process.exit(0);
 });
 main();