stepwise-migrations 1.0.14 → 1.0.16

package/README.md

@@ -10,8 +10,8 @@ Loosely based on flyway.
 Up migrations are first sorted in ascending order based on filename.
 No subdirectories are read below the migration directory.
 
-Name the "up" migration files as `.sql` and the "down" migration files with the same name but suffixed with `.down.sql`.
-e.g. `v1_users.sql` and `v1_users.down.sql`.
+Name the "up" migration files as `.sql` and the "down" migration files with the same name but suffixed with `.undo.sql`.
+e.g. `v1_users.sql` and `v1_users.undo.sql`.
 Down migrations are optional.
 
 ## Usage
@@ -22,17 +22,17 @@ Usage: stepwise-migrations [command] [options]
 Commands:
   migrate
     Migrate the database to the latest version
-  down
+  undo
     Rollback the database to the previous version
   validate
-    Validate the migration files and the migration history table
+    Validate the migration files and the stepwise_migration_events table
   audit
     Show the audit history for the migrations in the database
   info
     Show information about the current state of the migrations in the database
   drop
-    Drop all tables, schema and migration history table
-  get-script
+    Drop all tables, schema and stepwise_migration_events table
+  get-applied-script
     Get the script for the last applied migration
 
 Options:
@@ -40,8 +40,8 @@ Options:
   --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)
-  --nup                      Number of up migrations to apply (default: all)
-  --ndown                    Number of down migrations to apply (default: 1)
+  --napply                      Number of up migrations to apply (default: all)
+  --nundo                    Number of down migrations to apply (default: 1)
   --filename                 The filename to get the script for (default: last applied migration)
 
 Example:
@@ -70,11 +70,11 @@ npx stepwise-migrations migrate \
 
 ```text
 Creating schema myschema... done!
-Creating migration history table... done!
+Creating stepwise_migration_events table... done!
 Applying migration v1_connect_session_table.sql... done!
 Applying migration v2_auth.sql... done!
 All done! Applied 2 migrations
-Migration history:
+Migration state:
 ┌─────────┬────┬────────────────────────────────┬────────────┬──────────────────────────────┐
 │ (index) │ id │ name                           │ applied_by │ applied_at                   │
 ├─────────┼────┼────────────────────────────────┼────────────┼──────────────────────────────┤
@@ -89,10 +89,10 @@ Unapplied migrations:
 
 </details>
 
-### Down
+### Undo
 
 Runs a single down migration for the last applied migration.
-Can run multiple down migrations if the `--ndown` option is provided.
+Can run multiple down migrations if the `--nundo` option is provided.
 
 Command:
 
@@ -108,9 +108,9 @@ npx stepwise-migrations down \
 <summary>Example output</summary>
 
 ```text
-Applying down migration v2_auth.down.sql... done!
+Applying down migration v2_auth.undo.sql... done!
 All done! Applied 1 down migration
-Migration history:
+Migration state:
 ┌─────────┬────┬────────────────────────────────┬────────────┬──────────────────────────────┐
 │ (index) │ id │ name                           │ applied_by │ applied_at                   │
 ├─────────┼────┼────────────────────────────────┼────────────┼──────────────────────────────┤
@@ -128,7 +128,7 @@ Unapplied migrations:
 
 ### Validate
 
-Validates the migration files and the migration history table.
+Validates the migration files and the stepwise_migration_events table.
 
 ```bash
 npx stepwise-migrations validate \
@@ -143,7 +143,7 @@ npx stepwise-migrations validate \
 
 ```text
 Validation passed
-Migration history:
+Migration state:
 ┌─────────┬────┬────────────────────────────────┬────────────┬──────────────────────────────┐
 │ (index) │ id │ name                           │ applied_by │ applied_at                   │
 ├─────────┼────┼────────────────────────────────┼────────────┼──────────────────────────────┤
@@ -199,7 +199,7 @@ Audit history:
 ├─────────┼────┼────────┼────────────────────────────────┼────────────┼──────────────────────────────┤
 │ 0       │ 1  │ 'up'   │ 'v1_connect_session_table.sql' │ 'postgres' │ '2024-11-24 05:40:41.211617' │
 │ 1       │ 2  │ 'up'   │ 'v2_auth.sql'                  │ 'postgres' │ '2024-11-24 05:40:41.214732' │
-│ 2       │ 3  │ 'down' │ 'v2_auth.down.sql'             │ 'postgres' │ '2024-11-24 05:41:34.541462' │
+│ 2       │ 3  │ 'down' │ 'v2_auth.undo.sql'             │ 'postgres' │ '2024-11-24 05:41:34.541462' │
 └─────────┴────┴────────┴────────────────────────────────┴────────────┴──────────────────────────────┘
 ```
 
@@ -223,7 +223,7 @@ npx stepwise-migrations info \
 <summary>Example output</summary>
 
 ```text
-Migration history:
+Migration state:
 ┌─────────┬────┬────────────────────────────────┬────────────┬──────────────────────────────┐
 │ (index) │ id │ name                           │ applied_by │ applied_at                   │
 ├─────────┼────┼────────────────────────────────┼────────────┼──────────────────────────────┤
@@ -265,7 +265,7 @@ CREATE TABLE "users" (
 
 ### Drop
 
-Drops the tables, schema and migration history table.
+Drops the tables, schema and stepwise_migration_events table.
 
 Command:
 
@@ -280,7 +280,7 @@ npx stepwise-migrations drop \
 <summary>Example output</summary>
 
 ```text
-Dropping the tables, schema and migration history table... done!
+Dropping the tables, schema and migration stepwise_migration_events table... done!
 ```
 
 </details>

package/dist/{db.js → src/db.js}

@@ -42,8 +42,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dbGetScript = exports.dbCreateHistoryTable = exports.dbAuditHistory = exports.dbCreateSchema = exports.dbMigrationHistory = exports.dbTableExists = exports.dbHistorySchemaExists = exports.dbConnect = void 0;
+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
 });
@@ -67,46 +68,44 @@ const dbConnect = (argv) => __awaiter(void 0, void 0, void 0, function* () {
     return client;
 });
 exports.dbConnect = dbConnect;
-const dbHistorySchemaExists = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+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.dbHistorySchemaExists = dbHistorySchemaExists;
+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_migrations' and schemaname = '${schema}')`);
+    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 dbMigrationHistory = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    const migrationsQuery = yield client.query(`SELECT * FROM ${schema}.stepwise_migrations`);
-    return migrationsQuery.rows;
+const dbDropAll = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
+    yield client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
 });
-exports.dbMigrationHistory = dbMigrationHistory;
+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 dbAuditHistory = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    const auditQuery = yield client.query(`SELECT * FROM ${schema}.stepwise_audit`);
-    return auditQuery.rows;
+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.dbAuditHistory = dbAuditHistory;
-const dbCreateHistoryTable = (client, schema) => __awaiter(void 0, void 0, void 0, function* () {
-    process.stdout.write(`Creating migration history table... `);
+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_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 UNIQUE 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
@@ -114,9 +113,55 @@ CREATE TABLE IF NOT EXISTS ${schema}.stepwise_audit (
     `);
     console.log(`done!`);
 });
-exports.dbCreateHistoryTable = dbCreateHistoryTable;
-const dbGetScript = (client, schema, filename) => __awaiter(void 0, void 0, void 0, function* () {
-    const script = yield client.query(`SELECT script FROM ${schema}.stepwise_audit WHERE name = $1`, [filename]);
-    return script.rows[0].script;
+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.dbGetScript = dbGetScript;
+exports.applyUndoMigration = applyUndoMigration;

package/dist/src/index.js

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

package/dist/src/state.js

@@ -0,0 +1,123 @@
+"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.eventsToApplied = exports.getUndoFilename = exports.loadState = exports.validateMigrationFiles = void 0;
+const git_diff_1 = __importDefault(require("git-diff"));
+const path_1 = __importDefault(require("path"));
+const db_1 = require("./db");
+const utils_1 = require("./utils");
+const validateMigrationFiles = (state) => {
+    let errors = [];
+    if (state.files.allFiles.length === 0) {
+        return ["No migration files found"];
+    }
+    if (state.current.appliedVersionedMigrations.length >
+        state.files.versionedFiles.length) {
+        errors.push("Migration history is in a bad state: more applied versioned migrations than files");
+    }
+    for (let i = 0; i < state.current.appliedVersionedMigrations.length; i++) {
+        const { filename, script } = state.files.versionedFiles[i];
+        if (state.current.appliedVersionedMigrations[i].filename !== filename) {
+            errors.push(`Migration history is in a bad state: applied versioned migration ${state.current.appliedVersionedMigrations[i].filename} does not match file ${filename}`);
+            break;
+        }
+        if (state.current.appliedVersionedMigrations[i].script !== script) {
+            errors.push(`Migration history is in a bad state: applied versioned migration ${state.current.appliedVersionedMigrations[i].filename} has been modified.\n\n` +
+                (0, git_diff_1.default)(state.current.appliedVersionedMigrations[i].script, script, {
+                    color: true,
+                    noHeaders: true,
+                }));
+            break;
+        }
+    }
+    if (state.current.appliedRepeatableMigrations.length >
+        state.files.repeatableFiles.length) {
+        errors.push("Migration history is in a bad state: more applied repeatable migrations than files");
+    }
+    for (let i = 0; i < state.current.appliedRepeatableMigrations.length; i++) {
+        const { filename } = state.files.repeatableFiles[i];
+        if (state.current.appliedRepeatableMigrations[i].filename !== filename) {
+            errors.push(`Migration history is in a bad state: applied repeatable migration ${state.current.appliedRepeatableMigrations[i].filename} does not match file ${filename}`);
+            break;
+        }
+    }
+    return errors;
+};
+exports.validateMigrationFiles = validateMigrationFiles;
+const loadState = (client, schema, migrationPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const events = yield (0, db_1.dbEventHistory)(client, schema);
+    const { appliedVersionedMigrations, appliedRepeatableMigrations, errors: appliedErrors, } = (0, exports.eventsToApplied)(events);
+    const { files: allFiles, errors: readFileErrors } = yield (0, utils_1.readMigrationFiles)(path_1.default.join(process.cwd(), migrationPath), appliedVersionedMigrations);
+    const unappliedVersionedFiles = allFiles
+        .filter((file) => file.type === "versioned")
+        .filter((file) => !appliedVersionedMigrations.find((event) => event.filename === file.filename));
+    const unappliedRepeatableFiles = allFiles
+        .filter((file) => file.type === "repeatable")
+        .filter((file) => !appliedRepeatableMigrations.find((event) => event.filename === file.filename && event.script === file.script));
+    return {
+        schema,
+        current: {
+            appliedVersionedMigrations,
+            appliedRepeatableMigrations,
+        },
+        events,
+        files: {
+            allFiles,
+            unappliedVersionedFiles,
+            unappliedRepeatableFiles,
+            versionedFiles: allFiles.filter((file) => file.type === "versioned"),
+            undoFiles: allFiles.filter((file) => file.type === "undo"),
+            repeatableFiles: allFiles.filter((file) => file.type === "repeatable"),
+        },
+        errors: appliedErrors.concat(readFileErrors),
+    };
+});
+exports.loadState = loadState;
+const getUndoFilename = (filename) => {
+    return filename.replace(".sql", ".undo.sql");
+};
+exports.getUndoFilename = getUndoFilename;
+const eventsToApplied = (events) => {
+    let errors = [];
+    let appliedVersionedMigrations = [];
+    let appliedRepeatableMigrations = [];
+    for (const event of events) {
+        if (event.type === "versioned") {
+            appliedVersionedMigrations.push(event);
+        }
+        else if (event.type === "undo") {
+            if (appliedVersionedMigrations.length === 0) {
+                errors.push("Events table is in a bad state: undo event without a migration to undo");
+                break;
+            }
+            else if ((0, exports.getUndoFilename)(appliedVersionedMigrations[appliedVersionedMigrations.length - 1]
+                .filename) !== event.filename) {
+                errors.push("Events table is in a bad state: down migration does not match the most recently applied migration");
+                break;
+            }
+            else {
+                appliedVersionedMigrations.pop();
+            }
+        }
+        else if (event.type === "repeatable") {
+            appliedRepeatableMigrations.push(event);
+        }
+        else {
+            errors.push(`Events table is in a bad state: unknown event type ${event.type}`);
+            break;
+        }
+    }
+    return { errors, appliedVersionedMigrations, appliedRepeatableMigrations };
+};
+exports.eventsToApplied = eventsToApplied;

package/dist/src/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRow = void 0;
+const zod_1 = require("zod");
+const MigrationType = zod_1.z.enum(["versioned", "undo", "repeatable"]);
+exports.EventRow = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: MigrationType,
+    filename: zod_1.z.string(),
+    script: zod_1.z.string(),
+    applied_by: zod_1.z.string(),
+    applied_at: zod_1.z.string(),
+});