pi

promise-interactor

Promise pattern applied to the interactor pattern applied to the JS

Showing:

Popularity

Downloads/wk

7

GitHub Stars

4

Maintenance

Last Commit

1yr ago

Contributors

8

Package

Dependencies

0

License

MIT

Type Definitions

Built-In

Tree-Shakeable

No?

Categories

Readme

Node.js CI Dependency Status Dev Dependency Status Greenkeeper badge FOSSA Status

Interactors

Based on the popular ruby gem Interactor. Uses chainable promises to allow flow of completing multiple interactors.

Single Pattern

import PromiseInteractor from 'promise-interactor';

const { Interactor } = PromiseInteractor;

class AuthenticateUser extends Interactor {

  // optional before, if it returns a promise it is inserted in the promise chain
  before() {
    return Promise.resolve(true);
  }

  call() {
    const { password, email } = this.context;
    User.find({email: email}).then((user) => {
      if (user.password === password) {
        this.context.user = user;
        this.resolve();
      } else {
        this.reject(new Error("Invalid password"));
      }
    }).error( (err) => {
      this.reject(err);
    });
  }

  // optional after, if it returns a promise it is inserted in the promise chain
  // just before we resolve the root promise
  after() {
    return Promise.resolve(true);
  }
}

module.exports = AuthenticateUser;

Calling the interactor

(new AuthenticateUser({email, password}))
  .exec()
  .then((interactor) => {
    console.log(`User logged in: ${interactor.context.user}`);
  })
  .catch((err) => {
    console.log(`Error: ${error}`);
  });

Rollback

If your interactor rejected, you can optionally provide a rollback which will clean up

class AuthenticateUser extends Interactor{
  // If we returned a promise, it would wait on that before calling the reject
  // otherwise this is considered a sync call and the promise is rejected immediately after
  rollback(err) {
    console.log(err);
  }
}

Organization Pattern

Makes grouping interactors in sequence a little easier.

import PromiseInteractor from 'promise-interactor';

const { Organizer } = PromiseInteractor;

class AuthUserOrganizer extends Organizer {

  organize() {
    return [AuthenticateUser, SomeOtherInteractor];
  }
}

AuthUserOrganizer
  .exec({email, password})
  .then((i) => {
    console.log(i.context);
  });
...

rollback for Organizer will call rollback for previously RESOLVED interactors with the current state. You can override this functionality by implementing your own rollback on Organizer.

License

FOSSA Status

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