Finding duplicates in an array of objects

• I do not understand the flatMap. Does it just loop through and return pairs of user and ID? If it is a loop, you can just write it that way.

• I'm not sure users.reduce call is appropriate since you're using it for side-effects (pushing to array). I think a for..of or forEach loop is easier to understand than a more complicated reduce function that passes acc around.

• users.find is ok for small arrays but finding over large arrays will be slow and so a map data structure should be used for efficiency.

• I would avoid code like || [] for readability. Maybe it is a standard idiom. https://stackoverflow.com/questions/14614134/create-array-and-push-into-it-in-one-line

For optimal performance, you want to use a hash table for your data structure. Hash tables have amortized O(1) time performance for insertion and lookup. Use the user ID as they keys, and the values are a collection of roles for each user. Total of O(n).

Pseudocode:

hashtable = HashTable()

for user, role in table:
    hashtable[user].append(role)

for user, roles in hashtable:
    if len(roles) > 1:
        yield user

Alternatively, you should be able to roll this into a single SQL query with a JOIN, followed by COUNT and GROUP BY. https://www.w3resource.com/sql/aggregate-functions/count-with-group-by.php

I think your map/reduce are a fine approach.

You could combine the first two into a single pipeline (or all three), as the intermediate variable (users), besides being imprecisely named, isn't that useful.

I would say the third pipeline could be brought into line with the same techniques. Instead of array/push:

const usersWithManyRoles = []

  lookup.forEach((value, key) => {
    if (value.length > 1) {
      usersWithManyRoles.push({
        userId: key,
        userInfo: users.find(value => value.user.id === key).user,
        roles: value,
      })...

You could use filter and then map. Therefore:

const usersWithManyRoles = 
  lookup
   .filter((value) => value.length > 1)
   .map((value, key) => {
      return {
        userId: key,
        userInfo: users.find(value => value.user.id === key).user,
        roles: value,
...

It may be possible to reduce the amount of data you are shuffling around... I'm not sure how much of that you actually need. If you just need a list of user_ids, a different approach could be simpler.

Use a Map

The Array lookup where you add items by user id is in effect a map by user id. You can get all the information needed to find users with multiple roles while building that array. There is no need to process that array again. However rather than use an array use a hash map.

JavaScript has many hash map options Map, Set, WeakMap, and WeakSet. In this case you can use a Map to index by user id. While adding to the map you can check the number of roles. Each user that gets more than one role is added to the result array (users with multiple roles).

This way you can get the array of users with multiple roles in one pass and keep memory use to a minimum. 1 object per user.

Example

Note: example has modified input and output, thus is an example rather than a rewrite.

The objects returned seam to name the user userInfo and include the user id as userId. You are in effect duplicating data for no reason. Thus the example changes returned objects from {userId: user.id, userInfo: user, roles: [role]} to {user, roles: [role]} No data is lost from the returned array of users with multiple roles.

Also the function takes an reference to array of roles, rather than is a function of (unknown) object (ref to roles is this.roles).

function usersWithMultipleRoles(roles) {
    const rolesByUser = new Map(), multipleRoles = [];
    roles.forEach(role => {
        role.forEach(user => {
            const userRoles = rolesByUser.get(user.id);
            if (userRoles) {
                userRoles.roles.push(role);
                userRoles.roles.length === 2 && multipleRoles.push(userRoles);
            } else {
                rolesByUser.set(user.id, {user, roles: [role]});
            }
        });
    });
    return multipleRoles;
}