Refactor migrator to pass only repo's path into migration and not datastore instance.

License: MIT
Signed-off-by: Adam Uhlir <uhlir.a@gmail.com>

Author: AuHau

package.json

@@ -12,7 +12,11 @@
   "bin": {
     "jsipfs-migrations": "./src/cli.js"
   },
-  "browser": {},
+  "browser": {
+    "./src/option-node.js": "./src/option-browser.js",
+    "./src/repo/lock.js": "./src/repo/lock-memory.js",
+    "datastore-fs": "datastore-level"
+  },
   "scripts": {
     "test": "aegir test",
     "test:node": "aegir test --target node",

src/commands.js

@@ -1,22 +1,14 @@
+'use strict'
+
 const os = require('os')
 const path = require('path')
 const process = require('process')
 
-const datastore = require('datastore-fs')
 const chalk = require('chalk')
-const log = require('debug')('js-ipfs-repo-migrations:commands')
 
-const repo_version = require('./repo/version')
+const repoVersion = require('./repo/version')
 const migrator = require('./index')
 
-function getRepoRootStore(dir) {
-  const repoPath = dir || process.env.IPFS_PATH || path.join(os.homedir(), '.jsipfs')
-  log(`Operating with repo on path: ${repoPath}`)
-
-  // Will throw error if does not exist
-  return new datastore(repoPath, {extension: '', createIfMissing: false})
-}
-
 function asyncClosure(fnc) {
   return function asyncWrapper({resolve, ...options}) {
     resolve(fnc(options))
@@ -29,24 +21,24 @@ function reportingClosure(action){
 }
 
 async function migrate({repoPath, ver, dry}) {
-  const store = getRepoRootStore(repoPath)
-  await migrator.migrate(store, ver, reportingClosure(dry ? 'loaded migration' : 'migrated to version'), dry)
+  repoPath = repoPath || process.env.IPFS_PATH || path.join(os.homedir(), '.jsipfs')
+  await migrator.migrate(repoPath, ver, reportingClosure(dry ? 'loaded migration' : 'migrated to version'), dry)
 }
 
 async function revert({repoPath, ver, dry}) {
-  const store = getRepoRootStore(repoPath)
-  await migrator.revert(store, ver, reportingClosure(dry ? 'loaded migration' : 'reverted to version'), dry)
+  repoPath = repoPath || process.env.IPFS_PATH || path.join(os.homedir(), '.jsipfs')
+  await migrator.revert(repoPath, ver, reportingClosure(dry ? 'loaded migration' : 'reverted to version'), dry)
 }
 
 async function status({repoPath}) {
-  const store = getRepoRootStore(repoPath)
+  repoPath = repoPath || process.env.IPFS_PATH || path.join(os.homedir(), '.jsipfs')
 
-  const repoVersion = await repo_version.getVersion(store)
+  const version = await repoVersion.getVersion(repoPath)
   const lastMigrationVersion = migrator.getLatestMigrationVersion()
   const statusString =
-    repoVersion < lastMigrationVersion ? chalk.yellow('There are migrations to be applied!') : chalk.green('Nothing to migrate!')
+    version < lastMigrationVersion ? chalk.yellow('There are migrations to be applied!') : chalk.green('Nothing to migrate!')
 
-  return `${statusString}\nCurrent repo version: ${repoVersion}\nLast migration's version: ${lastMigrationVersion}`
+  return `${statusString}\nCurrent repo version: ${version}\nLast migration's version: ${lastMigrationVersion}`
 }
 
 module.exports = {

src/errors.js

@@ -1,23 +1,26 @@
 'use strict'
 
-exports = module.exports
-
+/**
+ * Exception raised when trying to revert migration that is not possible
+ * to revert.
+ */
 class NonReversibleMigration extends Error {
   constructor (message) {
     super(message)
     this.name = 'NonReversibleMigration'
     this.message = message
   }
 }
-
 exports.NonReversibleMigration = NonReversibleMigration
 
+/**
+ * Exception raised when structure of a repo is not as expected.
+ */
 class UnknownRepoStructure extends Error {
   constructor (message) {
     super(message)
     this.name = 'UnknownRepoStructure'
     this.message = message
   }
 }
-
 exports.UnknownRepoStructure = UnknownRepoStructure

src/index.js

@@ -1,33 +1,47 @@
 'use strict'
 
 const migrations = require('../migrations')
-const repo_version = require('./repo/version')
-const repo_lock = require('./repo/lock')
+const repoVersion = require('./repo/version')
+const repoLock = require('./repo/lock')
+const isBrowser = require('./option-node')
+const errors = require('./errors')
 const debug = require('debug')
 
 const log = debug('js-ipfs-repo-migrations:migrator')
 
-exports.getLatestMigrationVersion = getLatestMigrationVersion
 
 /**
  * Returns the version of latest migration.
  *
- * @returns int
+ * @returns {int}
  */
 function getLatestMigrationVersion() {
   return migrations[migrations.length - 1].version
 }
+exports.getLatestMigrationVersion = getLatestMigrationVersion
 
-async function migrate(store, toVersion, progressCb, isDryRun) {
+/**
+ * Main function to execute forward migrations.
+ * It acquire lock on the provided path before doing any migrations.
+ *
+ * Signature of the progress callback is: function(migrationObject: object, currentMigrationNumber: int, totalMigrationsCount: int)
+ *
+ * @param {string} path - Path to initialized (!) JS-IPFS repo
+ * @param {int|undefined} toVersion - Version to which the repo should be migrated, if undefined repo will be migrated to the latest version.
+ * @param {function|undefined} progressCb - Callback which will be called after each executed migration to report progress
+ * @param {boolean|undefined} isDryRun - Allows to simulate the execution of the migrations without any effect.
+ * @returns {Promise<void>}
+ */
+async function migrate(path, toVersion, progressCb, isDryRun) {
   if (toVersion && (!Number.isInteger(toVersion) || toVersion <= 0)) {
     throw new Error('Version has to be positive integer!')
   }
   toVersion = toVersion || getLatestMigrationVersion()
 
-  const currentVersion = await repo_version.getVersion(store)
+  const currentVersion = await repoVersion.getVersion(path)
 
   let lock
-  if (!isDryRun) lock = await repo_lock.lock(currentVersion, store.path)
+  if (!isDryRun) lock = await repoLock.lock(currentVersion, path)
 
   if (currentVersion === toVersion) {
     log('Nothing to migrate, skipping migrations.')
@@ -44,7 +58,7 @@ async function migrate(store, toVersion, progressCb, isDryRun) {
       log(`Migrating version ${migration.version}`)
       if (!isDryRun) {
         try {
-          await migration.migrate(store)
+          await migration.migrate(path, isBrowser)
         } catch (e) {
           e.message = `During migration to version ${migration.version} exception was raised: ${e.message}`
           throw e
@@ -55,16 +69,26 @@ async function migrate(store, toVersion, progressCb, isDryRun) {
     }
   }
 
-  if (!isDryRun) await repo_version.setVersion(store, toVersion || getLatestMigrationVersion())
+  if (!isDryRun) await repoVersion.setVersion(path, toVersion || getLatestMigrationVersion())
   log('All migrations successfully migrated ', toVersion !== undefined ? `to version ${toVersion}!` : 'to latest version!')
 
   if (!isDryRun) await lock.close()
-  await store.close()
 }
-
 exports.migrate = migrate
 
-async function revert(store, toVersion, progressCb, isDryRun) {
+/**
+ * Main function to execute backward migration (reversion).
+ * It acquire lock on the provided path before doing any migrations.
+ *
+ * Signature of the progress callback is: function(migrationObject: object, currentMigrationNumber: int, totalMigrationsCount: int)
+ *
+ * @param {string} path - Path to initialized (!) JS-IPFS repo
+ * @param {int} toVersion - Version to which the repo will be reverted.
+ * @param {function|undefined} progressCb - Callback which will be called after each reverted migration to report progress
+ * @param {boolean|undefined} isDryRun - Allows to simulate the execution of the reversion without any effect.
+ * @returns {Promise<void>}
+ */
+async function revert(path, toVersion, progressCb, isDryRun) {
   if (!toVersion) {
     throw new Error('When reverting migrations, you have to specify to which version to revert!')
   }
@@ -73,19 +97,19 @@ async function revert(store, toVersion, progressCb, isDryRun) {
     throw new Error('Version has to be positive integer!')
   }
 
-  const currentVersion = await repo_version.getVersion(store)
+  const currentVersion = await repoVersion.getVersion(path)
   if (currentVersion === toVersion) {
     log('Nothing to revert, skipping reverting.')
     return
   }
 
   let {reversible, problematicMigration} = verifyReversibility(currentVersion, toVersion)
   if (!reversible) {
-    throw new Error(`Migration version ${problematicMigration} is not possible to revert! Cancelling reversion.`)
+    throw new errors.NonReversibleMigration(`Migration version ${problematicMigration} is not possible to revert! Cancelling reversion.`)
   }
 
   let lock
-  if (!isDryRun) lock = await repo_lock.lock(currentVersion, store.path)
+  if (!isDryRun) lock = await repoLock.lock(currentVersion, path)
   let counter = 0, totalMigrations = currentVersion - toVersion
   const reversedMigrationArray = migrations.reverse()
   for (let migration of reversedMigrationArray) {
@@ -98,7 +122,7 @@ async function revert(store, toVersion, progressCb, isDryRun) {
       log(`Reverting migration version ${migration.version}`)
       if (!isDryRun) {
         try {
-          await migration.revert(store)
+          await migration.revert(path, isBrowser)
         } catch (e) {
           e.message = `During reversion to version ${migration.version} exception was raised: ${e.message}`
           throw e
@@ -109,15 +133,20 @@ async function revert(store, toVersion, progressCb, isDryRun) {
     }
   }
 
-  if (!isDryRun) await repo_version.setVersion(store, toVersion)
+  if (!isDryRun) await repoVersion.setVersion(path, toVersion)
   log(`All migrations successfully reverted to version ${toVersion}!`)
 
   if (!isDryRun) await lock.close()
-  await store.close()
 }
-
 exports.revert = revert
 
+/**
+ * Function checks if all migrations in given range supports reversion.
+ *
+ * @param {int} fromVersion
+ * @param {int} toVersion
+ * @returns {object}
+ */
 function verifyReversibility(fromVersion, toVersion) {
   const reversedMigrationArray = migrations.reverse()
   for (let migration of reversedMigrationArray) {

src/option-browser.js

@@ -0,0 +1,2 @@
+'use strict'
+exports = true

src/option-node.js

@@ -0,0 +1,2 @@
+'use strict'
+exports = false

src/repo/version.js

@@ -1,4 +1,7 @@
+'use strict'
+
 const errors = require('../errors')
+const Datastore = require('datastore-fs')
 
 const Key = require('interface-datastore').Key
 
@@ -11,27 +14,35 @@ exports.getVersion = getVersion
  * This function needs to be cross-repo-version functional to be able to fetch any version number,
  * even in case of change of repo's versioning.
  *
- * @param {FsDatastore|LevelDatastore} store
- * @returns Promise<int>
+ * @param {string} path
+ * @returns {Promise<int>}
  */
-async function getVersion(store) {
+async function getVersion(path) {
+  const store = new Datastore(path, {extension: '', createIfMissing: false})
+  await store.open()
 
   if (!await store.has(versionKey)) {
     throw new errors.UnknownRepoStructure('Repo does not have version file! Is the repo initialized?')
   }
 
-  return parseInt(await store.get(versionKey))
+  const version = parseInt(await store.get(versionKey))
+  await store.close()
+
+  return version
 }
 
 /**
  * Function for setting a version in cross-repo-version manner.
  *
- * @param {FsDatastore|LevelDatastore} store
+ * @param {string} path
  * @param {int} version
- * @returns {Promise<Promise<void>|*|void|IDBRequest<IDBValidKey>|Promise<void>>}
+ * @returns {Promise<void>}
  */
-async function setVersion(store, version) {
-  return store.put(versionKey, Buffer.from(String(version)))
+async function setVersion(path, version) {
+  const store = new Datastore(path, {extension: '', createIfMissing: false})
+  await store.open()
+  await store.put(versionKey, Buffer.from(String(version)))
+  await store.close()
 }
 
 exports.setVersion = setVersion