@plumjs/core/lib/core.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const tinspector_1 = tslib_1.__importStar(require("tinspector"));
const common_1 = require("./common");
/* ------------------------------------------------------------------------------- */
/* -------------------------------- HELPERS -------------------------------------- */
/* ------------------------------------------------------------------------------- */
var MiddlewareUtil;
(function (MiddlewareUtil) {
    function fromKoa(middleware) {
        return {
            execute: async (x) => {
                await middleware(x.context, async () => {
                    const nextResult = await x.proceed();
                    await nextResult.execute(x.context);
                });
                return ActionResult.fromContext(x.context);
            }
        };
    }
    MiddlewareUtil.fromKoa = fromKoa;
})(MiddlewareUtil = exports.MiddlewareUtil || (exports.MiddlewareUtil = {}));
/* ------------------------------------------------------------------------------- */
/* -------------------------------- CLASSES -------------------------------------- */
/* ------------------------------------------------------------------------------- */
class ActionResult {
    constructor(body, status) {
        this.body = body;
        this.status = status;
        this.headers = {};
    }
    static fromContext(ctx) {
        return new ActionResult(ctx.body, ctx.status);
    }
    setHeader(key, value) {
        this.headers[key] = value;
        return this;
    }
    setStatus(status) {
        this.status = status;
        return this;
    }
    async execute(ctx) {
        Object.keys(this.headers).forEach(x => {
            ctx.set(x, this.headers[x]);
        });
        if (this.body)
            ctx.body = this.body;
        if (this.status)
            ctx.status = this.status;
    }
}
exports.ActionResult = ActionResult;
class HttpStatusError extends Error {
    constructor(status, message) {
        super(message);
        this.status = status;
        Object.setPrototypeOf(this, HttpStatusError.prototype);
    }
}
exports.HttpStatusError = HttpStatusError;
class ConversionError extends HttpStatusError {
    constructor(issues) {
        super(400);
        this.issues = issues;
        Object.setPrototypeOf(this, ConversionError.prototype);
    }
}
exports.ConversionError = ConversionError;
class ValidationError extends HttpStatusError {
    constructor(issues) {
        super(422);
        this.issues = issues;
        Object.setPrototypeOf(this, ValidationError.prototype);
    }
}
exports.ValidationError = ValidationError;
class DefaultDependencyResolver {
    resolve(type) {
        return new type();
    }
}
exports.DefaultDependencyResolver = DefaultDependencyResolver;
/* ------------------------------------------------------------------------------- */
/* ----------------------------- DECORATORS -------------------------------------- */
/* ------------------------------------------------------------------------------- */
var bind;
(function (bind) {
    /**
     * Bind Koa Context
     *
     *    method(@bind.ctx() ctx:any) {}
     *
     * Use dot separated string to access child property
     *
     *    method(@bind.ctx("state.user") ctx:User) {}
     *    method(@bind.ctx("request.headers.ip") ip:string) {}
     *    method(@bind.ctx("body[0].id") id:string) {}
     *
     * @param part part of context, use dot separator to access child property
     */
    function ctx(part) {
        return tinspector_1.decorateParameter({
            type: "ParameterBinding",
            process: ctx => part ? common_1.getChildValue(ctx, part) : ctx
        });
    }
    bind.ctx = ctx;
    /**
     * Bind Koa request to parameter
     *
     *    method(@bind.request() req:Request){}
     *
     * If parameter provided, part of request property will be bound
     *
     *    method(@bind.request("method") httpMethod:string){}
     *    method(@bind.request("status") status:number){}
     *
     * @param part part of request ex: body, method, query etc
     */
    function request(part) {
        return ctx(["request", part].join("."));
    }
    bind.request = request;
    /**
     * Bind request body to parameter
     *
     *     method(@bind.body() body:AnimalDto){}
     *
     * If parameter provided, part of body property will be bound
     *
     *     method(@bind.body("name") name:string){}
     *     method(@bind.body("age") age:number){}
     */
    function body(part) {
        return ctx(["request", "body", part].join("."));
    }
    bind.body = body;
    /**
     * Bind request header to parameter
     *
     *     method(@bind.header() header:any){}
     *
     * If parameter provided, part of header property will be bound
     *
     *     method(@bind.header("accept") accept:string){}
     *     method(@bind.header("cookie") age:any){}
     */
    function header(key) {
        return ctx(["request", "headers", key].join("."));
    }
    bind.header = header;
    /**
     * Bind request query object to parameter
     *
     *     method(@bind.query() query:any){}
     *
     * If parameter provided, part of query property will be bound
     *
     *     method(@bind.query("id") id:string){}
     *     method(@bind.query("type") type:string){}
     */
    function query(name) {
        return ctx(["request", "query", name].join("."));
    }
    bind.query = query;
    /**
     * Bind current login user to parameter
     *
     *     method(@bind.user() user:User){}
     */
    function user() {
        return ctx("state.user");
    }
    bind.user = user;
    /**
     * Bind file parser for multi part file upload. This function required `FileUploadFacility`
    ```
    @route.post()
    async method(@bind.file() file:FileParser){
        const info = await file.parse()
    }
    ```
     */
    function file() {
        return tinspector_1.decorateParameter({
            type: "ParameterBinding",
            process: ctx => {
                if (!ctx.config.fileParser)
                    throw new Error("No file parser found in configuration");
                return ctx.config.fileParser(ctx);
            }
        });
    }
    bind.file = file;
    /**
     * Bind custom part of Koa context into parameter
     * example:
     *
     *    method(@bind.custom(ctx => ctx.request.body) user:User){}
     * @param process callback function to process the Koa context
     */
    function custom(process) {
        return tinspector_1.decorateParameter({ type: "ParameterBinding", process });
    }
    bind.custom = custom;
})(bind = exports.bind || (exports.bind = {}));
class RouteDecoratorImpl {
    decorateRoute(method, url) { return tinspector_1.decorateMethod({ name: "Route", method, url }); }
    /**
     * Mark method as POST method http handler
     ```
     class AnimalController{
        @route.post()
        method(id:number){}
     }
     //result: POST /animal/method?id=<number>
     ```
     * Override method name with absolute url
     ```
     class AnimalController{
        @route.post("/beast/:id")
        method(id:number){}
     }
     //result: POST /beast/:id
     ```
     * Override method name with relative url
     ```
     class AnimalController{
        @route.post("get")
        method(id:number){}
     }
     //result: POST /animal/get?id=<number>
     ```
     * @param url url override
     */
    post(url) { return this.decorateRoute("post", url); }
    /**
     * Mark method as GET method http handler
     ```
     class AnimalController{
        @route.get()
        method(id:number){}
     }
     //result: GET /animal/method?id=<number>
     ```
     * Override method name with absolute url
     ```
     class AnimalController{
        @route.get("/beast/:id")
        method(id:number){}
     }
     //result: GET /beast/:id
     ```
     * Override method name with relative url
     ```
     class AnimalController{
        @route.get("get")
        method(id:number){}
     }
     //result: GET /animal/get?id=<number>
     ```
     * @param url url override
     */
    get(url) { return this.decorateRoute("get", url); }
    /**
     * Mark method as PUT method http handler
     ```
     class AnimalController{
        @route.put()
        method(id:number){}
     }
     //result: PUT /animal/method?id=<number>
     ```
     * Override method name with absolute url
     ```
     class AnimalController{
        @route.put("/beast/:id")
        method(id:number){}
     }
     //result: PUT /beast/:id
     ```
     * Override method name with relative url
     ```
     class AnimalController{
        @route.put("get")
        method(id:number){}
     }
     //result: PUT /animal/get?id=<number>
     ```
     * @param url url override
     */
    put(url) { return this.decorateRoute("put", url); }
    /**
     * Mark method as DELETE method http handler
     ```
     class AnimalController{
        @route.delete()
        method(id:number){}
     }
     //result: DELETE /animal/method?id=<number>
     ```
     * Override method name with absolute url
     ```
     class AnimalController{
        @route.delete("/beast/:id")
        method(id:number){}
     }
     //result: DELETE /beast/:id
     ```
     * Override method name with relative url
     ```
     class AnimalController{
        @route.delete("get")
        method(id:number){}
     }
     //result: DELETE /animal/get?id=<number>
     ```
     * @param url url override
     */
    delete(url) { return this.decorateRoute("delete", url); }
    /**
     * Override controller name on route generation
     ```
     @route.root("/beast")
     class AnimalController{
        @route.get()
        method(id:number){}
     }
     //result: GET /beast/method?id=<number>
     ```
     * Parameterized root, useful for nested Restful resource
     ```
     @route.root("/beast/:type/bunny")
     class AnimalController{
        @route.get(":id")
        method(type:string, id:number){}
     }
     //result: GET /beast/:type/bunny/:id
     ```
     * @param url url override
     */
    root(url) { return tinspector_1.decorateClass({ name: "Root", url }); }
    /**
     * Ignore method from route generation
     ```
     class AnimalController{
        @route.get()
        method(id:number){}
        @route.ignore()
        otherMethod(type:string, id:number){}
     }
     //result: GET /animal/method?id=<number>
     //otherMethod not generated
     ```
     */
    ignore() { return tinspector_1.decorateMethod({ name: "Ignore" }); }
}
exports.RouteDecoratorImpl = RouteDecoratorImpl;
exports.route = new RouteDecoratorImpl();
var middleware;
(function (middleware_1) {
    function use(...middleware) {
        const mdw = middleware.map(x => typeof x == "function" ? MiddlewareUtil.fromKoa(x) : x).reverse();
        const value = { name: "Middleware", value: mdw };
        return tinspector_1.decorate(value, ["Class", "Method"]);
    }
    middleware_1.use = use;
})(middleware = exports.middleware || (exports.middleware = {}));
function domain() { return tinspector_1.default.parameterProperties(); }
exports.domain = domain;
class AuthDecoratorImpl {
    /**
     * Authorize controller/action to public
     */
    public() {
        return tinspector_1.decorate((...args) => {
            if (args.length === 3 && typeof args[2] === "number")
                throw new Error(errorMessage.PublicNotInParameter);
            return { type: "authorize:public", value: [] };
        }, ["Class", "Parameter", "Method"]);
    }
    /**
     * Authorize controller/action accessible by sepecific role
     * @param roles List of roles allowed
     */
    role(...roles) {
        return tinspector_1.mergeDecorator(tinspector_1.decorate({ type: "authorize:role", value: roles }, ["Class", "Parameter", "Method"]), (...args) => {
            if (args.length === 3 && typeof args[2] === "number")
                tinspector_1.decorateParameter({ type: "ValidatorDecorator", validator: "optional" })(args[0], args[1], args[2]);
        });
    }
}
exports.AuthDecoratorImpl = AuthDecoratorImpl;
exports.authorize = new AuthDecoratorImpl();
/* ------------------------------------------------------------------------------- */
/* -------------------------------- CONSTANTS ------------------------------------ */
/* ------------------------------------------------------------------------------- */
exports.DefaultConfiguration = {
    mode: "debug",
    controller: "./controller",
    dependencyResolver: new DefaultDependencyResolver()
};
var errorMessage;
(function (errorMessage) {
    //PLUM1XXX User configuration error
    errorMessage.RouteDoesNotHaveBackingParam = "PLUM1000: Route parameters ({0}) doesn't have appropriate backing parameter";
    errorMessage.ActionDoesNotHaveTypeInfo = "PLUM1001: Parameter binding skipped because action doesn't have @route decorator";
    errorMessage.DuplicateRouteFound = "PLUM1003: Duplicate route found in {0}";
    errorMessage.ControllerPathNotFound = "PLUM1004: Controller file or directory {0} not found";
    errorMessage.ModelWithoutTypeInformation = "PLUM1005: Parameter binding skipped because  {0} doesn't have @domain() decorator";
    errorMessage.ArrayWithoutTypeInformation = "PLUM1006: Parameter binding skipped because array field without @array() decorator found in ({0})";
    errorMessage.ModelNotFound = "PLUM1007: Domain model not found, no class decorated with @domain() on provided classes";
    errorMessage.ModelPathNotFound = "PLUM1007: Domain model not found, no class decorated with @domain() on path {0}";
    errorMessage.PublicNotInParameter = "PLUM1008: @authorize.public() can not be applied to parameter";
    //PLUM2XXX internal app error
    errorMessage.UnableToInstantiateModel = `PLUM2000: Unable to instantiate model {0}. Domain model should be instantiable using default constructor`;
    //End user error (no error code)
    errorMessage.UnableToConvertValue = `Unable to convert "{0}" into {1}`;
    errorMessage.FileSizeExceeded = "File {0} size exceeded the maximum size";
    errorMessage.NumberOfFilesExceeded = "Number of files exceeded the maximum allowed";
})(errorMessage = exports.errorMessage || (exports.errorMessage = {}));