stepwise-migrations 1.0.14 → 1.0.15

package/dist/src/utils.js

@@ -0,0 +1,184 @@
+"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());
+    });
+};
+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;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+exports.usage = `
+Usage: stepwise-migrations [command] [options]
+
+Commands:
+  migrate
+    Migrate the database to the latest version
+  down
+    Rollback the database to the previous version
+  info
+    Show information about the current state of the migrations in the database
+  drop
+    Drop the tables, schema and migration history table
+
+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)
+  --nundo                    Number of down migrations to apply (default: 1)
+
+Example:
+  npx stepwise-migrations migrate \\
+    --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \\
+    --schema=myschema \\
+    --path=./db/migration/
+`;
+const validateArgs = (argv) => {
+    const required = ["connection", "schema", "path", "_"];
+    if (required.some((key) => !(key in argv))) {
+        console.error("Missing required arguments", required.filter((key) => !(key in argv)));
+        console.log(exports.usage);
+        process.exit(1);
+    }
+    if (argv._.length !== 1) {
+        console.error(`Invalid number of arguments: ${argv._.length}`);
+        console.log(exports.usage);
+        process.exit(1);
+    }
+};
+exports.validateArgs = validateArgs;
+const filenameToType = (filename) => {
+    if (filename.endsWith(".undo.sql")) {
+        return "undo";
+    }
+    else if (filename.endsWith(".repeatable.sql")) {
+        return "repeatable";
+    }
+    return "versioned";
+};
+exports.filenameToType = filenameToType;
+const readMigrationFiles = (directory, appliedVersionedMigrations) => __awaiter(void 0, void 0, void 0, function* () {
+    let errors = [];
+    const files = yield promises_1.default.readdir(directory, { withFileTypes: true });
+    const migrationFiles = files
+        .filter((file) => file.isFile() && file.name.endsWith(".sql"))
+        .map((file) => path_1.default.join(directory, file.name));
+    migrationFiles.sort();
+    const results = [];
+    for (const fullFileName of migrationFiles) {
+        const script = yield promises_1.default.readFile(fullFileName, "utf8");
+        results.push({
+            type: (0, exports.filenameToType)(path_1.default.basename(fullFileName)),
+            filename: path_1.default.basename(fullFileName),
+            script,
+        });
+    }
+    for (const appliedMigration of appliedVersionedMigrations) {
+        const file = results.find((f) => f.filename === appliedMigration.filename);
+        if (file &&
+            file.type === "versioned" &&
+            file.script !== appliedMigration.script) {
+            errors.push(`Versioned migration ${appliedMigration.filename} has been altered. Cannot migrate in current state.`);
+        }
+    }
+    return { files: results, errors };
+});
+exports.readMigrationFiles = readMigrationFiles;
+const printMigrationHistoryAndUnappliedMigrations = (state) => {
+    console.log("All applied versioned migrations:");
+    console.table(state.current.appliedVersionedMigrations.map((h) => ({
+        id: h.id,
+        type: h.type,
+        filename: h.filename,
+        applied_by: h.applied_by,
+        applied_at: h.applied_at,
+    })));
+    if (state.current.appliedRepeatableMigrations.length > 0) {
+        console.log("All applied repeatable migrations:");
+        console.table(state.current.appliedRepeatableMigrations.map((h) => ({
+            id: h.id,
+            type: h.type,
+            filename: h.filename,
+            applied_by: h.applied_by,
+            applied_at: h.applied_at,
+        })));
+    }
+    console.log("Unapplied versioned migrations:");
+    console.table(state.files.unappliedVersionedFiles.map((h) => ({
+        type: h.type,
+        filename: h.filename,
+    })));
+    if (state.files.unappliedRepeatableFiles.length > 0) {
+        console.log("Unapplied repeatable migrations:");
+        console.table(state.files.unappliedRepeatableFiles.map((h) => ({
+            type: h.type,
+            filename: h.filename,
+        })));
+    }
+};
+exports.printMigrationHistoryAndUnappliedMigrations = printMigrationHistoryAndUnappliedMigrations;
+const printMigrationHistory = (state) => {
+    console.log("All applied versioned migrations:");
+    console.table(state.current.appliedVersionedMigrations.map((h) => ({
+        id: h.id,
+        type: h.type,
+        filename: h.filename,
+        applied_by: h.applied_by,
+        applied_at: h.applied_at,
+    })));
+    if (state.current.appliedRepeatableMigrations.length > 0) {
+        console.log("All applied repeatable migrations:");
+        console.table(state.current.appliedRepeatableMigrations.map((h) => ({
+            id: h.id,
+            type: h.type,
+            filename: h.filename,
+            applied_by: h.applied_by,
+            applied_at: h.applied_at,
+        })));
+    }
+};
+exports.printMigrationHistory = printMigrationHistory;
+const fileExists = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return (yield promises_1.default.stat(path)).isFile();
+    }
+    catch (error) {
+        return false;
+    }
+});
+exports.fileExists = fileExists;
+const abortIfErrors = (state) => {
+    if (state.errors.length > 0) {
+        console.error(`There were errors loading the migration state. Please fix the errors and try again.`);
+        console.error(state.errors.map((e) => "  - " + e).join("\n"));
+        process.exit(1);
+    }
+};
+exports.abortIfErrors = abortIfErrors;
+const exitIfNotInitialized = (schemaExists, tableExists) => {
+    if (!schemaExists) {
+        console.log("Schema does not exist. Run migrate to begin.");
+        process.exit(1);
+    }
+    if (!tableExists) {
+        console.log("Migration table has not been initialised. Run migrate to begin.");
+        process.exit(1);
+    }
+};
+exports.exitIfNotInitialized = exitIfNotInitialized;
+const sliceFromFirstNull = (array) => {
+    const indexOfFirstNull = array.findIndex((x) => x == null);
+    return indexOfFirstNull < 0
+        ? array
+        : array.slice(0, indexOfFirstNull);
+};
+exports.sliceFromFirstNull = sliceFromFirstNull;

package/dist/src/validate.js

@@ -0,0 +1 @@
+"use strict";

package/dist/test/index.test.js

@@ -0,0 +1,129 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_test_1 = require("node:test");
+const utils_1 = require("./utils");
+const connection = "postgresql://postgres:postgres@127.0.0.1:5432/stepwise-db";
+const schema = "stepwise";
+const paths = {
+    valid: "./test/migrations-valid",
+    invalid: "./test/migrations-invalid",
+};
+const executeCommand = (command, path = "", extraArgs = "") => (0, utils_1.execute)(`npm exec stepwise-migrations ${command} -- \\
+    --connection=${connection} \\
+    --schema=${schema} \\
+    --path=${path} ${extraArgs}
+  `);
+(0, node_test_1.describe)("valid 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!"));
+        node_assert_1.default.ok(exitCode === 0);
+        node_fs_1.default.rmSync(paths.valid, { recursive: true, force: true });
+        node_fs_1.default.cpSync("./test/migrations-template", paths.valid, {
+            recursive: true,
+        });
+    }));
+    (0, node_test_1.it)("migrate without params", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield (0, utils_1.execute)("npm exec stepwise-migrations"), ["Usage"]);
+    }));
+    (0, node_test_1.it)("migrate one versioned and undo, redo, undo", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.valid), [
+            "All done! Applied 4 migrations",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("status"), [
+            "v0_get_number.repeatable.sql",
+            "v1_first.sql",
+            "v2_second.sql",
+            "v3_third.sql",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("undo", paths.valid), [
+            "All done! Performed 1 undo migration",
+        ]);
+        (0, utils_1.assertIncludesExcludesAll)(yield executeCommand("status"), ["v0_get_number.repeatable.sql", "v1_first.sql", "v2_second.sql"], ["v3_third.sql"]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.valid), [
+            "All done! Applied 1 migration",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("status"), [
+            "v0_get_number.repeatable.sql",
+            "v1_first.sql",
+            "v2_second.sql",
+            "v3_third.sql",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("undo", paths.valid, "--nundo=2"), [
+            "All done! Performed 2 undo migrations",
+        ]);
+        (0, utils_1.assertIncludesExcludesAll)(yield executeCommand("status"), ["v0_get_number.repeatable.sql", "v1_first.sql"], ["v2_second.sql", "v3_third.sql"]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.valid), [
+            "All done! Applied 2 migrations",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("status"), [
+            "v0_get_number.repeatable.sql",
+            "v1_first.sql",
+            "v2_second.sql",
+            "v3_third.sql",
+        ]);
+    }));
+    (0, node_test_1.it)("migrate with altered repeatable migration", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.valid), [
+            "All done! Applied 4 migrations",
+        ]);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("status"), [
+            "v0_get_number.repeatable.sql",
+            "v1_first.sql",
+            "v2_second.sql",
+            "v3_third.sql",
+        ]);
+        node_fs_1.default.writeFileSync("./test/migrations-valid/v0_get_number.repeatable.sql", `
+      CREATE OR REPLACE FUNCTION get_number()
+      RETURNS integer AS $$
+      BEGIN
+          RETURN 2;
+      END; $$
+      LANGUAGE plpgsql;
+      `);
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.valid), [
+            "All done! Applied 1 migration",
+        ]);
+    }));
+}));
+node_test_1.describe.only("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!"));
+        node_assert_1.default.ok(exitCode === 0);
+        node_fs_1.default.rmSync(paths.invalid, { recursive: true, force: true });
+        node_fs_1.default.cpSync("./test/migrations-template", paths.invalid, {
+            recursive: true,
+        });
+    }));
+    node_test_1.it.only("missing undo migration", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.invalid), [
+            "All done!",
+        ]);
+        node_fs_1.default.unlinkSync("./test/migrations-invalid/v3_third.undo.sql");
+        (0, utils_1.assertIncludesAll)(yield executeCommand("undo", paths.invalid, "--nundos=2"), ["Error: not enough sequential (from last) undo migrations to apply"]);
+    }));
+    (0, node_test_1.it)("alter migration", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.invalid), [
+            "All done!",
+        ]);
+        node_fs_1.default.writeFileSync("./test/migrations-invalid/v1_first.sql", "ALTER TABLE test ADD COLUMN test_column TEXT;");
+        (0, utils_1.assertIncludesAll)(yield executeCommand("migrate", paths.invalid), [
+            "Versioned migration v1_first.sql has been altered. Cannot migrate in current state.",
+        ]);
+    }));
+}));

package/dist/test/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIncludesExcludesAll = exports.assertExcludesAll = exports.assertIncludesAll = exports.includesExcludesAll = exports.excludesAll = exports.includesAll = exports.execute = void 0;
+const node_child_process_1 = require("node:child_process");
+const execute = (cmd) => {
+    const child = (0, node_child_process_1.exec)(cmd);
+    let scriptOutput = "";
+    let scriptError = "";
+    if (!child.stdout || !child.stderr) {
+        return { output: "", error: "", exitCode: 1 };
+    }
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (data) => {
+        scriptOutput += data.toString();
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (data) => {
+        scriptError += data.toString();
+    });
+    return new Promise((res, rej) => child.on("close", function (code) {
+        res({ output: scriptOutput, error: scriptError, exitCode: code !== null && code !== void 0 ? code : 1 });
+    }));
+};
+exports.execute = execute;
+const includesAll = (output, expected) => expected.every((x) => output.includes(x));
+exports.includesAll = includesAll;
+const excludesAll = (output, expected) => expected.every((x) => !output.includes(x));
+exports.excludesAll = excludesAll;
+const includesExcludesAll = (output, includes, excludes) => (0, exports.includesAll)(output, includes) && (0, exports.excludesAll)(output, excludes);
+exports.includesExcludesAll = includesExcludesAll;
+const assertIncludesAll = ({ output, error }, expected) => {
+    if (!(0, exports.includesAll)(output + error, expected)) {
+        console.log(output);
+        console.error(error);
+        throw new Error(`Expected ${expected} to be in output.`);
+    }
+};
+exports.assertIncludesAll = assertIncludesAll;
+const assertExcludesAll = ({ output, error }, expected) => {
+    if (!(0, exports.excludesAll)(output + error, expected)) {
+        console.log(output);
+        console.error(error);
+        throw new Error(`Expected ${expected} to be be excluded from output.`);
+    }
+};
+exports.assertExcludesAll = assertExcludesAll;
+const assertIncludesExcludesAll = ({ output, error }, includes, excludes) => {
+    (0, exports.assertIncludesAll)({ output, error }, includes);
+    (0, exports.assertExcludesAll)({ output, error }, excludes);
+};
+exports.assertIncludesExcludesAll = assertIncludesExcludesAll;

package/docker-compose.yml

@@ -0,0 +1,21 @@
+services:
+  stepwise-db:
+    container_name: stepwise-db
+    image: postgres:17.2
+    environment:
+      POSTGRES_DB: stepwise-db
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 1s
+      timeout: 5s
+      retries: 5
+    ports:
+      - "5432:5432"
+    networks:
+      - mynet
+
+networks:
+  mynet:
+    driver: bridge

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "stepwise-migrations",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "",
-  "main": "index.js",
+  "main": "src/index.js",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "npm run build; glob -c \"tsx --test --test-reporter spec \" \"./test/**/*.test.ts\"",
+    "test:only": "npm run build; glob -c \"tsx --test --test-only --test-reporter spec \" \"./test/**/*.test.ts\""
   },
   "keywords": [
     "migrations",
@@ -17,14 +19,18 @@
   "devDependencies": {
     "@types/git-diff": "^2.0.7",
     "@types/pg": "^8.11.10",
-    "@types/yargs": "^17.0.33"
+    "@types/yargs": "^17.0.33",
+    "glob": "^11.0.0",
+    "tsx": "^4.19.2"
   },
   "bin": {
-    "stepwise-migrations": "dist/index.js"
+    "stepwise-migrations": "dist/src/index.js"
   },
   "dependencies": {
     "git-diff": "^2.0.6",
     "pg": "^8.13.1",
-    "yargs": "^17.7.2"
+    "sqlite": "^5.1.1",
+    "yargs": "^17.7.2",
+    "zod": "^3.23.8"
   }
 }

package/src/db.ts

@@ -1,5 +1,5 @@
 import pg, { Pool, PoolClient } from "pg";
-import { AuditRow, MigrationRow } from "./types";
+import { EventRow, MigrationFile, MigrationState } from "./types";
 
 pg.types.setTypeParser(1114, function (stringValue) {
   return stringValue; //1114 for time without timezone type
@@ -27,10 +27,7 @@ export const dbConnect = async (argv: { connection: string; ssl?: string }) => {
   return client;
 };
 
-export const dbHistorySchemaExists = async (
-  client: PoolClient,
-  schema: string
-) => {
+export const dbSchemaExists = async (client: PoolClient, schema: string) => {
   const result = await client.query(
     `SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = '${schema}')`
   );
@@ -39,20 +36,14 @@ export const dbHistorySchemaExists = async (
 
 export const dbTableExists = async (client: PoolClient, schema: string) => {
   const tableExistsResult = await client.query(
-    `SELECT EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'stepwise_migrations' and schemaname = '${schema}')`
+    `SELECT EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'stepwise_migration_events' and schemaname = '${schema}')`
   );
 
   return tableExistsResult.rows[0].exists;
 };
 
-export const dbMigrationHistory = async (
-  client: PoolClient,
-  schema: string
-) => {
-  const migrationsQuery = await client.query(
-    `SELECT * FROM ${schema}.stepwise_migrations`
-  );
-  return migrationsQuery.rows as MigrationRow[];
+export const dbDropAll = async (client: PoolClient, schema: string) => {
+  await client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
 };
 
 export const dbCreateSchema = async (client: PoolClient, schema: string) => {
@@ -61,31 +52,29 @@ export const dbCreateSchema = async (client: PoolClient, schema: string) => {
   console.log(`done!`);
 };
 
-export const dbAuditHistory = async (client: PoolClient, schema: string) => {
-  const auditQuery = await client.query(
-    `SELECT * FROM ${schema}.stepwise_audit`
-  );
-  return auditQuery.rows as AuditRow[];
+export const dbEventHistory = async (client: PoolClient, schema: string) => {
+  try {
+    const eventQuery = await client.query(
+      `SELECT * FROM ${schema}.stepwise_migration_events`
+    );
+    return eventQuery.rows.map((row) => EventRow.parse(row));
+  } catch (error) {
+    console.error("Error fetching event history", error);
+    process.exit(1);
+  }
 };
 
-export const dbCreateHistoryTable = async (
+export const dbCreateEventsTable = async (
   client: PoolClient,
   schema: string
 ) => {
-  process.stdout.write(`Creating migration history table... `);
+  process.stdout.write(`Creating stepwise_migration_events table... `);
   await client.query(
     `
-CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migrations (
-  id SERIAL PRIMARY KEY,
-  name TEXT UNIQUE NOT NULL,
-  script TEXT NOT NULL,
-  applied_by TEXT NOT NULL DEFAULT current_user,
-  applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-CREATE TABLE IF NOT EXISTS ${schema}.stepwise_audit (
+CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migration_events (
   id SERIAL PRIMARY KEY,
   type TEXT NOT NULL,
-  name 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
@@ -95,14 +84,80 @@ CREATE TABLE IF NOT EXISTS ${schema}.stepwise_audit (
   console.log(`done!`);
 };
 
-export const dbGetScript = async (
+export const dbGetAppliedScript = async (
+  state: MigrationState,
+  filename: string
+) => {
+  return state.current.appliedVersionedMigrations
+    .concat(state.current.appliedRepeatableMigrations)
+    .find((file) => file.filename === filename)?.script;
+};
+
+export const applyMigration = async (
   client: PoolClient,
   schema: string,
-  filename: string
+  migration: MigrationFile
 ) => {
-  const script = await client.query(
-    `SELECT script FROM ${schema}.stepwise_audit WHERE name = $1`,
-    [filename]
-  );
-  return script.rows[0].script;
+  try {
+    process.stdout.write(
+      `Applying ${migration.type} migration ${migration.filename}... `
+    );
+    await client.query("BEGIN");
+
+    await client.query(
+      `SET search_path TO ${schema};
+    ${migration.script.toString()}`
+    );
+
+    await client.query(
+      `INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`,
+      [migration.type, migration.filename, migration.script]
+    );
+
+    await client.query("COMMIT");
+
+    console.log(`done!`);
+  } catch (error) {
+    try {
+      await client.query("ROLLBACK");
+    } catch (error) {
+      console.error("Error rolling back transaction", error);
+    }
+    console.error("Error applying migration", error);
+    process.exit(1);
+  }
+};
+
+export const applyUndoMigration = async (
+  client: PoolClient,
+  schema: string,
+  filename: string,
+  script: string
+) => {
+  try {
+    process.stdout.write(`Applying undo migration ${filename}... `);
+    await client.query("BEGIN");
+
+    await client.query(
+      `SET search_path TO ${schema};
+    ${script.toString()}`
+    );
+
+    await client.query(
+      `INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`,
+      ["undo", filename, script]
+    );
+
+    await client.query("COMMIT");
+
+    console.log(`done!`);
+  } catch (error) {
+    try {
+      await client.query("ROLLBACK");
+    } catch (error) {
+      console.error("Error rolling back transaction", error);
+    }
+    console.error("Error applying undo migration", error);
+    process.exit(1);
+  }
 };