feat: implement migrateUp command

lib/commands/createEmptyMigration.ts

@@ -4,7 +4,11 @@ import * as ReaderTaskEither from 'fp-ts/ReaderTaskEither';
 import * as TaskEither from 'fp-ts/TaskEither';
 import { kebabCase } from 'lodash/fp';
 import { z as zod } from 'zod';
-import { toValidationError, ValidationError } from 'zod-validation-error';
+import {
+  isValidationErrorLike,
+  toValidationError,
+  ValidationError,
+} from 'zod-validation-error';
 
 import {
   MigrationRepoReadError,
@@ -42,7 +46,6 @@ export function createEmptyMigration(
   props: CreateEmptyMigrationInputProps
 ): ReaderTaskEither.ReaderTaskEither<
   CreateEmptyMigrationDeps,
-  | ValidationError
   | MigrationRepoWriteError
   | MigrationTemplateNotFoundError
   | MigrationRepoReadError,
@@ -62,6 +65,15 @@ export function createEmptyMigration(
             [timestamp, description].join('-')
           ),
           Either.flatMap(MigrationId.parse),
+          Either.mapLeft((err) => {
+            if (isValidationErrorLike(err)) {
+              return new MigrationRepoWriteError(`Invalid migration ID`, {
+                cause: err,
+              });
+            }
+
+            return err;
+          }),
           TaskEither.fromEither,
           TaskEither.bindTo('migrationId'),
           TaskEither.bindW('template', getMigrationTemplate),

lib/commands/index.ts

@@ -1,2 +1,3 @@
 export * from './createEmptyMigration';
 export * from './collectMigrationState';
+export * from './migrateUp';

lib/commands/migrateUp.ts

@@ -0,0 +1,162 @@
+import * as ArrayFp from 'fp-ts/Array';
+import * as Either from 'fp-ts/Either';
+import { pipe } from 'fp-ts/function';
+import * as ReaderTaskEither from 'fp-ts/ReaderTaskEither';
+import * as TaskEither from 'fp-ts/TaskEither';
+import { z as zod } from 'zod';
+import {
+  isValidationErrorLike,
+  toValidationError,
+  ValidationError,
+} from 'zod-validation-error';
+
+import {
+  InvalidMigrationHistoryLogError,
+  InvalidMigrationStateError,
+  MigrationHistoryLogNotFoundError,
+  MigrationHistoryLogReadError,
+  MigrationHistoryLogWriteError,
+  MigrationNotFoundError,
+  MigrationRepoNotFoundError,
+  MigrationRepoReadError,
+  MigrationRepoWriteError,
+  MigrationRuntimeError,
+  MigrationTemplateNotFoundError,
+} from '../errors';
+import {
+  HistoryLogEntry,
+  Migration,
+  MigrationId,
+  MigrationState,
+} from '../models';
+import { isPendingMigration } from '../models/MigrationState';
+import { MigrationHistoryLog } from '../ports';
+import {
+  collectMigrationState,
+  type CollectMigrationStateDeps,
+} from './collectMigrationState';
+
+const schema = zod.object({
+  migrationId: MigrationId.schema.optional(),
+});
+
+export type MigrateUpInputProps = zod.infer<typeof schema>;
+
+export function parseMigrateUpInputProps(
+  value: zod.input<typeof schema>
+): Either.Either<ValidationError, MigrateUpInputProps> {
+  return Either.tryCatch(() => schema.parse(value), toValidationError());
+}
+
+export type MigrateUpDeps = CollectMigrationStateDeps & {
+  addExecutedMigration: MigrationHistoryLog['addExecutedMigration'];
+};
+
+export function migrateUp(
+  props: MigrateUpInputProps
+): ReaderTaskEither.ReaderTaskEither<
+  MigrateUpDeps,
+  | InvalidMigrationHistoryLogError
+  | InvalidMigrationStateError
+  | MigrationHistoryLogNotFoundError
+  | MigrationHistoryLogReadError
+  | MigrationHistoryLogWriteError
+  | MigrationNotFoundError
+  | MigrationRepoNotFoundError
+  | MigrationRepoReadError
+  | MigrationRepoWriteError
+  | MigrationRuntimeError
+  | MigrationTemplateNotFoundError,
+  Array<MigrationId.MigrationId>
+> {
+  return pipe(
+    collectMigrationState(),
+    ReaderTaskEither.flatMapEither((migrationState) =>
+      calculateMigrationsToApply(migrationState, props.migrationId)
+    ),
+    ReaderTaskEither.flatMap((migrationsToApply) => {
+      return pipe(
+        ReaderTaskEither.ask<MigrateUpDeps>(),
+        ReaderTaskEither.chainTaskEitherK(({ addExecutedMigration }) => {
+          return pipe(
+            migrationsToApply,
+            ArrayFp.map((migration) =>
+              pipe(
+                TaskEither.tryCatch(
+                  () => migration.up(),
+                  (err) =>
+                    err instanceof Error
+                      ? new MigrationRuntimeError(
+                          `Unknown error occurred while applying migration "${migration.id}"`,
+                          { cause: err }
+                        )
+                      : new MigrationRuntimeError(
+                          `Unknown error occurred while applying migration "${migration.id}"`
+                        )
+                ),
+                TaskEither.flatMapEither(() =>
+                  HistoryLogEntry.parse({
+                    id: migration.id,
+                    executedAt: new Date(),
+                    checksum: migration.checksum,
+                  })
+                ),
+                TaskEither.mapLeft((err) => {
+                  if (isValidationErrorLike(err)) {
+                    return new MigrationRuntimeError(
+                      `Invalid migration history log entry for migration "${migration.id}"`,
+                      { cause: err }
+                    );
+                  }
+
+                  return err;
+                }),
+                TaskEither.flatMap(addExecutedMigration),
+                TaskEither.map(() => migration.id)
+              )
+            ),
+            ArrayFp.sequence(TaskEither.ApplicativeSeq)
+          );
+        })
+      );
+    })
+  );
+}
+
+function calculateMigrationsToApply(
+  migrationState: MigrationState.MigrationState,
+  targetMigrationId?: MigrationId.MigrationId
+): Either.Either<
+  MigrationNotFoundError | MigrationRuntimeError,
+  Array<Migration.Migration>
+> {
+  if (targetMigrationId == null) {
+    return Either.of(migrationState.filter(isPendingMigration));
+  }
+
+  const targetIndex = migrationState.findLastIndex(
+    (migration) => migration.id === targetMigrationId
+  );
+
+  if (targetIndex === -1) {
+    return Either.left(
+      new MigrationNotFoundError(
+        `Target migration "${targetMigrationId}" not found`
+      )
+    );
+  }
+
+  const migrationRecord = migrationState[targetIndex];
+
+  if (migrationRecord.status === 'EXECUTED') {
+    return Either.left(
+      new MigrationRuntimeError(
+        `Target migration "${targetMigrationId}" is already applied`
+      )
+    );
+  }
+
+  return Either.of(
+    migrationState.slice(0, targetIndex + 1).filter(isPendingMigration)
+  );
+}

lib/errors.ts

@@ -37,3 +37,7 @@ export class InvalidMigrationHistoryLogError extends Error {
 export class InvalidMigrationStateError extends Error {
   name = 'InvalidMigrationStateError' as const;
 }
+
+export class MigrationRuntimeError extends Error {
+  name = 'MigrationRuntimeError' as const;
+}

lib/models/MigrationState.ts

@@ -4,10 +4,21 @@ import { pipe } from 'fp-ts/lib/function';
 
 import { InvalidMigrationStateError } from '../errors';
 import * as HistoryLog from './HistoryLog';
+import * as HistoryLogEntry from './HistoryLogEntry';
 import * as Migration from './Migration';
-import * as MigrationStateRecord from './MigrationStateRecord';
 
-export type MigrationState = Array<MigrationStateRecord.MigrationStateRecord>;
+export type ExecutedMigration = Migration.Migration & {
+  status: 'EXECUTED';
+  executedAt: HistoryLogEntry.HistoryLogEntry['executedAt'];
+};
+
+export type PendingMigration = Migration.Migration & {
+  status: 'PENDING';
+  executedAt: null;
+};
+
+export type MigrationStateRecord = ExecutedMigration | PendingMigration;
+export type MigrationState = Array<MigrationStateRecord>;
 
 export function create(
   migrations: Array<Migration.Migration>,
@@ -27,10 +38,7 @@ export function create(
       (
         index,
         migration
-      ): Either.Either<
-        InvalidMigrationStateError,
-        MigrationStateRecord.MigrationStateRecord
-      > => {
+      ): Either.Either<InvalidMigrationStateError, MigrationStateRecord> => {
         const historyLogEntry = historyLog.entries[index];
 
         if (historyLogEntry == null) {
@@ -67,3 +75,15 @@ export function create(
     ArrayFp.sequence(Either.Applicative)
   );
 }
+
+export function isPendingMigration(
+  record: MigrationStateRecord
+): record is PendingMigration {
+  return record.status === 'PENDING';
+}
+
+export function isExecutedMigration(
+  record: MigrationStateRecord
+): record is ExecutedMigration {
+  return record.status === 'EXECUTED';
+}

lib/models/index.ts

@@ -5,4 +5,3 @@ export * as Migration from './Migration';
 export * as HistoryLog from './HistoryLog';
 export * as HistoryLogEntry from './HistoryLogEntry';
 export * as MigrationState from './MigrationState';
-export * as MigrationStateRecord from './MigrationStateRecord';