starhq

The StarHQ Web Framework

StarHQ is a DI(dependency injection) included web framework for MSA(micro-service arcihtecture) using RabbitMQ, MongoDB, Redis and Consul.

StarHQ is inspired by Island, but made it easier to use.

Installation

$ npm i starhq

Service Topology

Client <-> GatewayStar <-> RabbitMQ <-> HelloStar <-> (RabbitMQ, Redis)

Getting Started

I personally you recommend to use Controller - Service - Repository structure to build the app.

• Controller takes the responsibility for the taking and validating parameters.
• Service takes the responsilbilty for all the business logics.
• Repository takes the responsibility for dealing with Storages like MongoDB, Redis, Consul, etc.

Available Environment Variable

Name	Default	Description
CONSUL_URL	consul
CONSUL_PORT	"8500"
CONSUL_TOKEN	01CE1A0F-F2CB-3BA5-B21F-3048816B5928
MQ_URL	rabbitmq
MQ_PORT	"5672"
MONGO_URL	mongo
MONGO_PORT	"27017"
MONGO_DB	test
LOG_LEVEL	debug

Example

 
// app.ts
 
import * as uuid4 from 'uuid/v4'
import { Star, Decorator, Di, Param, IEvent, logger } from 'starhq';
 
import rpc = Decorator.Endpoint.rpc;
import rest = Decorator.Endpoint.rest;
import Request = Param.Request;
import inject = Di.inject;
import worker = Decorator.Event.worker;
import fanout = Decorator.Event.fanout;
 
// Your starting point
class EchoStar extends Star {
  async postInitialize() {
    Di.bindClass(EndpointController);
    Di.bindClass(RpcController);
    Di.bindClass(EventController);
    Di.bindClass(Service);
    Di.bindClass(Repository);
 
    this.registerRestController(EndpointController);
    this.registerRpcController(RpcController);
    this.registerEventController(EventController);
  }
}
 
new EchoStar('echo').run();
 
// Endpoint example
export class EndpointController {
  @rest('GET /echo')
  async echo(req: Request): Promise<string> {
    return 'pong';
  }
 
  @rest('GET /echo/:id')
  async echoUserId(req: Request): Promise<string> {
    const { id } = req.params;
    return `user id: ${id}`;
  }
}
 
// Event example
export class EchoEvent implements IEvent<string> {
  key: string;
  publishedAt: Date;
 
  constructor(public root: string, public body: string) {
    this.key = 'user.echo';
    this.publishedAt = new Date();
  }
}
 
export class EventController {
  @worker(EchoEvent)
  async onWorker(event: EchoEvent): Promise<void> {
    const { root, key, body } = event;
    logger.info(`Round Robin Event ${key} : ${root} => ${body}`);
  }
 
  @fanout('user.echo')  // use key name directly
  async onFanout(event: EchoEvent): Promise<void> {
    const { root, key, body } = event;
    logger.info(`Fanout Event ${key} => ${root} => ${body}`);
  }
 
}
 
// RPC example
export class RpcController {
  constructor(@inject private service: Service) {
  }
 
  @rpc()
  async echo(param): Promise<string> {
    return this.service.echo(param.text);
  }
}
 
// Service
class Service {
  constructor(@inject private messageDust: MessageDust,
              @inject private repository: Repository) {
  }
 
  async echo(text: string): Promise<string> {
    const res = await this.repository.echo(text);
    await this.messageDust.publishEvent(new EchoEvent(uuid4().toString(), res));
    return res;
  }
}
 
// Repository
class Repository {
  async echo(text: string): Promise<string> {
    return text;
  }
}

and run the server

$ tsc
$ node app.js