typed-framework
TypeScript icon, indicating that this package has built-in type declarations

0.8.12 • Public • Published

I'm working hard to test this against production, once it's ready, I will release the 1.0.0, please stay tuned.

NPM version Downloads Build Status Dependency status Dev Dependency status Coverage Status

Initialize Application

Enterprise ready spring like framework build on Typescript and Express

Initialize Application

  • Dependency Injection (constructor injection and property injection)
  • Service class
  • Rest route and controller, param data injection support
  • Middleware
  • Filter
  • Log support
  • DB support

Initialize Application

@ApplicationSettings({rootDir: `${__dirname}/../`})
class Application extends ApplicationLoader {
 
    public static initialize() {
        return new Application().start();
    }
}
 
Application
    .initialize()
    .catch(e => {
        throw e
    });
 
 

Support ApplicationSettings options:

interface SettingOptions {
    // Required
    rootDir: string;
 
    srcDir?: string;
 
    publicDir?: string;
 
    logDir?: string;
 
    configDir?: string;
 
    dbDir?: string;
 
    env?: string;
 
    port?: string|number;
}
 

Handle a request

@RestController()
// RestController support baseUrl options, for example: @RestController("/users")
export class HomeController {
 
    @Get("/")
    public indexAction(@Data() data: any, @Res() res: Express.Response) {
        res.send(data);
    }
 
}
 

Support parameter types:

@PathParam
@QueryParam
@BodyParam
@HeaderParam
@CookieParam
@Req
@Res
@Next
@Err
@Data

Support Http request method:

@Get 
@Post
@Put
@Patch
@Delete
@Head
@Options

Use a filter, pass data across filter and controller

@Filter()
export class CurrentUser implements IMiddleware {
 
    constructor(private userService: UserService) {
    }
 
    public async use(@Data() data: any, @Next() next: Express.NextFunction) {
 
        data.user = await this.userService.findById(1);
 
        next();
    }
}
 
@RestController()
@BeforeFilter(CurrentUser) 
// also support options only and except, for example: 
// @BeforeFilter(CurrentUser, only: ['indexAction'])
// @BeforeFilter(CurrentUser, except: ['indexAction'])
// @AfterFilter(CurrentUser) only, except options as well
export class HomeController {
 
    @Get("/")
    public indexAction(@Data() data: any, @Res() res: Express.Response) {
        res.send(data);
    }
 
}
 

Use global middleware

@Middleware({order: 0}) 
// middleware support two options: order and baseUrl
export class Middleware1 implements IMiddleware {
 
    public use(@Data() data: any, @Next() next: Express.NextFunction) {
        data.message = "global middleware";
        next();
    }
}

Use global error middleware

@ErrorMiddleware()
// error middleware support two options: order and baseUrl
export class ErrMiddleware implements IMiddleware {
 
    public use(@Err() err: any, @Res() res: Express.Response) {
        res.send(err.message);
    }
}

Use a service and inject into controller and middleware, filter

@Service()
export class UserService {
 
    public findById(id: number) {
 
        const userFromDB = {
            uuid: "123",
            created_at: Date.now()
        };
        
        return userFromDB;
    }
}
 
@RestController()
export class HomeController {
    
    constructor(private userService: UserService) {
    }
 
}

Use logger and db connection

@RestController()
export class HomeController {
    
    private connection = ConnectionFactory.getConnection(); // Database connection is Knex instance 
    private logger = LogFactory.getLogger(); // Logger is winston instance
 
}

Type convert in parameters

 
class User {
 
    // decorate the property you want to convert
    @Property()
    public name: string;
 
    // if it is an array or an map, you need to provide the baseType
    @Property({baseType: Number})
    public ids: number[];
 
    // provide an alias name, or pass in {name: "created_at"} is also valid
    @Property("created_at")
    public createdAt: Date;
 
}
 
 
@RestController()
export class UserController {
 
    @Post("/users")
    public createAction(@BodyParam("user") user: User) {
        user instanceof User // true
        ...
    }
}

Support @BodyParam, @PathParam, @QueryParam, based on the type you provided,
the converter service will automatic convert the data from user to the type.
!! Must use @Property to decorate the property you want to convert

Use convert service

const userObj = {
    name: "tester",
    ids: [1, 2, 3],
    created_at: "2017-04-17T00:59:56.729Z"
}
 
class UserService {
    constructor(private converter: ConverterService) {}
 
    public findUser() {
 
        // first parameter is the data need to convert
        // second parameter is the target type
        // if second parameter is Array or Map, you need provide the baseType in the third parameter
        const user = this.converter.convert(userObj, User);
 
        user instanceof User // true
    }
}

Quick start

Quick start example: link

Full feature example: link

Roadmap

for 2.0, please go to 2.0 Roadmap

Version Code Target Date Release Date Description
0.1.0 2017-02-17 2017-02-17 controller/server/service api
0.2.0 2017-03-05 2017-03-12 middleware/plugin system
0.3.0 2017-03-12 2017-03-13 enrich controller api
0.4.0 2017-03-19 2017-03-14 global and error middleware
0.5.0 2017-03-26 2017-03-14 stable api/pre-production version
1.0.0 2017-04-01 enrich document

Release note

v0.8.0 (2017-04-18)

  • add test solution: use bootstrap function
  • add PropertyInherited decorator

v0.7.0 (2017-04-17)

  • add type convert in controller parameters
  • add ConverterService to convert data
  • add Property decorator

v0.6.0 (2017-03-17)

  • add required parameter options
  • add @Head, @Options http request

v0.5.0 (2017-03-14)

  • add logger config

v0.4.0 (2017-03-14)

  • @Middleware and @ErrorMiddleware support
  • middleware order and base url support

v0.3.0 (2017-03-13)

  • Support @Filter decorator to decorate a class as a Filter
  • Support @BeforeFilter, @AfterFilter to filter for a controller, add options: only, except
  • Support @Data param type to inject data for the controller and filters

v0.2.0 (2017-03-12)

  • Support @Middleware decorator to inject for controllers
  • Support Middleware, Controller parameter injections, now your middleware have the same ability as Controller to inject not only Req, Res, and BodyParam, PathParam and so on.
  • Support new @ApplicationSettings and ApplicationLoader for new start up application way
  • Support convert class to object and object to class by Converter, and provide template ability

v0.1.0 (2017-02-17)

  • Spring like routes and controller support based on express
  • Build in support for log based on winston
  • Build in support for query builder based on knex
  • Best practice middlewares preinstalled
  • Best practice project structure
  • Easy server initialization
  • Dependency Injection

Core Team


Vincent

Founder of typed-framework

Package Sidebar

Install

npm i typed-framework

Weekly Downloads

2

Version

0.8.12

License

Apache-2.0

Last publish

Collaborators

  • vincent178