Take Advantage of Higher-Order Functions for Atomic Changes

[aklatzke]

    reqTypes.forEach(item => {
      item = item.toLowerCase()
      let lowerCaseProjectTypes = availableTypes.projectTypes.map(value => value.toLowerCase())
      let lowerCaseGlobalTypes = availableTypes.globalTypes.map(value => value.toLowerCase())
      
      if (lowerCaseProjectTypes.indexOf(item) !== -1) {
        added.proj.push(availableTypes.projectTypes[lowerCaseProjectTypes.indexOf(item)])
      } else if (lowerCaseGlobalTypes.indexOf(item) !== -1) {
        added.global.push(availableTypes.globalTypes[lowerCaseGlobalTypes.indexOf(item)])
      } else {
        missing.push(item)
      }
    })

This is totally up to you depending on how you prefer to structure things, but it seems like you're embracing the functional style and using higher order functions where available. You can use a .map() here to handle the atomic change (toLowerCase) on each option. You can also use the ES6 Array.includes to clean up some of the messy !== -1 checking.

This is definitely more of a preference kind of thing so feel free to just close this one if you prefer. The (very small) changes I'd recommend are the following:

    reqTypes
     .map(item => item.toLowerCase())
     .forEach(item => {
      let lowerCaseProjectTypes = availableTypes.projectTypes.map(value => value.toLowerCase())
      let lowerCaseGlobalTypes = availableTypes.globalTypes.map(value => value.toLowerCase())
      
      if (lowerCaseProjectTypes.includes(item)) {
        added.proj.push(availableTypes.projectTypes[lowerCaseProjectTypes.indexOf(item)])
      } else if (lowerCaseGlobalTypes.includes(item)) {
        added.global.push(availableTypes.globalTypes[lowerCaseGlobalTypes.indexOf(item)])
      } else {
        missing.push(item)
      }
    })