chore: use monorepo organization

packages/server/lib/new-admin/graphql/resolvers/bill.resolver.js

@@ -0,0 +1,9 @@
+const bills = require('../../services/bills')
+
+const resolvers = {
+  Query: {
+    bills: (...[, { filters }]) => bills.getBills(filters)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/blacklist.resolver.js

@@ -0,0 +1,18 @@
+const blacklist = require('../../../blacklist')
+
+const resolvers = {
+  Query: {
+    blacklist: () => blacklist.getBlacklist(),
+    blacklistMessages: () => blacklist.getMessages()
+  },
+  Mutation: {
+    deleteBlacklistRow: (...[, { address }]) =>
+      blacklist.deleteFromBlacklist(address),
+    insertBlacklistRow: (...[, { address }]) =>
+      blacklist.insertIntoBlacklist(address),
+    editBlacklistMessage: (...[, { id, content }]) =>
+      blacklist.editBlacklistMessage(id, content)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/cashbox.resolver.js

@@ -0,0 +1,17 @@
+const { parseAsync } = require('json2csv')
+const cashbox = require('../../../cashbox-batches')
+const logDateFormat = require('../../../logs').logDateFormat
+
+const resolvers = {
+  Query: {
+    cashboxBatches: () => cashbox.getBatches(),
+    cashboxBatchesCsv: (...[, { from, until, timezone }]) => cashbox.getBatches(from, until)
+      .then(data => parseAsync(logDateFormat(timezone, cashbox.logFormatter(data), ['created'])))
+  },
+  Mutation: {
+    createBatch: (...[, { deviceId, cashboxCount }]) => cashbox.createCashboxBatch(deviceId, cashboxCount),
+    editBatch: (...[, { id, performedBy }]) => cashbox.editBatchById(id, performedBy)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/config.resolver.js

@@ -0,0 +1,11 @@
+const { accounts: accountsConfig, countries, languages } = require('../../config')
+
+const resolver = {
+  Query: {
+    countries: () => countries,
+    languages: () => languages,
+    accountsConfig: () => accountsConfig
+  }
+}
+
+module.exports = resolver

packages/server/lib/new-admin/graphql/resolvers/currency.resolver.js

@@ -0,0 +1,10 @@
+const { coins, currencies } = require('../../config')
+
+const resolver = {
+  Query: {
+    currencies: () => currencies,
+    cryptoCurrencies: () => coins
+  }
+}
+
+module.exports = resolver

packages/server/lib/new-admin/graphql/resolvers/customInfoRequests.resolver.js

@@ -0,0 +1,33 @@
+const authentication = require('../modules/userManagement')
+const queries = require('../../services/customInfoRequests')
+const DataLoader = require('dataloader')
+
+const customerCustomInfoRequestsLoader = new DataLoader(ids => queries.batchGetAllCustomInfoRequestsForCustomer(ids), { cache: false })
+
+const customInfoRequestLoader = new DataLoader(ids => queries.batchGetCustomInfoRequest(ids), { cache: false })
+
+const resolvers = {
+  Customer: {
+    customInfoRequests: parent => customerCustomInfoRequestsLoader.load(parent.id)
+  },
+  CustomRequestData: {
+    customInfoRequest: parent => customInfoRequestLoader.load(parent.infoRequestId)
+  },
+  Query: {
+    customInfoRequests: (...[, { onlyEnabled }]) => queries.getCustomInfoRequests(onlyEnabled),
+    customerCustomInfoRequests: (...[, { customerId }]) => queries.getAllCustomInfoRequestsForCustomer(customerId),
+    customerCustomInfoRequest: (...[, { customerId, infoRequestId }]) => queries.getCustomInfoRequestForCustomer(customerId, infoRequestId)
+  },
+  Mutation: {
+    insertCustomInfoRequest: (...[, { customRequest }]) => queries.addCustomInfoRequest(customRequest),
+    removeCustomInfoRequest: (...[, { id }]) => queries.removeCustomInfoRequest(id),
+    editCustomInfoRequest: (...[, { id, customRequest }]) => queries.editCustomInfoRequest(id, customRequest),
+    setAuthorizedCustomRequest: (...[, { customerId, infoRequestId, override }, context]) => {
+      const token = authentication.getToken(context)
+      return queries.setAuthorizedCustomRequest(customerId, infoRequestId, override, token)
+    },
+    setCustomerCustomInfoRequest: (...[, { customerId, infoRequestId, data }]) => queries.setCustomerData(customerId, infoRequestId, data)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/customer.resolver.js

@@ -0,0 +1,66 @@
+const authentication = require('../modules/userManagement')
+const anonymous = require('../../../constants').anonymousCustomer
+const customers = require('../../../customers')
+const filters = require('../../filters')
+const customerNotes = require('../../../customer-notes')
+const machineLoader = require('../../../machine-loader')
+
+const addLastUsedMachineName = customer =>
+  (customer.lastUsedMachine ? machineLoader.getMachineName(customer.lastUsedMachine) : Promise.resolve(null))
+    .then(lastUsedMachineName => Object.assign(customer, { lastUsedMachineName }))
+
+const resolvers = {
+  Customer: {
+    isAnonymous: parent => (parent.customerId === anonymous.uuid)
+  },
+  Query: {
+    customers: (...[, { phone, email, name, address, id }]) => customers.getCustomersList(phone, name, address, id, email),
+    customer: (...[, { customerId }]) => customers.getCustomerById(customerId).then(addLastUsedMachineName),
+    customerFilters: () => filters.customer()
+  },
+  Mutation: {
+    setCustomer: (root, { customerId, customerInput }, context, info) => {
+      const token = authentication.getToken(context)
+      if (customerId === anonymous.uuid) return customers.getCustomerById(customerId)
+      return customers.updateCustomer(customerId, customerInput, token)
+    },
+    addCustomField: (...[, { customerId, label, value }]) => customers.addCustomField(customerId, label, value),
+    saveCustomField: (...[, { customerId, fieldId, value }]) => customers.saveCustomField(customerId, fieldId, value),
+    removeCustomField: (...[, [ { customerId, fieldId } ]]) => customers.removeCustomField(customerId, fieldId),
+    editCustomer: async (root, { customerId, customerEdit }, context) => {
+      const token = authentication.getToken(context)
+      const editedData = await customerEdit
+      return customers.edit(customerId, editedData, token)
+    },
+    replacePhoto: async (root, { customerId, photoType, newPhoto }, context) => {
+      const token = authentication.getToken(context)
+      const { file } = newPhoto
+      const photo = await file
+      if (!photo) return customers.getCustomerById(customerId)
+      return customers.updateEditedPhoto(customerId, photo, photoType)
+        .then(newPatch => customers.edit(customerId, newPatch, token))
+    },
+    deleteEditedData: (root, { customerId, customerEdit }) => {
+      // TODO: NOT IMPLEMENTING THIS FEATURE FOR THE CURRENT VERSION
+      return customers.getCustomerById(customerId)
+    },
+    createCustomerNote: (...[, { customerId, title, content }, context]) => {
+      const token = authentication.getToken(context)
+      return customerNotes.createCustomerNote(customerId, token, title, content)
+    },
+    editCustomerNote: (...[, { noteId, newContent }, context]) => {
+      const token = authentication.getToken(context)
+      return customerNotes.updateCustomerNote(noteId, token, newContent)
+    },
+    deleteCustomerNote: (...[, { noteId }]) => {
+      return customerNotes.deleteCustomerNote(noteId)
+    },
+    createCustomer: (...[, { phoneNumber }]) => customers.add({ phone: phoneNumber }),
+    enableTestCustomer: (...[, { customerId }]) =>
+      customers.enableTestCustomer(customerId),
+    disableTestCustomer: (...[, { customerId }]) =>
+      customers.disableTestCustomer(customerId)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/funding.resolver.js

@@ -0,0 +1,9 @@
+const funding = require('../../services/funding')
+
+const resolvers = {
+  Query: {
+    funding: () => funding.getFunding()
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/index.js

@@ -0,0 +1,53 @@
+const { mergeResolvers } = require('@graphql-tools/merge')
+
+const bill = require('./bill.resolver')
+const blacklist = require('./blacklist.resolver')
+const cashbox = require('./cashbox.resolver')
+const config = require('./config.resolver')
+const currency = require('./currency.resolver')
+const customer = require('./customer.resolver')
+const customInfoRequests = require('./customInfoRequests.resolver')
+const funding = require('./funding.resolver')
+const log = require('./log.resolver')
+const loyalty = require('./loyalty.resolver')
+const machine = require('./machine.resolver')
+const market = require('./market.resolver')
+const notification = require('./notification.resolver')
+const pairing = require('./pairing.resolver')
+const rates = require('./rates.resolver')
+const sanctions = require('./sanctions.resolver')
+const scalar = require('./scalar.resolver')
+const settings = require('./settings.resolver')
+const sms = require('./sms.resolver')
+const status = require('./status.resolver')
+const transaction = require('./transaction.resolver')
+const user = require('./users.resolver')
+const version = require('./version.resolver')
+
+const resolvers = [
+  bill,
+  blacklist,
+  cashbox,
+  config,
+  currency,
+  customer,
+  customInfoRequests,
+  funding,
+  log,
+  loyalty,
+  machine,
+  market,
+  notification,
+  pairing,
+  rates,
+  sanctions,
+  scalar,
+  settings,
+  sms,
+  status,
+  transaction,
+  user,
+  version
+]
+
+module.exports = mergeResolvers(resolvers)

packages/server/lib/new-admin/graphql/resolvers/log.resolver.js

@@ -0,0 +1,22 @@
+const { parseAsync } = require('json2csv')
+const _ = require('lodash/fp')
+
+const logs = require('../../../logs')
+const serverLogs = require('../../services/server-logs')
+
+const resolvers = {
+  Query: {
+    machineLogs: (...[, { deviceId, from, until, limit, offset }]) =>
+      logs.simpleGetMachineLogs(deviceId, from, until, limit, offset),
+    machineLogsCsv: (...[, { deviceId, from, until, limit, offset, timezone }]) =>
+      logs.simpleGetMachineLogs(deviceId, from, until, limit, offset)
+        .then(res => parseAsync(logs.logDateFormat(timezone, res, ['timestamp']))),
+    serverLogs: (...[, { from, until, limit, offset }]) =>
+      serverLogs.getServerLogs(from, until, limit, offset),
+    serverLogsCsv: (...[, { from, until, limit, offset, timezone }]) =>
+      serverLogs.getServerLogs(from, until, limit, offset)
+        .then(res => parseAsync(logs.logDateFormat(timezone, res, ['timestamp'])))
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/loyalty.resolver.js

@@ -0,0 +1,26 @@
+const DataLoader = require('dataloader')
+
+const loyalty = require('../../../loyalty')
+const { getSlimCustomerByIdBatch } = require('../../../customers')
+
+const customerLoader = new DataLoader(ids => {
+  return getSlimCustomerByIdBatch(ids)
+}, { cache: false })
+
+const resolvers = {
+  IndividualDiscount: {
+    customer: parent => customerLoader.load(parent.customerId)
+  },
+  Query: {
+    promoCodes: () => loyalty.getAvailablePromoCodes(),
+    individualDiscounts: () => loyalty.getAvailableIndividualDiscounts()
+  },
+  Mutation: {
+    createPromoCode: (...[, { code, discount }]) => loyalty.createPromoCode(code, discount),
+    deletePromoCode: (...[, { codeId }]) => loyalty.deletePromoCode(codeId),
+    createIndividualDiscount: (...[, { customerId, discount }]) => loyalty.createIndividualDiscount(customerId, discount),
+    deleteIndividualDiscount: (...[, { discountId }]) => loyalty.deleteIndividualDiscount(discountId)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/machine.resolver.js

@@ -0,0 +1,27 @@
+const DataLoader = require('dataloader')
+
+const { machineAction } = require('../../services/machines')
+
+const machineLoader = require('../../../machine-loader')
+const machineEventsByIdBatch = require('../../../postgresql_interface').machineEventsByIdBatch
+
+const machineEventsLoader = new DataLoader(ids => {
+  return machineEventsByIdBatch(ids)
+}, { cache: false })
+
+const resolvers = {
+  Machine: {
+    latestEvent: parent => machineEventsLoader.load(parent.deviceId)
+  },
+  Query: {
+    machines: () => machineLoader.getMachineNames(),
+    machine: (...[, { deviceId }]) => machineLoader.getMachine(deviceId),
+    unpairedMachines: () => machineLoader.getUnpairedMachines()
+  },
+  Mutation: {
+    machineAction: (...[, { deviceId, action, cashUnits, newName }, context]) =>
+      machineAction({ deviceId, action, cashUnits, newName }, context)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/market.resolver.js

@@ -0,0 +1,9 @@
+const exchange = require('../../../exchange')
+
+const resolvers = {
+  Query: {
+    getMarkets: () => exchange.getMarkets()
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/notification.resolver.js

@@ -0,0 +1,15 @@
+const notifierQueries = require('../../../notifier/queries')
+
+const resolvers = {
+  Query: {
+    notifications: () => notifierQueries.getNotifications(),
+    hasUnreadNotifications: () => notifierQueries.hasUnreadNotifications(),
+    alerts: () => notifierQueries.getAlerts()
+  },
+  Mutation: {
+    toggleClearNotification: (...[, { id, read }]) => notifierQueries.setRead(id, read),
+    clearAllNotifications: () => notifierQueries.markAllAsRead()
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/pairing.resolver.js

@@ -0,0 +1,9 @@
+const pairing = require('../../services/pairing')
+
+const resolvers = {
+  Mutation: {
+    createPairingTotem: (...[, { name }]) => pairing.totem(name)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/rates.resolver.js

@@ -0,0 +1,21 @@
+const settingsLoader = require('../../../new-settings-loader')
+const forex = require('../../../forex')
+const plugins = require('../../../plugins')
+
+const resolvers = {
+  Query: {
+    cryptoRates: () =>
+      settingsLoader.loadLatest().then(settings => {
+        const pi = plugins(settings)
+        return pi.getRawRates().then(r => {
+          return {
+            withCommissions: pi.buildRates(r),
+            withoutCommissions: pi.buildRatesNoCommission(r)
+          }
+        })
+      }),
+    fiatRates: () => forex.getFiatRates()
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/sanctions.resolver.js

@@ -0,0 +1,13 @@
+const sanctions = require('../../../sanctions')
+const authentication = require('../modules/userManagement')
+
+const resolvers = {
+  Query: {
+    checkAgainstSanctions: (...[, { customerId }, context]) => {
+      const token = authentication.getToken(context)
+      return sanctions.checkByUser(customerId, token)
+    }
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/scalar.resolver.js

@@ -0,0 +1,9 @@
+const { DateTimeISOResolver, JSONResolver, JSONObjectResolver } = require('graphql-scalars')
+
+const resolvers = {
+  JSON: JSONResolver,
+  JSONObject: JSONObjectResolver,
+  DateTimeISO: DateTimeISOResolver
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/settings.resolver.js

@@ -0,0 +1,14 @@
+const settingsLoader = require('../../../new-settings-loader')
+
+const resolvers = {
+  Query: {
+    accounts: () => settingsLoader.showAccounts(),
+    config: () => settingsLoader.loadLatestConfigOrNone()
+  },
+  Mutation: {
+    saveAccounts: (...[, { accounts }]) => settingsLoader.saveAccounts(accounts),
+    saveConfig: (...[, { config }]) => settingsLoader.saveConfig(config),
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/sms.resolver.js

@@ -0,0 +1,14 @@
+const smsNotices = require('../../../sms-notices')
+
+const resolvers = {
+  Query: {
+    SMSNotices: () => smsNotices.getSMSNotices()
+  },
+  Mutation: {
+    editSMSNotice: (...[, { id, event, message }]) => smsNotices.editSMSNotice(id, event, message),
+    enableSMSNotice: (...[, { id }]) => smsNotices.enableSMSNotice(id),
+    disableSMSNotice: (...[, { id }]) => smsNotices.disableSMSNotice(id)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/status.resolver.js

@@ -0,0 +1,9 @@
+const supervisor = require('../../services/supervisor')
+
+const resolvers = {
+  Query: {
+    uptime: () => supervisor.getAllProcessInfo()
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/transaction.resolver.js

@@ -0,0 +1,43 @@
+const DataLoader = require('dataloader')
+const { parseAsync } = require('json2csv')
+const _ = require('lodash/fp')
+
+const filters = require('../../filters')
+const cashOutTx = require('../../../cash-out/cash-out-tx')
+const cashInTx = require('../../../cash-in/cash-in-tx')
+const transactions = require('../../services/transactions')
+const anonymous = require('../../../constants').anonymousCustomer
+const logDateFormat = require('../../../logs').logDateFormat
+
+const transactionsLoader = new DataLoader(ids => transactions.getCustomerTransactionsBatch(ids), { cache: false })
+
+const resolvers = {
+  Customer: {
+    transactions: parent => transactionsLoader.load(parent.id)
+  },
+  Transaction: {
+    isAnonymous: parent => (parent.customerId === anonymous.uuid)
+  },
+  Query: {
+    transactions: (...[, { from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept, excludeTestingCustomers }]) =>
+      transactions.batch(from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept, excludeTestingCustomers),
+    transactionsCsv: (...[, { from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept, timezone, excludeTestingCustomers, simplified }]) =>
+      transactions.batch(from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept, excludeTestingCustomers, simplified)
+        .then(data => parseAsync(logDateFormat(timezone, data, ['created', 'sendTime', 'publishedAt']))),
+    transactionCsv: (...[, { id, txClass, timezone }]) =>
+      transactions.getTx(id, txClass).then(data => 
+        parseAsync(logDateFormat(timezone, [data], ['created', 'sendTime', 'publishedAt']))
+      ),
+    txAssociatedDataCsv: (...[, { id, txClass, timezone }]) =>
+      transactions.getTxAssociatedData(id, txClass).then(data =>
+        parseAsync(logDateFormat(timezone, data, ['created']))
+      ),
+    transactionFilters: () => filters.transaction()
+  },
+  Mutation: {
+    cancelCashOutTransaction: (...[, { id }]) => cashOutTx.cancel(id),
+    cancelCashInTransaction: (...[, { id }]) => cashInTx.cancel(id)
+  }
+}
+
+module.exports = resolvers

packages/server/lib/new-admin/graphql/resolvers/users.resolver.js

@@ -0,0 +1,92 @@
+const authentication = require('../modules/authentication')
+const userManagement = require('../modules/userManagement')
+const users = require('../../../users')
+const sessionManager = require('../../../session-manager')
+
+const getAttestationQueryOptions = variables => {
+  switch (authentication.CHOSEN_STRATEGY) {
+    case 'FIDO2FA':
+      return { userId: variables.userID, domain: variables.domain }
+    case 'FIDOPasswordless':
+      return { userId: variables.userID, domain: variables.domain }
+    case 'FIDOUsernameless':
+      return { userId: variables.userID, domain: variables.domain }
+    default:
+      return {}
+  }
+}
+
+const getAssertionQueryOptions = variables => {
+  switch (authentication.CHOSEN_STRATEGY) {
+    case 'FIDO2FA':
+      return { username: variables.username, password: variables.password, domain: variables.domain }
+    case 'FIDOPasswordless':
+      return { username: variables.username, domain: variables.domain }
+    case 'FIDOUsernameless':
+      return { domain: variables.domain }
+    default:
+      return {}
+  }
+}
+
+const getAttestationMutationOptions = variables => {
+  switch (authentication.CHOSEN_STRATEGY) {
+    case 'FIDO2FA':
+      return { userId: variables.userID, attestationResponse: variables.attestationResponse, domain: variables.domain }
+    case 'FIDOPasswordless':
+      return { userId: variables.userID, attestationResponse: variables.attestationResponse, domain: variables.domain }
+    case 'FIDOUsernameless':
+      return { userId: variables.userID, attestationResponse: variables.attestationResponse, domain: variables.domain }
+    default:
+      return {}
+  }
+}
+
+const getAssertionMutationOptions = variables => {
+  switch (authentication.CHOSEN_STRATEGY) {
+    case 'FIDO2FA':
+      return { username: variables.username, password: variables.password, rememberMe: variables.rememberMe, assertionResponse: variables.assertionResponse, domain: variables.domain }
+    case 'FIDOPasswordless':
+      return { username: variables.username, rememberMe: variables.rememberMe, assertionResponse: variables.assertionResponse, domain: variables.domain }
+    case 'FIDOUsernameless':
+      return { assertionResponse: variables.assertionResponse, domain: variables.domain }
+    default:
+      return {}
+  }
+}
+
+const resolver = {
+  Query: {
+    users: () => users.getUsers(),
+    sessions: () => sessionManager.getSessions(),
+    userSessions: (...[, { username }]) => sessionManager.getSessionsByUsername(username),
+    userData: (...[, {}, context]) => userManagement.getUserData(context),
+    get2FASecret: (...[, { username, password }]) => userManagement.get2FASecret(username, password),
+    confirm2FA: (...[, { code }, context]) => userManagement.confirm2FA(code, context),
+    validateRegisterLink: (...[, { token }]) => userManagement.validateRegisterLink(token),
+    validateResetPasswordLink: (...[, { token }]) => userManagement.validateResetPasswordLink(token),
+    validateReset2FALink: (...[, { token }]) => userManagement.validateReset2FALink(token),
+    generateAttestationOptions: (...[, variables, context]) => authentication.strategy.generateAttestationOptions(context.req.session, getAttestationQueryOptions(variables)),
+    generateAssertionOptions: (...[, variables, context]) => authentication.strategy.generateAssertionOptions(context.req.session, getAssertionQueryOptions(variables))
+  },
+  Mutation: {
+    enableUser: (...[, { confirmationCode, id }, context]) => userManagement.enableUser(confirmationCode, id, context),
+    disableUser: (...[, { confirmationCode, id }, context]) => userManagement.disableUser(confirmationCode, id, context),
+    deleteSession: (...[, { sid }, context]) => userManagement.deleteSession(sid, context),
+    deleteUserSessions: (...[, { username }]) => sessionManager.deleteSessionsByUsername(username),
+    changeUserRole: (...[, { confirmationCode, id, newRole }, context]) => userManagement.changeUserRole(confirmationCode, id, newRole, context),
+    login: (...[, { username, password }]) => userManagement.login(username, password),
+    input2FA: (...[, { username, password, rememberMe, code }, context]) => userManagement.input2FA(username, password, rememberMe, code, context),
+    setup2FA: (...[, { username, password, rememberMe, codeConfirmation }, context]) => userManagement.setup2FA(username, password, rememberMe, codeConfirmation, context),
+    createResetPasswordToken: (...[, { confirmationCode, userID }, context]) => userManagement.createResetPasswordToken(confirmationCode, userID, context),
+    createReset2FAToken: (...[, { confirmationCode, userID }, context]) => userManagement.createReset2FAToken(confirmationCode, userID, context),
+    createRegisterToken: (...[, { username, role }]) => userManagement.createRegisterToken(username, role),
+    register: (...[, { token, username, password, role }]) => userManagement.register(token, username, password, role),
+    resetPassword: (...[, { token, userID, newPassword }, context]) => userManagement.resetPassword(token, userID, newPassword, context),
+    reset2FA: (...[, { token, userID, code }, context]) => userManagement.reset2FA(token, userID, code, context),
+    validateAttestation: (...[, variables, context]) => authentication.strategy.validateAttestation(context.req.session, getAttestationMutationOptions(variables)),
+    validateAssertion: (...[, variables, context]) => authentication.strategy.validateAssertion(context.req.session, getAssertionMutationOptions(variables))
+  }
+}
+
+module.exports = resolver

packages/server/lib/new-admin/graphql/resolvers/version.resolver.js

@@ -0,0 +1,9 @@
+const serverVersion = require('../../../../package.json').version
+
+const resolvers = {
+  Query: {
+    serverVersion: () => serverVersion
+  }
+}
+
+module.exports = resolvers