@azteam/express 1.2.118 → 1.2.121

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.118",
+    "version": "1.2.121",
     "description": "",
     "main": "src/index.js",
     "repository": {

package/src/AdminController.js

@@ -1,194 +1,178 @@
-import { NOT_EXISTS, PERMISSION } from '@azteam/error';
+import { NOT_EXISTS } from '@azteam/error';
 
-import { HTTP_METHOD, paginateMiddleware, REQUEST_TYPE, roleMiddleware, validateMiddleware, rulesID } from './ApiServer';
+import { REQUEST_TYPE, USER_LEVEL } from './constant';
+import { paginateMiddleware, roleMiddleware, validateMiddleware } from './middleware';
+import { rulesID } from './validate';
 import Controller from './Controller';
 
-import { USER_LEVEL } from './constant';
-
 
 class AdminController extends Controller {
     constructor(pathName, repository, options = {}) {
-        this.options = {
+        super(pathName, repository, {
             roles: {
                 READ: 1,
                 CREATE: 2,
                 UPDATE: 3,
                 DELETE: 4,
-                RESTORE: 5,
+                RESTORE: 5
             }, // system roles
 
+            paginateOptions: {},
             rulesCreate: {},
             rulesModify: {},
 
             guardResponse: {},
             allowResponse: {},
 
-            ...options,
-        }
-
-        super(pathName, repository);
-    }
-
-
-    usePublic(controllers = []){
-        return super([
-            getPaginate,
-            getPaginateTrash,
-            getOne,
-            getOneTrash,
-            postCreate,
-            putModify,
-            deleteOne,
-            postRestore,
-        ]);
+            ...options
+        });
     }
 
-
     getPaginate() {
         return {
-            path: `/${this.pathName}`,
+            path: '/public',
             method: [
                 roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
-                paginateMiddleware(paginateOptions),
-                async function(req, res) {
+                paginateMiddleware(this.options.paginateOptions),
+                async (req, res) => {
                     const paginateData = await this.repository.find(req.query, req.paginate);
 
                     return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
-    }
+                }
+            ]
+        };
+    };
 
     getPaginateTrash() {
         return {
-            path: `/trash_${this.pathName}`,
+            path: '/trash',
             method: [
                 roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
-                paginateMiddleware(paginateOptions),
-                async function(req, res) {
+                paginateMiddleware(this.options.paginateOptions),
+                async (req, res) => {
                     const paginateData = await this.repository.findTrash(req.query, req.paginate);
 
                     return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
-    }
+                }
+            ]
+        };
+    };
 
     getOne() {
         return {
-            path: `/${this.pathName}/:id`,
+            path: '/public/:id',
             method: [
                 roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async function(req, res) {
+                async (req, res) => {
                     const item = await this.repository.findOneById(req.params.id);
                     if (!item) return res.error(NOT_EXISTS);
                     return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
+                }
+            ]
+        };
 
-    }
+    };
 
     getOneTrash() {
         return {
-            path: `/trash_${this.pathName}/:id`,
+            path: '/trash/:id',
             method: [
                 roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async function(req, res) {
+                async (req, res) => {
                     const item = await this.repository.findOneTrashById(req.params.id);
                     if (!item) return res.error(NOT_EXISTS);
                     return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
+                }
+            ]
+        };
 
-    }
+    };
 
 
-    beforePostCreate(data) {
+    async beforeCreate(data, user) {
         return data;
-    }
+    };
 
     postCreate() {
         return {
-            path: `/${this.pathName}`,
+            path: '/public',
             method: [
                 roleMiddleware([this.options.roles.CREATE], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesCreate),
-                async function(req, res) {
+                async (req, res) => {
 
-                    const data = this.beforePostCreate(req.body);
+                    const data = await this.beforeCreate(req.body, req.user);
 
                     const item = await this.repository.createByUser(req.user.id, data);
 
                     return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
-    }
+                }
+            ]
+        };
+    };
 
 
-    beforePutModify(item) {
+    async beforeModify(item, user) {
         return item;
-    }
+    };
 
     putModify() {
         return {
-            path: `/${this.pathName}/:id`,
+            path: '/public/:id',
             method: [
                 roleMiddleware([this.options.roles.UPDATE], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
                 validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesModify),
-                async function(req, res) {
+                async (req, res) => {
 
                     let item = await this.options.roles.findOneById(req.params.id);
                     if (!item) return res.error(NOT_EXISTS);
 
-                    item = await this.beforePutModify(item);
+                    item = await this.beforeModify(item, req.user);
 
                     item = await this.options.roles.modifyByUser(req.user.id, item, req.body);
 
                     return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
-        }
-    }
+                }
+            ]
+        };
+    };
 
-    deleteOne() {
+    delete() {
         return {
-            path: `/${this.pathName}/:id`,
+            path: '/public/:id',
             method: [
                 roleMiddleware([this.options.roles.DELETE], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async function(req, res) {
+                async (req, res) => {
                     const item = await this.repository.findOneById(req.params.id);
                     if (!item) return res.error(NOT_EXISTS);
 
                     await this.repository.deleteByUser(req.user.id, item);
                     return res.success(true);
-                },
-            ],
-        }
-    }
+                }
+            ]
+        };
+    };
 
     postRestore() {
         return {
-            path: `/trash_${this.pathName}/:id`,
+            path: '/trash/:id',
             method: [
                 roleMiddleware([this.options.roles.RESTORE], USER_LEVEL.ADMIN),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async function(req, res) {
+                async (req, res) => {
                     const item = await this.repository.findOneTrashById(req.params.id);
                     if (!item) return res.error(NOT_EXISTS);
 
                     await this.repository.restoreByUser(req.user.id, item);
                     return res.success(true);
-                },
-            ],
-        }
-    },
+                }
+            ]
+        };
+    };
 }
 
-export default Controller;
+export default AdminController;

package/src/ApiServer.js

@@ -9,8 +9,7 @@ import morgan from 'morgan';
 import cors from 'cors';
 import _ from 'lodash';
 import 'express-async-errors';
-import { decryptAES, encryptAES } from '@azteam/crypto';
-import { errorCatch, ErrorException, NOT_FOUND, UNKNOWN } from '@azteam/error';
+import {errorCatch, ErrorException, NOT_FOUND, UNKNOWN} from '@azteam/error';
 
 function omitItem(item, guard) {
     if (item.toJSON) {
@@ -33,7 +32,7 @@ class ApiServer {
             httpOnly: true,
             signed: true,
             sameSite: 'Lax'
-        }
+        };
 
         this.middlewares = [];
         this.controllers = [];
@@ -114,8 +113,8 @@ class ApiServer {
             }));
 
             app.use(methodOverride());
-            app.use(bodyParser.urlencoded({ limit: '5mb', extended: true }));
-            app.use(bodyParser.json({ limit: '5mb' }));
+            app.use(bodyParser.urlencoded({limit: '5mb', extended: true}));
+            app.use(bodyParser.json({limit: '5mb'}));
 
             app.set('trust proxy', 1);
 
@@ -128,11 +127,11 @@ class ApiServer {
                     if (
                         !origin || !WHITE_LIST.length ||
                         WHITE_LIST.some(re => origin.endsWith(re))) {
-                        callback(null, true)
+                        callback(null, true);
                     } else {
                         callback(new Error(`${origin} Not allowed by CORS`));
                     }
-                },
+                }
             }));
 
             if (this.debug) {
@@ -150,13 +149,13 @@ class ApiServer {
                     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',
-                }
+                    os: req.get('X-OS') || 'web'
+                };
 
 
                 res.error = function(code, errors = []) {
                     throw new ErrorException(code, errors);
-                }
+                };
 
                 res.success = function(data = {}, guard = [], allows = []) {
                     if (data) {
@@ -176,7 +175,7 @@ class ApiServer {
                                 'metadata_disable',
                                 'metadata_keywords',
                                 'metadata_description',
-                                'metadata_image_url',
+                                'metadata_image_url'
                             ];
                         }
 
@@ -200,7 +199,7 @@ class ApiServer {
                     return res.json({
                         success: true,
                         data,
-                        options: req.resOptions,
+                        options: req.resOptions
                     });
                 };
 
@@ -210,7 +209,7 @@ class ApiServer {
                             domain: COOKIE_OPTIONS.domain
                         });
                     });
-                }
+                };
 
                 res.addCookie = function(data) {
                     _.map(data, (value, key) => {
@@ -221,7 +220,7 @@ class ApiServer {
                             expires: new Date(Date.now() + maxAge)
                         });
                     });
-                }
+                };
                 next();
             });
 
@@ -231,19 +230,32 @@ class ApiServer {
 
             const msg = [];
             _.map(this.controllers, (obj) => {
-                const controller = obj.controller;
-                _.map(controller, (item, key) => {
-                    item.path = obj.version.startsWith('v') ? `/${obj.version}${item.path}` : item.path;
-
-                    msg.push({
-                        controller: obj.name,
-                        version: obj.version,
-                        type: item.type,
-                        method: key,
-                        path: item.path,
-                    });
 
-                    app[item.type.toLowerCase()](item.path, ...item.method);
+                const {name, controller, version} = obj;
+
+                const listPublicMethod = obj.controller.publicMethod();
+
+                _.map(listPublicMethod, (methodName) => {
+
+                    const matches = methodName.match(/get|post|put|patch|delete/);
+                    if (matches) {
+                        const type = matches[0];
+                        const item = controller[methodName]();
+
+                        item.path = controller.pathName ? `/${controller.pathName}${item.path}` : item.path;
+
+                        item.path = version.startsWith('v') ? `/${version}${item.path}` : item.path;
+
+                        msg.push({
+                            controller: name,
+                            version,
+                            type,
+                            method: methodName,
+                            path: item.path
+                        });
+
+                        app[type](item.path, ...item.method);
+                    }
                 });
             });
 
@@ -268,7 +280,7 @@ class ApiServer {
                     this.callbackError(error);
                 }
 
-                return res.status(error.status).json({ success: false, errors: error.errors });
+                return res.status(error.status).json({success: false, errors: error.errors});
             });
 
             const server = http.Server(app);
@@ -324,4 +336,4 @@ class ApiServer {
     }
 }
 
-export default ApiServer;
+export default ApiServer;

package/src/Controller.js

@@ -1,21 +1,30 @@
-import { NOT_EXISTS, PERMISSION } from '@azteam/error';
-
-import { HTTP_METHOD, paginateMiddleware, REQUEST_TYPE, roleMiddleware, validateMiddleware, rulesID } from './ApiServer';
-import { USER_LEVEL } from './constant';
-
-
 class Controller {
-    constructor(pathName, repository) {
+    constructor(pathName = '', repository = null, options = {}) {
         this.pathName = pathName;
         this.repository = repository;
+
+        this.options = {
+            ...options
+        };
     }
 
+    publicMethod() {
+        let child = this;
+        let result = [];
+
+        while (Object.getPrototypeOf(child.__proto__)) {
+
+            const data = Object.getOwnPropertyNames(Object.getPrototypeOf(child));
+
+            result = [
+                ...result,
+                ...data.filter((methodName) => methodName.match(/^get|post|put|patch|delete/))
+            ]
 
-    usePublic(controllers = []) {
-        return [
-            ...controllers
-        ]
+            child = child.__proto__;
+        }
+        return result;
     }
 }
 
-export default Controller;
+export default Controller;

package/src/constant.js

@@ -1,11 +1,3 @@
-export const HTTP_METHOD = {
-    HEAD: 'HEAD',
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DEL: 'DELETE',
-};
-
 export const REQUEST_TYPE = {
     PARAMS: 'params',
     BODY: 'body',

package/src/index.js

@@ -1,6 +1,7 @@
 import ApiServer from './ApiServer';
 import SocketServer from './SocketServer';
 
+import Controller from './Controller';
 import AdminController from './AdminController';
 
 
@@ -12,5 +13,6 @@ export {
     ApiServer,
     SocketServer,
 
+    Controller,
     AdminController,
-}
+}

package/src/middleware/etagMiddleware.js

@@ -1,6 +1,5 @@
 import etag from 'etag';
 
-import { HTTP_GET } from '../constant';
 
 
 function floorToMinute(time, minutes) {
@@ -11,7 +10,7 @@ function floorToMinute(time, minutes) {
 
 export default function(mTimeout = 5) {
     return async function(req, res, next) {
-        if (req.method === HTTP_GET) {
+        if (req.method === 'GET') {
             const etag_hash = etag(req.url + floorToMinute(Math.floor(Date.now() / 1000), mTimeout));
             if (req.headers['if-none-match'] === etag_hash) {
                 return res.status(304).send();