stepwise-migrations 1.0.24 → 1.0.26

package/dist/src/utils.js

@@ -16,7 +16,6 @@ exports.checkSchemaAndTable = exports.sliceFromFirstNull = exports.exitIfNotInit
 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]
 
@@ -35,41 +34,51 @@ 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/
 `;
 const parseArgs = (argv) => {
-    var _a;
+    var _a, _b;
     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 };
+    const connection = argv.connection;
+    const ssl = (_b = argv.ssl) !== null && _b !== void 0 ? _b : "false";
+    const filename = argv.filename;
+    return {
+        schema,
+        command,
+        napply,
+        nundo,
+        filePath,
+        connection,
+        ssl,
+        filename,
+    };
 };
 exports.parseArgs = parseArgs;
-const validateArgs = (argv) => {
-    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);
-        process.exit(1);
-    }
-    if (argv._.length !== 1) {
-        console.error(`Invalid number of arguments: ${argv._.length}`);
+const validateArgs = (args) => {
+    const required = ["connection", "filePath", "command"];
+    if (required.some((key) => !(key in args))) {
+        console.error("Missing required arguments", required.filter((key) => !(key in args)));
         console.log(exports.usage);
         process.exit(1);
     }
@@ -205,9 +214,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);
+const checkSchemaAndTable = (client) => __awaiter(void 0, void 0, void 0, function* () {
+    const schemaExists = yield client.dbSchemaExists();
+    const tableExists = yield client.dbTableExists();
     return { schemaExists, tableExists };
 });
 exports.checkSchemaAndTable = checkSchemaAndTable;

package/dist/test/index.test.js

@@ -40,6 +40,12 @@ const executeCommand = (command, path = "", extraArgs = "") => (0, utils_1.execu
     (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)("baseline", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, utils_1.assertIncludesAll)(yield executeCommand("baseline", paths.valid), [
+            "All done! (Shadow)-applied 3 migrations to baseline to v3_third.sql",
+        ]);
+        (0, utils_1.assertIncludesExcludesAll)(yield executeCommand("status"), ["v1_first.sql", "v2_second.sql", "v3_third.sql"], ["v0_get_number.repeatable.sql"]);
+    }));
     (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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stepwise-migrations",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "A JavaScript CLI tool for managing Raw SQL migrations in a Postgres database. Loosely based on flyway.",
   "main": "./dist/src/index.js",
   "scripts": {
@@ -18,6 +18,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/git-diff": "^2.0.7",
+    "@types/mysql": "^2.15.26",
     "@types/pg": "^8.11.10",
     "@types/yargs": "^17.0.33",
     "glob": "^11.0.0",
@@ -28,6 +29,7 @@
   },
   "dependencies": {
     "git-diff": "^2.0.6",
+    "mysql": "^2.18.1",
     "pg": "^8.13.1",
     "sqlite": "^5.1.1",
     "yargs": "^17.7.2",

package/src/commands.ts

@@ -1,38 +1,31 @@
-import { PoolClient } from "pg";
-import {
-  applyMigration,
-  applyUndoMigration,
-  dbCreateEventsTable,
-  dbCreateSchema,
-  dbDropAll,
-  dbGetAppliedScript,
-} from "./db";
+import assert from "node:assert";
+import { DbClient, dbConnect } from "./db";
 import { getUndoFilename, loadState } from "./state";
 import {
   abortIfErrors,
+  Args,
   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
-  );
-
+export const ensureTableInitialised = async (client: DbClient) => {
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
   if (!schemaExists) {
-    await dbCreateSchema(client, schema);
+    await client.dbCreateSchema();
   }
   if (!tableExists) {
-    await dbCreateEventsTable(client, schema);
+    await client.dbCreateEventsTable();
   }
+};
 
-  const state = await loadState(client, schema, filePath);
+export const migrateCommand = async (args: Args) => {
+  const { napply, filePath } = args;
+  const client = await dbConnect(args);
+  await ensureTableInitialised(client);
+  const state = await loadState(client, filePath);
 
   abortIfErrors(state);
 
@@ -50,7 +43,7 @@ export const migrateCommand = async (client: PoolClient, argv: any) => {
   ].slice(0, napply);
 
   for (const migration of migrationsToApply) {
-    await applyMigration(client, schema, migration);
+    await client.dbApplyMigration(migration);
   }
 
   console.log(
@@ -60,16 +53,14 @@ export const migrateCommand = async (client: PoolClient, argv: any) => {
   );
 
   printMigrationHistoryAndUnappliedMigrations(
-    await loadState(client, schema, filePath)
+    await loadState(client, filePath)
   );
 };
 
-export const infoCommand = async (client: PoolClient, argv: any) => {
-  const { schema, filePath } = parseArgs(argv);
-  const { schemaExists, tableExists } = await checkSchemaAndTable(
-    client,
-    schema
-  );
+export const infoCommand = async (args: Args) => {
+  const { connection, schema, filePath } = args;
+  const client = await dbConnect(args);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
 
   if (!schemaExists) {
     console.log("Schema does not exist");
@@ -83,17 +74,15 @@ export const infoCommand = async (client: PoolClient, argv: any) => {
 
   if (schemaExists && tableExists) {
     printMigrationHistoryAndUnappliedMigrations(
-      await loadState(client, schema, filePath)
+      await loadState(client, filePath)
     );
   }
 };
 
-export const statusCommand = async (client: PoolClient, argv: any) => {
-  const { schema, filePath } = parseArgs(argv);
-  const { schemaExists, tableExists } = await checkSchemaAndTable(
-    client,
-    schema
-  );
+export const statusCommand = async (args: Args) => {
+  const { connection, schema, filePath } = args;
+  const client = await dbConnect(args);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
   if (!schemaExists) {
     console.log("Schema does not exist");
   }
@@ -105,19 +94,17 @@ export const statusCommand = async (client: PoolClient, argv: any) => {
   }
 
   if (schemaExists && tableExists) {
-    printMigrationHistory(await loadState(client, schema, filePath));
+    printMigrationHistory(await loadState(client, filePath));
   }
 };
 
-export const validateCommand = async (client: PoolClient, argv: any) => {
-  const { schema } = parseArgs(argv);
-  const { schemaExists, tableExists } = await checkSchemaAndTable(
-    client,
-    schema
-  );
+export const validateCommand = async (args: Args) => {
+  const { connection, schema, filePath } = args;
+  const client = await dbConnect(args);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
   exitIfNotInitialized(schemaExists, tableExists);
 
-  const state = await loadState(client, schema, argv.path);
+  const state = await loadState(client, filePath);
   if (schemaExists && tableExists) {
     abortIfErrors(state);
   }
@@ -126,18 +113,20 @@ export const validateCommand = async (client: PoolClient, argv: any) => {
   printMigrationHistoryAndUnappliedMigrations(state);
 };
 
-export const dropCommand = async (client: PoolClient, argv: any) => {
-  const { schema } = parseArgs(argv);
+export const dropCommand = async (args: Args) => {
+  const { connection, schema } = args;
+  const client = await dbConnect(args);
   process.stdout.write(
     `Dropping the tables, schema and migration history table... `
   );
-  await dbDropAll(client, schema);
+  await client.dbDropAll();
   console.log(`done!`);
 };
 
-export const undoCommand = async (client: PoolClient, argv: any) => {
-  const { schema, nundo, filePath } = parseArgs(argv);
-  const state = await loadState(client, schema, filePath);
+export const undoCommand = async (args: Args) => {
+  const { connection, schema, filePath, nundo } = args;
+  const client = await dbConnect(args);
+  const state = await loadState(client, filePath);
 
   abortIfErrors(state);
 
@@ -160,7 +149,7 @@ export const undoCommand = async (client: PoolClient, argv: any) => {
   }
 
   for (const { filename, script } of undosToApply) {
-    await applyUndoMigration(client, schema, filename, script);
+    await client.dbApplyUndoMigration(filename, script);
   }
   console.log(
     `All done! Performed ${undosToApply.length} undo migration${
@@ -171,16 +160,14 @@ export const undoCommand = async (client: PoolClient, argv: any) => {
   printMigrationHistoryAndUnappliedMigrations(state);
 };
 
-export const auditCommand = async (client: PoolClient, argv: any) => {
-  const { schema } = parseArgs(argv);
-  const { schemaExists, tableExists } = await checkSchemaAndTable(
-    client,
-    schema
-  );
+export const auditCommand = async (args: Args) => {
+  const { connection, schema, filePath } = args;
+  const client = await dbConnect(args);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
 
   exitIfNotInitialized(schemaExists, tableExists);
 
-  const state = await loadState(client, schema, argv.path);
+  const state = await loadState(client, filePath);
   console.log("Event history:");
   console.table(
     state.events.map((row) => ({
@@ -193,25 +180,64 @@ export const auditCommand = async (client: PoolClient, argv: any) => {
   );
 };
 
-export const getAppliedScriptCommand = async (
-  client: PoolClient,
-  argv: any
-) => {
-  const { schema } = parseArgs(argv);
-  const { schemaExists, tableExists } = await checkSchemaAndTable(
-    client,
-    schema
-  );
+export const getAppliedScriptCommand = async (args: Args) => {
+  const { connection, schema, filePath, filename } = args;
+  assert.ok(filename, "filename is required for this command");
+  const client = await dbConnect(args);
+  const { schemaExists, tableExists } = await checkSchemaAndTable(client);
 
   exitIfNotInitialized(schemaExists, tableExists);
 
-  const state = await loadState(client, schema, argv.path);
-  const script = await dbGetAppliedScript(state, argv.filename);
+  const state = await loadState(client, filePath);
+  const script = await client.dbGetAppliedScript(state, filename);
   if (script) {
     console.log(script);
   } else {
     console.error(
-      `Script for ${argv.filename} not found, use the audit command to check all applied migrations`
+      `Script for ${filename} not found, use the audit command to check all applied migrations`
     );
   }
 };
+
+export const baselineCommand = async (args: Args) => {
+  const { connection, schema, filePath, filename: argvFilename } = args;
+  const client = await dbConnect(args);
+  await ensureTableInitialised(client);
+
+  const state = await loadState(client, filePath);
+
+  if (state.files.unappliedVersionedFiles.length === 0) {
+    console.error("Error: No unapplied versioned migrations, aborting.");
+    process.exit(1);
+  }
+
+  const filename =
+    argvFilename ??
+    state.files.unappliedVersionedFiles[
+      state.files.unappliedVersionedFiles.length - 1
+    ].filename;
+
+  if (
+    !state.files.unappliedVersionedFiles.find(
+      (file) => file.filename === filename
+    )
+  ) {
+    console.error(
+      `Error: '${filename}' is not an unapplied versioned migration, aborting.`
+    );
+    process.exit(1);
+  }
+
+  let appliedCount = 0;
+  for (const file of state.files.unappliedVersionedFiles) {
+    await client.dbBaseline(file);
+    appliedCount++;
+    if (file.filename === filename) {
+      break;
+    }
+  }
+
+  console.log(
+    `All done! (Shadow)-applied ${appliedCount} migrations to baseline to ${filename}`
+  );
+};

package/src/db/index.ts

@@ -0,0 +1,20 @@
+import { Args } from "../utils";
+import * as pg from "./pg";
+
+export const dbConnect = async (args: Args) => {
+  if (args.connection.startsWith("postgresql://")) {
+    return await pg._dbConnect(args);
+  }
+  // else if (connection.startsWith("mysql://")) {
+  //   const client = await mysql._dbConnect(argv);
+  //   return {
+  //     type: "mysql",
+  //     client,
+  //     ...mysql,
+  //   };
+  // }
+
+  throw new Error("Invalid database connection string");
+};
+
+export type DbClient = Awaited<ReturnType<typeof dbConnect>>;

package/src/db/pg.ts

@@ -0,0 +1,189 @@
+import pg, { Pool, PoolClient } from "pg";
+import { EventRow, MigrationFile, MigrationState } from "../types";
+import { Args } from "../utils";
+
+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 ({ ssl, connection, schema }: Args) => {
+  const pool = new Pool({
+    connectionString: connection,
+    ssl: ssl === "true",
+  });
+
+  let client: PoolClient | undefined;
+  try {
+    client = await pool.connect();
+    await client.query("SELECT 1");
+  } catch (error) {
+    console.error("Failed to connect to the database", error);
+    process.exit(1);
+  }
+
+  const dbSchemaExists = async () => {
+    const result = await client.query(
+      `SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = '${schema}')`
+    );
+    return result.rows[0].exists;
+  };
+
+  const dbTableExists = async () => {
+    const tableExistsResult = await client.query(
+      `SELECT EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'stepwise_migration_events' and schemaname = '${schema}')`
+    );
+
+    return tableExistsResult.rows[0].exists;
+  };
+
+  const dbDropAll = async () => {
+    await client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
+  };
+
+  const dbCreateSchema = async () => {
+    process.stdout.write(`Creating schema ${schema}... `);
+    await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+    console.log(`done!`);
+  };
+
+  const dbEventHistory = async () => {
+    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);
+    }
+  };
+
+  const dbCreateEventsTable = async () => {
+    process.stdout.write(`Creating stepwise_migration_events table... `);
+    await client.query(
+      `
+  CREATE TABLE IF NOT EXISTS ${schema}.stepwise_migration_events (
+    id SERIAL PRIMARY KEY,
+    type TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    script TEXT NOT NULL,
+    applied_by TEXT NOT NULL DEFAULT current_user,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );
+      `
+    );
+    console.log(`done!`);
+  };
+
+  const dbGetAppliedScript = async (
+    state: MigrationState,
+    filename: string
+  ) => {
+    return state.current.appliedVersionedMigrations
+      .concat(state.current.appliedRepeatableMigrations)
+      .find((file) => file.filename === filename)?.script;
+  };
+
+  const dbApplyMigration = async (migration: MigrationFile) => {
+    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);
+    }
+  };
+
+  const dbBaseline = async (migration: MigrationFile) => {
+    try {
+      process.stdout.write(`Baselining ${migration.filename}... `);
+      await client.query("BEGIN");
+
+      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 baselining migration", error);
+      process.exit(1);
+    }
+  };
+
+  const dbApplyUndoMigration = async (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);
+    }
+  };
+
+  return {
+    type: "pg",
+    schema,
+    dbSchemaExists,
+    dbTableExists,
+    dbDropAll,
+    dbCreateSchema,
+    dbEventHistory,
+    dbCreateEventsTable,
+    dbGetAppliedScript,
+    dbApplyMigration,
+    dbBaseline,
+    dbApplyUndoMigration,
+  };
+};

package/src/index.ts

@@ -3,6 +3,7 @@
 import yargs from "yargs";
 import {
   auditCommand,
+  baselineCommand,
   dropCommand,
   getAppliedScriptCommand,
   infoCommand,
@@ -11,39 +12,40 @@ import {
   undoCommand,
   validateCommand,
 } from "./commands";
-import { dbConnect } from "./db";
-import { usage, validateArgs } from "./utils";
+import { parseArgs, usage, validateArgs } from "./utils";
 
 const main = async () => {
   const argv: any = yargs(process.argv.slice(2)).argv;
-  validateArgs(argv);
 
-  const command = argv._[0];
-  const client = await dbConnect(argv);
+  const args = parseArgs(argv);
+  validateArgs(args);
+
+  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);
 };