v12.0.0 - initial commit

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,25 @@
+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,15 @@
+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,56 @@
+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,84 @@
+const authentication = require('../modules/userManagement')
+const anonymous = require('../../../constants').anonymousCustomer
+const customers = require('../../../customers')
+const customerNotes = require('../../../customer-notes')
+const machineLoader = require('../../../machine-loader')
+const {
+  customers: { searchCustomers },
+} = require('typesafe-db')
+
+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: () => customers.getCustomersList(),
+    customer: (...[, { customerId }]) =>
+      customers.getCustomerById(customerId).then(addLastUsedMachineName),
+    searchCustomers: (...[, { searchTerm, limit = 20 }]) =>
+      searchCustomers(searchTerm, limit),
+  },
+  Mutation: {
+    setCustomer: (root, { customerId, customerInput }, context) => {
+      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 }) => {
+      // 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,57 @@
+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 machineGroups = require('./machineGroups.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 triggers = require('./triggers.resolver')
+
+const resolvers = [
+  bill,
+  blacklist,
+  cashbox,
+  config,
+  currency,
+  customer,
+  customInfoRequests,
+  funding,
+  log,
+  loyalty,
+  machine,
+  machineGroups,
+  market,
+  notification,
+  pairing,
+  rates,
+  sanctions,
+  scalar,
+  settings,
+  sms,
+  status,
+  transaction,
+  user,
+  version,
+  triggers,
+]
+
+module.exports = mergeResolvers(resolvers)

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

@@ -0,0 +1,29 @@
+const { parseAsync } = require('json2csv')
+
+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,32 @@
+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,33 @@
+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: {
+    assignMachinesToGroup: (...[, { deviceIds, groupId }]) =>
+      machineLoader.assignToGroup(deviceIds, groupId),
+    machineAction: (...[, { deviceId, action, cashUnits, newName }, context]) =>
+      machineAction({ deviceId, action, cashUnits, newName }, context),
+  },
+}
+
+module.exports = resolvers

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

@@ -0,0 +1,39 @@
+const DataLoader = require('dataloader')
+
+const {
+  getAllMachineGroups,
+  createMachineGroup,
+  deleteMachineGroup,
+  assignComplianceTriggerSetToMachineGroup,
+} = require('../../services/machineGroups')
+
+const {
+  getComplianceTriggerSetsByIdsBatch,
+} = require('../../services/triggers')
+
+const complianceTriggerSetsLoader = new DataLoader(
+  ids => getComplianceTriggerSetsByIdsBatch(ids),
+  { cache: false },
+)
+
+const resolvers = {
+  MachineGroup: {
+    complianceTriggerSet: parent =>
+      parent.complianceTriggerSetId
+        ? complianceTriggerSetsLoader.load(parent.complianceTriggerSetId)
+        : null,
+  },
+  Query: {
+    machineGroups: () => getAllMachineGroups(),
+  },
+  Mutation: {
+    createMachineGroup: (...[, { name }]) => createMachineGroup(name),
+    deleteMachineGroup: (...[, { id }]) => deleteMachineGroup(id),
+    assignComplianceTriggerSetToMachineGroup: (
+      source,
+      { id, complianceTriggerSetId },
+    ) => assignComplianceTriggerSetToMachineGroup(id, complianceTriggerSetId),
+  },
+}
+
+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,16 @@
+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.load().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,13 @@
+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,15 @@
+const settingsLoader = require('../../../new-settings-loader')
+
+const resolvers = {
+  Query: {
+    accounts: () => settingsLoader.showAccounts(),
+    config: () => settingsLoader.loadConfig(),
+  },
+  Mutation: {
+    saveAccounts: (...[, { accounts }]) =>
+      settingsLoader.saveAccounts(accounts),
+    saveConfig: (source, { config }) => settingsLoader.saveConfig(config),
+  },
+}
+
+module.exports = resolvers

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

@@ -0,0 +1,15 @@
+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,13 @@
+const supervisor = require('../../services/supervisor')
+const {
+  getCachedRestrictionLevel,
+} = require('../../services/restriction-level')
+
+const resolvers = {
+  Query: {
+    uptime: () => supervisor.getAllProcessInfo(),
+    restrictionLevel: () => getCachedRestrictionLevel(),
+  },
+}
+
+module.exports = resolvers

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

@@ -0,0 +1,126 @@
+const { parseAsync } = require('json2csv')
+
+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 resolvers = {
+  Transaction: {
+    isAnonymous: parent => parent.customerId === anonymous.uuid,
+  },
+  Query: {
+    transactions: (
+      ...[
+        ,
+        {
+          from,
+          until,
+          limit,
+          offset,
+          txClass,
+          deviceId,
+          customerName,
+          customerId,
+          fiatCode,
+          cryptoCode,
+          toAddress,
+          status,
+          swept,
+          excludeTestingCustomers,
+        },
+      ]
+    ) =>
+      transactions.batch({
+        from,
+        until,
+        limit,
+        offset,
+        txClass,
+        deviceId,
+        customerName,
+        customerId,
+        fiatCode,
+        cryptoCode,
+        toAddress,
+        status,
+        swept,
+        excludeTestingCustomers,
+      }),
+    transactionsCsv: (
+      ...[
+        ,
+        {
+          from,
+          until,
+          limit,
+          offset,
+          txClass,
+          deviceId,
+          customerName,
+          customerId,
+          fiatCode,
+          cryptoCode,
+          toAddress,
+          status,
+          swept,
+          timezone,
+          excludeTestingCustomers,
+          simplified,
+        },
+      ]
+    ) =>
+      transactions
+        .batch({
+          from,
+          until,
+          limit,
+          offset,
+          txClass,
+          deviceId,
+          customerName,
+          customerId,
+          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/triggers.resolver.js

@@ -0,0 +1,48 @@
+const {
+  getComplianceTriggerSets,
+  getComplianceTriggerSetById,
+  getComplianceTriggers,
+  createComplianceTriggerSet,
+  deleteComplianceTriggerSet,
+  createComplianceTrigger,
+  deleteComplianceTrigger,
+} = require('../../services/triggers')
+
+const Query = {
+  complianceTriggerSets() {
+    return getComplianceTriggerSets()
+  },
+
+  complianceTriggerSetById(source, { id }) {
+    return getComplianceTriggerSetById(id)
+  },
+
+  complianceTriggers(source, { complianceTriggerSetId }) {
+    return getComplianceTriggers(complianceTriggerSetId)
+  },
+}
+
+const Mutation = {
+  createComplianceTriggerSet(source, { name }) {
+    return createComplianceTriggerSet(name)
+  },
+
+  deleteComplianceTriggerSet(source, { id }) {
+    return deleteComplianceTriggerSet(id)
+  },
+
+  createComplianceTrigger(source, { complianceTriggerSetId, trigger }) {
+    return createComplianceTrigger(complianceTriggerSetId, trigger).then(
+      () => true,
+    )
+  },
+
+  deleteComplianceTrigger(source, { id }) {
+    return deleteComplianceTrigger(id).then(() => true)
+  },
+}
+
+module.exports = {
+  Query,
+  Mutation,
+}

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

@@ -0,0 +1,170 @@
+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