typed-framework

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

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