@nathapp/na-cli 1.0.1-rc.1 → 1.0.1

package/dist/templates/mxw-base-api-express/src/app-service.ts

@@ -1,498 +0,0 @@
-"use strict";
-
-import { Server } from "http";
-import express, { Express, Router, Request, Response, NextFunction, RequestHandler } from "express";
-import cors from "cors";
-import bodyParser from "body-parser";
-import responseTime from "response-time";
-import multer from "multer";
-
-import { finalHandler, errorHandler } from "./http-handler";
-import { allowNullOrEmpty, checkFormat, checkPositiveNumber, checkString, isUndefinedOrNull, isUndefinedOrNullOrEmpty, notAllowNullOrEmpty } from "mxw-libs-utils";
-import { clog, levels } from "mxw-libs-clogger";
-import { createError, describeError, errors, throwError } from "mxw-libs-errors";
-import { ApiService } from "mxw-libs-api-token";
-import { Mysql as DB } from "mxw-libs-database";
-import { EmailAgent, EmailServiceEnvironment } from "mxw-libs-email-notify";
-import AuthUser, { CREDENTIAL_TYPE } from "./auth/auth-user";
-
-
-const { name, version } = require("../package.json");
-
-const DEFAULT_FILE_CACHE_DIR = "/tmp"; // Default received file cache directory
-const DEFAULT_MAX_FILE_SIZE = 20000 * (1000 * 1024); // Default to 20MB of max file size
-
-enum AuthType {
-    API = "API",
-    NIL = "NIL",
-    JWT = "JWT",
-    JWT_GUEST = "JWT_GUEST",
-    JWT_USER = "JWT_USER",
-}
-
-enum ContentType {
-    JSON = "JSON",
-    RAW = "RAW",
-    FILE = "FILE",
-}
-
-enum HttpMethod {
-    GET = "GET",
-    POST = "POST",
-    PATCH = "PATCH",
-    PUT = "PUT",
-    DELETE = "DELETE",
-    HEAD = "HEAD",
-    OPTIONS = "OPTIONS",
-}
-
-type CallFunc = (req: Request, res: Response) => Promise<void>;
-
-export function goodRes(res: Response, data?: any, statusCode?: number) {
-    const resp = {
-        ret: "0"
-    }
-    if (!isUndefinedOrNull(data)) {
-        delete data.ret;
-        resp["data"] = data;
-    }
-
-    if (!isUndefinedOrNull(statusCode)) {
-        res.status(statusCode).json(resp);
-    }
-    else {
-        res.json(resp);
-    }
-}
-
-export function errorRes(res: Response, ret: number | string, message: string, data?: any, statusCode?: number) {
-    const resp = {
-        ret,
-        msg: message,
-    }
-
-    if (!isUndefinedOrNull(data)) {
-        delete data.ret;
-        delete data.msg;
-        if (!isUndefinedOrNull(data)) {
-            resp["data"] = data;
-        }
-    }
-
-    if (!isUndefinedOrNull(statusCode)) {
-        res.status(statusCode).json(resp);
-    } else {
-        res.json(resp)
-    }
-}
-
-export default class AppService {
-    private static self: AppService;
-
-    private app: Express;
-    private listener: Server;
-
-    private whitelist: { [walletAddress: string]: boolean } = {};
-
-    public config: {
-        JWT_SECRET: string;
-
-        SERVICE_DOMAIN: string;
-        SERVICE_SESSION_TIMEOUT?: number;
-        SERVICE_WALLET_JSON: string;
-        SERVICE_WALLET_PASSWORD: string;
-
-        MYSQL_URL: string;
-
-        CACHE_DIR?: string;
-        MAX_FILE_SIZE?: number;
-    };
-
-    private mailConfig: EmailServiceEnvironment;
-
-    public static get Instance() {
-        return this.self || throwError(errors.NOT_INITIALIZED, "AppService initialization is required");
-    }
-
-    private async onLiveness(req: Request, res: Response) {
-        res.json();
-    }
-
-    public async onReadiness(req: Request, res: Response) {
-        res.json();
-    }
-
-    private async onRoot(req: Request, res: Response) {
-        res.json({
-            message: `Welcome to the coolest API on earth - ${name}:${version}!`
-        });
-    }
-
-    public static async init() {
-        const self = new this();
-
-        try {
-            const checkPathString = function (value) {
-                let v: string = checkString(value);
-                if (!v.endsWith("/")) {
-                    v = v + "/";
-                }
-                return v;
-            }
-
-            self.config = checkFormat({
-                JWT_SECRET: notAllowNullOrEmpty(checkString),
-
-                SERVICE_DOMAIN: notAllowNullOrEmpty(checkString),
-                SERVICE_SESSION_TIMEOUT: allowNullOrEmpty(checkPositiveNumber, 60000),
-                SERVICE_WALLET_JSON: notAllowNullOrEmpty(checkString),
-                SERVICE_WALLET_PASSWORD: notAllowNullOrEmpty(checkString),
-
-                MYSQL_URL: notAllowNullOrEmpty(checkString),
-
-                CACHE_DIR: allowNullOrEmpty(checkPathString),
-                MAX_FILE_SIZE: allowNullOrEmpty(checkPositiveNumber)
-            }, {
-                JWT_SECRET: process.env.JWT_SECRET,
-
-                SERVICE_DOMAIN: process.env.SERVICE_DOMAIN,
-                SERVICE_SESSION_TIMEOUT: process.env.SERVICE_SESSION_TIMEOUT,
-                SERVICE_WALLET_JSON: process.env.SERVICE_WALLET_JSON,
-                SERVICE_WALLET_PASSWORD: process.env.SERVICE_WALLET_PASSWORD,
-
-                MYSQL_URL: process.env.MYSQL_URL,
-
-                CACHE_DIR: process.env.CACHE_DIR,
-                MAX_FILE_SIZE: process.env.MAX_FILE_SIZE,
-            });
-            /*
-                        // Set email agent settings
-                        self.mailConfig = {
-                            domain: process.env.EMAIL_NOTIFY_DOMAIN,
-                            url: process.env.EMAIL_NOTIFY_URL,
-                            requestTimeout: process.env.EMAIL_NOTIFY_REQUEST_TIMEOUT ? Number(process.env.EMAIL_NOTIFY_REQUEST_TIMEOUT) : 10000,
-                            wallet: process.env.EMAIL_NOTIFY_WALLET_JSON,
-                            password: process.env.EMAIL_NOTIFY_WALLET_PASSWORD
-                        }
-            */
-        }
-        catch (error) {
-            const { message } = describeError(error);
-            throwError(errors.NOT_CONFIGURED, "Environment: " + message, { error });
-        }
-
-        if (process.env.WHITELIST) {
-            if ("*" === process.env.WHITELIST) {
-                self.whitelist["*"] = true;
-            }
-            else {
-                for (const walletAddress of process.env.WHITELIST.split(",")) {
-                    self.whitelist[walletAddress.trim()] = true;
-                }
-            }
-        }
-
-        // Initialize server
-        self.app = express();
-
-        self.app.set("x-powered-by", false);
-
-        const origins: string[] | string =
-            !isUndefinedOrNullOrEmpty(process.env.CORS)
-                ? process.env.CORS == "*"
-                    ? "*"
-                    : process.env.CORS.split(",")
-                : "*";
-
-        const corsOptions = {
-            origin: origins,
-            allowedHeaders: "Origin,X-Requested-With,Content-Type,Accept,Lang,Authorization,Accept-Version,Content-Language,app-id,Location",
-            exposedHeaders: "X-Requested-With,X-Metadata",
-            preflightContinue: false
-        };
-
-        self.app.use(cors(corsOptions));
-
-        self.app.use(bodyParser.json({
-            limit: 20 * 1024 * 1024, // default to 1MB of max body size
-        }));
-
-        self.app.use(responseTime((req: Request, res: Response, time: number) => {
-            res["elapsed"] = time.toFixed(3);
-        }));
-
-        this.self = self;
-
-        return self;
-    }
-
-    public static async term() {
-        if (this.self) {
-            if (this.self.listener) {
-                await new Promise<void>((resolve, reject) => {
-                    try {
-                        this.self.listener.close((error) => {
-                            if (error) return reject(error);
-                            return resolve();
-                        });
-                    }
-                    catch (error) {
-                        return reject(error);
-                    }
-                });
-
-                this.self.listener = undefined;
-            }
-
-            await DB.Instance.term(null);
-
-            this.self = undefined;
-        }
-    }
-
-    public async run() {
-        // Initialize service token verifier
-        await ApiService.Instance.init({
-            domain: this.config.SERVICE_DOMAIN,
-            sessionTimeout: this.config.SERVICE_SESSION_TIMEOUT,
-            wallet: this.config.SERVICE_WALLET_JSON,
-            password: this.config.SERVICE_WALLET_PASSWORD
-        });
-
-        // Initialize dependencies and modules
-        await DB.Instance.init(null, this.config.MYSQL_URL);
-
-        // Initialize modules
-        AuthUser.init(
-            this.config.JWT_SECRET,
-            undefined,
-            {
-                JWT_SIGN_ALGO: process.env.JWT_SIGN_ALGO
-            }
-        );
-
-        const router = express.Router();
-
-        // ** Health endpoints **
-        this.entryPoint(router, "/", this.onRoot, undefined, [HttpMethod.GET, HttpMethod.POST], AuthType.NIL, ContentType.JSON, true);
-        this.entryPoint(router, "/liveness", this.onLiveness, undefined, [HttpMethod.GET, HttpMethod.POST], AuthType.NIL, ContentType.RAW, true);
-        this.entryPoint(router, "/readiness", this.onReadiness, undefined, [HttpMethod.GET, HttpMethod.POST], AuthType.NIL, ContentType.RAW, true);
-
-        this.app.use(router);
-        this.app.use(finalHandler); // Make sure this handler is place at the last of the router stack
-
-        this.app.use(errorHandler);
-
-        return new Promise<string>((resolve, reject) => {
-            try {
-                this.listener = this.app.listen(8080, () => {
-                    return resolve("http://0.0.0.0:8080");
-                });
-            }
-            catch (error) {
-                return reject(error);
-            }
-        });
-    }
-
-    private entryPoint(router: Router, uri: string, func: CallFunc, preCheckFunc: CallFunc, methods: HttpMethod[], authType: AuthType, contentType: ContentType, logExcluded: boolean, overrides?: any) {
-        for (const method of methods) {
-            let methodPreHandler: RequestHandler;
-
-            if (ContentType.FILE === contentType) {
-                const options: multer.Options = {
-                    dest: this.config.CACHE_DIR || DEFAULT_FILE_CACHE_DIR,
-                    limits: {
-                        fileSize: this.config.MAX_FILE_SIZE || DEFAULT_MAX_FILE_SIZE
-                    }
-                };
-                const upload = multer(options);
-
-                methodPreHandler = async (req: Request, res: Response, next: NextFunction) => {
-                    req["logExcluded"] = logExcluded;
-
-                    if (!logExcluded) {
-                        const ip = req.headers?.['x-forwarded-for'] || req.headers?.['x-real-ip'] || "0.0.0.0";
-                        clog(levels.NORMAL, `REQ: ${req.method} ${req.url} HTTP/${req.httpVersion} @${ip}`);
-                    }
-
-                    await this.onAuth(authType, req, next);
-
-                    return upload.single(overrides?.fieldName || "file")(req, res, next);
-                };
-            }
-            else {
-                methodPreHandler = async (req: Request, res: Response, next: NextFunction) => {
-                    req["logExcluded"] = logExcluded;
-
-                    if (!logExcluded) {
-                        const ip = req.headers?.['x-forwarded-for'] || req.headers?.['x-real-ip'] || "0.0.0.0";
-                        clog(levels.NORMAL, `REQ: ${req.method} ${req.url} HTTP/${req.httpVersion} @${ip}`);
-                    }
-
-                    await this.onAuth(authType, req, next);
-
-                    switch (req.method) {
-                        case "GET":
-                        case "HEAD":
-                            break;
-
-                        case "POST":
-                        case "PUT":
-                        case "PATCH":
-                        case "DELETE":
-                            switch (contentType) {
-                                case ContentType.JSON:
-                                    if (!req.is("json")) {
-                                        const contentType = req.headers?.['content-type'];
-                                        throwError(errors.INVALID_FORMAT, "Content type is not supported", { contentType });
-                                    }
-                            }
-                            break;
-                    }
-
-                    return next();
-                };
-            }
-
-            const methodHandler = async (req: Request, res: Response, next: NextFunction) => {
-                try {
-                    preCheckFunc && await preCheckFunc.apply(this, [req, res]);
-                    func && await func.apply(this, [req, res]);
-
-                    return next();
-                }
-                catch (error) {
-                    let { code, message, reason } = errors.describeError(error);
-
-                    clog(levels.ERROR, `ERROR ${code}:`, reason || message);
-
-                    if (errors.DATABASE_ERROR == code) {
-                        code = isUndefinedOrNullOrEmpty(error.ret) ? "SYSTEM_BUSY" : error.ret;
-                        if (!isUndefinedOrNullOrEmpty(error.msg)) {
-                            message = error.msg;
-                        }
-                    }
-
-                    try {
-                        const translated = await this.translateError(req.headers["content-language"], code, message);
-
-                        code = translated.code;
-                        message = translated.message;
-                    }
-                    catch (error) { }
-
-                    return next(createError(code, message, { error }));
-                }
-            };
-
-            switch (method) {
-                case HttpMethod.GET: router.get(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.POST: router.post(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.PATCH: router.patch(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.PUT: router.put(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.DELETE: router.delete(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.HEAD: router.head(uri, methodPreHandler, methodHandler); break;
-                case HttpMethod.OPTIONS: router.options(uri, methodPreHandler, methodHandler); break;
-            }
-        }
-    }
-
-    private async onAuth(authType: AuthType, req: Request, next: NextFunction) {
-        try {
-            switch (authType) {
-                case AuthType.JWT:
-                    {
-                        const credential = (req.headers["authorization"] || "").split(" ")?.[1];
-                        req["cred"] = AuthUser.Instance.verifyToken(credential, null);
-                    }
-                    return;
-
-                case AuthType.JWT_GUEST:
-                    {
-                        const credential = (req.headers["authorization"] || "").split(" ")?.[1];
-                        req["cred"] = AuthUser.Instance.verifyToken(credential, CREDENTIAL_TYPE.GUEST);
-                    }
-                    return;
-
-                case AuthType.JWT_USER:
-                    {
-                        const credential = (req.headers["authorization"] || "").split(" ")?.[1];
-                        req["cred"] = AuthUser.Instance.verifyToken(credential, CREDENTIAL_TYPE.USER);
-                    }
-                    return;
-
-                case AuthType.API:
-                    {
-                        const credential = (req.headers["authorization"] || "").split(" ")?.[1];
-
-                        if (credential) {
-                            try {
-                                const walletAddress = ApiService.Instance.verifyToken(credential);
-
-                                if (walletAddress) {
-                                    // Check whitelist
-                                    if (this.whitelist["*"] || this.whitelist[walletAddress]) {
-                                        req["walletAddress"] = walletAddress;
-                                        return;
-                                    }
-                                }
-                            } catch (error) {
-                                const { message } = describeError(error)
-                                clog(levels.ERROR, "failed to verify api token ", message)
-                                return next(createError(errors.UNAUTHORISED, message));
-                            }
-                        }
-                    }
-                    break;
-
-                case AuthType.NIL:
-                    return;
-            }
-        }
-        catch (error) {
-            const { code, message } = describeError(error);
-
-            if (errors.EXPIRED === code) {
-                //throw error;
-                return next(createError(code, message))
-            }
-        }
-
-        return next(createError(errors.UNAUTHORISED, "Unauthorised"));
-    }
-
-    private async translateError(language: string, code: string, message: string) {
-        if (!language) {
-            language = "en_US"; // Default language
-        }
-
-        const codeId = !isNaN(Number(code)) ? Number(code) : 0;
-        clog(levels.DETAIL, "Translating error", language, "(", codeId, ")", code, ":", message);
-
-        try {
-            const results = await DB.Instance.callQuery(null, "sp_cm_get_err_msg_sys", [codeId, code, message, language, 1]);
-
-            let translatedMessage = "";
-            if (0 < results.recordsets.length && 0 < results.recordsets[0].length) {
-                if (!isUndefinedOrNullOrEmpty(results.recordsets[0][0].msg)) {
-                    translatedMessage = results.recordsets[0][0].msg;
-                }
-            }
-            clog(levels.INFO, "Translated error", language, "(", codeId, ")", code, ":", translatedMessage);
-            return { code, message: translatedMessage };
-        }
-        catch (error) {
-            if (errors.NOT_CONFIGURED != error.code) {
-                clog(levels.ERROR, "Translate error message failed", language, "(", codeId, ")", code, ":", message, "ERROR:", JSON.stringify(error));
-            }
-            return errors.throwError("SYSTEM_BUSY", "System busy", {
-                language,
-                codeId,
-                code,
-                message,
-                error
-            });
-        }
-    }
-}