@bitfinex/bfx-facs-auth-google 1.2.3 → 2.0.0

package/index.js

@@ -6,25 +6,14 @@ const assert = require('assert')
 const _ = require('lodash')
 const async = require('async')
 const crypto = require('crypto')
-const DbBase = require('bfx-facs-db-sqlite')
+const DbBase = require('@bitfinex/bfx-facs-db-sqlite')
 const uuidv4 = require('uuid/v4')
+const { cloneDeep } = require('@bitfinex/lib-js-util-base')
 const { google } = require('googleapis')
-const { UserError } = require('./errors')
 const migrations = require('./migrations')
-const { cloneDeep } = require('@bitfinexcom/lib-js-util-base')
-
-const FORMS_FIELD = 'forms'
-
-async function hash (password, salt = '') {
-  return new Promise((resolve, reject) => {
-    const computedSalt = salt || crypto.randomBytes(8).toString('hex')
-
-    crypto.scrypt(password, computedSalt, 64, (err, derivedKey) => {
-      if (err) reject(err)
-      resolve(computedSalt + ':' + derivedKey.toString('hex'))
-    })
-  })
-}
+const AdminUserRepository = require('./src/admin-user-repo')
+const PrivilegeRepository = require('./src/privilege-repo')
+const AdminPrivilegeRepository = require('./src/admin-privilege-repo')
 
 async function verify (password, hash) {
   return new Promise((resolve, reject) => {
@@ -36,26 +25,7 @@ async function verify (password, hash) {
   })
 }
 
-const tableName = 'admin_users'
 /**
- * @typedef {{
- *  email: string,
- *  level: number,
- *  readOnly?: boolean,
- *  blockPrivilege?: boolean,
- *  analyticsPrivilege?: boolean,
- *  manageAdminsPrivilege?: boolean,
- *  fetchMotivationsPrivilege?: boolean,
- *  passwordResetToken?: string,
- *  passwordResetSentAt?: Date,
- *  company?: string,
- *  forms?: string[]
- * }} BaseAdminT
- * @typedef { BaseAdminT & { password: string }} AddAdminT
- * @typedef { BaseAdminT & {
- *  active: boolean,
- *  id: number
- * }} AddedAdminT
  * @typedef {{ username: string, password: string }} LoginUserT
  * @typedef {{
  *  access_token: string | null;
@@ -70,7 +40,7 @@ const tableName = 'admin_users'
  *  id_token?: string | null;
  *  scope?: string;
  * }} TokenCredentials
- * @typedef { AddedAdminT & {
+ * @typedef { AdminUserRepository.AddedAdminT & {
  *  username: string,
  *  token: string,
  *  expires_at: Date
@@ -80,23 +50,7 @@ class GoogleAuth extends DbBase {
   constructor (caller, opts = {}, ctx) {
     opts.name = 'auth-google'
     opts.runSqlAtStart = [
-      `CREATE TABLE IF NOT EXISTS ${tableName} (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        email TEXT UNIQUE NOT NULL,
-        password TEXT,
-        level INTEGER NOT NULL,
-        active TINYINTEGER DEFAULT 1,
-        readOnly TINYINTEGER,
-        blockPrivilege TINYINTEGER,
-        analyticsPrivilege TINYINTEGER,
-        manageAdminsPrivilege TINYINTEGER,
-        passwordResetToken TEXT,
-        passwordResetSentAt DATETIME,
-        company TEXT,
-        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-        ${FORMS_FIELD} TEXT
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS uidx_email ON ${tableName}(email ASC)`
+      ...AdminUserRepository.runSqlAtStart
     ]
     super(caller, opts, ctx)
 
@@ -218,6 +172,11 @@ class GoogleAuth extends DbBase {
         }
       },
       super._start.bind(this),
+      async () => {
+        this.adminUserRepo = new AdminUserRepository(this.db, this.conf)
+        this.privilegeRepo = new PrivilegeRepository(this.db, this.conf)
+        this.adminPrivilegeRepo = new AdminPrivilegeRepository(this.db, this.conf)
+      },
       cb => {
         this.runMigrations(migrations, cb)
       },
@@ -238,9 +197,9 @@ class GoogleAuth extends DbBase {
   /**
    * @param {{ user: LoginUserT, google: Credentials, ip: number }} args
    * @param { (err: null|Error, res: LoginResp) => void } cb
-   * @returns { void }
+   * @returns { Promise<void> }
    */
-  loginAdmin (args, cb) {
+  async loginAdmin (args, cb) {
     const { user, google, ip } = args
 
     if (!user && !google) {
@@ -292,7 +251,7 @@ class GoogleAuth extends DbBase {
         : cb(new Error('AUTH_FAC_ACCOUNT_IS_NOT_VALID'))
     } catch (e) {
       console.log(e)
-      cb(new Error('AUTH_FAC_INCORRECT_GOOGLE_TOKEN'))
+      cb(new Error('AUTH_FAC_ACCOUNT_IS_NOT_VALID'))
     }
   }
 
@@ -304,7 +263,8 @@ class GoogleAuth extends DbBase {
     const query = { username, token, ip, level, expires_at: exp }
     try {
       await this._createUniqueAndExpireDbToken(query)
-      return cb(null, { username, token, level, ...extra, expires_at: exp })
+      const privileges = await this.adminPrivilegeRepo.getAdminPrivileges(extra.id)
+      return cb(null, { username, token, level, privileges, ...extra, expires_at: exp })
     } catch (e) {
       return cb(new Error('AUTH_FAC_ADMIN_TOKEN_CREATE_ERROR'))
     }
@@ -464,7 +424,7 @@ class GoogleAuth extends DbBase {
   async _saveAdminsFromConfig () {
     const admins = this.conf.ADM_USERS
     if (!(admins && Array.isArray(admins))) return true
-    const adminDbHasData = await this._checkIfAdminDbHasData()
+    const adminDbHasData = await this.adminUserRepo.doesAdminDbHaveData()
     if (adminDbHasData) return true
 
     const tasks = admins.map(async (admin) => {
@@ -479,236 +439,37 @@ class GoogleAuth extends DbBase {
   }
 
   /**
-   * @param { AddAdminT } user
-   * @returns { Promise<AddedAdminT> }
+   * @param { AdminUserRepository.AddAdminT } user
+   * @returns { Promise<AdminUserRepository.AddedAdminT> }
    */
   async addAdmin (user) {
     assert.ok(this.conf.useDB, 'Cannot add admins if DB is not available')
 
-    const {
-      email,
-      password,
-      level,
-      readOnly,
-      blockPrivilege,
-      analyticsPrivilege,
-      manageAdminsPrivilege,
-      fetchMotivationsPrivilege,
-      company
-    } = user
-
-    assert.ok(typeof email === 'string', 'Email is required')
-    assert.ok(typeof level === 'number', 'Level must be a number')
-
-    if (password) {
-      assert.ok(typeof password === 'string', 'Password should be a string')
-    }
-
-    if (readOnly) {
-      assert.ok(typeof readOnly === 'boolean', 'readOnly should be a boolean')
-    }
-
-    if (blockPrivilege) {
-      assert.ok(typeof blockPrivilege === 'boolean', 'blockPrivilege should be a boolean')
-    }
-
-    if (analyticsPrivilege) {
-      assert.ok(typeof analyticsPrivilege === 'boolean', 'analyticsPrivilege should be a boolean')
-    }
-
-    if (manageAdminsPrivilege) {
-      assert.ok(typeof manageAdminsPrivilege === 'boolean', 'manageAdminsPrivilege should be a boolean')
-    }
-
-    if (fetchMotivationsPrivilege) {
-      assert.ok(typeof fetchMotivationsPrivilege === 'boolean', 'fetchMotivationsPrivilege should be a boolean')
-    }
-
-    if (company) {
-      assert.ok(typeof company === 'string', 'company should be a string')
-    }
-
-    const adm = await this._getAdmin(email, false)
-    if (adm) throw new UserError('ADMIN_ACCOUNT_EXISTS')
-
-    const hashedPassword = password
-      ? await hash(password, this.conf.hashSalt)
-      : null
-
-    user.password = hashedPassword
-
-    return new Promise((resolve, reject) => {
-      const keys = Object.keys(user)
-
-      this.db.run(
-        `INSERT INTO ${tableName} (${keys.join(', ')}) VALUES (${Array(keys.length).fill('?').join(', ')})`,
-        keys.map(key => key === FORMS_FIELD ? JSON.stringify(user[key]) : user[key]),
-        function (err) {
-          if (err) return reject(err)
-
-          resolve({
-            email,
-            level,
-            readOnly,
-            blockPrivilege,
-            analyticsPrivilege,
-            manageAdminsPrivilege,
-            fetchMotivationsPrivilege,
-            company,
-            active: true,
-            id: this.lastID
-          })
-        }
-      )
-    })
+    return this.adminUserRepo.add(user)
   }
 
   async updateAdmin (email, user) {
-    assert.ok(this.conf.useDB, 'Cannot add admins if DB is not available')
-
-    const {
-      password,
-      level,
-      readOnly,
-      blockPrivilege,
-      analyticsPrivilege,
-      manageAdminsPrivilege,
-      fetchMotivationsPrivilege,
-      company,
-      active
-    } = user
-
-    assert.ok(typeof email === 'string', 'Email is required')
-
-    if (user.email) {
-      throw new UserError('Email cannot be updated')
-    }
-
-    if (password) {
-      throw new UserError('Use Change Password endpoint to update user password')
-    }
-
-    if (level) {
-      assert.ok(typeof level === 'number', 'Level must be a number')
-    }
-
-    if (readOnly) {
-      assert.ok(typeof readOnly === 'boolean', 'readOnly should be a boolean')
-    }
-
-    if (blockPrivilege) {
-      assert.ok(typeof blockPrivilege === 'boolean', 'blockPrivilege should be a boolean')
-    }
-
-    if (analyticsPrivilege) {
-      assert.ok(typeof analyticsPrivilege === 'boolean', 'analyticsPrivilege should be a boolean')
-    }
-
-    if (manageAdminsPrivilege) {
-      assert.ok(typeof manageAdminsPrivilege === 'boolean', 'manageAdminsPrivilege should be a boolean')
-    }
+    assert.ok(this.conf.useDB, 'Cannot update admins if DB is not available')
 
-    if (fetchMotivationsPrivilege) {
-      assert.ok(typeof fetchMotivationsPrivilege === 'boolean', 'fetchMotivationsPrivilege should be a boolean')
-    }
-
-    if (company) {
-      assert.ok(typeof company === 'string', 'company should be a string')
-    }
-
-    if (active) {
-      assert.ok(typeof active === 'boolean', 'active should be a boolean')
-    }
-
-    const adm = await this._getAdmin(email, !active)
-    if (!adm) throw new UserError('ADMIN_ACCOUNT_DOES_NOT_EXIST_OR_IS_NOT_ACTIVE')
-
-    return new Promise((resolve, reject) => {
-      const keys = Object.keys(user)
-
-      this.db.run(
-        `UPDATE ${tableName} SET ${keys.join(' = ?, ')} = ? WHERE id = ?`,
-        keys.map(key => user[key]).concat(adm.id),
-        function (err) {
-          if (err) return reject(err)
-
-          resolve(user)
-        }
-      )
-    })
+    return this.adminUserRepo.update(email, user)
   }
 
   async updateAdminPassword (email, newPassword, oldPassword) {
-    assert.ok(this.conf.useDB, 'Cannot add admins if DB is not available')
-
-    assert.ok(typeof email === 'string', 'Email is required')
-    assert.ok(typeof newPassword === 'string', 'New Password is required')
-    assert.ok(typeof oldPassword === 'string', 'Old Password is required')
-
-    const adm = await this._getAdmin(email)
-    if (!adm) throw new UserError('ADMIN_ACCOUNT_DOES_NOT_EXIST_OR_IS_NOT_ACTIVE')
-
-    if (!(await verify(oldPassword, adm.password))) {
-      throw new UserError('INVALID_PASSWORD')
-    }
+    assert.ok(this.conf.useDB, 'Cannot update admins if DB is not available')
 
-    const password = await hash(newPassword, this.conf.hashSalt)
-
-    return new Promise((resolve, reject) => {
-      this.db.run(
-        `UPDATE ${tableName} SET password = ? WHERE id = ?`,
-        [password, adm.id],
-        function (err) {
-          if (err) return reject(err)
-
-          resolve(true)
-        }
-      )
-    })
+    return this.adminUserRepo.updatePassword(email, newPassword, oldPassword)
   }
 
   async resetAdminPassword (email, newPassword, passwordResetToken) {
-    assert.ok(this.conf.useDB, 'Cannot add admins if DB is not available')
-
-    assert.ok(typeof email === 'string', 'Email is required')
-    assert.ok(typeof newPassword === 'string', 'New Password is required')
-
-    const admin = await this._getAdmin(email)
-    if (!admin) throw new UserError('ADMIN_ACCOUNT_DOES_NOT_EXIST_OR_IS_NOT_ACTIVE')
-    if (admin.passwordResetToken !== passwordResetToken) throw new UserError('INVALID_passwordResetToken')
-    const expiryDate = new Date(admin.passwordResetSentAt)
-    expiryDate.setDate(expiryDate.getDate() + 1)
-    if (Date.now() > expiryDate) throw new UserError('RESET_LINK_EXPIRED')
-
-    const password = await hash(newPassword, this.conf.hashSalt)
-
-    return new Promise((resolve, reject) => {
-      this.db.run(
-        `UPDATE ${tableName} SET password = ? WHERE id = ?`,
-        [password, admin.id],
-        function (err) {
-          if (err) return reject(err)
+    assert.ok(this.conf.useDB, 'Cannot update admins if DB is not available')
 
-          resolve(true)
-        }
-      )
-    })
+    return this.adminUserRepo.resetPassword(email, newPassword, passwordResetToken)
   }
 
   async removeAdmin (idOrEmail) {
     assert.ok(this.conf.useDB, 'Cannot remove admins if DB is not available')
 
-    return new Promise((resolve, reject) => {
-      this.db.serialize(() => {
-        const statement = this.db.prepare(`DELETE FROM ${tableName} WHERE id = ? OR LOWER(email) = ?`)
-        statement.run([idOrEmail, `${idOrEmail}`.toLowerCase()])
-        statement.finalize(err => {
-          if (err) return reject(err)
-
-          resolve(idOrEmail)
-        })
-      })
-    })
+    return this.adminUserRepo.remove(idOrEmail)
   }
 
   async basicAuthAdmLogCheck (sentEmail, sentPassword) {
@@ -769,36 +530,35 @@ class GoogleAuth extends DbBase {
     return !!(admin.level === 0 && admin.manageAdminsPrivilege)
   }
 
-  async checkAdmHasFetchMotivationsPrivilege (adminEmail) {
+  async checkAdmHasCasesPrivilege (adminEmail) {
     const admin = await this._getAdmin(adminEmail)
     if (!admin) throw new Error('Searched admin was not found')
 
-    return !!(admin.level === 0 || admin.fetchMotivationsPrivilege)
+    return !!(admin.level === 0 && admin.casesPrivilege)
   }
 
-  _checkIfAdminDbHasData () {
-    return new Promise((resolve, reject) => {
-      const query = `SELECT EXISTS(SELECT 1 FROM ${tableName}) as exist`
-      this.db.get(query, (err, row) => {
-        if (err) return reject(err)
-        resolve(row?.exist)
-      })
-    })
+  async checkAdmHasFetchMotivationsPrivilege (adminEmail) {
+    const admin = await this._getAdmin(adminEmail)
+    if (!admin) throw new Error('Searched admin was not found')
+
+    return !!(admin.level === 0 || admin.fetchMotivationsPrivilege)
   }
 
   /**
    * @param { string|number } emailOrId - Identifier used for searching the admin, it can be either the admin email address or its database id.
    * @param { boolean } [active=true] - Flag for considering only the active users, it is `true` by default. If `false`, it will search through inactive users too.
    * @param { boolean } [id=false] - Flag for searching as well by id criterion, it's `false` by default. If `true`, enables the mentioned behavior.
-   * @returns { Promise<BaseAdminT & { timestamp: Date, active: boolean }> }
+   * @returns { Promise<AdminUserRepository.BaseAdminT & { timestamp: Date, active: boolean }> }
    */
   async getAdmin (emailOrId, active = true, id = false) {
     const admin = await this._getAdmin(emailOrId, active, id)
-    const displayKeys = ['email', 'level', 'blockPrivilege', 'company',
-      'analyticsPrivilege', 'manageAdminsPrivilege', 'fetchMotivationsPrivilege', 'readOnly', 'active', 'timestamp', FORMS_FIELD]
+    const displayKeys = ['id', 'email', 'level', 'blockPrivilege', 'company',
+      'analyticsPrivilege', 'manageAdminsPrivilege', 'casesPrivilege', 'fetchMotivationsPrivilege', 'readOnly', 'active', 'timestamp', AdminUserRepository.FORMS_FIELD, 'whitelistedIps']
 
-    if (this.conf.useDB && admin && admin[FORMS_FIELD]) {
-      admin[FORMS_FIELD] = JSON.parse(admin[FORMS_FIELD])
+    if (this.conf.useDB && admin) {
+      for (const field of AdminUserRepository.JSON_FIELDS) {
+        if (admin[field]) admin[field] = JSON.parse(admin[field])
+      }
     }
 
     return admin
@@ -810,32 +570,10 @@ class GoogleAuth extends DbBase {
     if (!emailOrId) return false
 
     return this.conf.useDB
-      ? this._getAdminFromDB(emailOrId, active, id)
+      ? this.adminUserRepo.getAdmin(emailOrId, active, id)
       : this._getAdminFromConfig(emailOrId)
   }
 
-  async _getAdminFromDB (emailOrId, active, id) {
-    return new Promise((resolve, reject) => {
-      const identifierCondition = id
-        ? '(LOWER(email) = ? OR id = ?)'
-        : 'LOWER(email) = ?'
-
-      const query = active
-        ? `SELECT * FROM ${tableName} WHERE ${identifierCondition} AND active = 1`
-        : `SELECT * FROM ${tableName} WHERE ${identifierCondition}`
-
-      const params = [String(emailOrId).toLowerCase()]
-      if (id) {
-        params.push(emailOrId)
-      }
-
-      this.db.get(query, params, (err, row) => {
-        if (err) return reject(err)
-        resolve(row)
-      })
-    })
-  }
-
   _getAdminFromConfig (email) {
     const admins = this.conf.ADM_USERS || []
 
@@ -848,33 +586,10 @@ class GoogleAuth extends DbBase {
 
   async getAdminEmails (active = true, company) {
     return this.conf.useDB
-      ? this._getAdminEmailsFromDB(active, company)
+      ? this.adminUserRepo.getAdminEmails(active, company)
       : this._getAdminEmailsFromConfig(company)
   }
 
-  async _getAdminEmailsFromDB (active, company) {
-    return new Promise((resolve, reject) => {
-      const whereClause = [['active', active && 1], ['company', company && `'${company}'`]].reduce((query, prop) => {
-        if (prop[1]) {
-          if (query.length) {
-            query += ' AND '
-          }
-          query += `${prop[0]} = ${prop[1]}`
-        }
-        return query
-      }, '')
-
-      const query = active || company
-        ? `SELECT LOWER(email) AS email FROM ${tableName} WHERE ${whereClause} ORDER BY email ASC`
-        : `SELECT LOWER(email) AS email FROM ${tableName} ORDER BY email ASC`
-
-      this.db.all(query, [], (err, rows) => {
-        if (err) return reject(err)
-        resolve((rows || []).map(row => row.email))
-      })
-    })
-  }
-
   async _getAdminEmailsFromConfig (company) {
     const admins = this.conf.ADM_USERS || []
     return admins
@@ -891,6 +606,77 @@ class GoogleAuth extends DbBase {
     const admin = await this._getAdmin(email)
     return !!admin?.password
   }
+
+  addPrivilege (name) {
+    return this.privilegeRepo.add({ name })
+  }
+
+  getAllPrivileges () {
+    return this.privilegeRepo.findAll()
+  }
+
+  /**
+   *
+   * @param {string} emailOrId
+   * @param {number} privilegeId
+   * @returns {Promise<{ admin: emailOrId, privilege: string }>}
+   */
+  async assignAdminPrivilege (emailOrId, privilegeId) {
+    const admin = await this.adminUserRepo.getAdmin(emailOrId, true, true)
+    if (!admin) throw new Error('INVALID_ADMIN')
+
+    const privilege = await this.privilegeRepo.findById(privilegeId)
+    if (!privilege) throw new Error('INVALID_PRIVILEGE_ID')
+
+    await this.adminPrivilegeRepo.add({ adminId: admin.id, privilegeId: privilege.id })
+    return { admin: emailOrId, privilege: privilege.name }
+  }
+
+  /**
+   *
+   * @param {string} emailOrId
+   * @param {number} privilegeId
+   * @returns {Promise<{ admin: emailOrId, privilege: string }>}
+   */
+  async unAssignAdminPrivilege (emailOrId, privilegeId) {
+    const admin = await this.adminUserRepo.getAdmin(emailOrId, true, true)
+    if (!admin) throw new Error('INVALID_ADMIN')
+
+    const privilege = await this.privilegeRepo.findById(privilegeId)
+    if (!privilege) throw new Error('INVALID_PRIVILEGE_ID')
+
+    await this.adminPrivilegeRepo.remove(admin.id, privilege.id)
+    return { admin: emailOrId, privilege: privilege.name }
+  }
+
+  /**
+   *
+   * @param {string} emailOrId
+   * @param {string} privilege
+   * @returns {Promise<Boolean>}
+   */
+  async checkAdminHasRequiredPrivilege (emailOrId, privilege) {
+    const admin = await this.adminUserRepo.getAdmin(emailOrId, true, true)
+    if (!admin) throw new Error('INVALID_ADMIN')
+
+    const adminPrivilege = await this.adminPrivilegeRepo.findAdminPrivilege(admin.id, privilege)
+    return Boolean(adminPrivilege)
+  }
+
+  /**
+   * @param { string } email
+   * @param { boolean } [active=true]
+   * @param { boolean } [id=false]
+   * @returns {Promise<AdminUserRepository.BaseAdminT & {timestamp: Date, active: boolean, privileges: Array<{id: number, name: string}>}>}
+   */
+  async getAdminWithPrivileges (email, active = true, id = false) {
+    const admin = await this.getAdmin(email, active, id)
+    if (!admin) return admin
+
+    const privileges = await this.adminPrivilegeRepo.getAdminPrivileges(admin.id)
+
+    return { ...admin, privileges }
+  }
 }
 
 module.exports = GoogleAuth

package/migrations.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const tableName = 'admin_users'
+const privilegesTable = 'privileges'
+const adminPrivilegeTable = 'admin_privileges'
 
 const migrations = [
   (_this, cb) => {
@@ -57,6 +59,52 @@ const migrations = [
         ADD fetchMotivationsPrivilege BOOLEAN
       `, cb)
     })
+  },
+  (_this, cb) => {
+    _this.db.all(`PRAGMA table_info(${tableName})`, [], (err, rows) => {
+      if (err) return cb(err)
+      if (rows?.find(row => row.name === 'casesPrivilege')) return cb()
+
+      _this.db.run(`
+        ALTER TABLE ${tableName}
+        ADD casesPrivilege TINYINTEGER
+      `, cb)
+    })
+  },
+  (_this, cb) => {
+    _this.db.all(`PRAGMA table_info(${tableName})`, [], (err, rows) => {
+      if (err) return cb(err)
+      if (rows?.find(row => row.name === 'whitelistedIps')) return cb()
+
+      _this.db.run(`
+        ALTER TABLE ${tableName}
+        ADD whitelistedIps TEXT
+      `, cb)
+    })
+  },
+  (_this, cb) => {
+    _this.db.exec('PRAGMA foreign_keys = ON;', cb)
+  },
+  (_this, cb) => {
+    _this.db.run(`
+      CREATE TABLE IF NOT EXISTS ${privilegesTable} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE
+      );
+    `, cb)
+  },
+  (_this, cb) => {
+    _this.db.run(`
+      CREATE TABLE IF NOT EXISTS ${adminPrivilegeTable} (
+        admin_id INTEGER NOT NULL,
+        privilege_id INTEGER NOT NULL,
+
+        PRIMARY KEY (admin_id, privilege_id),
+
+        FOREIGN KEY (admin_id) REFERENCES admin_users(id) ON DELETE CASCADE,
+        FOREIGN KEY (privilege_id) REFERENCES privileges(id) ON DELETE CASCADE
+      );
+    `, cb)
   }
 ]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitfinex/bfx-facs-auth-google",
-  "version": "1.2.3",
+  "version": "2.0.0",
   "private": false,
   "description": "Bitfinex Google Oauth Facility",
   "author": {
@@ -14,7 +14,7 @@
   "dependencies": {
     "@bitfinex/bfx-facs-base": "git+https://github.com/bitfinexcom/bfx-facs-base.git",
     "@bitfinex/bfx-facs-db-sqlite": "git+https://github.com/bitfinexcom/bfx-facs-db-sqlite.git",
-    "@bitfinexcom/lib-js-util-base": "git+https://github.com/bitfinexcom/lib-js-util-base.git",
+    "@bitfinex/lib-js-util-base": "git+https://github.com/bitfinexcom/lib-js-util-base.git",
     "async": "^2.6.4",
     "googleapis": "^68.0.0",
     "lodash": "^4.17.21",