stepwise-migrations 1.0.0

package/README.md

@@ -0,0 +1,74 @@
+# Stepwise Migrations
+
+A tool for managing migrations in a Postgres database.
+Loosely based, but in Typescript.
+
+Only "up" migrations are supported so far, but what more do you need?
+
+## Usage
+
+### Migrate
+
+```bash
+npx stepwise-migrations migrate \
+  --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydb \
+  --schema=myschema \
+  --path=./db/migration/
+```
+
+Outputs:
+
+```
+Connected to the database
+Creating schema collie
+Schema collie created
+Creating migration history table
+Migration history table created
+Found 2 migration files
+Applied migration V0_01__connect_session_table.sql
+Applied migration V0_02__auth.sql
+
+All done!
+```
+
+### Info
+
+```bash
+npx stepwise-migrations info \
+  --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydb \
+  --schema=myschema \
+  --path=./db/migration/
+```
+
+Outputs:
+
+```
+Connected to the database
+Showing information about the current state of the migrations in the database
+Migration history schema exists
+Migration history table exists
+Migration history:
+┌─────────┬────┬────────────────────────────────────┬────────────────────────────────────────────────────────────────────┬────────────┬──────────────────────────────┐
+│ (index) │ id │ name                               │ hash                                                               │ applied_by │ applied_at                   │
+├─────────┼────┼────────────────────────────────────┼────────────────────────────────────────────────────────────────────┼────────────┼──────────────────────────────┤
+│ 0       │ 1  │ 'V0_01__connect_session_table.sql' │ 'f08638e58139ae0e2dda24b1bdba29f3f2128597066a23d2bb382d448bbe9d7e' │ 'postgres' │ '2024-11-23 16:24:50.437496' │
+│ 1       │ 2  │ 'V0_02__auth.sql'                  │ '0a4c5df39f03df85cb68ef0b297b913d7c15477fa9dcba13b6e0577d88258a8e' │ 'postgres' │ '2024-11-23 16:24:50.440493' │
+└─────────┴────┴────────────────────────────────────┴────────────────────────────────────────────────────────────────────┴────────────┴──────────────────────────────┘
+```
+
+### Drop
+
+```bash
+npx stepwise-migrations drop \
+  --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydb \
+  --schema=myschema
+```
+
+Outputs:
+
+```
+Connected to the database
+Dropping the tables, schema and migration history table
+
+All done!
+```

package/dist/db.js

@@ -0,0 +1,103 @@
+"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.dbCreateHistoryTable = exports.dbCreateSchema = exports.dbMigrationHistory = exports.dbTableExists = exports.dbHistorySchemaExists = exports.dbConnect = void 0;
+const pg_1 = __importStar(require("pg"));
+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 = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const pool = new pg_1.Pool({
+        connectionString: argv.connection,
+        ssl: argv.ssl === "true",
+    });
+    let client;
+    try {
+        client = yield pool.connect();
+        yield client.query("SELECT 1");
+        console.log("Connected to the database");
+    }
+    catch (error) {
+        console.error("Failed to connect to the database", error);
+        process.exit(1);
+    }
+    return client;
+});
+exports.dbConnect = dbConnect;
+const dbHistorySchemaExists = (client, schema) => __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;
+});
+exports.dbHistorySchemaExists = dbHistorySchemaExists;
+const dbTableExists = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableExistsResult = yield client.query(`SELECT EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'stepwise_migrations' and schemaname = '${schema}')`);
+    return tableExistsResult.rows[0].exists;
+});
+exports.dbTableExists = dbTableExists;
+const dbMigrationHistory = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    const migrationsQuery = yield client.query(`SELECT * FROM ${schema}.stepwise_migrations`);
+    return migrationsQuery.rows;
+});
+exports.dbMigrationHistory = dbMigrationHistory;
+const dbCreateSchema = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(`Creating schema ${schema}`);
+    yield client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+    console.log(`Schema ${schema} created`);
+});
+exports.dbCreateSchema = dbCreateSchema;
+const dbCreateHistoryTable = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(`Creating migration history table`);
+    yield client.query(`CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migrations (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL,
+    hash TEXT NOT NULL,
+    applied_by TEXT NOT NULL DEFAULT current_user,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )`);
+    console.log(`Migration history table created`);
+});
+exports.dbCreateHistoryTable = dbCreateHistoryTable;

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+"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 yargs_1 = __importDefault(require("yargs"));
+const db_1 = require("./db");
+const migrate_1 = require("./migrate");
+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 client = yield (0, db_1.dbConnect)(argv);
+    const historySchemaExists = yield (0, db_1.dbHistorySchemaExists)(client, schema);
+    const tableExists = yield (0, db_1.dbTableExists)(client, schema);
+    if (command === "migrate") {
+        if (!historySchemaExists) {
+            yield (0, db_1.dbCreateSchema)(client, schema);
+        }
+        if (!tableExists) {
+            yield (0, db_1.dbCreateHistoryTable)(client, schema);
+        }
+        const migrationHistory = yield (0, db_1.dbMigrationHistory)(client, schema);
+        const migrationFiles = yield (0, utils_1.readMigrationFiles)(argv.path);
+        console.log(`Found ${migrationFiles.length} migration files`);
+        (0, migrate_1.validateMigrationFiles)(migrationFiles, migrationHistory);
+        const migrationsToApply = migrationFiles.slice(migrationHistory.length);
+        for (const { filename, contents, hash } of migrationsToApply) {
+            yield (0, migrate_1.applyMigration)(client, schema, filename, contents, hash);
+        }
+        console.log("\nAll done!");
+    }
+    else if (command === "info") {
+        console.log("Showing information about the current state of the migrations in the database");
+        console.log(historySchemaExists ? "Schema exists" : "Schema does not exist");
+        console.log(tableExists
+            ? "Migration history table exists"
+            : "Migration history table does not exist");
+        console.log("Migration history:");
+        console.table(yield (0, db_1.dbMigrationHistory)(client, schema));
+    }
+    else if (command === "drop") {
+        console.log("Dropping the tables, schema and migration history table");
+        yield client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
+        console.log("\nAll done!");
+    }
+    client.release();
+    process.exit(0);
+});
+main();

package/dist/migrate.js

@@ -0,0 +1,62 @@
+"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.applyMigration = exports.validateMigrationFiles = void 0;
+const validateMigrationFiles = (migrationFiles, migrationHistory) => {
+    if (migrationFiles.length === 0) {
+        console.log("No migrations found");
+        process.exit(0);
+    }
+    if (migrationFiles.length < migrationHistory.length) {
+        console.error("Error: migration history is longer than the number of migration files, aborting.");
+        process.exit(1);
+    }
+    if (migrationFiles.length === migrationHistory.length) {
+        console.log("All migrations are already applied");
+        process.exit(0);
+    }
+    for (let i = 0; i < migrationFiles.length; i++) {
+        const { filename, hash: migrationHash } = migrationFiles[i];
+        if (i >= migrationHistory.length) {
+            continue;
+        }
+        if (migrationHistory[i].name !== filename) {
+            console.error(`Error: migration ${filename} has been renamed, aborting.`);
+            process.exit(1);
+        }
+        if (migrationHistory[i].hash !== migrationHash) {
+            console.error(`Error: migration ${filename} has been modified, aborting.`);
+            process.exit(1);
+        }
+    }
+};
+exports.validateMigrationFiles = validateMigrationFiles;
+const applyMigration = (client, schema, filename, contents, hash) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield client.query("BEGIN");
+        yield client.query(`SET search_path TO ${schema};
+    ${contents.toString()}`);
+        yield client.query(`INSERT INTO ${schema}.stepwise_migrations (name, hash) VALUES ($1, $2)`, [filename, hash]);
+        yield client.query("COMMIT");
+        console.log(`Applied migration ${filename}`);
+    }
+    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);
+    }
+});
+exports.applyMigration = applyMigration;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.js

@@ -0,0 +1,86 @@
+"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.readMigrationFiles = exports.validateArgs = exports.usage = exports.hashFile = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const hashFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    const file = yield promises_1.default.readFile(path);
+    return crypto_1.default.createHash("sha256").update(file).digest("hex");
+});
+exports.hashFile = hashFile;
+exports.usage = `
+Usage: stepwise-migrations [command] [options]
+
+Commands:
+  migrate
+    Migrate the database to the latest 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)
+
+Example:
+  npx stepwise-migrations \
+    --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \
+    --schema=myschema \
+    --path=./db/migration/ \
+    migrate
+`;
+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);
+    }
+    if (argv._[0] !== "migrate" && argv._[0] !== "info" && argv._[0] !== "drop") {
+        console.error(`Invalid command: ${argv._[0]}`);
+        console.log(exports.usage);
+        process.exit(1);
+    }
+};
+exports.validateArgs = validateArgs;
+const readMigrationFiles = (directory) => __awaiter(void 0, void 0, void 0, function* () {
+    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 fullFilePath of migrationFiles) {
+        const hash = yield (0, exports.hashFile)(fullFilePath);
+        const contents = yield promises_1.default.readFile(fullFilePath, "utf8");
+        results.push({
+            fullFilePath,
+            filename: path_1.default.basename(fullFilePath),
+            hash,
+            contents,
+        });
+    }
+    return results;
+});
+exports.readMigrationFiles = readMigrationFiles;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "stepwise-migrations",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/pg": "^8.11.10",
+    "@types/yargs": "^17.0.33"
+  },
+  "bin": {
+    "stepwise-migrations": "./dist/index.js"
+  }
+}

package/src/db.ts

@@ -0,0 +1,79 @@
+import pg, { Pool, PoolClient } from "pg";
+
+pg.types.setTypeParser(1114, function (stringValue) {
+  return stringValue; //1114 for time without timezone type
+});
+
+pg.types.setTypeParser(1082, function (stringValue) {
+  return stringValue; //1082 for date type
+});
+
+export const dbConnect = async (argv: { connection: string; ssl?: string }) => {
+  const pool = new Pool({
+    connectionString: argv.connection,
+    ssl: argv.ssl === "true",
+  });
+
+  let client: PoolClient | undefined;
+  try {
+    client = await pool.connect();
+    await client.query("SELECT 1");
+    console.log("Connected to the database");
+  } catch (error) {
+    console.error("Failed to connect to the database", error);
+    process.exit(1);
+  }
+
+  return client;
+};
+
+export const dbHistorySchemaExists = async (
+  client: PoolClient,
+  schema: string
+) => {
+  const result = await client.query(
+    `SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = '${schema}')`
+  );
+  return result.rows[0].exists;
+};
+
+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}')`
+  );
+
+  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;
+};
+
+export const dbCreateSchema = async (client: PoolClient, schema: string) => {
+  console.log(`Creating schema ${schema}`);
+  await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+  console.log(`Schema ${schema} created`);
+};
+
+export const dbCreateHistoryTable = async (
+  client: PoolClient,
+  schema: string
+) => {
+  console.log(`Creating migration history table`);
+  await client.query(
+    `CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migrations (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL,
+    hash TEXT NOT NULL,
+    applied_by TEXT NOT NULL DEFAULT current_user,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )`
+  );
+  console.log(`Migration history table created`);
+};

package/src/index.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import {
+  dbConnect,
+  dbCreateHistoryTable,
+  dbCreateSchema,
+  dbHistorySchemaExists,
+  dbMigrationHistory,
+  dbTableExists,
+} from "./db";
+import { applyMigration, validateMigrationFiles } from "./migrate";
+import { readMigrationFiles, 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 client = await dbConnect(argv);
+  const historySchemaExists = await dbHistorySchemaExists(client, schema);
+  const tableExists = await dbTableExists(client, schema);
+
+  if (command === "migrate") {
+    if (!historySchemaExists) {
+      await dbCreateSchema(client, schema);
+    }
+    if (!tableExists) {
+      await dbCreateHistoryTable(client, schema);
+    }
+
+    const migrationHistory = await dbMigrationHistory(client, schema);
+    const migrationFiles = await readMigrationFiles(argv.path);
+    console.log(`Found ${migrationFiles.length} migration files`);
+
+    validateMigrationFiles(migrationFiles, migrationHistory);
+
+    const migrationsToApply = migrationFiles.slice(migrationHistory.length);
+
+    for (const { filename, contents, hash } of migrationsToApply) {
+      await applyMigration(client, schema, filename, contents, hash);
+    }
+    console.log("\nAll done!");
+  } else if (command === "info") {
+    console.log(
+      "Showing information about the current state of the migrations in the database"
+    );
+    console.log(
+      historySchemaExists ? "Schema exists" : "Schema does not exist"
+    );
+    console.log(
+      tableExists
+        ? "Migration history table exists"
+        : "Migration history table does not exist"
+    );
+    console.log("Migration history:");
+    console.table(await dbMigrationHistory(client, schema));
+  } else if (command === "drop") {
+    console.log("Dropping the tables, schema and migration history table");
+    await client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
+    console.log("\nAll done!");
+  }
+
+  client.release();
+  process.exit(0);
+};
+
+main();

package/src/migrate.ts

@@ -0,0 +1,75 @@
+import { PoolClient } from "pg";
+import { MigrationRow } from "./types";
+
+export const validateMigrationFiles = (
+  migrationFiles: { fullFilePath: string; filename: string; hash: string }[],
+  migrationHistory: MigrationRow[]
+) => {
+  if (migrationFiles.length === 0) {
+    console.log("No migrations found");
+    process.exit(0);
+  }
+
+  if (migrationFiles.length < migrationHistory.length) {
+    console.error(
+      "Error: migration history is longer than the number of migration files, aborting."
+    );
+    process.exit(1);
+  }
+
+  if (migrationFiles.length === migrationHistory.length) {
+    console.log("All migrations are already applied");
+    process.exit(0);
+  }
+
+  for (let i = 0; i < migrationFiles.length; i++) {
+    const { filename, hash: migrationHash } = migrationFiles[i];
+    if (i >= migrationHistory.length) {
+      continue;
+    }
+    if (migrationHistory[i].name !== filename) {
+      console.error(`Error: migration ${filename} has been renamed, aborting.`);
+      process.exit(1);
+    }
+    if (migrationHistory[i].hash !== migrationHash) {
+      console.error(
+        `Error: migration ${filename} has been modified, aborting.`
+      );
+      process.exit(1);
+    }
+  }
+};
+
+export const applyMigration = async (
+  client: PoolClient,
+  schema: string,
+  filename: string,
+  contents: string,
+  hash: string
+) => {
+  try {
+    await client.query("BEGIN");
+
+    await client.query(
+      `SET search_path TO ${schema};
+    ${contents.toString()}`
+    );
+
+    await client.query(
+      `INSERT INTO ${schema}.stepwise_migrations (name, hash) VALUES ($1, $2)`,
+      [filename, hash]
+    );
+
+    await client.query("COMMIT");
+
+    console.log(`Applied migration ${filename}`);
+  } 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);
+  }
+};

package/src/types.ts

@@ -0,0 +1,7 @@
+export interface MigrationRow {
+  id: string;
+  name: string;
+  hash: string;
+  applied_by: string;
+  applied_at: string;
+}

package/src/utils.ts

@@ -0,0 +1,80 @@
+import crypto from "crypto";
+import fs from "fs/promises";
+import path from "path";
+
+export const hashFile = async (path: string) => {
+  const file = await fs.readFile(path);
+  return crypto.createHash("sha256").update(file).digest("hex");
+};
+
+export const usage = `
+Usage: stepwise-migrations [command] [options]
+
+Commands:
+  migrate
+    Migrate the database to the latest 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)
+
+Example:
+  npx stepwise-migrations \
+    --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \
+    --schema=myschema \
+    --path=./db/migration/ \
+    migrate
+`;
+
+export const validateArgs = (argv: any) => {
+  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(usage);
+    process.exit(1);
+  }
+  if (argv._.length !== 1) {
+    console.error(`Invalid number of arguments: ${argv._.length}`);
+    console.log(usage);
+    process.exit(1);
+  }
+  if (argv._[0] !== "migrate" && argv._[0] !== "info" && argv._[0] !== "drop") {
+    console.error(`Invalid command: ${argv._[0]}`);
+    console.log(usage);
+    process.exit(1);
+  }
+};
+
+export const readMigrationFiles = async (directory: string) => {
+  const files = await fs.readdir(directory, { withFileTypes: true });
+  const migrationFiles = files
+    .filter((file) => file.isFile() && file.name.endsWith(".sql"))
+    .map((file) => path.join(directory, file.name));
+  migrationFiles.sort();
+  const results: {
+    fullFilePath: string;
+    filename: string;
+    hash: string;
+    contents: string;
+  }[] = [];
+  for (const fullFilePath of migrationFiles) {
+    const hash = await hashFile(fullFilePath);
+    const contents = await fs.readFile(fullFilePath, "utf8");
+    results.push({
+      fullFilePath,
+      filename: path.basename(fullFilePath),
+      hash,
+      contents,
+    });
+  }
+  return results;
+};

package/tsconfig.json

@@ -0,0 +1,111 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}