@bigtyphoon/melo 1.7.6

package/dist/lib/common/service/filterService.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterService = void 0;
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const path = require("path");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+/**
+ * Filter service.
+ * Register and fire before and after filters.
+ */
+class FilterService {
+    constructor() {
+        this.befores = []; // before filters
+        this.afters = []; // after filters
+        this.name = 'filter';
+    }
+    removeBefore(filter) {
+        let index = this.befores.findIndex(v => v === filter);
+        if (index >= 0) {
+            this.befores.splice(index);
+        }
+    }
+    removeAfter(filter) {
+        let index = this.afters.findIndex(v => v === filter);
+        if (index >= 0) {
+            this.afters.splice(index);
+        }
+    }
+    /**
+     * Add before filter into the filter chain.
+     *
+     * @param filter {Object|Function} filter instance or filter function.
+     */
+    before(filter) {
+        this.befores.push(filter);
+    }
+    /**
+     * Add after filter into the filter chain.
+     *
+     * @param filter {Object|Function} filter instance or filter function.
+     */
+    after(filter) {
+        this.afters.unshift(filter);
+    }
+    /**
+     * TODO: other insert method for filter? such as unshift
+     */
+    /**
+     * Do the before filter.
+     * Fail over if any filter pass err parameter to the next function.
+     *
+     * @param msg {Object} clienet request msg
+     * @param session {Object} a session object for current request
+     * @param cb {Function} cb(err) callback function to invoke next chain node
+     */
+    beforeFilter(routeRecord, msg, session, cb) {
+        let index = 0, self = this;
+        let next = function (err, resp) {
+            if (err || index >= self.befores.length) {
+                cb(err, resp);
+                return;
+            }
+            let handler = self.befores[index++];
+            if (typeof handler === 'function') {
+                handler(routeRecord, msg, session, next);
+            }
+            else if (typeof handler.before === 'function') {
+                handler.before(routeRecord, msg, session, next);
+            }
+            else {
+                logger.error('meet invalid before filter, handler or handler.before should be function.');
+                next(new Error('invalid before filter.'));
+            }
+        }; // end of next
+        next();
+    }
+    /**
+     * Do after filter chain.
+     * Give server a chance to do clean up jobs after request responsed.
+     * After filter can not change the request flow before.
+     * After filter should call the next callback to let the request pass to next after filter.
+     *
+     * @param err {Object} error object
+     * @param session {Object} session object for current request
+     * @param {Object} resp response object send to client
+     * @param cb {Function} cb(err) callback function to invoke next chain node
+     */
+    afterFilter(err, routeRecord, msg, session, resp, cb) {
+        let index = 0, self = this;
+        function next(err) {
+            // if done
+            if (index >= self.afters.length) {
+                cb(err);
+                return;
+            }
+            let handler = self.afters[index++];
+            if (typeof handler === 'function') {
+                handler(err, routeRecord, msg, session, resp, next);
+            }
+            else if (typeof handler.after === 'function') {
+                handler.after(err, routeRecord, msg, session, resp, next);
+            }
+            else {
+                logger.error('meet invalid after filter, handler or handler.after should be function.');
+                next(new Error('invalid after filter.'));
+            }
+        } // end of next
+        next(err);
+    }
+}
+exports.FilterService = FilterService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/common/service/handlerService.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manualReloadHandlers = exports.HandlerService = void 0;
+const fs = require("fs");
+const utils = require("../../util/utils");
+const Loader = require("@bigtyphoon/melo-loader");
+const pathUtil = require("../../util/pathUtil");
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const path = require("path");
+const melo_loader_1 = require("@bigtyphoon/melo-loader");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+let forwardLogger = (0, melo_logger_1.getLogger)('forward-log', path.basename(__filename));
+/**
+ * Handler service.
+ * Dispatch request to the relactive handler.
+ *
+ * @param {Object} app      current application context
+ */
+class HandlerService {
+    constructor(app, opts) {
+        this.handlerMap = {};
+        this.handlerPaths = {};
+        this.name = 'handler';
+        this.app = app;
+        if (!!opts.reloadHandlers) {
+            watchHandlers(app, this.handlerMap);
+        }
+        this.enableForwardLog = opts.enableForwardLog || false;
+        // 添加默认路径到ServerInfo中
+        let info = app.getCurrentServer();
+        let handlerPath = info.serverType ? pathUtil.getHandlerPath(app.getBase(), info.serverType) : undefined;
+        info.handlerPaths = [];
+        if (handlerPath) {
+            info.handlerPaths.push(handlerPath);
+        }
+        // 添加插件中的handler到ServerInfo中
+        for (let plugin of app.usedPlugins) {
+            if (plugin.handlerPath) {
+                info.handlerPaths.push(plugin.handlerPath);
+            }
+        }
+        // 添加一台服务器
+        this.addServer(info);
+    }
+    /**
+     * Handler the request.
+     */
+    handle(routeRecord, msg, session, cb) {
+        // the request should be processed by current server
+        let handler = this.getHandler(routeRecord);
+        if (!handler) {
+            logger.error('[handleManager]: fail to find handler for %j', routeRecord.route);
+            utils.invokeCallback(cb, new Error('fail to find handler for ' + routeRecord.route));
+            return;
+        }
+        let start = Date.now();
+        let self = this;
+        let callback = function (err, resp, opts) {
+            if (self.enableForwardLog) {
+                let log = {
+                    route: routeRecord.route,
+                    args: msg,
+                    time: utils.format(new Date(start)),
+                    timeUsed: Date.now() - start
+                };
+                forwardLogger.info(JSON.stringify(log));
+            }
+            // resp = getResp(arguments);
+            utils.invokeCallback(cb, err, resp, opts);
+        };
+        let method = routeRecord.method;
+        if (!Array.isArray(msg)) {
+            handler[method](msg, session).then((resp) => {
+                callback(null, resp);
+            }, (reason) => {
+                callback(reason);
+            });
+        }
+        else {
+            msg.push(session);
+            handler[method].apply(handler, msg).then((resp) => {
+                callback(null, resp);
+            }, (reason) => {
+                callback(reason);
+            });
+        }
+        return;
+    }
+    /**
+     * Get handler instance by routeRecord.
+     *
+     * @param  {Object} handlers    handler map
+     * @param  {Object} routeRecord route record parsed from route string
+     * @return {Object}             handler instance if any matchs or null for match fail
+     */
+    getHandler(routeRecord) {
+        let serverType = routeRecord.serverType;
+        if (!this.handlerMap[serverType]) {
+            this.loadHandlers(serverType);
+        }
+        let handlers = this.handlerMap[serverType] || {};
+        let handler = handlers[routeRecord.handler];
+        if (!handler) {
+            logger.warn('could not find handler for routeRecord: %j', routeRecord);
+            return null;
+        }
+        if (typeof handler[routeRecord.method] !== 'function') {
+            logger.warn('could not find the method %s in handler: %s', routeRecord.method, routeRecord.handler);
+            return null;
+        }
+        return handler;
+    }
+    parseHandler(serverType, handlerPath) {
+        let modules = Loader.load(handlerPath, this.app, false, true, melo_loader_1.LoaderPathType.PINUS_HANDLER);
+        for (let name in modules) {
+            let targetHandlers = this.handlerMap[serverType];
+            if (!targetHandlers) {
+                targetHandlers = {};
+                this.handlerMap[serverType] = targetHandlers;
+            }
+            targetHandlers[name] = modules[name];
+        }
+    }
+    addServer(serverInfo) {
+        let targetPaths = this.handlerPaths[serverInfo.serverType];
+        if (!targetPaths) {
+            targetPaths = new Set();
+            this.handlerPaths[serverInfo.serverType] = targetPaths;
+        }
+        for (let path of serverInfo.handlerPaths) {
+            targetPaths.add(path);
+        }
+    }
+    /**
+     * Load handlers from current application
+     */
+    loadHandlers(serverType) {
+        let paths = this.handlerPaths[serverType];
+        for (let path of paths) {
+            this.parseHandler(serverType, path);
+        }
+    }
+}
+exports.HandlerService = HandlerService;
+function manualReloadHandlers(app) {
+    if (!app.components.__server__) {
+        return;
+    }
+    let p = pathUtil.getHandlerPath(app.getBase(), app.serverType);
+    if (!p) {
+        return;
+    }
+    const handlerMap = app.components.__server__.server.handlerService.handlerMap;
+    handlerMap[app.serverType] = Loader.load(p, app, true, true, melo_loader_1.LoaderPathType.PINUS_HANDLER);
+}
+exports.manualReloadHandlers = manualReloadHandlers;
+let watchHandlers = function (app, handlerMap) {
+    let p = pathUtil.getHandlerPath(app.getBase(), app.serverType);
+    if (!!p) {
+        fs.watch(p, function (event, name) {
+            if (event === 'change') {
+                handlerMap[app.serverType] = Loader.load(p, app, true, true, melo_loader_1.LoaderPathType.PINUS_HANDLER);
+            }
+        });
+    }
+};
+let getResp = function (args) {
+    let len = args.length;
+    if (len === 1) {
+        return [];
+    }
+    if (len === 2) {
+        return [args[1]];
+    }
+    if (len === 3) {
+        return [args[1], args[2]];
+    }
+    if (len === 4) {
+        return [args[1], args[2], args[3]];
+    }
+    let r = new Array(len);
+    for (let i = 1; i < len; i++) {
+        r[i] = args[i];
+    }
+    return r;
+};
+//# sourceMappingURL=data:application/json;base64,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