@azteam/express 1.2.114 → 1.2.117

package/package.json

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

package/src/AdminController.js

@@ -0,0 +1,179 @@
+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, options = {}) {
+        this.pathName = pathName;
+        this.repository = repository;
+
+        this.options = {
+            roles: {
+                READ: 1,
+                CREATE: 2,
+                UPDATE: 3,
+                DELETE: 4,
+                RESTORE: 5,
+            }, // system roles
+
+            rulesCreate: {},
+            rulesModify: {},
+
+            guardResponse: {},
+            allowResponse: {},
+            
+            ...options,
+        }
+    }
+
+    getPaginate() {
+        return {
+            path: `/${this.pathName}`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                paginateMiddleware(paginateOptions),
+                async function(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}`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                paginateMiddleware(paginateOptions),
+                async function(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`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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) {
+        return data;
+    }
+
+    postCreate() {
+        return {
+            path: `/${this.pathName}`,
+            method: [
+                roleMiddleware([this.options.roles.CREATE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesCreate),
+                async function(req, res) {
+
+                    const data = this.beforePostCreate(req.body);
+
+                    const item = await this.repository.createByUser(req.user.id, data);
+
+                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+
+    beforePutModify(item) {
+        return item;
+    }
+
+    putModify() {
+        return {
+            path: `/${this.pathName}/: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) {
+
+                    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.options.roles.modifyByUser(req.user.id, item, req.body);
+
+                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+    delete() {
+        return {
+            path: `/${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.DELETE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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`,
+            method: [
+                roleMiddleware([this.options.roles.RESTORE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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;

package/src/constant.js

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

package/src/index.js

@@ -1,10 +1,16 @@
 import ApiServer from './ApiServer';
 import SocketServer from './SocketServer';
 
+import AdminController from './AdminController';
+
+
 export * from './middleware';
 export * from './constant';
+export * from './validate';
 
 export {
     ApiServer,
     SocketServer,
+
+    AdminController,
 }

package/src/validate.js

@@ -0,0 +1,132 @@
+export const schemaID = (optional = false) => ({
+    type: 'string',
+    length: 24,
+    pattern: /^[A-Fa-f0-9]{24}$/,
+    optional,
+});
+
+export const schemaEmail = (optional = false) => ({
+    type: 'email',
+    optional,
+});
+
+export const schemaUrl = (optional = false) => ({
+    type: 'url',
+    optional,
+});
+
+export const schemaBoolean = (optional = false) => ({
+    type: 'boolean',
+    convert: true,
+    optional,
+});
+
+export const schemaDate = (optional = false) => ({
+    type: 'number',
+    convert: true,
+    integer: true,
+    optional,
+});
+
+export const schemaNumber = (optional = false) => ({
+    type: 'number',
+    convert: true,
+    optional,
+});
+export const schemaInteger = (min = 0, max = 999999999, optional = false) => ({
+    type: 'number',
+    integer: true,
+    convert: true,
+    min,
+    max,
+    optional,
+});
+
+export const schemaString = (min = 1, max = 255, optional = false) => ({
+    type: 'string',
+    min,
+    max,
+    optional,
+});
+export const schemaPassword = (optional = false) => ({
+    type: 'string',
+    min: 6,
+    max: 32,
+    optional,
+});
+export const schemaOTP = (optional = false) => ({
+    type: 'string',
+    length: 6,
+    pattern: /\d+/,
+    optional,
+});
+export const schemaImage = (optional = false) => ({
+    type: 'string',
+    max: 255,
+    optional,
+});
+export const schemaVideo = (optional = false) => ({
+    type: 'string',
+    max: 255,
+    optional,
+});
+export const schemaPhoneNumber = (optional = false) => ({
+    type: 'string',
+    length: 10,
+    pattern: /^((09|03|07|08|05)+([0-9]{8})\b)$/,
+    optional,
+});
+export const schemaSlug = (optional = false) => ({
+    type: 'string',
+    pattern: /[A-Za-z0-9_-]+/,
+    max: 300,
+    optional,
+});
+export const schemaVersion = (optional = false) => ({
+    type: 'string',
+    pattern: /^(\d+)\.(\d+)\.(\d+)$/,
+    max: 300,
+    optional,
+});
+export const schemaJSON = (optional = false) => ({
+    type: 'json',
+    optional,
+});
+
+export const schemaGallery = (optional = false) => ({
+    type: 'array',
+    items: schemaImage(),
+    optional,
+});
+
+export const schemaObject = (props = {}, optional = false) => ({
+    type: 'object',
+    strict: 'remove',
+    props,
+    optional,
+});
+
+
+/* rules */
+
+export const rulesID = {
+    id: schemaID(),
+};
+export const rulesSlug = {
+    slug: schemaSlug(),
+};
+export const rulesPlatformType = {
+    type: {
+        type: 'enum',
+        values: ['web', 'app'],
+    },
+};
+export const rulesMetadata = {
+    metadata_disable: schemaBoolean(true),
+    metadata_title: schemaString(0, 255, true),
+    metadata_title_og: schemaString(0, 255, true),
+    metadata_description: schemaString(0, 255, true),
+    metadata_description_og: schemaString(0, 255, true),
+    metadata_keywords: schemaString(0, 255, true),
+    metadata_image_url: schemaImage(true),
+};