stepwise-migrations 1.0.24 → 1.0.27

package/src/index.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
 import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import {
   auditCommand,
+  baselineCommand,
   dropCommand,
   getAppliedScriptCommand,
   infoCommand,
@@ -11,39 +13,140 @@ import {
   undoCommand,
   validateCommand,
 } from "./commands";
-import { dbConnect } from "./db";
-import { usage, validateArgs } from "./utils";
-
+import { parseArgs, usage } from "./utils";
 const main = async () => {
-  const argv: any = yargs(process.argv.slice(2)).argv;
-  validateArgs(argv);
+  const argv = yargs(hideBin(process.argv))
+    .command(
+      "migrate",
+      "Migrate the database to the latest version",
+      (yargs) => {
+        return yargs.options({
+          napply: {
+            type: "number",
+            describe: "Number of migrations to apply, defaults to all",
+          },
+        });
+      }
+    )
+    .command(
+      "validate",
+      "Validate the migration files and the stepwise_migration_events table"
+    )
+    .command(
+      "info",
+      "Show information about the current state of the migrations in the database and in the migration files"
+    )
+    .command(
+      "status",
+      "Only show the status of the migrations in the database, not the migration files"
+    )
+    .command(
+      "undo",
+      "Rollback the database to the previous version",
+      (yargs) => {
+        return yargs.options({
+          nundo: {
+            type: "number",
+            describe: "Number of migrations to undo, defaults to 1",
+          },
+        });
+      }
+    )
+    .command(
+      "get-applied-script",
+      "Get the script for the last applied migration",
+      (yargs) => {
+        return yargs.options({
+          filename: {
+            type: "string",
+            describe: "The filename to get the script for",
+          },
+        });
+      }
+    )
+    .command("drop", "Drop the tables, schema and migration history table")
+    .command(
+      "baseline",
+      "Without applying any migrations, set the migration table state to a specific version",
+      (yargs) => {
+        return yargs.options({
+          filename: {
+            type: "string",
+            describe: "The filename to baseline to",
+            default: null,
+          },
+        });
+      }
+    )
+    .options({
+      connection: {
+        type: "string",
+        demandOption: true,
+        alias: "c",
+        describe: "The connection string to use to connect to the database",
+      },
+      schema: {
+        type: "string",
+        default: "public",
+        alias: "s",
+        describe: "The schema to use for the migrations",
+      },
+      ssl: {
+        type: "boolean",
+        default: false,
+        describe: "Whether to use SSL for the connection",
+      },
+      path: {
+        type: "string",
+        default: "./",
+        alias: "p",
+        describe: "The path to the migrations directory",
+      },
+    })
+    .example([
+      [
+        `npx stepwise-migrations migrate \\
+      --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \\
+      --schema=myschema \\
+      --path=./test/migrations-template/`,
+        "Migrate the database to the latest version",
+      ],
+    ])
+    .wrap(yargs.terminalWidth())
+    .demandCommand(1)
+    .recommendCommands()
+    .strict()
+    .help()
+    .version(false)
+    .parse();
 
-  const command = argv._[0];
-  const client = await dbConnect(argv);
+  const args = parseArgs(argv);
+  const command = args.command;
 
   if (command === "migrate") {
-    await migrateCommand(client, argv);
+    await migrateCommand(args);
   } else if (command === "info") {
-    await infoCommand(client, argv);
+    await infoCommand(args);
   } else if (command === "status") {
-    await statusCommand(client, argv);
+    await statusCommand(args);
   } else if (command === "validate") {
-    await validateCommand(client, argv);
+    await validateCommand(args);
   } else if (command === "drop") {
-    await dropCommand(client, argv);
+    await dropCommand(args);
   } else if (command === "undo") {
-    await undoCommand(client, argv);
+    await undoCommand(args);
   } else if (command === "audit") {
-    await auditCommand(client, argv);
+    await auditCommand(args);
   } else if (command === "get-applied-script") {
-    await getAppliedScriptCommand(client, argv);
+    await getAppliedScriptCommand(args);
+  } else if (command === "baseline") {
+    await baselineCommand(args);
   } else {
     console.error(`Invalid command: ${command}`);
     console.log(usage);
     process.exit(1);
   }
 
-  client.release();
   process.exit(0);
 };
 

package/src/state.ts

@@ -1,7 +1,6 @@
 import gitDiff from "git-diff";
 import path from "path";
-import { PoolClient } from "pg";
-import { dbEventHistory } from "./db";
+import { DbClient } from "./db";
 import { AppliedMigration, MigrationState } from "./types";
 import { readMigrationFiles } from "./utils";
 
@@ -64,11 +63,10 @@ export const validateMigrationFiles = (state: MigrationState) => {
 };
 
 export const loadState = async (
-  client: PoolClient,
-  schema: string,
+  client: DbClient,
   migrationPath: string
 ): Promise<MigrationState> => {
-  const events = await dbEventHistory(client, schema);
+  const events = await client.dbEventHistory();
   const {
     appliedVersionedMigrations,
     appliedRepeatableMigrations,
@@ -97,7 +95,7 @@ export const loadState = async (
     );
 
   return {
-    schema,
+    schema: client.schema,
     current: {
       appliedVersionedMigrations,
       appliedRepeatableMigrations,

package/src/utils.ts

@@ -1,8 +1,7 @@
 import fs from "fs/promises";
 import gitDiff from "git-diff";
 import path from "path";
-import { PoolClient } from "pg";
-import { dbSchemaExists, dbTableExists } from "./db";
+import { DbClient } from "./db";
 import {
   AppliedMigration,
   MigrationFile,
@@ -28,48 +27,69 @@ Commands:
     Drop all tables, schema and stepwise_migration_events table
   get-applied-script
     Get the script for the last applied migration
+  baseline
+    Without applying any migrations, set the migration table state to a specific version
 
 Options:
   --connection <connection>  The connection string to use to connect to the database
-  --schema <schema>          The schema to use for the migrations
+  --schema <schema>          The schema to use for the migrations (default: public)
   --path <path>              The path to the migrations directory
   --ssl true/false           Whether to use SSL for the connection (default: false)
   --napply                   Number of up migrations to apply (default: all)
   --nundo                    Number of undo migrations to apply (default: 1)
-  --filename                 The filename to get the script for (default: last applied migration)
+  --filename                 (get-applied-script) The filename to get the script for (default: last applied migration)
+  --filename                 (baseline) The filename to baseline (default: last unapplied versioned migration)
 
 Example:
-  npx stepwise-migrations migrate \\
-    --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \\
-    --schema=myschema \\
+  npx stepwise-migrations migrate \
+    --connection=postgresql://postgres:postgres@127.0.0.1:5432/mydatabase \
+    --schema=myschema \
     --path=./test/migrations-template/
 `;
 
-export const parseArgs = (argv: any) => {
+export type Args = {
+  schema: string;
+  command: string;
+  napply: number;
+  nundo: number;
+  filePath: string;
+  connection: string;
+  filename?: string;
+  ssl: string;
+};
+
+export const parseArgs = (argv: any): Args => {
   const schema = argv.schema ?? "public";
   const command = argv._[0];
   const napply = argv.napply || Infinity;
   const nundo = argv.nundo || 1;
   const filePath = argv.path;
+  const connection = argv.connection;
+  const ssl = argv.ssl ?? "false";
+  const filename = argv.filename;
 
-  return { schema, command, napply, nundo, filePath };
+  return {
+    schema,
+    command,
+    napply,
+    nundo,
+    filePath,
+    connection,
+    ssl,
+    filename,
+  };
 };
 
-export const validateArgs = (argv: any) => {
-  const required = ["connection", "path", "_"];
-  if (required.some((key) => !(key in argv))) {
+export const validateArgs = (args: Args) => {
+  const required = ["connection", "filePath", "command"];
+  if (required.some((key) => !(key in args))) {
     console.error(
       "Missing required arguments",
-      required.filter((key) => !(key in argv))
+      required.filter((key) => !(key in args))
     );
     console.log(usage);
     process.exit(1);
   }
-  if (argv._.length !== 1) {
-    console.error(`Invalid number of arguments: ${argv._.length}`);
-    console.log(usage);
-    process.exit(1);
-  }
 };
 
 export const filenameToType = (filename: string): MigrationType => {
@@ -239,11 +259,8 @@ export const sliceFromFirstNull = <T>(array: (T | undefined)[]): 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);
+export const checkSchemaAndTable = async (client: DbClient) => {
+  const schemaExists = await client.dbSchemaExists();
+  const tableExists = await client.dbTableExists();
   return { schemaExists, tableExists };
 };

package/test/index.test.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import fs from "node:fs";
 import { beforeEach, describe, it } from "node:test";
 import { assertIncludesAll, assertIncludesExcludesAll, execute } from "./utils";
@@ -23,13 +22,9 @@ const executeCommand = (
 
 describe("valid migrations", async () => {
   beforeEach(async () => {
-    const { output, error, exitCode } = await executeCommand("drop", "");
-    assert.ok(
-      output.includes(
-        "Dropping the tables, schema and migration history table... done!"
-      )
-    );
-    assert.ok(exitCode === 0);
+    assertIncludesAll(await executeCommand("drop", ""), [
+      "Dropping the tables, schema and migration history table... done!",
+    ]);
 
     fs.rmSync(paths.valid, { recursive: true, force: true });
     fs.cpSync("./test/migrations-template", paths.valid, {
@@ -38,7 +33,20 @@ describe("valid migrations", async () => {
   });
 
   it("migrate without params", async () => {
-    assertIncludesAll(await execute("npm exec stepwise-migrations"), ["Usage"]);
+    assertIncludesAll(await execute("npm exec stepwise-migrations"), [
+      "stepwise-migrations <command>",
+    ]);
+  });
+
+  it("baseline", async () => {
+    assertIncludesAll(await executeCommand("baseline", paths.valid), [
+      "All done! (Shadow)-applied 3 migrations to baseline to v3_third.sql",
+    ]);
+    assertIncludesExcludesAll(
+      await executeCommand("status"),
+      ["v1_first.sql", "v2_second.sql", "v3_third.sql"],
+      ["v0_get_number.repeatable.sql"]
+    );
   });
 
   it("migrate one versioned and undo, redo, undo", async () => {
@@ -120,15 +128,11 @@ describe("valid migrations", async () => {
   });
 });
 
-describe("invalid migrations", async () => {
+describe.only("invalid migrations", async () => {
   beforeEach(async () => {
-    const { output, error, exitCode } = await executeCommand("drop", "");
-    assert.ok(
-      output.includes(
-        "Dropping the tables, schema and migration history table... done!"
-      )
-    );
-    assert.ok(exitCode === 0);
+    assertIncludesAll(await executeCommand("drop", ""), [
+      "Dropping the tables, schema and migration history table... done!",
+    ]);
 
     fs.rmSync(paths.invalid, { recursive: true, force: true });
     fs.cpSync("./test/migrations-template", paths.invalid, {
@@ -136,7 +140,7 @@ describe("invalid migrations", async () => {
     });
   });
 
-  it("missing undo migration", async () => {
+  it.only("missing undo migration", async () => {
     assertIncludesAll(await executeCommand("migrate", paths.invalid), [
       "All done!",
     ]);
@@ -144,7 +148,7 @@ describe("invalid migrations", async () => {
     fs.unlinkSync("./test/migrations-invalid/v3_third.undo.sql");
 
     assertIncludesAll(
-      await executeCommand("undo", paths.invalid, "--nundos=2"),
+      await executeCommand("undo", paths.invalid, "--nundo=2"),
       ["Error: not enough sequential (from last) undo migrations to apply"]
     );
   });

package/dist/src/db.js

@@ -1,167 +0,0 @@
-"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.applyUndoMigration = exports.applyMigration = exports.dbGetAppliedScript = exports.dbCreateEventsTable = exports.dbEventHistory = exports.dbCreateSchema = exports.dbDropAll = exports.dbTableExists = exports.dbSchemaExists = exports.dbConnect = void 0;
-const pg_1 = __importStar(require("pg"));
-const types_1 = require("./types");
-pg_1.default.types.setTypeParser(1114, function (stringValue) {
-    return stringValue; //1114 for time without timezone type
-});
-pg_1.default.types.setTypeParser(1082, function (stringValue) {
-    return stringValue; //1082 for date type
-});
-const dbConnect = (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");
-    }
-    catch (error) {
-        console.error("Failed to connect to the database", error);
-        process.exit(1);
-    }
-    return client;
-});
-exports.dbConnect = dbConnect;
-const dbSchemaExists = (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.dbSchemaExists = dbSchemaExists;
-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_migration_events' and schemaname = '${schema}')`);
-    return tableExistsResult.rows[0].exists;
-});
-exports.dbTableExists = dbTableExists;
-const dbDropAll = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    yield client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
-});
-exports.dbDropAll = dbDropAll;
-const dbCreateSchema = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    process.stdout.write(`Creating schema ${schema}... `);
-    yield client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
-    console.log(`done!`);
-});
-exports.dbCreateSchema = dbCreateSchema;
-const dbEventHistory = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const eventQuery = yield client.query(`SELECT * FROM ${schema}.stepwise_migration_events`);
-        return eventQuery.rows.map((row) => types_1.EventRow.parse(row));
-    }
-    catch (error) {
-        console.error("Error fetching event history", error);
-        process.exit(1);
-    }
-});
-exports.dbEventHistory = dbEventHistory;
-const dbCreateEventsTable = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    process.stdout.write(`Creating stepwise_migration_events table... `);
-    yield client.query(`
-CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migration_events (
-  id SERIAL PRIMARY KEY,
-  type TEXT NOT NULL,
-  filename TEXT NOT NULL,
-  script TEXT NOT NULL,
-  applied_by TEXT NOT NULL DEFAULT current_user,
-  applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-    `);
-    console.log(`done!`);
-});
-exports.dbCreateEventsTable = dbCreateEventsTable;
-const dbGetAppliedScript = (state, filename) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    return (_a = state.current.appliedVersionedMigrations
-        .concat(state.current.appliedRepeatableMigrations)
-        .find((file) => file.filename === filename)) === null || _a === void 0 ? void 0 : _a.script;
-});
-exports.dbGetAppliedScript = dbGetAppliedScript;
-const applyMigration = (client, schema, migration) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        process.stdout.write(`Applying ${migration.type} migration ${migration.filename}... `);
-        yield client.query("BEGIN");
-        yield client.query(`SET search_path TO ${schema};
-    ${migration.script.toString()}`);
-        yield client.query(`INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`, [migration.type, migration.filename, migration.script]);
-        yield client.query("COMMIT");
-        console.log(`done!`);
-    }
-    catch (error) {
-        try {
-            yield client.query("ROLLBACK");
-        }
-        catch (error) {
-            console.error("Error rolling back transaction", error);
-        }
-        console.error("Error applying migration", error);
-        process.exit(1);
-    }
-});
-exports.applyMigration = applyMigration;
-const applyUndoMigration = (client, schema, filename, script) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        process.stdout.write(`Applying undo migration ${filename}... `);
-        yield client.query("BEGIN");
-        yield client.query(`SET search_path TO ${schema};
-    ${script.toString()}`);
-        yield client.query(`INSERT INTO ${schema}.stepwise_migration_events (type, filename, script) VALUES ($1, $2, $3)`, ["undo", filename, script]);
-        yield client.query("COMMIT");
-        console.log(`done!`);
-    }
-    catch (error) {
-        try {
-            yield client.query("ROLLBACK");
-        }
-        catch (error) {
-            console.error("Error rolling back transaction", error);
-        }
-        console.error("Error applying undo migration", error);
-        process.exit(1);
-    }
-});
-exports.applyUndoMigration = applyUndoMigration;

package/dist/src/validate.js

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