feat: Adds dryRun option. (#9)

Author: ryasmi

src/migrate/Signature.ts

@@ -1,3 +1,7 @@
-type Signature = () => Promise<void>;
+export interface Opts {
+  readonly dryRun?: boolean;
+}
+
+type Signature = (opts?: Opts) => Promise<void>;
 
 export default Signature;

src/migrate/index.ts

@@ -3,16 +3,16 @@ import FacadeConfig from '../FacadeConfig';
 import getUnprocessedKeys from '../utils/getUnprocessedKeys';
 import handleLocks from '../utils/handleLocks';
 import migrateKey from '../utils/migrateKey';
-import Signature from './Signature';
+import Signature, { Opts } from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async () => {
+  return async ({ dryRun = false }: Opts = {}) => {
     await handleLocks(config, async () => {
       const unprocessedKeys = await getUnprocessedKeys(config);
       const batchStart = new Date();
 
       await Promise.resolve(reduce(unprocessedKeys, async (_result, key) => {
-        await migrateKey({ config, key, batchStart });
+        await migrateKey({ config, key, batchStart, dryRun });
       }, Promise.resolve()));
     });
   };

src/migrate/test.ts

@@ -16,8 +16,7 @@ const testMigrate: TestFactory = (createService) => {
 
   describe('migrate', () => {
     it('should not error when there are no migrations', async () => {
-      const service = createService([]);
-      await service.migrate();
+      await createService([]).migrate();
     });
 
     it('should error when there are duplicate keys', async () => {
@@ -26,6 +25,10 @@ const testMigrate: TestFactory = (createService) => {
       await assertRejects(promise, DuplicateKeyError);
     });
 
+    it('should not error when a migration fails during a dry run', async () => {
+      await createService([failingMigration]).migrate({ dryRun: true });
+    });
+
     it('should error when the first migration errors', async () => {
       const promise = createService([failingMigration, successfulMigration]).migrate();
       await assertRejects(promise, FailingMigrationError);

src/migrateByKey/Signature.ts

@@ -1,6 +1,7 @@
 export interface Opts {
   readonly key: string;
   readonly force?: boolean;
+  readonly dryRun?: boolean;
 }
 
 type Signature = (opts: Opts) => Promise<void>;

src/migrateByKey/index.ts

@@ -6,14 +6,14 @@ import migrateKey from '../utils/migrateKey';
 import Signature from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async ({ key, force = false }) => {
+  return async ({ key, force = false, dryRun = false }) => {
     await handleLocks(config, async () => {
       const isProcessed = await hasProcessedKey(config, key);
       if (isProcessed && !force) {
         throw new ProcessedMigrationError(key);
       }
 
-      await migrateKey({ config, key });
+      await migrateKey({ config, key, dryRun });
     });
   };
 };

src/migrateByKey/test.ts

@@ -27,6 +27,11 @@ const testMigrateByKey: TestFactory = (createService) => {
       await assertRejects(promise, DuplicateKeyError);
     });
 
+    it('should not error when the migration fails during a dry run', async () => {
+      const service = createService([failingMigration]);
+      await service.migrateByKey({ key: testMigrationKey, dryRun: true });
+    });
+
     it('should error when the migration errors', async () => {
       const service = createService([failingMigration]);
       const promise = service.migrateByKey({ key: testMigrationKey });

src/rollback/Signature.ts

@@ -1,3 +1,7 @@
-type Signature = () => Promise<void>;
+export interface Opts {
+  readonly dryRun?: boolean;
+}
+
+type Signature = (opts?: Opts) => Promise<void>;
 
 export default Signature;

src/rollback/index.ts

@@ -3,15 +3,15 @@ import FacadeConfig from '../FacadeConfig';
 import getLastBatchKeys from '../utils/getLastBatchKeys';
 import handleLocks from '../utils/handleLocks';
 import rollbackKey from '../utils/rollbackKey';
-import Signature from './Signature';
+import Signature, { Opts } from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async () => {
+  return async ({ dryRun = false }: Opts = {}) => {
     await handleLocks(config, async () => {
       const lastBatchKeys = await getLastBatchKeys(config);
 
       await Promise.resolve(reduce(lastBatchKeys, async (_result, key) => {
-        await rollbackKey({ config, key });
+        await rollbackKey({ config, key, dryRun });
       }, Promise.resolve()));
     });
   };

src/rollback/test.ts

@@ -37,6 +37,12 @@ const testRollback: TestFactory = (createService) => {
       await assertRejects(promise, MissingMigrationError);
     });
 
+    it('should not error when the migration fails during a dry run', async () => {
+      const service = createService([failingMigration]);
+      await service.migrate();
+      await service.rollback({ dryRun: true });
+    });
+
     it('should error when the first migration errors', async () => {
       const service = createService([failingMigration, successfulMigration]);
       await service.migrate();

src/rollbackByKey/Signature.ts

@@ -1,6 +1,7 @@
 export interface Opts {
   readonly key: string;
   readonly force?: boolean;
+  readonly dryRun?: boolean;
 }
 
 type Signature = (opts: Opts) => Promise<void>;