# @guseyn/cutie

> Cutie is a library with beautiful abstractions and primitives that make your asynchronous code in Node simple and declarative.

Latest version **1.4.0** (published 2018-05-28) · MIT license · 0 weekly downloads

## Install

```sh
npm install @guseyn/cutie
pnpm add @guseyn/cutie
yarn add @guseyn/cutie
bun add @guseyn/cutie
```

## 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.4.0 |
| Published | 2018-05-28 |
| First published | 2018-03-11 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 18.1 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 21 |
| Author | guseyn |
| Maintainers | guseyn |
| Keywords | cutie, async, object, tree, abstractions, oop, desing, guseyn |

## Links

- npm: https://www.npmjs.com/package/@guseyn/cutie
- Repository: https://github.com/Guseyn/cutie
- Homepage: https://github.com/Guseyn/cutie#readme
- Issues: https://github.com/Guseyn/cutie/issues
- npm.io page: https://npm.io/package/@guseyn/cutie

## 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.4.0 (latest) — 2018-05-28
- 1.3.9 — 2018-05-28
- 1.3.8 — 2018-05-28
- 1.3.7 — 2018-05-20
- 1.3.6 — 2018-05-15
- 1.3.5 — 2018-05-15
- 1.3.4 — 2018-05-08
- 1.3.3 — 2018-05-06
- 1.3.2 — 2018-05-05
- 1.3.1 — 2018-05-04
- 1.3.0 — 2018-05-04
- 1.2.8 — 2018-05-01
- 1.2.7 — 2018-05-01
- 1.2.6 — 2018-05-01
- 1.2.5 — 2018-04-14
- … 25 more at https://npm.io/package/@guseyn/cutie/versions

## README

# Cutie

[![NPM Version][npm-image]][npm-url]

Cutie is a lightweight library without any external dependencies, the main point of which is just to provide user with abstractions that make asynchronous code in Node simple and declarative.

# Motivation
Let's say we want to write content to a file that has been read from another one. And all these operations are asynchronous, of course. So, instead of writing something like this:
```js
fs.readFile('./../file1.txt', 'utf8', (err, result) => {
  if (err != null) {
    throw err;
  }
 
  fs.writeFile('/../file2.txt', result, (err) => {
    if (err != null) {
      throw err;
    }
  });
});
```
we can design our code in the following style:
```js
new WrittenFile(
  './../file2.txt',
  new ReadFile('./../file1.txt', 'utf8')
).call();
```
# How to use
You can use Cutie as a dependency via npm:
<b>npm install @guseyn/cutie</b>
```js
const AsyncObject = require('@guseyn/cutie').AsyncObject;
const fs = require('fs');

class WrittenFile extends AsyncObject {

  constructor(path, content) {
    super(path, content);
  }
  
  definedAsyncCall() {
    return fs.writeFile;
  }
  
}
```
```js
const AsyncObject = require('@guseyn/cutie').AsyncObject;
const fs = require('fs');

class ReadFile extends AsyncObject {

  constructor(path, encoding) {
    super(path, encoding);
  }
  
  definedAsyncCall() {
    return fs.readFile;
  }

}
```
AsyncObject also provides methods OnResult and OnError, so that you can process the result from async call and handle an error in the specific way (error is being thrown by default).

Let's say we want to read a json file and parse all information from there. Cutie provides two ways. First of them is just to create <b>ReadJsonFile</b> async object like this:
```js
const AsyncObject = require('@guseyn/cutie').AsyncObject;
const fs = require('fs');

class ReadJsonFile extends AsyncObject {
  
  constructor(path, encoding) {
    super(path, encoding);
  }
  
  definedAsyncCall() {
    return fs.readFile;
  }
  
  onResult(result) {
    return JSON.parse(result);
  }

}

// usage
new ReadJsonFile('./../file.txt', 'utf8').call();
```
<b>ReadJsonFile</b> also could be designed like this:
```js
const fs = require('fs');
const ReadFile = require('./ReadFile');

class ReadJsonFile extends ReadFile {
  
  constructor(path, encoding) {
    super(path, encoding);
  }
  
  onResult(result) {
    return JSON.parse(result);
  }

}

// usage
new ReadJsonFile('./../file.txt', 'utf8').call();
```
Or you can use <b>ReadFile</b> with <b>ParsedJson</b> that looks like this:
```js
const AsyncObject = require('@guseyn/cutie').AsyncObject;
const fs = require('fs');
const ReadFile = require('./ReadFile');

class ParsedJson extends AsyncObject {

  constructor(text) {
    super(text);
  }
  
  /*
    you can't call here async operations with I/O
  */
  definedSyncCall() {
    return (text) => {
      return JSON.parse(text);
    }
  }

}

// usage
new ParsedJson(
  new ReadFile('./../file.txt', 'utf8')
).call();
```
[Learn more](http://guseyn.com/post-reconsidering-async-object-with-cutie#intro).

Also Cutie provides <b>Event</b> abstraction for event listeners in Node. [Read more](http://guseyn.com/post-event-new-abstraction-in-cutie#intro).

# Updates:

'As' conception: [Read](http://guseyn.com/post-as-conception#intro).

API of 'As' conception is changed (since v.1.3.7): [Read](http://guseyn.com/post-after-conception#intro).

Consider the following example with async tree:
```js
new SavedNewAccountOfUser(
  new RetrievedUser(userId),
  new RetrievedOldAccountOfUser(
    new RetrievedUser(userId)
  )
).call();
```
So, here we try to save new account for user that based(somehow) on its old one. And as you can see, we retrieve user here twice. `RetrievedUser` might be a quite expensive operation, so we don't want to do it more than one time.

Cutie proposes following solution:

```js
new RetrievedUser(userId).as('user')
  .after(
    new SavedNewAccountOfUser(
      as('user'),
      new RetrievedOldAccountOfUser(
        as('user')
      )
    )
  ).call();
```
Every `async object` can has `as(key)` method, which says to the `async object` that it must save its represented value(result) into the cache with the specified `key`.

If `as(key)` method is used as independent(separate) function, it returns `AsyncObject`, which represented value is cached value from the cache with the specified `key`.

Sequence of async trees(about 'after' word): [Read](http://guseyn.com/post-after-conception#intro).

[npm-image]: https://img.shields.io/npm/v/@guseyn/cutie.svg
[npm-url]: https://npmjs.org/package/@guseyn/cutie

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