@azteam/express 1.2.282 → 1.2.283

package/src/Server.js

@@ -0,0 +1,409 @@
+import _ from 'lodash';
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import express from 'express';
+import helmet from 'helmet';
+import methodOverride from 'method-override';
+import bodyParser from 'body-parser';
+import cookieParser from 'cookie-parser';
+import morgan from 'morgan';
+import cors from 'cors';
+import psl from 'psl';
+import 'express-async-errors';
+import {CORS, errorCatch, ErrorException, NOT_FOUND, UNKNOWN} from '@azteam/error';
+
+const RES_TYPE = {
+    ARRAY: 'ARRAY',
+    OBJECT: 'OBJECT',
+    DOCS: 'DOCS',
+};
+
+function omitItem(item, guard, allow) {
+    let guardFields = guard;
+    let itemFields = item;
+
+    if (_.isArray(guardFields)) {
+        guardFields = _.difference(guardFields, allow);
+    }
+
+    if (itemFields.toJSON) {
+        itemFields = item.toJSON();
+    }
+    if (_.isObject(itemFields)) {
+        if (guardFields === '*') {
+            return _.pick(itemFields, allow);
+        }
+        return _.omit(itemFields, guardFields);
+    }
+    return itemFields;
+}
+
+class Server {
+    constructor(currentDir = '', options = {}) {
+        this.redis = null;
+        this.options = {
+            isAllowEmptyOrigin: true,
+            ...options,
+        };
+
+        this.cookieOption = {
+            domain: null,
+            path: '/',
+            secure: process.env.NODE_ENV !== 'development',
+            httpOnly: true,
+            signed: true,
+            sameSite: 'Lax',
+        };
+
+        this.middlewares = [];
+        this.controllers = [];
+        this.whiteList = [];
+        this.debug = process.env.NODE_ENV === 'development';
+
+        this.initController(currentDir);
+    }
+
+    setRedis(redis) {
+        this.redis = redis;
+        return this;
+    }
+
+    setCookieOption(cookieOption) {
+        this.cookieOption = {
+            ...this.cookieOption,
+            ...cookieOption,
+        };
+        return this;
+    }
+
+    setCallbackError(callback = null) {
+        this.callbackError = callback;
+        return this;
+    }
+
+    setWhiteList(whiteList) {
+        this.whiteList = whiteList;
+        return this;
+    }
+
+    setDebug(debug) {
+        this.debug = debug;
+        return this;
+    }
+
+    addController(name, version, controller) {
+        this.controllers.push({
+            name,
+            version,
+            controller,
+        });
+        return this;
+    }
+
+    initController(apiDir) {
+        if (apiDir) {
+            const controllerDirs = fs.readdirSync(apiDir);
+
+            for (let i = 0; i < controllerDirs.length; i += 1) {
+                const dirName = controllerDirs[i];
+                if (fs.statSync(`${apiDir}/${dirName}`).isDirectory()) {
+                    const versionDirs = fs.readdirSync(`${apiDir}/${dirName}`);
+
+                    for (let j = 0; j < versionDirs.length; j += 1) {
+                        const versionName = versionDirs[j];
+
+                        // eslint-disable-next-line global-require,import/no-dynamic-require
+                        const controller = require(`${apiDir}/${dirName}/${versionName}/controller`).default;
+                        this.addController(dirName, versionName, controller);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+
+    addGlobalMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+
+    startAPI(port) {
+        if (!_.isEmpty(this.controllers)) {
+            const WHITE_LIST = this.whiteList;
+            const COOKIE_OPTION = this.cookieOption;
+            const {isAllowEmptyOrigin} = this.options;
+
+            const app = express();
+            app.use(
+                helmet({
+                    frameguard: false,
+                })
+            );
+
+            app.use(methodOverride());
+            app.use(bodyParser.urlencoded({limit: '5mb', extended: true}));
+            app.use(bodyParser.json({limit: '5mb'}));
+
+            app.set('trust proxy', 1);
+
+            app.use(cookieParser(process.env.SECRET_KEY));
+
+            app.use(
+                cors(function (req, callback) {
+                    const origin = req.header('Origin');
+                    const authorization = req.header('Authorization');
+                    const appSecret = req.header('x-app-secret');
+                    const agent = req.header('User-Agent');
+
+                    let error = null;
+                    if (!authorization && !appSecret && !agent.startsWith('toda')) {
+                        if (!origin) {
+                            if (!isAllowEmptyOrigin) {
+                                error = new ErrorException(CORS, `Not allowed by CORS`);
+                            }
+                        } else if (!WHITE_LIST.some((re) => origin.endsWith(re))) {
+                            error = new ErrorException(CORS, `${origin} Not allowed by CORS`);
+                        }
+                    }
+                    callback(error, {
+                        credentials: true,
+                        origin: true,
+                    });
+                })
+            );
+
+            if (this.debug) {
+                app.use(morgan('dev'));
+            }
+
+            app.get('/robots.txt', function (req, res) {
+                res.type('text/plain');
+                res.send('User-agent: *\nDisallow: /');
+            });
+            app.get('/favicon.ico', (req, res) => res.status(204).json({}));
+
+            const {redis} = this;
+
+            if (redis) {
+                app.request.redis = redis;
+                app.response.redis = redis;
+            }
+
+            app.response.error = function (code, errors = []) {
+                throw new ErrorException(code, errors);
+            };
+
+            app.response.success = function (data = {}, guard = [], allow = []) {
+                let guardData = data;
+                if (data) {
+                    let resType = null;
+                    if (_.isArray(data)) {
+                        resType = RES_TYPE.ARRAY;
+                    } else if (_.isObject(data)) {
+                        resType = RES_TYPE.OBJECT;
+                        if (data.docs) {
+                            resType = RES_TYPE.DOCS;
+                        }
+                    }
+
+                    let responseGuard = guard;
+                    const responseAllows = allow;
+                    if (_.isArray(guard)) {
+                        responseGuard = [
+                            ...guard,
+                            '__v',
+                            '_id',
+                            'deleted_at',
+                            'updated_at',
+                            'created_id',
+                            'modified_id',
+                            'resource',
+                            'is_processing',
+                            'priority',
+                        ];
+                    }
+                    if (resType === RES_TYPE.DOCS) {
+                        guardData.docs = _.map(data.docs, (item) => {
+                            return omitItem(item, responseGuard, responseAllows);
+                        });
+                    } else if (resType === RES_TYPE.ARRAY) {
+                        guardData = _.map(data, (item) => {
+                            return omitItem(item, responseGuard, responseAllows);
+                        });
+                    } else if (resType === RES_TYPE.OBJECT) {
+                        guardData = omitItem(data, responseGuard, responseAllows);
+                    }
+                }
+
+                const resData = {
+                    success: true,
+                    data: guardData,
+                    options: this.resOptions,
+                };
+
+                if (this.redis && this.cache) {
+                    this.redis.set(this.cache.key, resData, this.cache.ttl);
+                }
+
+                return this.json(resData);
+            };
+
+            app.response.cleanCookie = function (data) {
+                _.map(data, (name) => {
+                    this.clearCookie(name, {
+                        domain: COOKIE_OPTION.domain,
+                    });
+                });
+            };
+
+            app.response.addCookie = function (data) {
+                _.map(data, (value, key) => {
+                    const maxAge = 86400000 * 365; // 1 year
+                    this.cookie(key, value, {
+                        ...COOKIE_OPTION,
+                        maxAge,
+                        expires: new Date(Date.now() + maxAge),
+                    });
+                });
+            };
+
+            app.use(function (req, res, next) {
+                delete res.cache;
+
+                const origin = req.get('Origin');
+                req.rootOrigin = origin ? psl.parse(origin).domain : null;
+
+                req.trackDevice = {
+                    ip: req.headers['x-forwarded-for'] || req.headers['x-real-ip'] || req.ip,
+                    device: req.get('X-DEVICE') || req.get('User-Agent'),
+                    device_id: req.get('X-DEVICE-ID') || 'web',
+                    os: req.get('X-OS') || 'web',
+                };
+
+                next();
+            });
+
+            _.map(this.middlewares, function (middleware) {
+                app.use(middleware);
+            });
+
+            const msg = [];
+            _.map(this.controllers, (data) => {
+                const {controller} = data;
+                const controllerName = data.name;
+                const controllerVersion = data.version;
+
+                const listPublicRouter = controller.publicRouter();
+
+                _.map(listPublicRouter, (method) => {
+                    const {name, type} = method;
+
+                    const router = controller[name]();
+                    if (!router.disabled) {
+                        router.path = `/${method.path}/${router.path}`;
+                        router.path = controller.pathName ? `/${controller.pathName}${router.path}` : router.path;
+                        router.path = controllerVersion.startsWith('v') ? `/${controllerVersion}${router.path}` : router.path;
+                        router.path = path.normalize(router.path);
+
+                        msg.push({
+                            controller: controllerName,
+                            version: controllerVersion,
+                            type,
+                            method: name,
+                            path: router.path,
+                        });
+                        app[type](router.path, ...router.method);
+                    }
+                });
+            });
+
+            console.table(msg);
+
+            app.all('/', async function (req, res) {
+                return res.success('welcome');
+            });
+            app.get('/track', async function (req, res) {
+                return res.success({
+                    ...req.trackDevice,
+                    host: req.hostname,
+                    origin: req.get('origin'),
+                });
+            });
+
+            app.use(function (req, res) {
+                throw new ErrorException(NOT_FOUND);
+            });
+
+            app.use((err, req, res, next) => {
+                const error = errorCatch(err);
+
+                if (process.env.NODE_ENV === 'development') {
+                    console.log(error.errors);
+                } else if (error.errors[0].code === UNKNOWN) {
+                    console.error(req.originalUrl, err);
+                }
+
+                if (this.callbackError) {
+                    this.callbackError(error, req.originalUrl);
+                }
+
+                return res.status(error.status).json({success: false, errors: error.errors});
+            });
+
+            const server = http.Server(app);
+
+            server.on('listening', () => {
+                this._alert('listening', `Server start at http://localhost:${server.address().port}`);
+            });
+
+            server.on('error', (error) => {
+                if (error.syscall !== 'listen') {
+                    throw error;
+                }
+
+                const bind = typeof port === 'string' ? `Pipe ${port}` : `Port ${port}`;
+
+                switch (error.code) {
+                    case 'EACCES':
+                        this._alert('EACCES', `${bind} requires elevated privileges`);
+                        process.exit(1);
+                        break;
+                    case 'EADDRINUSE':
+                        this._alert('EACCES', `${bind} is already in use`);
+                        process.exit(1);
+                        break;
+                    default:
+                        throw error;
+                }
+            });
+
+            server.listen(port);
+
+            return server;
+        }
+        throw new Error('No controllers in use API');
+    }
+
+    startSocket(port) {
+        if (!_.isEmpty(this.controllers)) {
+            return this;
+        }
+        throw new Error('No controllers in use SOCKET');
+    }
+
+    setAlertCallback(callback) {
+        this.alertCallback = callback;
+        return this;
+    }
+
+    _alert(status, msg) {
+        if (typeof this.alertCallback === 'function') {
+            this.alertCallback(status, msg);
+        } else {
+            console.log(status, msg);
+        }
+    }
+}
+
+export default Server;

package/src/SocketServer.js

@@ -0,0 +1,186 @@
+import fs from 'fs';
+import http from 'http';
+import express from 'express';
+import socketIO from 'socket.io';
+import bodyParser from 'body-parser';
+import cookieParser from 'cookie-parser';
+import redisAdapter from 'socket.io-redis';
+import _ from 'lodash';
+
+const wrap = (middleware) => (socket, next) => middleware(socket.request, {}, next);
+
+class SocketServer {
+    constructor(currentDir = '', options = {}) {
+        this.options = {
+            redisConfig: null,
+            ...options,
+        };
+
+        this.middlewares = [];
+        this.controllers = [];
+        this.whiteList = [];
+        this.debug = process.env.NODE_ENV === 'development';
+        this.initController(currentDir);
+    }
+
+    setCallbackError(callback = null) {
+        this.callbackError = callback;
+        return this;
+    }
+
+    setWhiteList(whiteList) {
+        this.whiteList = whiteList;
+        return this;
+    }
+
+    setDebug(debug) {
+        this.debug = debug;
+        return this;
+    }
+
+    addController(name, version, controller) {
+        this.controllers.push({
+            name,
+            version,
+            controller,
+        });
+        return this;
+    }
+
+    initController(apiDir) {
+        if (apiDir) {
+            const controllerDirs = fs.readdirSync(apiDir);
+
+            for (const dirName of controllerDirs) {
+                if (fs.statSync(`${apiDir}/${dirName}`).isDirectory()) {
+                    const versionDirs = fs.readdirSync(`${apiDir}/${dirName}`);
+
+                    for (const versionName of versionDirs) {
+                        // eslint-disable-next-line import/no-dynamic-require,global-require
+                        const controller = require(`${apiDir}/${dirName}/${versionName}/controller`).default;
+                        this.addController(dirName, versionName, controller);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+
+    addGlobalMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+
+    startPort(port) {
+        if (!_.isEmpty(this.controllers)) {
+            const WHITE_LIST = this.whiteList;
+
+            const server = http.Server(express());
+
+            const io = socketIO(server, {
+                wsEngine: 'eiows',
+                perMessageDeflate: {
+                    threshold: 32768,
+                },
+                cors: {
+                    credentials: true,
+                    origin(origin, callback) {
+                        if (!origin || !WHITE_LIST.length || WHITE_LIST.some((re) => origin.endsWith(re))) {
+                            callback(null, true);
+                        } else {
+                            callback(new Error(`${origin} Not allowed by CORS`));
+                        }
+                    },
+                },
+            });
+
+            if (this.options.redisConfig) {
+                io.adapter(redisAdapter(this.options.redisConfig));
+            }
+
+            const msg = [];
+            _.map(this.controllers, (obj) => {
+                const {controller} = obj;
+
+                _.map(controller, (item, key) => {
+                    item.path = obj.version.startsWith('v') ? `/${obj.version}${item.path}` : item.path;
+
+                    const nsp = io.of(item.path);
+
+                    const middlewares = [...this.middlewares, ...(item.middlewares || [])];
+
+                    nsp.use(wrap(bodyParser.urlencoded({limit: '5mb', extended: true})));
+                    nsp.use(wrap(bodyParser.json({limit: '5mb'})));
+                    nsp.use(wrap(cookieParser(process.env.SECRET_KEY)));
+
+                    _.map(middlewares, (middleware) => {
+                        nsp.use(wrap(middleware));
+                    });
+
+                    if (item.schedule) {
+                        item.schedule(io);
+                    }
+
+                    if (item.connection) {
+                        nsp.on('connection', (socket) => {
+                            item.connection(io, socket);
+                        });
+                    }
+
+                    msg.push({
+                        controller: obj.name,
+                        version: obj.version,
+                        path: item.path,
+                    });
+                });
+            });
+
+            console.table(msg);
+
+            server.on('listening', () => {
+                this._alert('listening', `Server start at http://localhost:${server.address().port}`);
+            });
+
+            server.on('error', (error) => {
+                if (error.syscall !== 'listen') {
+                    throw error;
+                }
+
+                let bind = typeof port === 'string' ? `Pipe ${port}` : `Port ${port}`;
+
+                switch (error.code) {
+                    case 'EACCES':
+                        this._alert('EACCES', `${bind} requires elevated privileges`);
+                        process.exit(1);
+                        break;
+                    case 'EADDRINUSE':
+                        this._alert('EACCES', `${bind} is already in use`);
+                        process.exit(1);
+                        break;
+                    default:
+                        throw error;
+                }
+            });
+
+            server.listen(port);
+
+            return server;
+        }
+        throw new Error('No controllers in use');
+    }
+
+    setAlertCallback(callback) {
+        this.alertCallback = callback;
+        return this;
+    }
+
+    _alert(status, msg) {
+        if (typeof this.alertCallback === 'function') {
+            this.alertCallback(status, msg);
+        } else {
+            console.log(status, msg);
+        }
+    }
+}
+
+export default SocketServer;

package/src/constant.js

@@ -0,0 +1,12 @@
+export const REQUEST_TYPE = {
+    PARAMS: 'params',
+    BODY: 'body',
+    QUERY: 'query',
+};
+
+export const USER_LEVEL = {
+    GUESS: 0,
+    USER: 1,
+    ADMIN: 50,
+    SYSTEM: 100,
+};

package/src/index.js

@@ -0,0 +1,12 @@
+import Server from './Server';
+
+import Controller from './Controller';
+import AdminController from './AdminController';
+
+export * from './middleware';
+export * from './constant';
+export * from './validate';
+
+export {Controller, AdminController};
+
+export default Server;

package/src/middleware/adminRoleMiddleware.js

@@ -0,0 +1,7 @@
+import {USER_LEVEL} from '../constant';
+
+import roleMiddleware from './roleMiddleware';
+
+export default function (roles = null) {
+    return roleMiddleware(roles, USER_LEVEL.ADMIN);
+}

package/src/middleware/authMiddleware.js

@@ -0,0 +1,53 @@
+import jwt from 'jsonwebtoken';
+import {ErrorException, TOKEN_EXPIRED, TOKEN_FAILED} from '@azteam/error';
+
+function systemLogin(userData = null) {
+    let user = {};
+    if (userData) {
+        try {
+            user = JSON.parse(userData);
+        } catch (err) {}
+    }
+    return user;
+}
+
+export default function (cbLoginAPI) {
+    return async function (req, res, next) {
+        const {headers} = req;
+
+        if (headers['x-app-secret'] === process.env.SECRET_KEY) {
+            req.user = systemLogin(headers['x-app-user']);
+        } else {
+            let token = null;
+
+            if (headers.authorization) {
+                token = headers.authorization;
+            }
+
+            if (token) {
+                if (token.startsWith('Bearer ')) {
+                    token = token.replace('Bearer ', '');
+
+                    try {
+                        req.user = jwt.verify(token, process.env.SECRET_KEY);
+                        return next();
+                    } catch (err) {
+                        if (err.name === 'TokenExpiredError') {
+                            throw new ErrorException(TOKEN_EXPIRED, err);
+                        }
+                        throw new ErrorException(TOKEN_FAILED, err);
+                    }
+                } else {
+                    const data = await cbLoginAPI(token);
+                    if (data) {
+                        req.user = data;
+                    } else {
+                        return next(ErrorException(TOKEN_FAILED));
+                    }
+                }
+            }
+        }
+
+        return next();
+    };
+}