Inside _.mapValues I want get some modified values with some latency (for example from DB), but I was faced with problem: while I modify values in sync mode everything is good, when i try use promises or callback its work incorrectly (in first case I get Promise object, in second: undefined value). Here some simplified example, how i can rewrite code inside mapValues to solve this problem?

'use strict';
const _ = require('lodash');
const Promise = require('bluebird');

let obj = {
  one: 1,
  two: 2,
};

let increment = (value) => {
  return value + 1;
};

let incrementProm = (value) => {
  return Promise.resolve(value + 1);
};

let incrementCb = (value, cb) => {
  let res = value + 1;
  let err = null;
  setTimeout(cb.bind(undefined, err, res), 100);
};

let t1 = _.mapValues(obj, (value) => {
  return increment(value);
});

let t2 = _.mapValues(obj, (value) => {
  return incrementProm(value);
});

let t3 = _.mapValues(obj, (value) => {
  let temp;
  incrementCb(value, (err, res) => {
    temp = res;
  });
  return temp;
});

console.log('Sync res:');
console.log(t1);
console.log('Promise res:');
console.log(t2);
console.log('Callback res:');
console.log(t3);

Inside _.mapValues I want get some modified values with some latency (for example from DB), but I was faced with problem: while I modify values in sync mode everything is good, when i try use promises or callback its work incorrectly (in first case I get Promise object, in second: undefined value). Here some simplified example, how i can rewrite code inside mapValues to solve this problem?

'use strict';
const _ = require('lodash');
const Promise = require('bluebird');

let obj = {
  one: 1,
  two: 2,
};

let increment = (value) => {
  return value + 1;
};

let incrementProm = (value) => {
  return Promise.resolve(value + 1);
};

let incrementCb = (value, cb) => {
  let res = value + 1;
  let err = null;
  setTimeout(cb.bind(undefined, err, res), 100);
};

let t1 = _.mapValues(obj, (value) => {
  return increment(value);
});

let t2 = _.mapValues(obj, (value) => {
  return incrementProm(value);
});

let t3 = _.mapValues(obj, (value) => {
  let temp;
  incrementCb(value, (err, res) => {
    temp = res;
  });
  return temp;
});

console.log('Sync res:');
console.log(t1);
console.log('Promise res:');
console.log(t2);
console.log('Callback res:');
console.log(t3);

• javascript
• node.js
• lodash

4 Answers 4

You can use bluebird's props() function to resolve all properties with promises.

Promise.props(_.mapValues(obj, incrementProm))
.then(result => console.log(result));

var obj = {
  one: 1,
  two: 2
};

var incrementProm = value => Promise.resolve(value + 1);

Promise.props(_.mapValues(obj, incrementProm))
.then(result => console.log(result));

<script src="https://cdn.jsdelivr/lodash/4.13.1/lodash.js"></script>
<script src="https://cdnjs.cloudflare./ajax/libs/bluebird/3.4.1/bluebird.js"></script>

You're mapping onto promises, so something I do might be:

var _ = require('lodash');
let incrementProm = (value) => {
  return Promise.resolve(value + 1);
};

let obj = {
    foo: 1,
    bar: 2
}

let keys = _.keys(obj);
let promises = _.map(keys, k => {
    return incrementProm(obj[k])
    .then(newValue => { return { key: k, value: newValue } });
})
Promise.all(promises).then(values => {
    values.forEach(v => obj[v.key] = v.value)
})
.then(() => {
    // now your object is updated: foo = 2 and bar = 3
    console.log(obj);
});

You can implement an async version of mapValues. Something like...

async function mapValuesAsync(object, asyncFn) {
  return Object.fromEntries(
    await Promise.all(
      Object.entries(object).map(async ([key, value]) => [
        key,
        await asyncFn(value, key, object)
      ])
    )
  );
}

Then call it like you would call _.mapValues:

let t2 = await mapValuesAsync(obj, (value) => {
    return incrementProm(value);
});

or, simply

let t2 = await mapValuesAsync(obj, incrementProm);

Here's a TypeScript solution, built on top of lodash functions:

import { fromPairs, toPairs, ObjectIterator } from 'lodash';

export async function mapValuesAsync<T extends object, TResult>(
  obj: T | null | undefined,
  callback: ObjectIterator<T, Promise<TResult>>,
): Promise<{ [P in keyof T]: TResult }> {
  return fromPairs(
    await Promise.all(
      toPairs(obj).map(async ([key, value]) => [
        key,
        await callback(value, key, obj),
      ]),
    ),
  ) as { [P in keyof T]: TResult };
}

If you don't need types, here's the JavaScript version:

import { fromPairs, toPairs } from 'lodash';

export async function mapValuesAsync(obj, callback) {
  return fromPairs(
    await Promise.all(
      toPairs(obj).map(async ([key, value]) => [
        key,
        await callback(value, key, obj),
      ]),
    ),
  );
}

And here's a test, just in case you need it:

import { mapValuesAsync } from './map-values-async';

describe('mapValuesAsync', () => {
  it('should map values with an async callback', async () => {
    const result = await mapValuesAsync(
      {
        a: 1,
        b: 2,
      },
      async (value) => {
        return await Promise.resolve(value * 2);
      },
    );

    const expected = {
      a: 2,
      b: 4,
    };
    expect(result).toEqual(expected);
  });
});

This is inspired by Rui Castro's response, posted above, which elegantly makes use of Object.entries and Object.fromEntries. However, that requires es2019 or later to work. Lodash has equivalent functions, toPairs and fromPairs, which work with any flavour of JavaScript.