@plumjs/plumier/lib/router.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const core_1 = require("@plumjs/core");
const reflect_1 = require("@plumjs/reflect");
const chalk_1 = tslib_1.__importDefault(require("chalk"));
const debug_1 = tslib_1.__importDefault(require("debug"));
const Fs = tslib_1.__importStar(require("fs"));
const Path = tslib_1.__importStar(require("path"));
const path_to_regexp_1 = tslib_1.__importDefault(require("path-to-regexp"));
const log = debug_1.default("plum:router");
/* ------------------------------------------------------------------------------- */
/* ------------------------------- HELPERS --------------------------------------- */
/* ------------------------------------------------------------------------------- */
function striveController(name) {
    return name.substring(0, name.lastIndexOf("Controller")).toLowerCase();
}
exports.striveController = striveController;
function getControllerRoute(controller) {
    const root = controller.decorators.find((x) => x.name == "Root");
    return (root && root.url) || `/${striveController(controller.name)}`;
}
exports.getControllerRoute = getControllerRoute;
function getActionName(route) {
    return `${route.controller.name}.${route.action.name}(${route.action.parameters.map(x => x.name).join(", ")})`;
}
function resolveDir(path, ext) {
    //resolve provided path directory or file
    if (Fs.lstatSync(path).isDirectory()) {
        const files = Fs.readdirSync(path)
            //take only file in extension list
            .filter(x => ext.some(ex => Path.extname(x) === ex))
            //add root path + file name
            .map(x => Path.join(path, x));
        log(`[Router] Resolve files with ${ext.join("|")}`);
        log(`${files.join("\n")}`);
        return files;
    }
    else
        return [path];
}
/* ------------------------------------------------------------------------------- */
/* ---------------------------------- TRANSFORMER -------------------------------- */
/* ------------------------------------------------------------------------------- */
function transformRouteDecorator(controller, method) {
    if (method.decorators.some((x) => x.name == "Ignore"))
        return;
    const root = getControllerRoute(controller);
    const decorator = method.decorators.find((x) => x.name == "Route");
    const result = { action: method, method: decorator.method, controller: controller };
    //absolute route
    if (decorator.url && decorator.url.startsWith("/"))
        return Object.assign({}, result, { url: decorator.url });
    //empty string
    else if (decorator.url === "")
        return Object.assign({}, result, { url: root });
    //relative route
    else {
        const actionUrl = decorator.url || method.name.toLowerCase();
        return Object.assign({}, result, { url: [root, actionUrl].join("/") });
    }
}
function transformRegular(controller, method) {
    return {
        method: "get",
        url: `${getControllerRoute(controller)}/${method.name.toLowerCase()}`,
        action: method,
        controller: controller,
    };
}
function transformController(object) {
    const controller = typeof object === "function" ? reflect_1.reflect(object) : object;
    if (!controller.name.toLowerCase().endsWith("controller"))
        return [];
    return controller.methods.map(method => {
        //first priority is decorator
        if (method.decorators.some((x) => x.name == "Ignore" || x.name == "Route"))
            return transformRouteDecorator(controller, method);
        else
            return transformRegular(controller, method);
    })
        //ignore undefined
        .filter(x => Boolean(x));
}
exports.transformController = transformController;
function transformModule(path, extensions) {
    //read all files and get module reflection
    const modules = resolveDir(path, extensions)
        //reflect the file
        .map(x => reflect_1.reflect(x));
    //get all module.members and combine into one array
    return modules.reduce((a, b) => a.concat(b.members), [])
        //take only the controller class
        .filter(x => x.type === "Class" && x.name.toLowerCase().endsWith("controller"))
        //traverse and change into route
        .map(x => transformController(x))
        //flatten the result
        .flatten();
}
exports.transformModule = transformModule;
/* ------------------------------------------------------------------------------- */
/* ------------------------------- ROUTER ---------------------------------------- */
/* ------------------------------------------------------------------------------- */
function checkUrlMatch(route, ctx) {
    const keys = [];
    const regexp = path_to_regexp_1.default(route.url, keys);
    const match = regexp.exec(ctx.path);
    log(`[Router] Route: ${core_1.b(route.method)} ${core_1.b(route.url)} Ctx Path: ${core_1.b(ctx.method)} ${core_1.b(ctx.path)} Match: ${core_1.b(match)}`);
    return { keys, match, method: route.method.toUpperCase(), route };
}
function router(infos, config, handler) {
    return async (ctx, next) => {
        const match = infos.map(x => checkUrlMatch(x, ctx))
            .find(x => Boolean(x.match) && x.method == ctx.method);
        if (match) {
            log(`[Router] Match route ${core_1.b(match.route.method)} ${core_1.b(match.route.url)} with ${core_1.b(ctx.method)} ${core_1.b(ctx.path)}`);
            //assign config and route to context
            Object.assign(ctx, { config, route: match.route });
            //add query
            const query = match.keys.reduce((a, b, i) => {
                a[b.name.toString().toLowerCase()] = match.match[i + 1];
                return a;
            }, {});
            log(`[Router] Extracted parameter from url ${core_1.b(query)}`);
            Object.assign(ctx.query, query);
            await handler(ctx);
        }
        else {
            log(`[Router] Not route match ${core_1.b(ctx.method)} ${core_1.b(ctx.url)}`);
            await next();
        }
    };
}
exports.router = router;
/* ------------------------------------------------------------------------------- */
/* --------------------------- ANALYZER FUNCTION --------------------------------- */
/* ------------------------------------------------------------------------------- */
//------ Analyzer Helpers
function getModelsInParameters(par) {
    return par
        .map((x, i) => ({ type: x.typeAnnotation, index: i }))
        .filter(x => x.type && core_1.isCustomClass(x.type))
        .map(x => ({ meta: reflect_1.reflect((Array.isArray(x.type) ? x.type[0] : x.type)), index: x.index }));
}
function traverseModel(par) {
    const models = getModelsInParameters(par).map(x => x.meta);
    const child = models.map(x => traverseModel(x.ctorParameters))
        .filter((x) => Boolean(x))
        .reduce((a, b) => a.concat(b), []);
    return models.concat(child);
}
function traverseArray(parent, par) {
    const models = getModelsInParameters(par);
    if (models.length > 0) {
        return models.map((x, i) => traverseArray(x.meta.name, x.meta.ctorParameters))
            .flatten();
    }
    return par.filter(x => x.typeAnnotation === Array)
        .map(x => `${parent}.${x.name}`);
}
//----- 
function backingParameterTest(route, allRoutes) {
    const ids = route.url.split("/")
        .filter(x => x.startsWith(":"))
        .map(x => x.substring(1));
    const missing = ids.filter(id => route.action.parameters.map(x => x.name).indexOf(id) === -1);
    if (missing.length > 0) {
        return {
            type: "error",
            message: core_1.errorMessage.RouteDoesNotHaveBackingParam.format(missing.join(", "))
        };
    }
    else
        return { type: "success" };
}
function metadataTypeTest(route, allRoutes) {
    const hasTypeInfo = route.action
        .parameters.some(x => Boolean(x.typeAnnotation));
    if (!hasTypeInfo && route.action.parameters.length > 0) {
        return {
            type: "warning",
            message: core_1.errorMessage.ActionDoesNotHaveTypeInfo
        };
    }
    else
        return { type: "success" };
}
function multipleDecoratorTest(route, allRoutes) {
    const decorator = route.action.decorators.filter(x => x.name == "Route");
    if (decorator.length > 1) {
        return {
            type: "error",
            message: core_1.errorMessage.MultipleDecoratorNotSupported
        };
    }
    else
        return { type: "success" };
}
function duplicateRouteTest(route, allRoutes) {
    const dup = allRoutes.filter(x => x.url == route.url && x.method == route.method);
    if (dup.length > 1) {
        return {
            type: "error",
            message: core_1.errorMessage.DuplicateRouteFound.format(dup.map(x => getActionName(x)).join(" "))
        };
    }
    else
        return { type: "success" };
}
function modelTypeInfoTest(route, allRoutes) {
    const classes = traverseModel(route.action.parameters)
        .filter(x => x.ctorParameters.every(par => typeof par.typeAnnotation == "undefined"))
        .map(x => x.object);
    log(`[Analyzer] Checking model types ${core_1.b(classes)}`);
    //get only unique type
    const noTypeInfo = Array.from(new Set(classes));
    if (noTypeInfo.length > 0) {
        log(`[Analyzer] Model without type information ${core_1.b(noTypeInfo.map(x => x.name).join(", "))}`);
        return {
            type: "warning",
            message: core_1.errorMessage.ModelWithoutTypeInformation.format(noTypeInfo.map(x => x.name).join(", "))
        };
    }
    else
        return { type: "success" };
}
function arrayTypeInfoTest(route, allRoutes) {
    const issues = traverseArray(`${route.controller.name}.${route.action.name}`, route.action.parameters);
    const array = Array.from(new Set(issues));
    if (array.length > 0) {
        log(`[Analyzer] Array without item type information in ${array.join(", ")}`);
        return {
            type: "warning",
            message: core_1.errorMessage.ArrayWithoutTypeInformation.format(array.join(", "))
        };
    }
    else
        return { type: 'success' };
}
/* ------------------------------------------------------------------------------- */
/* -------------------------------- ANALYZER ------------------------------------- */
/* ------------------------------------------------------------------------------- */
function analyzeRoute(route, tests, allRoutes) {
    const issues = tests.map(test => {
        log(`[Analyzer] Analyzing using ${core_1.b(test.name)}`);
        return test(route, allRoutes);
    })
        .filter(x => x.type != "success");
    return { route, issues };
}
function analyzeRoutes(routes) {
    log(`[Analyzer] Analysing ${core_1.b(routes.map(x => x.url).join(", "))}`);
    const tests = [
        backingParameterTest, metadataTypeTest, multipleDecoratorTest,
        duplicateRouteTest, modelTypeInfoTest, arrayTypeInfoTest
    ];
    return routes.map(x => analyzeRoute(x, tests, routes));
}
exports.analyzeRoutes = analyzeRoutes;
function printAnalysis(results) {
    const data = results.map(x => {
        const method = x.route.method.toUpperCase();
        const action = getActionName(x.route);
        const issues = x.issues.map(issue => ` - ${issue.type} ${issue.message}`);
        return { method, url: x.route.url, action, issues };
    });
    console.log();
    console.log(chalk_1.default.bold("Route Analysis Report"));
    if (data.length == 0)
        console.log("No controller found");
    data.forEach((x, i) => {
        const num = (i + 1).toString().padStart(data.length.toString().length);
        const action = x.action.padEnd(Math.max(...data.map(x => x.action.length)));
        const method = x.method.padEnd(Math.max(...data.map(x => x.method.length)));
        //const url = x.url.padEnd(Math.max(...data.map(x => x.url.length)))
        const issueColor = (issue) => issue.startsWith(" - warning") ? chalk_1.default.yellow(issue) : chalk_1.default.red(issue);
        const color = x.issues.length == 0 ? (x) => x :
            x.issues.some(x => x.startsWith(" - warning")) ? chalk_1.default.yellow : chalk_1.default.red;
        console.log(color(`${num}. ${action} -> ${method} ${x.url}`));
        x.issues.forEach(issue => console.log(issueColor(issue)));
    });
    if (data.length > 0)
        console.log();
}
exports.printAnalysis = printAnalysis;