@nathapp/na-cli 1.0.0-rc.10 → 1.0.0-rc.12

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

@@ -0,0 +1,94 @@
+'use strict';
+
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import { expect } from 'chai';
+import Sinon from "sinon";
+import AppService from './app-service';
+
+let sandbox: Sinon.SinonSandbox;
+
+describe('Suite: Endpoint - App Service', () => {
+    beforeEach(() => {
+        sandbox = Sinon.createSandbox();
+    });
+
+    afterEach(() => {
+        if (sandbox) {
+            sandbox.restore();
+            sandbox = undefined;
+        }
+    });
+
+    describe("Initialization", async () => {
+        it("Initialize service", async () => {
+            sandbox.stub(process, "env").get(() => {
+                return {
+                    JWT_SECRET: "secret",
+
+                    SERVICE_DOMAIN: "default",
+                    SERVICE_SESSION_TIMEOUT: 6000,
+                    SERVICE_WALLET_JSON: "hello",
+                    SERVICE_WALLET_PASSWORD: "world",
+
+                    MYSQL_URL: "hello mysql",
+
+                    CACHE_DIR: null,
+                    MAX_FILE_SIZE: null,
+
+                    MAX_REQUEST: 100
+                };
+            });
+
+            const instance = await AppService.init();
+
+            expect(instance).is.instanceOf(AppService);
+            expect(AppService.Instance).is.instanceOf(AppService);
+        });
+    });
+
+    describe("GET /readiness", async () => {
+        it("Service is ready", async () => {
+            const req: any = {
+                query: {}
+            };
+            const res: any = {
+                json: () => { }
+            };
+
+            const stubRes = sandbox.stub(res, "json").callsFake((body: any) => {
+                // console.log(JSON.stringify(body, null, 2));
+                expect(body).is.undefined;
+            });
+
+            await AppService.Instance["onReadiness"](req, res);
+
+            Sinon.assert.calledOnce(stubRes);
+        });
+    });
+
+    describe("GET /liveness", async () => {
+        it("Service is alive", async () => {
+            const req: any = {
+                query: {}
+            };
+            const res: any = {
+                json: () => { }
+            };
+
+            const stubRes = sandbox.stub(res, "json").callsFake((body: any) => {
+                // console.log(JSON.stringify(body, null, 2));
+                expect(body).is.undefined;
+            });
+
+            await AppService.Instance["onLiveness"](req, res);
+
+            Sinon.assert.calledOnce(stubRes);
+        });
+    });
+
+    describe("Termination", async () => {
+        it("Terminate service", async () => {
+            await AppService.term();
+        });
+    });
+});

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

@@ -0,0 +1,498 @@
+"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
+            });
+        }
+    }
+}