am

async-mapper

Asynchronously map any JS value to another JS value

Showing:

Popularity

Downloads/wk

0

GitHub Stars

1

Maintenance

Last Commit

5yrs ago

Contributors

0

Package

Dependencies

0

License

MIT

Type Definitions

Tree-Shakeable

No?

Categories

Readme

async-mapper

Library to asynchronously map one JS value to another JS value. Typically, to convert some object received from API server to an object that conforms you internal ORM or something.

Why?

There are tons of nice libraries on npm to map JS values, but all of them consider only synchronous rules (e.g. parse integer from string, rename object property, lowercase the string, sum all float items of the array, etc.). But we often bump into need to do some async check, or to read something from DB or third-party API to properly convert received data. After all, NodeJS is all about being asynchronous, and that's what we love it for, right? So we need async mapping rules.

Why callbacks, not Promises?

Well, Promises would be much nicer and cleaner, sure. But this library was born from the project that heavily uses famous async library. Hence this old-school callback-based style. Sorry for inconvenience, hipsters.

Ah, yeah, while being partly inspired by async library, async-mapper doesn't depend on it. It actually doesn't depend on any other library. I believe you can bloat you node_modules yourself, without my help.

Usage


import assert from 'assert';
import * as lib from 'async-mapper';

const source = {
    name: 'John Doe',
    pets: [{name: 'Dog'}, {name: 'Cat'}]
};

const rules = {
    // exact value no matter what the source is
    'constant': lib.exactly(123),

    // get object property by name
    'byName': 'name',

    // ...or by path traversing nested objects and/or arrays
    'byPath': 'pets.1.name',

    // arbitrary synchronous rule (1 argument)
    'syncRule': (source) => source.name,

    // or arbitrary asynchronous rule (2 arguments)
    'asyncRule': (source, cb) => cb(null, source.name),

    // combine rules in sequence
    'sequenceOfRules': lib.seq([
        'name',
        (input) => input.toUpperCase(),
        (input, cb) => `${input}${input.lenght}`
    ]),

    // combine rules in parallel map
    'mapOfRules': lib.map({
        'lower': [
            'name',
            (input) => input.toLowerCase()
        ],
        'upper': [
            'name',
            (input) => input.toUpperCase()
        ]
    })
};

const result = lib.map(rules)(source);

assert.deepStrictEqual(result, {
    constant: 123,
    byName: 'John Doe',
    byPath: 'Cat',
    syncRule: 'John Doe',
    asyncRule: 'John Doe',
    sequenceOfRules: 'JOHN DOE8',
    mapOfRules: {
        lower: 'john doe',
        upper: 'JOHN DOE'
    }
});

More usage examples in tests.

License

MIT

Rate & Review

Great Documentation0
Easy to Use0
Performant0
Highly Customizable0
Bleeding Edge0
Responsive Maintainers0
Poor Documentation0
Hard to Use0
Slow0
Buggy0
Abandoned0
Unwelcoming Community0
100
No reviews found
Be the first to rate

Alternatives

No alternatives found

Tutorials

No tutorials found
Add a tutorial