Noncollinear Perpendicular Microcrystalline

    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

    Install

    npm i typed-framework

    DownloadsWeekly Downloads

    2

    Version

    0.8.12

    License

    Apache-2.0

    Last publish

    Collaborators

    • vincent178