# @justindfuller/async-lodash

> Lodash wrapped to work with Promises

Latest version **1.0.9** (published 2018-01-18) · ISC license · 0 weekly downloads

## Install

```sh
npm install @justindfuller/async-lodash
pnpm add @justindfuller/async-lodash
yarn add @justindfuller/async-lodash
bun add @justindfuller/async-lodash
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.9 |
| Published | 2018-01-18 |
| First published | 2018-01-18 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Justin Fuller |
| Maintainers | justindfuller |
| Keywords | javascript, async, promise, lodash |

## Links

- npm: https://www.npmjs.com/package/@justindfuller/async-lodash
- Homepage: https://github.com/JustinDFuller/Async-Lodash
- Issues: https://github.com/JustinDFuller/Async-Lodash/issues
- npm.io page: https://npm.io/package/@justindfuller/async-lodash

## Dependencies (2)

- [lodash](https://npm.io/package/lodash.md) ^4.17.4
- [rollup-plugin-commonjs](https://npm.io/package/rollup-plugin-commonjs.md) ^8.0.2

## Alternatives

- [@commercetools/sync-actions](https://npm.io/package/@commercetools/sync-actions.md) — 25.1K weekly downloads
- [cwait](https://npm.io/package/cwait.md) — 21.4K weekly downloads
- [@ledgerhq/hw-app-cosmos](https://npm.io/package/@ledgerhq/hw-app-cosmos.md) — 4.2K weekly downloads
- [@financial-times/o-loading](https://npm.io/package/@financial-times/o-loading.md) — 2.8K weekly downloads
- [fa](https://npm.io/package/fa.md) — 185 weekly downloads

## Recent versions

- 1.0.9 (latest) — 2018-01-18

## README

# Async-Lodash

This is a very simple wrapper around lodash. It has all the same methods (except chain as of v1.0.0).

Before invoking the lodash method it will resolve all promises that are in the arguments.

## Install

`npm i async-lodash -s`

## Why

Lodash is an amazing library, and it is a pretty standard one to include in most modern JavaScript applications. Promises are another amazing addition to the JS standard. When we put them together, life gets pretty easy. Up until now when you wanted to combine them, you might do something like this:

```javascript
import lodash from 'lodash';

// This async object could be a user event, an HTTP request, or any other async action. We'll mock it quickly here with Promise.resolve.
const asyncObject = Promise.resolve({
  user: {
    id: 4,
    name: 'Buddy',
  },
});

function getUser(asyncUser) {
  return new Promise(resolve => {
    return asyncUser.then(user => resolve(lodash.get(user, 'user.id')));
  });
}

getUser(asyncObject).then(console.log); // 4
```

Honestly, that's really not that bad... BUT I think it could be even easier. What if we could do something like?

```javascript
import lodash from 'lodash';

// This asynchronous object could be a user event, an HTTP request, or any other async action. We'll mock it quickly here with Promise.resolve.
const asyncObject = Promise.resolve({
  user: {
    id: 4,
    name: 'Buddy',
  },
});

function getUser(asyncUser) {
  return lodash.get(asyncUser, 'user.id');
}

getUser(asyncObject).then(console.log); // 4
```

The difference is small, but the benefit is huge. The dirty work of opening and resolving the promise has been taken care of! All you see is the lodash method, just like you would when working with synchronous data.

## Usage

```javascript
import _ from 'async-lodash';

const promise = Promise.resolve({ my: { test: 'value' }});

async function getMyTest(asyncValue) {
  const result = await _.get(asyncValue, 'my.test');
  console.log(result); // 'value'
}
```

```javascript
import _ from 'async-lodash';
import fetch from 'node-fetch';

function getObjectAsync() {
  return new Promise(resolve =>
    fetch('https://github.com/')
      .then(res => res.json())
      .then(resolve);
  });
}

function getMyTest(asyncValue) {
  _.get(getObjectAsync(), 'body.value')
   .then(console.log); // 'whatever property value was returned from fetch';
}
```

## Nested Methods

Often times when using Lodash, methods are nested within each other. This can still be done with Async-Lodash. Here's an example:

```javascript
import _ from 'async-lodash';

const data = [
  {
    id: 5,
    name: 'Tom',
    isActive: false,
  },
  {
    id: 23,
    name: 'Billy',
    isActive: true,
  },
];

_.get(
  _.head(
    _.map(
      // Filter out all inactive users.
      _.filter(Promise.resolve(data), d => d.isActive),
      // Merge the object and return a new one with an info property
      d => Promise.resolve(
        asyncLodash.merge(Promise.resolve(d), { info: `${d.name} is an active user` })
      )
    ),
  ),
  'info',
).then(console.log); // "Billy is an active user"
```

The above example demonstrates that these async methods can be nested, and when promises are included they will still work.

---
_Source: https://npm.io/package/@justindfuller/async-lodash · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._