feat: Enables logging to be passed in by facade user.

ryasmi · ryasmi · commit 408258f7e500 · 2018-03-18T19:34:25.000Z
diff --git a/src/FacadeConfig.ts b/src/FacadeConfig.ts
@@ -2,5 +2,4 @@ import RepoFacade from './RepoFacade';
 
 export default interface FacadeConfig {
   readonly repo: RepoFacade;
-  readonly log: (message: string) => void;
 }
diff --git a/src/factory.test.ts b/src/factory.test.ts
@@ -6,6 +6,6 @@ import factoryTest from './factoryTest';
 import testRepoFactory from './utils/tests/testRepoFactory';
 
 factoryTest((migrations) => {
-  const log = () => null;
-  return factory({ log, repo: testRepoFactory(migrations) });
+  const repo = testRepoFactory(migrations);
+  return factory({ repo });
 });
diff --git a/src/migrate/Signature.ts b/src/migrate/Signature.ts
@@ -1,5 +1,8 @@
+import Status from '../utils/statuses/Status';
+
 export interface Opts {
   readonly dryRun?: boolean;
+  readonly log?: (status: Status) => void;
 }
 
 type Signature = (opts?: Opts) => Promise<void>;
diff --git a/src/migrate/index.ts b/src/migrate/index.ts
@@ -1,18 +1,19 @@
 import { reduce } from 'bluebird';
 import FacadeConfig from '../FacadeConfig';
+import defaultLog from '../utils/defaultLog';
 import getUnprocessedKeys from '../utils/getUnprocessedKeys';
 import handleLocks from '../utils/handleLocks';
 import migrateKey from '../utils/migrateKey';
 import Signature, { Opts } from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async ({ dryRun = false }: Opts = {}) => {
-    await handleLocks(config, async () => {
+  return async ({ dryRun = false, log = defaultLog }: Opts = {}) => {
+    await handleLocks({ config, log }, async () => {
       const unprocessedKeys = await getUnprocessedKeys(config);
       const batchStart = new Date();
 
       await Promise.resolve(reduce(unprocessedKeys, async (_result, key) => {
-        await migrateKey({ config, key, batchStart, dryRun });
+        await migrateKey({ config, key, batchStart, dryRun, log });
       }, Promise.resolve()));
     });
   };
diff --git a/src/migrateByKey/Signature.ts b/src/migrateByKey/Signature.ts
@@ -1,7 +1,10 @@
+import Status from '../utils/statuses/Status';
+
 export interface Opts {
   readonly key: string;
   readonly force?: boolean;
   readonly dryRun?: boolean;
+  readonly log?: (status: Status) => void;
 }
 
 type Signature = (opts: Opts) => Promise<void>;
diff --git a/src/migrateByKey/index.ts b/src/migrateByKey/index.ts
@@ -1,19 +1,20 @@
 import FacadeConfig from '../FacadeConfig';
+import defaultLog from '../utils/defaultLog';
 import ProcessedMigrationError from '../utils/errors/ProcessedMigrationError';
 import handleLocks from '../utils/handleLocks';
 import hasProcessedKey from '../utils/hasProcessedKey';
 import migrateKey from '../utils/migrateKey';
 import Signature from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async ({ key, force = false, dryRun = false }) => {
-    await handleLocks(config, async () => {
+  return async ({ key, force = false, dryRun = false, log = defaultLog }) => {
+    await handleLocks({ config, log }, async () => {
       const isProcessed = await hasProcessedKey(config, key);
       if (isProcessed && !force) {
         throw new ProcessedMigrationError(key);
       }
 
-      await migrateKey({ config, key, dryRun });
+      await migrateKey({ config, key, dryRun, log });
     });
   };
 };
diff --git a/src/rollback/Signature.ts b/src/rollback/Signature.ts
@@ -1,5 +1,8 @@
+import Status from '../utils/statuses/Status';
+
 export interface Opts {
   readonly dryRun?: boolean;
+  readonly log?: (status: Status) => void;
 }
 
 type Signature = (opts?: Opts) => Promise<void>;
diff --git a/src/rollback/index.ts b/src/rollback/index.ts
@@ -1,17 +1,18 @@
 import { reduce } from 'bluebird';
 import FacadeConfig from '../FacadeConfig';
+import defaultLog from '../utils/defaultLog';
 import getLastBatchKeys from '../utils/getLastBatchKeys';
 import handleLocks from '../utils/handleLocks';
 import rollbackKey from '../utils/rollbackKey';
 import Signature, { Opts } from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async ({ dryRun = false }: Opts = {}) => {
-    await handleLocks(config, async () => {
+  return async ({ dryRun = false, log = defaultLog }: Opts = {}) => {
+    await handleLocks({ config, log }, async () => {
       const lastBatchKeys = (await getLastBatchKeys(config)).reverse();
 
       await Promise.resolve(reduce(lastBatchKeys, async (_result, key) => {
-        await rollbackKey({ config, key, dryRun });
+        await rollbackKey({ config, key, dryRun, log });
       }, Promise.resolve()));
     });
   };
diff --git a/src/rollbackByKey/Signature.ts b/src/rollbackByKey/Signature.ts
@@ -1,7 +1,10 @@
+import Status from '../utils/statuses/Status';
+
 export interface Opts {
   readonly key: string;
   readonly force?: boolean;
   readonly dryRun?: boolean;
+  readonly log?: (status: Status) => void;
 }
 
 type Signature = (opts: Opts) => Promise<void>;
diff --git a/src/rollbackByKey/index.ts b/src/rollbackByKey/index.ts
@@ -1,19 +1,20 @@
 import FacadeConfig from '../FacadeConfig';
+import defaultLog from '../utils/defaultLog';
 import UnprocessedMigrationError from '../utils/errors/UnprocessedMigrationError';
 import handleLocks from '../utils/handleLocks';
 import hasProcessedKey from '../utils/hasProcessedKey';
 import rollbackKey from '../utils/rollbackKey';
 import Signature from './Signature';
 
 export default (config: FacadeConfig): Signature => {
-  return async ({ key, force = false, dryRun = false }) => {
-    await handleLocks(config, async () => {
+  return async ({ key, force = false, dryRun = false, log = defaultLog }) => {
+    await handleLocks({ config, log }, async () => {
       const isProcessed = await hasProcessedKey(config, key);
       if (!isProcessed && !force) {
         throw new UnprocessedMigrationError(key);
       }
 
-      await rollbackKey({ config, key, dryRun });
+      await rollbackKey({ config, key, dryRun, log });
     });
   };
 };
diff --git a/src/utils/defaultLog.ts b/src/utils/defaultLog.ts
@@ -0,0 +1,32 @@
+import LockedStatus from './statuses/LockedStatus';
+import MigrationEndStatus from './statuses/MigrationEndStatus';
+import MigrationStartStatus from './statuses/MigrationStartStatus';
+import RollbackEndStatus from './statuses/RollbackEndStatus';
+import RollbackStartStatus from './statuses/RollbackStartStatus';
+import Status from './statuses/Status';
+import UnlockedCompletionStatus from './statuses/UnlockedCompletionStatus';
+import UnlockedErrorStatus from './statuses/UnlockedErrorStatus';
+
+export default (status: Status) => {
+  const log = (_message: string) => {
+    return;
+  };
+  if (status instanceof LockedStatus) {
+    log('Locked migrations');
+  } else if (status instanceof MigrationEndStatus) {
+    log(`Completed migration (${status.key})`);
+  } else if (status instanceof MigrationStartStatus) {
+    log(`Starting migration (${status.key})`);
+  } else if (status instanceof RollbackEndStatus) {
+    log(`Completed rollback (${status.key})`);
+  } else if (status instanceof RollbackStartStatus) {
+    log(`Starting rollback (${status.key})`);
+  } else if (status instanceof UnlockedCompletionStatus) {
+    log('Unlocking migratons after completion');
+  } else if (status instanceof UnlockedErrorStatus) {
+    log('Unlocking migratons after error');
+  } else {
+    /* istanbul ignore next - Unknown status */
+    return;
+  }
+};
diff --git a/src/utils/handleLocks.ts b/src/utils/handleLocks.ts
@@ -1,14 +1,23 @@
 import FacadeConfig from '../FacadeConfig';
+import LockedStatus from './statuses/LockedStatus';
+import Status from './statuses/Status';
+import UnlockedCompletionStatus from './statuses/UnlockedCompletionStatus';
+import UnlockedErrorStatus from './statuses/UnlockedErrorStatus';
 
-export default async (config: FacadeConfig, handler: () => Promise<void>) => {
+export interface Opts {
+  readonly config: FacadeConfig;
+  readonly log: (status: Status) => void;
+}
+
+export default async ({ config, log }: Opts, handler: () => Promise<void>) => {
   await config.repo.lockMigrations();
-  config.log('Locked migrations');
+  log(new LockedStatus());
   try {
     await handler();
-    config.log('Unlocked migrations after completion');
+    log(new UnlockedCompletionStatus());
     await config.repo.unlockMigrations();
   } catch (err) {
-    config.log('Unlocked migrations after error');
+    log(new UnlockedErrorStatus());
     await config.repo.unlockMigrations();
     throw err;
   }
diff --git a/src/utils/migrateKey.ts b/src/utils/migrateKey.ts
@@ -2,18 +2,22 @@ import { defaultTo } from 'lodash';
 import FacadeConfig from '../FacadeConfig';
 import FailingMigrationError from './errors/FailingMigrationError';
 import getMigrationByKey from './getMigrationByKey';
+import MigrationEndStatus from './statuses/MigrationEndStatus';
+import MigrationStartStatus from './statuses/MigrationStartStatus';
+import Status from './statuses/Status';
 
 export interface Opts {
   readonly config: FacadeConfig;
   readonly key: string;
   readonly batchStart?: Date;
   readonly dryRun: boolean;
+  readonly log: (status: Status) => void;
 }
 
-export default async ({ config, key, batchStart, dryRun }: Opts) => {
+export default async ({ config, key, batchStart, dryRun, log }: Opts) => {
   const migrations = await config.repo.getMigrations();
   const selectedMigration = getMigrationByKey(migrations, key);
-  config.log(`Starting to migrate with ${key}`);
+  log(new MigrationStartStatus(key));
   if (!dryRun) {
     const processStart = new Date();
     try {
@@ -29,5 +33,5 @@ export default async ({ config, key, batchStart, dryRun }: Opts) => {
       processStart,
     });
   }
-  config.log(`Completed migration with ${key}`);
+  log(new MigrationEndStatus(key));
 };
diff --git a/src/utils/rollbackKey.ts b/src/utils/rollbackKey.ts
@@ -1,17 +1,21 @@
 import FacadeConfig from '../FacadeConfig';
 import FailingMigrationError from './errors/FailingMigrationError';
 import getMigrationByKey from './getMigrationByKey';
+import RollbackEndStatus from './statuses/RollbackEndStatus';
+import RollbackStartStatus from './statuses/RollbackStartStatus';
+import Status from './statuses/Status';
 
 export interface Opts {
   readonly config: FacadeConfig;
   readonly key: string;
   readonly dryRun: boolean;
+  readonly log: (status: Status) => void;
 }
 
-export default async ({ config, key, dryRun }: Opts) => {
+export default async ({ config, key, dryRun, log }: Opts) => {
   const migrations = await config.repo.getMigrations();
   const migration = getMigrationByKey(migrations, key);
-  config.log(`Starting to rollback with ${key}`);
+  log(new RollbackStartStatus(key));
   if (!dryRun) {
     try {
       await migration.down();
@@ -20,5 +24,5 @@ export default async ({ config, key, dryRun }: Opts) => {
     }
   }
   await config.repo.removeProcessedMigration(key);
-  config.log(`Completed rollback with ${key}`);
+  log(new RollbackEndStatus(key));
 };
diff --git a/src/utils/statuses/LockedStatus.ts b/src/utils/statuses/LockedStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class LockedStatus extends Status {
+  constructor() {
+    super();
+  }
+}
diff --git a/src/utils/statuses/MigrationEndStatus.ts b/src/utils/statuses/MigrationEndStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class MigrationEndStatus extends Status {
+  constructor(public key: string) {
+    super();
+  }
+}
diff --git a/src/utils/statuses/MigrationStartStatus.ts b/src/utils/statuses/MigrationStartStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class MigrationStartStatus extends Status {
+  constructor(public key: string) {
+    super();
+  }
+}
diff --git a/src/utils/statuses/RollbackEndStatus.ts b/src/utils/statuses/RollbackEndStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class RollbackEndStatus extends Status {
+  constructor(public key: string) {
+    super();
+  }
+}
diff --git a/src/utils/statuses/RollbackStartStatus.ts b/src/utils/statuses/RollbackStartStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class RollbackStartStatus extends Status {
+  constructor(public key: string) {
+    super();
+  }
+}
diff --git a/src/utils/statuses/Status.ts b/src/utils/statuses/Status.ts
@@ -0,0 +1,2 @@
+// tslint:disable-next-line:no-class
+export default class Status { }
diff --git a/src/utils/statuses/UnlockedCompletionStatus.ts b/src/utils/statuses/UnlockedCompletionStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class UnlockedCompletionStatus extends Status {
+  constructor() {
+    super();
+  }
+}
diff --git a/src/utils/statuses/UnlockedErrorStatus.ts b/src/utils/statuses/UnlockedErrorStatus.ts
@@ -0,0 +1,8 @@
+import Status from './Status';
+
+// tslint:disable-next-line:no-class
+export default class UnlockedErrorStatus extends Status {
+  constructor() {
+    super();
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,4 @@ import RepoFacade from './RepoFacade';`
`2`	`2`
`3`	`3`	`export default interface FacadeConfig {`
`4`	`4`	`readonly repo: RepoFacade;`
`5`		`- readonly log: (message: string) => void;`
`6`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,8 @@`
	`1`	`+import Status from '../utils/statuses/Status';`
	`2`	`+`
`1`	`3`	`export interface Opts {`
`2`	`4`	`readonly dryRun?: boolean;`
	`5`	`+ readonly log?: (status: Status) => void;`
`3`	`6`	`}`
`4`	`7`
`5`	`8`	`type Signature = (opts?: Opts) => Promise<void>;`