typed-framework v0.8.12

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

Enterprise ready spring like framework build on Typescript and Express

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

@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;
}

@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

@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);
    }

}

@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();
    }
}

@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);
    }
}

@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) {
    }

}

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

}

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

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 example: link

Full feature example: link

for 2.0, please go to 2.0 Roadmap

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