@napp/dti-server/route.js

data transaction interface server library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DtiServerRoute = void 0;
const dti_core_1 = require("@napp/dti-core");
class DtiServerRoute {
    constructor(meta, server) {
        this.meta = meta;
        this.server = server;
        this.base62 = new dti_core_1.Base62();
    }
    param(action, req) {
        var _a;
        let mode = action.meta.getMode();
        if (mode === dti_core_1.DtiMode.QString) {
            return req.query;
        }
        else if (mode === dti_core_1.DtiMode.QJson) {
            try {
                let p = (_a = req.query) === null || _a === void 0 ? void 0 : _a.p;
                if (p) {
                    let json = this.base62.decode(p);
                    return JSON.parse(json);
                }
            }
            catch (error) {
            }
            return {};
        }
        else if (mode === dti_core_1.DtiMode.BJson || mode === dti_core_1.DtiMode.BFrom) {
            return req.body;
        }
        throw new Error('not supported mode');
    }
    callAction(sa, req, res, next) {
        try {
            let param = this.param(sa, req);
            sa.validation(param);
            return sa.action(param, { req, res })
                .then(rsu => {
                if (dti_core_1.DtiRawResponse.is(rsu) === false) {
                    return res.json(rsu);
                }
            })
                .catch(err => next(err));
        }
        catch (error) {
            return next(error);
        }
    }
    setupAction(expressRoute, action, setuper) {
        let mode = action.meta.getMode();
        let path = action.meta.getPath();
        let endpoint = (req, res, next) => {
            this.callAction(action, req, res, next);
        };
        if (mode === dti_core_1.DtiMode.QString || mode === dti_core_1.DtiMode.QJson) {
            expressRoute.get(path, endpoint);
        }
        else if (mode === dti_core_1.DtiMode.BJson) {
            if (setuper.factoryBodyparseJson) {
                expressRoute.post(path, [setuper.factoryBodyparseJson(), endpoint]);
            }
            else {
                throw new Error('not define server.factoryBodyparseJson');
            }
        }
        else if (mode === dti_core_1.DtiMode.BFrom) {
            if (setuper.factoryBodyparseUrlencode) {
                expressRoute.post(path, [setuper.factoryBodyparseUrlencode(), endpoint]);
            }
            else {
                throw new Error('not define server.factoryBodyparseUrlencode');
            }
        }
        else {
            throw new Error("not support methid. logic error");
        }
    }
    setupActions(expressRoute, setuper) {
        let actions = this.meta.getActions();
        for (let a of actions) {
            let name = a.getFullname();
            let action = this.server.getActionByName(name);
            if (action) {
                this.setupAction(expressRoute, action, setuper);
            }
            else {
                console.warn(`not registered server action. action(${name})`);
            }
        }
    }
    setupRaws(expressRoute, setuper) {
        let name = this.meta.getFullname();
        let handles = this.server.getRawByName(name);
        if (Array.isArray(handles)) {
            for (let handle of handles) {
                handle(expressRoute);
            }
        }
    }
    setup(setuper) {
        let pRoute = setuper.factoryExpressRouter(this.meta);
        this.setupActions(pRoute, setuper);
        this.setupRaws(pRoute, setuper);
        for (let dtiRoute of this.meta.getChildroutes()) {
            let lRoute = new DtiServerRoute(dtiRoute, this.server).setup(setuper);
            pRoute.use(dtiRoute.getLocalPath(), lRoute);
        }
        return pRoute;
    }
}
exports.DtiServerRoute = DtiServerRoute;