stepwise-migrations 1.0.22 → 1.0.24

package/README.md

@@ -3,8 +3,8 @@
 A JavaScript CLI tool for managing Raw SQL migrations in a Postgres database.
 Loosely based on flyway.
 
-[![npm version](https://badge.fury.io/js/stepwise-migrations.svg?icon=si%3Anpm&)](https://badge.fury.io/js/stepwise-migrations)
-![test workflow](https://github.com/github/docs/actions/workflows/test.yml/badge.svg)
+![NPM Version](https://img.shields.io/npm/v/stepwise-migrations)
+![Test Workflow](https://github.com/github/docs/actions/workflows/test.yml/badge.svg)
 
 ## Table of Contents
 

package/dist/src/commands.js

@@ -0,0 +1,136 @@
+"use strict";
+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.getAppliedScriptCommand = exports.auditCommand = exports.undoCommand = exports.dropCommand = exports.validateCommand = exports.statusCommand = exports.infoCommand = exports.migrateCommand = void 0;
+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);
+    if (!schemaExists) {
+        yield (0, db_1.dbCreateSchema)(client, schema);
+    }
+    if (!tableExists) {
+        yield (0, db_1.dbCreateEventsTable)(client, schema);
+    }
+    const state = yield (0, state_1.loadState)(client, schema, filePath);
+    (0, utils_1.abortIfErrors)(state);
+    if (state.files.unappliedVersionedFiles.length === 0 &&
+        state.files.unappliedRepeatableFiles.length === 0) {
+        console.log("All migrations are already applied");
+        process.exit(0);
+    }
+    const migrationsToApply = [
+        ...state.files.unappliedVersionedFiles,
+        ...state.files.unappliedRepeatableFiles,
+    ].slice(0, napply);
+    for (const migration of migrationsToApply) {
+        yield (0, db_1.applyMigration)(client, schema, 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));
+});
+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);
+    if (!schemaExists) {
+        console.log("Schema does not exist");
+    }
+    if (!tableExists) {
+        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));
+    }
+});
+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);
+    if (!schemaExists) {
+        console.log("Schema does not exist");
+    }
+    if (!tableExists) {
+        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));
+    }
+});
+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);
+    (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
+    const state = yield (0, state_1.loadState)(client, schema, argv.path);
+    if (schemaExists && tableExists) {
+        (0, utils_1.abortIfErrors)(state);
+    }
+    console.log("Validation passed");
+    (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);
+    process.stdout.write(`Dropping the tables, schema and migration history table... `);
+    yield (0, db_1.dbDropAll)(client, schema);
+    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);
+    (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)));
+    const undosToApply = (0, utils_1.sliceFromFirstNull)(undosToApplyAll).slice(0, nundo);
+    if (undosToApply.length < nundo) {
+        console.error(`Error: not enough sequential (from last) undo migrations to apply ${nundo} undos.`);
+        process.exit(1);
+    }
+    for (const { filename, script } of undosToApply) {
+        yield (0, db_1.applyUndoMigration)(client, schema, 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);
+    (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
+    const state = yield (0, state_1.loadState)(client, schema, argv.path);
+    console.log("Event history:");
+    console.table(state.events.map((row) => ({
+        id: row.id,
+        type: row.type,
+        filename: row.filename,
+        applied_by: row.applied_by,
+        applied_at: row.applied_at,
+    })));
+});
+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);
+    (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);
+    if (script) {
+        console.log(script);
+    }
+    else {
+        console.error(`Script for ${argv.filename} not found, use the audit command to check all applied migrations`);
+    }
+});
+exports.getAppliedScriptCommand = getAppliedScriptCommand;

package/dist/src/index.js

@@ -14,126 +14,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const yargs_1 = __importDefault(require("yargs"));
+const commands_1 = require("./commands");
 const db_1 = require("./db");
-const state_1 = require("./state");
 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 schema = argv.schema;
     const command = argv._[0];
-    const napply = argv.napply || Infinity;
-    const nundo = argv.nundo || 1;
-    const filePath = argv.path;
     const client = yield (0, db_1.dbConnect)(argv);
-    const schemaExists = yield (0, db_1.dbSchemaExists)(client, schema);
-    const tableExists = yield (0, db_1.dbTableExists)(client, schema);
     if (command === "migrate") {
-        if (!schemaExists) {
-            yield (0, db_1.dbCreateSchema)(client, schema);
-        }
-        if (!tableExists) {
-            yield (0, db_1.dbCreateEventsTable)(client, schema);
-        }
-        const state = yield (0, state_1.loadState)(client, schema, argv.path);
-        (0, utils_1.abortIfErrors)(state);
-        if (state.files.unappliedVersionedFiles.length === 0 &&
-            state.files.unappliedRepeatableFiles.length === 0) {
-            console.log("All migrations are already applied");
-            process.exit(0);
-        }
-        const migrationsToApply = [
-            ...state.files.unappliedVersionedFiles,
-            ...state.files.unappliedRepeatableFiles,
-        ].slice(0, napply);
-        for (const migration of migrationsToApply) {
-            yield (0, db_1.applyMigration)(client, schema, 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));
+        yield (0, commands_1.migrateCommand)(client, argv);
     }
     else if (command === "info") {
-        if (!schemaExists) {
-            console.log("Schema does not exist");
-        }
-        if (!tableExists) {
-            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));
-        }
+        yield (0, commands_1.infoCommand)(client, argv);
     }
     else if (command === "status") {
-        if (!schemaExists) {
-            console.log("Schema does not exist");
-        }
-        if (!tableExists) {
-            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));
-        }
+        yield (0, commands_1.statusCommand)(client, argv);
     }
     else if (command === "validate") {
-        (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
-        const state = yield (0, state_1.loadState)(client, schema, argv.path);
-        if (schemaExists && tableExists) {
-            (0, utils_1.abortIfErrors)(state);
-        }
-        console.log("Validation passed");
-        (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(state);
+        yield (0, commands_1.validateCommand)(client, argv);
     }
     else if (command === "drop") {
-        process.stdout.write(`Dropping the tables, schema and migration history table... `);
-        yield (0, db_1.dbDropAll)(client, schema);
-        console.log(`done!`);
+        yield (0, commands_1.dropCommand)(client, argv);
     }
     else if (command === "undo") {
-        const state = yield (0, state_1.loadState)(client, schema, 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)));
-        const undosToApply = (0, utils_1.sliceFromFirstNull)(undosToApplyAll).slice(0, nundo);
-        if (undosToApply.length < nundo) {
-            console.error(`Error: not enough sequential (from last) undo migrations to apply ${nundo} undos.`);
-            process.exit(1);
-        }
-        console.log(undosToApply);
-        for (const { filename, script } of undosToApply) {
-            yield (0, db_1.applyUndoMigration)(client, schema, filename, script);
-        }
-        console.log(`All done! Performed ${undosToApply.length} undo migration${undosToApply.length === 1 ? "" : "s"}`);
-        (0, utils_1.printMigrationHistoryAndUnappliedMigrations)(state);
+        yield (0, commands_1.undoCommand)(client, argv);
     }
     else if (command === "audit") {
-        (0, utils_1.exitIfNotInitialized)(schemaExists, tableExists);
-        const state = yield (0, state_1.loadState)(client, schema, argv.path);
-        console.log("Event history:");
-        console.table(state.events.map((row) => ({
-            id: row.id,
-            type: row.type,
-            filename: row.filename,
-            applied_by: row.applied_by,
-            applied_at: row.applied_at,
-        })));
+        yield (0, commands_1.auditCommand)(client, argv);
     }
     else if (command === "get-applied-script") {
-        if (!schemaExists) {
-            console.log("Schema does not exist");
-            process.exit(1);
-        }
-        if (!tableExists) {
-            console.log("Migration table has not been initialised. Run migrate to begin.");
-            process.exit(1);
-        }
-        const state = yield (0, state_1.loadState)(client, schema, argv.path);
-        const script = yield (0, db_1.dbGetAppliedScript)(state, argv.filename);
-        if (script) {
-            console.log(script);
-        }
-        else {
-            console.error(`Script for ${argv.filename} not found, use the audit command to check all applied migrations`);
-        }
+        yield (0, commands_1.getAppliedScriptCommand)(client, argv);
     }
     else {
         console.error(`Invalid command: ${command}`);

package/dist/src/utils.js

@@ -12,39 +12,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sliceFromFirstNull = exports.exitIfNotInitialized = exports.abortIfErrors = exports.fileExists = exports.printMigrationHistory = exports.printMigrationHistoryAndUnappliedMigrations = exports.readMigrationFiles = exports.filenameToType = exports.validateArgs = exports.usage = void 0;
+exports.checkSchemaAndTable = exports.sliceFromFirstNull = exports.exitIfNotInitialized = exports.abortIfErrors = exports.fileExists = exports.printMigrationHistory = exports.printMigrationHistoryAndUnappliedMigrations = exports.readMigrationFiles = exports.filenameToType = exports.validateArgs = exports.parseArgs = exports.usage = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const git_diff_1 = __importDefault(require("git-diff"));
 const path_1 = __importDefault(require("path"));
+const db_1 = require("./db");
 exports.usage = `
 Usage: stepwise-migrations [command] [options]
 
 Commands:
   migrate
     Migrate the database to the latest version
-  down
+  undo
     Rollback the database to the previous version
+  validate
+    Validate the migration files and the stepwise_migration_events table
+  audit
+    Show the audit history for the migrations in the database
   info
     Show information about the current state of the migrations in the database
   drop
-    Drop the tables, schema and migration history table
+    Drop all tables, schema and stepwise_migration_events table
+  get-applied-script
+    Get the script for the last applied migration
 
 Options:
   --connection <connection>  The connection string to use to connect to the database
   --schema <schema>          The schema to use for the migrations
   --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)
+  --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)
 
 Example:
   npx stepwise-migrations migrate \\
     --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \\
     --schema=myschema \\
-    --path=./db/migration/
+    --path=./test/migrations-template/
 `;
+const parseArgs = (argv) => {
+    var _a;
+    const schema = (_a = argv.schema) !== null && _a !== void 0 ? _a : "public";
+    const command = argv._[0];
+    const napply = argv.napply || Infinity;
+    const nundo = argv.nundo || 1;
+    const filePath = argv.path;
+    return { schema, command, napply, nundo, filePath };
+};
+exports.parseArgs = parseArgs;
 const validateArgs = (argv) => {
-    const required = ["connection", "schema", "path", "_"];
+    const required = ["connection", "path", "_"];
     if (required.some((key) => !(key in argv))) {
         console.error("Missing required arguments", required.filter((key) => !(key in argv)));
         console.log(exports.usage);
@@ -97,6 +115,7 @@ const readMigrationFiles = (directory, appliedVersionedMigrations) => __awaiter(
 });
 exports.readMigrationFiles = readMigrationFiles;
 const printMigrationHistoryAndUnappliedMigrations = (state) => {
+    // console.log(JSON.stringify(state, null, 2));
     console.log("All applied versioned migrations:");
     console.table(state.current.appliedVersionedMigrations.map((h) => ({
         id: h.id,
@@ -115,6 +134,7 @@ const printMigrationHistoryAndUnappliedMigrations = (state) => {
             applied_at: h.applied_at,
         })));
     }
+    (0, exports.abortIfErrors)(state);
     console.log("Unapplied versioned migrations:");
     console.table(state.files.unappliedVersionedFiles.map((h) => ({
         type: h.type,
@@ -185,3 +205,9 @@ const sliceFromFirstNull = (array) => {
         : array.slice(0, indexOfFirstNull);
 };
 exports.sliceFromFirstNull = sliceFromFirstNull;
+const checkSchemaAndTable = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    const schemaExists = yield (0, db_1.dbSchemaExists)(client, schema);
+    const tableExists = yield (0, db_1.dbTableExists)(client, schema);
+    return { schemaExists, tableExists };
+});
+exports.checkSchemaAndTable = checkSchemaAndTable;

package/dist/test/index.test.js

@@ -100,7 +100,7 @@ const executeCommand = (command, path = "", extraArgs = "") => (0, utils_1.execu
         ]);
     }));
 }));
-node_test_1.describe.only("invalid migrations", () => __awaiter(void 0, void 0, void 0, function* () {
+(0, node_test_1.describe)("invalid migrations", () => __awaiter(void 0, void 0, void 0, function* () {
     (0, node_test_1.beforeEach)(() => __awaiter(void 0, void 0, void 0, function* () {
         const { output, error, exitCode } = yield executeCommand("drop", "");
         node_assert_1.default.ok(output.includes("Dropping the tables, schema and migration history table... done!"));
@@ -126,7 +126,7 @@ node_test_1.describe.only("invalid migrations", () => __awaiter(void 0, void 0,
             "Versioned migration v1_first.sql has been altered. Cannot migrate in current state.",
         ]);
     }));
-    node_test_1.it.only("bad creds", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, node_test_1.it)("bad creds", () => __awaiter(void 0, void 0, void 0, function* () {
         (0, utils_1.assertIncludesAll)(yield (0, utils_1.execute)(`npm exec stepwise-migrations info -- \\
       --connection=postgresql://postgres:badpassword@127.0.0.1:5432/mydb \\
       --schema=${schema} \\

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stepwise-migrations",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "A JavaScript CLI tool for managing Raw SQL migrations in a Postgres database. Loosely based on flyway.",
   "main": "./dist/src/index.js",
   "scripts": {

package/src/commands.ts

@@ -0,0 +1,217 @@
+import { PoolClient } from "pg";
+import {
+  applyMigration,
+  applyUndoMigration,
+  dbCreateEventsTable,
+  dbCreateSchema,
+  dbDropAll,
+  dbGetAppliedScript,
+} from "./db";
+import { getUndoFilename, loadState } from "./state";
+import {
+  abortIfErrors,
+  checkSchemaAndTable,
+  exitIfNotInitialized,
+  parseArgs,
+  printMigrationHistory,
+  printMigrationHistoryAndUnappliedMigrations,
+  sliceFromFirstNull,
+} from "./utils";
+
+export const migrateCommand = async (client: PoolClient, argv: any) => {
+  const { schema, napply, filePath } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+
+  if (!schemaExists) {
+    await dbCreateSchema(client, schema);
+  }
+  if (!tableExists) {
+    await dbCreateEventsTable(client, schema);
+  }
+
+  const state = await loadState(client, schema, filePath);
+
+  abortIfErrors(state);
+
+  if (
+    state.files.unappliedVersionedFiles.length === 0 &&
+    state.files.unappliedRepeatableFiles.length === 0
+  ) {
+    console.log("All migrations are already applied");
+    process.exit(0);
+  }
+
+  const migrationsToApply = [
+    ...state.files.unappliedVersionedFiles,
+    ...state.files.unappliedRepeatableFiles,
+  ].slice(0, napply);
+
+  for (const migration of migrationsToApply) {
+    await applyMigration(client, schema, migration);
+  }
+
+  console.log(
+    `All done! Applied ${migrationsToApply.length} migration${
+      migrationsToApply.length === 1 ? "" : "s"
+    }`
+  );
+
+  printMigrationHistoryAndUnappliedMigrations(
+    await loadState(client, schema, filePath)
+  );
+};
+
+export const infoCommand = async (client: PoolClient, argv: any) => {
+  const { schema, filePath } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+
+  if (!schemaExists) {
+    console.log("Schema does not exist");
+  }
+
+  if (!tableExists) {
+    console.log(
+      "Migration table has not been initialised. Run migrate to begin."
+    );
+  }
+
+  if (schemaExists && tableExists) {
+    printMigrationHistoryAndUnappliedMigrations(
+      await loadState(client, schema, filePath)
+    );
+  }
+};
+
+export const statusCommand = async (client: PoolClient, argv: any) => {
+  const { schema, filePath } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+  if (!schemaExists) {
+    console.log("Schema does not exist");
+  }
+
+  if (!tableExists) {
+    console.log(
+      "Migration table has not been initialised. Run migrate to begin."
+    );
+  }
+
+  if (schemaExists && tableExists) {
+    printMigrationHistory(await loadState(client, schema, filePath));
+  }
+};
+
+export const validateCommand = async (client: PoolClient, argv: any) => {
+  const { schema } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+  exitIfNotInitialized(schemaExists, tableExists);
+
+  const state = await loadState(client, schema, argv.path);
+  if (schemaExists && tableExists) {
+    abortIfErrors(state);
+  }
+  console.log("Validation passed");
+
+  printMigrationHistoryAndUnappliedMigrations(state);
+};
+
+export const dropCommand = async (client: PoolClient, argv: any) => {
+  const { schema } = parseArgs(argv);
+  process.stdout.write(
+    `Dropping the tables, schema and migration history table... `
+  );
+  await dbDropAll(client, schema);
+  console.log(`done!`);
+};
+
+export const undoCommand = async (client: PoolClient, argv: any) => {
+  const { schema, nundo, filePath } = parseArgs(argv);
+  const state = await loadState(client, schema, filePath);
+
+  abortIfErrors(state);
+
+  const reversedAppliedVersionedMigrations =
+    state.current.appliedVersionedMigrations.slice().reverse();
+
+  const undosToApplyAll = reversedAppliedVersionedMigrations.map((migration) =>
+    state.files.undoFiles.find(
+      (file) => file.filename === getUndoFilename(migration.filename)
+    )
+  );
+
+  const undosToApply = sliceFromFirstNull(undosToApplyAll).slice(0, nundo);
+
+  if (undosToApply.length < nundo) {
+    console.error(
+      `Error: not enough sequential (from last) undo migrations to apply ${nundo} undos.`
+    );
+    process.exit(1);
+  }
+
+  for (const { filename, script } of undosToApply) {
+    await applyUndoMigration(client, schema, filename, script);
+  }
+  console.log(
+    `All done! Performed ${undosToApply.length} undo migration${
+      undosToApply.length === 1 ? "" : "s"
+    }`
+  );
+
+  printMigrationHistoryAndUnappliedMigrations(state);
+};
+
+export const auditCommand = async (client: PoolClient, argv: any) => {
+  const { schema } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+
+  exitIfNotInitialized(schemaExists, tableExists);
+
+  const state = await loadState(client, schema, argv.path);
+  console.log("Event history:");
+  console.table(
+    state.events.map((row) => ({
+      id: row.id,
+      type: row.type,
+      filename: row.filename,
+      applied_by: row.applied_by,
+      applied_at: row.applied_at,
+    }))
+  );
+};
+
+export const getAppliedScriptCommand = async (
+  client: PoolClient,
+  argv: any
+) => {
+  const { schema } = parseArgs(argv);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(
+    client,
+    schema
+  );
+
+  exitIfNotInitialized(schemaExists, tableExists);
+
+  const state = await loadState(client, schema, argv.path);
+  const script = await dbGetAppliedScript(state, argv.filename);
+  if (script) {
+    console.log(script);
+  } else {
+    console.error(
+      `Script for ${argv.filename} not found, use the audit command to check all applied migrations`
+    );
+  }
+};

package/src/index.ts

@@ -2,197 +2,41 @@
 
 import yargs from "yargs";
 import {
-  applyMigration,
-  applyUndoMigration,
-  dbConnect,
-  dbCreateEventsTable,
-  dbCreateSchema,
-  dbDropAll,
-  dbGetAppliedScript,
-  dbSchemaExists,
-  dbTableExists,
-} from "./db";
-import { getUndoFilename, loadState } from "./state";
-import {
-  abortIfErrors,
-  exitIfNotInitialized,
-  printMigrationHistoryAndUnappliedMigrations,
-  sliceFromFirstNull,
-  usage,
-  validateArgs,
-} from "./utils";
+  auditCommand,
+  dropCommand,
+  getAppliedScriptCommand,
+  infoCommand,
+  migrateCommand,
+  statusCommand,
+  undoCommand,
+  validateCommand,
+} from "./commands";
+import { dbConnect } from "./db";
+import { usage, validateArgs } from "./utils";
 
 const main = async () => {
   const argv: any = yargs(process.argv.slice(2)).argv;
-
   validateArgs(argv);
 
-  const schema = argv.schema;
   const command = argv._[0];
-  const napply = argv.napply || Infinity;
-  const nundo = argv.nundo || 1;
-  const filePath = argv.path;
-
   const client = await dbConnect(argv);
-  const schemaExists = await dbSchemaExists(client, schema);
-  const tableExists = await dbTableExists(client, schema);
 
   if (command === "migrate") {
-    if (!schemaExists) {
-      await dbCreateSchema(client, schema);
-    }
-    if (!tableExists) {
-      await dbCreateEventsTable(client, schema);
-    }
-
-    const state = await loadState(client, schema, argv.path);
-
-    abortIfErrors(state);
-
-    if (
-      state.files.unappliedVersionedFiles.length === 0 &&
-      state.files.unappliedRepeatableFiles.length === 0
-    ) {
-      console.log("All migrations are already applied");
-      process.exit(0);
-    }
-
-    const migrationsToApply = [
-      ...state.files.unappliedVersionedFiles,
-      ...state.files.unappliedRepeatableFiles,
-    ].slice(0, napply);
-
-    for (const migration of migrationsToApply) {
-      await applyMigration(client, schema, migration);
-    }
-
-    console.log(
-      `All done! Applied ${migrationsToApply.length} migration${
-        migrationsToApply.length === 1 ? "" : "s"
-      }`
-    );
-
-    printMigrationHistoryAndUnappliedMigrations(
-      await loadState(client, schema, filePath)
-    );
+    await migrateCommand(client, argv);
   } else if (command === "info") {
-    if (!schemaExists) {
-      console.log("Schema does not exist");
-    }
-
-    if (!tableExists) {
-      console.log(
-        "Migration table has not been initialised. Run migrate to begin."
-      );
-    }
-
-    if (schemaExists && tableExists) {
-      printMigrationHistoryAndUnappliedMigrations(
-        await loadState(client, schema, filePath)
-      );
-    }
+    await infoCommand(client, argv);
   } else if (command === "status") {
-    if (!schemaExists) {
-      console.log("Schema does not exist");
-    }
-
-    if (!tableExists) {
-      console.log(
-        "Migration table has not been initialised. Run migrate to begin."
-      );
-    }
-
-    if (schemaExists && tableExists) {
-      printMigrationHistoryAndUnappliedMigrations(
-        await loadState(client, schema, filePath)
-      );
-    }
+    await statusCommand(client, argv);
   } else if (command === "validate") {
-    exitIfNotInitialized(schemaExists, tableExists);
-
-    const state = await loadState(client, schema, argv.path);
-    if (schemaExists && tableExists) {
-      abortIfErrors(state);
-    }
-    console.log("Validation passed");
-
-    printMigrationHistoryAndUnappliedMigrations(state);
+    await validateCommand(client, argv);
   } else if (command === "drop") {
-    process.stdout.write(
-      `Dropping the tables, schema and migration history table... `
-    );
-    await dbDropAll(client, schema);
-    console.log(`done!`);
+    await dropCommand(client, argv);
   } else if (command === "undo") {
-    const state = await loadState(client, schema, filePath);
-
-    abortIfErrors(state);
-
-    const reversedAppliedVersionedMigrations =
-      state.current.appliedVersionedMigrations.slice().reverse();
-
-    const undosToApplyAll = reversedAppliedVersionedMigrations.map(
-      (migration) =>
-        state.files.undoFiles.find(
-          (file) => file.filename === getUndoFilename(migration.filename)
-        )
-    );
-
-    const undosToApply = sliceFromFirstNull(undosToApplyAll).slice(0, nundo);
-
-    if (undosToApply.length < nundo) {
-      console.error(
-        `Error: not enough sequential (from last) undo migrations to apply ${nundo} undos.`
-      );
-      process.exit(1);
-    }
-
-    for (const { filename, script } of undosToApply) {
-      await applyUndoMigration(client, schema, filename, script);
-    }
-    console.log(
-      `All done! Performed ${undosToApply.length} undo migration${
-        undosToApply.length === 1 ? "" : "s"
-      }`
-    );
-
-    printMigrationHistoryAndUnappliedMigrations(state);
+    await undoCommand(client, argv);
   } else if (command === "audit") {
-    exitIfNotInitialized(schemaExists, tableExists);
-
-    const state = await loadState(client, schema, argv.path);
-    console.log("Event history:");
-    console.table(
-      state.events.map((row) => ({
-        id: row.id,
-        type: row.type,
-        filename: row.filename,
-        applied_by: row.applied_by,
-        applied_at: row.applied_at,
-      }))
-    );
+    await auditCommand(client, argv);
   } else if (command === "get-applied-script") {
-    if (!schemaExists) {
-      console.log("Schema does not exist");
-      process.exit(1);
-    }
-
-    if (!tableExists) {
-      console.log(
-        "Migration table has not been initialised. Run migrate to begin."
-      );
-      process.exit(1);
-    }
-
-    const state = await loadState(client, schema, argv.path);
-    const script = await dbGetAppliedScript(state, argv.filename);
-    if (script) {
-      console.log(script);
-    } else {
-      console.error(
-        `Script for ${argv.filename} not found, use the audit command to check all applied migrations`
-      );
-    }
+    await getAppliedScriptCommand(client, argv);
   } else {
     console.error(`Invalid command: ${command}`);
     console.log(usage);

package/src/utils.ts

@@ -1,6 +1,8 @@
 import fs from "fs/promises";
 import gitDiff from "git-diff";
 import path from "path";
+import { PoolClient } from "pg";
+import { dbSchemaExists, dbTableExists } from "./db";
 import {
   AppliedMigration,
   MigrationFile,
@@ -43,8 +45,18 @@ Example:
     --path=./test/migrations-template/
 `;
 
+export const parseArgs = (argv: any) => {
+  const schema = argv.schema ?? "public";
+  const command = argv._[0];
+  const napply = argv.napply || Infinity;
+  const nundo = argv.nundo || 1;
+  const filePath = argv.path;
+
+  return { schema, command, napply, nundo, filePath };
+};
+
 export const validateArgs = (argv: any) => {
-  const required = ["connection", "schema", "path", "_"];
+  const required = ["connection", "path", "_"];
   if (required.some((key) => !(key in argv))) {
     console.error(
       "Missing required arguments",
@@ -116,6 +128,7 @@ export const readMigrationFiles = async (
 export const printMigrationHistoryAndUnappliedMigrations = (
   state: MigrationState
 ) => {
+  // console.log(JSON.stringify(state, null, 2));
   console.log("All applied versioned migrations:");
   console.table(
     state.current.appliedVersionedMigrations.map((h) => ({
@@ -138,6 +151,9 @@ export const printMigrationHistoryAndUnappliedMigrations = (
       }))
     );
   }
+
+  abortIfErrors(state);
+
   console.log("Unapplied versioned migrations:");
   console.table(
     state.files.unappliedVersionedFiles.map((h) => ({
@@ -222,3 +238,12 @@ export const sliceFromFirstNull = <T>(array: (T | undefined)[]): T[] => {
     ? (array as T[])
     : (array.slice(0, indexOfFirstNull) as T[]);
 };
+
+export const checkSchemaAndTable = async (
+  client: PoolClient,
+  schema: string
+) => {
+  const schemaExists = await dbSchemaExists(client, schema);
+  const tableExists = await dbTableExists(client, schema);
+  return { schemaExists, tableExists };
+};

package/test/index.test.ts

@@ -120,7 +120,7 @@ describe("valid migrations", async () => {
   });
 });
 
-describe.only("invalid migrations", async () => {
+describe("invalid migrations", async () => {
   beforeEach(async () => {
     const { output, error, exitCode } = await executeCommand("drop", "");
     assert.ok(
@@ -164,7 +164,7 @@ describe.only("invalid migrations", async () => {
     ]);
   });
 
-  it.only("bad creds", async () => {
+  it("bad creds", async () => {
     assertIncludesAll(
       await execute(`npm exec stepwise-migrations info -- \\
       --connection=postgresql://postgres:badpassword@127.0.0.1:5432/mydb \\

package/test/migrations-invalid/v1_first.sql

@@ -2,5 +2,3 @@ create table first (
   id serial primary key,
   name text not null
 );
-
-ALTER TABLE first ADD COLUMN age int;

package/test/migrations-template/v1_first.sql

@@ -2,5 +2,3 @@ create table first (
   id serial primary key,
   name text not null
 );
-
-ALTER TABLE first ADD COLUMN age int;