Simple Node.js user management system

Question

I am working on a application that is made completely in JavaScript (other than the database) and I've created a simple user management system for the application.

This user management system creates a query to the database containing the user info (the database contains the user info not the query) based on a few command line arguments, decrypts the data in the database, and then prints the result to the console.

I have been programming for 2 years but am self-taught and was looking for some feedback/criticism on my code.

Note: Some of the modules in the Main script are not included but, for the most part, their functions should be intuitive.

Edit: for more information about the DataBase class see this question.

Here is my code:

Main script:

// this is a instance of a `DataBase` class:
const users = require('../../Code/MiddleWare/Database-comms/createUser').users
const lookup = require('./lookup')
const decryptAll = require('./decrypt')

void async function() {
  if(process.argv[2] === '-e') {
    console.dir(decryptAll(await lookup('Email', process.argv[3], users, process.argv[4] === '-ex')), {colors: true, depth: Infinity})
  } else if(process.argv[2] ? process.argv[2].match(/^\d+$/) : false) {
    console.dir(decryptAll(await lookup('ID', parseInt(process.argv[2]), users, process.argv[3] === '-ex', false)), {colors: true, depth: Infinity})
  } else {
    console.dir(decryptAll(await lookup('Username', process.argv[2] ? process.argv[2] : '', users, process.argv[3] === '-ex')), {colors: true, depth: Infinity})
  }
}()

"lookup" module:

module.exports = async function(type, string, users, exact,  encrypted = true) {
  const aes = require('../../Code/MiddleWare/Security/index').encryption.AES
   const retval = []
   await users.query('Users').then((data) => {
     for(let i of data) {
        if(encrypted ? (exact? aes.decrypt(i[type]) === string : aes.decrypt(i[type]).match(string)) : i[type] === string) {
          retval.push(i)
        }
     }
   })

   return retval.length === 0 ? false : retval
}

The "decrypt" module:

const decrypt = require('../../Code/MiddleWare/Security/encryption').AES.decrypt

module.exports = function(array) {
  if(!array) {
    return false    
  }

  const retval = []

  function decryptAll(obj) {
    return {ID: obj.ID, Username: decrypt(obj.Username), Email: decrypt(obj.Email), Data: decrypt(obj.Data), Password: obj.Password}
  }

  for(const i of array) {
    const item = decryptAll(i)
    item.Data = JSON.parse(item.Data)
    retval.push(item)
  }

  return retval
}

Answer 1

Main script

• Consider using the commander module. One benefit you get is that it parses arguments for you. Another is that the API that declares the arguments and options autogenerates --help text for you. This way, you avoid having to write all the argument parsing yourself and you get a self-documenting CLI.

Lookup module

• Move that require call outside the function. You only need to import aes once, not on every call to the lookup function.

• When inside an async function, you can use await to write async operations in a synchronous-looking fashion. When you use await, you can assign the resolved value of an async operation to a variable in the same way you do it with synchronous operation.

• The code inside the for-of is essentially a filter operation. Consider using array.filter() instead, assuming data is just an array.

• I also recommend breaking out that nested ternary into nested if statements for readability. You could arrange the conditions so that it's cascading rather than nested.

• I recommend returning an empty array instead of false when no matches are found. This way, the consuming code won't have to deal with type checking.

Decrypt module

• The decryptAll function does not appear to rely on any variables in the scope of the exported function. You can move decryptAll out of that function.

• That for-of is essentially a mapping function (transforming one array's values into another array of values). Use array.map() instead.

• Since decryptAll is just mapping select properties into a new object, you can use a combination of destructuring and shorthand properties to simplify it.

---

Bottom line, your code could look like this:

Lookup

const aes = require('../../Code/MiddleWare/Security/index').encryption.AES

module.exports = async function(type, string, users, exact,  encrypted = true) {
  return await users.query('Users').filter(i => {

    // Technically, the encrypted block is a nested ternary in the
    // false portion of the first ternary. But written this way, 
    // it looks like a flat list.
    return !encrypted ? i[type] === string
      : exact ? aes.decrypt(i[type]) === string
      : aes.decrypt(i[type]).match(string)
  })
}

Decrypt

const decrypt = require('../../Code/MiddleWare/Security/encryption').AES.decrypt

// Destructure arguments, then return an object with shorthand properties.
// Eliminates obj.
const decryptAll = ({ ID, Username, Email, Data, Password }) => {
  return { ID, Username, Email, Data, Password }
}

module.exports = function(array) {
  // We're expecting an array so the check is no longer needed.

  const retval = array.map(i => {
    const item = decryptAll(i)
    const itemWithDecryptedData = { ...item, Data: JSON.parse(item.Data) }
    return itemWithDecryptedData
  })

  return retval
}