Piti

Piti is a small cli framework developed with Typescript. You can develop reactive applications by Redux and RxJS in Piti.

Install

$ yarn add @pitijs/core

or

$ npm i @pitijs/core --save

Quick Start

hello.ts

import { Command } from 'piti';

@Command({
  name: 'hello',
  description: 'The hello world command',
})
class HelloCommand {
  handler() {
    console.log('Hello World!');
  }
}

export default HelloCommand;

index.ts

import Piti from 'piti';
import HelloCommand from './hello';

Piti.run({
  scriptName: 'console-app',
  commands: [HelloCommand],
});

Test

$ npx ts-node index.ts hello

Command arguments

Piti uses yargs for command arguments. Created command builder will be inject to command class constructor. So you can be detail your command arguments.

Example:

import { Command } from 'piti';
import { Argv, Arguments } from 'yargs';

@Command({
  name: 'login',
  description: 'Login to platform',
})
class LoginCommand {
  builder(yargs: Argv) {
    builder
      .positional('username', {
        type: 'string',
        describe: 'The user name',
      })
      .positional('password', {
        type: 'string',
        describe: 'The user password',
      });
  }

  handler(args: Arguments) {
    console.log('username:', args.username, 'password:', args.password);
  }
}

export default LoginCommand;

Test

$ npx ts-node index.ts login --username [email protected] --password 1234

For more advanced usage, please visit: http://yargs.js.org

Dependency Injection

With the @Command decorator you can inject parameters into the command class constructor.

@Command({
  name: '...',
  description: '...',
  commands: [],
  inject: [auth, user],
})
class LoginCommand {
  constructor(auth, user) {
    // ...
  }
}

Use with Redux

You can manage state of objects using pure ReduxJS library. For this first of all, you should be configure the redux then pass the store to Piti.

Install Redux:

$ yarn add redux

Create store:

import Piti from 'piti';
import { createStore } from 'redux';

const store = createStore(reducers);

Piti.run({
  commands: [],
  scriptName: 'console-app',
  store,
});

That's all.

Actions and Subscribers

Action creator

const fetchUser = (email: string) => async (dispatch) => {
  try {
    dispatch({ type: 'FETCH_USER_PENDING' });
    const result = await fetch(/**api request**/);
    dispatch({ type: 'FETCH_USER_FULFILLED', data: result });
  } catch (e) {
    dispatch({ type: 'FETCH_USER_REJECTED', error: e });
  }
};

Reducer

const initialState = {
  pending: false,
  error: null,
  user: null,
};

const userReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'FETCH_USER_PENDING': {
      return {
        ...state,
        pending: true,
      };
    },
    case 'FETCH_USER_FULFILLED': {
      return {
        ...state,
        pending: false,
        user: action.data
      }
    },
    case 'FETCH_USER_REJECTED': {
      return {
        error: action.error,
        pending: false,
        user: null,
      }
    }
    default:
      return state;
  }
};

Command

import { Command, Subscribe, dispatch, getState } from 'piti';

@Command({
  name: 'create-user [email]',
  description: 'Create a new user',
})
class CreateUserCommand {
  args = {};

  @Subscribe('FETCH_USER_FULFILLED')
  userAlreadyExists() {
    console.log('The user already created!');
  }

  @Subscribe('FETCH_USER_REJECTED')
  fetchUserRejected() {
    const { user } = getState();
    if (user.error.message === 'user not found') {
      this.createNewUser();
    }
  }

  @Subscribe('CREATE_USER_FULFILLED')
  createUserFulfilled() {
    console.log('User created!');
  }

  createNewUser() {
    const { email } = this.args;
    dispatch(createUser(email));
  }

  handler(args: Arguments) {
    this.args = args;
    dispatch(fetchUser(args.email));
  }
}

Test

$ npx ts-node index.ts create-user [email protected]

RxJS Operators

import { Subject, Observable } from 'rxjs';
import { filter } from 'rxjs/operators';

@Command({
  name: 'fetch-users',
  description: 'Fetch users and filter vip ones',
})
class CreateUserCommand {
  @Subscribe({
    action: 'FETCH_USERS_FULFILLED',
    observer(subject: Subject<any>): Observable<any> {
      return subject.pipe(filter((user) => user.isVip));
    },
  })
  fetchUsersFulfilled(result) {
    console.log(result);
    // [{name: 'Thor', isVip: true}]
  }

  handle() {
    dispatch(fetchUsers());
  }
}

Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

License

MIT