@nathapp/na-cli 1.0.0-rc.4 → 1.0.0-rc.41

package/dist/templates/mxw-base-api-express/src/auth/auth-user.test.ts

@@ -0,0 +1,215 @@
+'use strict';
+
+import { describe, it, before, after, beforeEach, afterEach } from 'mocha';
+import { expect } from 'chai';
+import Sinon from "sinon";
+import jwt from "jsonwebtoken";
+import AuthUser from './auth-user';
+import { CREDENTIAL_TYPE } from './auth';
+import { errors } from 'mxw-libs-errors';
+
+let sandbox: Sinon.SinonSandbox;
+let clock: Sinon.SinonFakeTimers;
+
+const JWT_SECRET = "secret";
+
+describe('Suite: AuthUser', () => {
+    before(function () {
+        clock = Sinon.useFakeTimers({
+            now: new Date().getTime(),
+            shouldAdvanceTime: true
+        });
+    });
+
+    beforeEach(function () {
+        sandbox = Sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        if (sandbox) {
+            sandbox.restore();
+            sandbox = undefined;
+        }
+    });
+
+    after(function () {
+        if (clock) {
+            clock.restore();
+            clock = undefined;
+        }
+    });
+
+    describe("Create credential", async () => {
+        it("Create token with minimum fields", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                username: "bean"
+            });
+
+            expect(token).is.a("string").lengthOf.greaterThan(0);
+        });
+
+        it("Create token with all fields", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                id: 1,
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                orgId: 100,
+                email: "bean@happy.com",
+                username: "bean"
+            });
+
+            expect(token).is.a("string").lengthOf.greaterThan(0);
+        });
+
+        it("Create token with missing field", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const fields = {
+                id: 1,
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                orgId: 100,
+                email: "bean@happy.com",
+                username: "bean"
+            }
+
+            delete fields.userId;
+
+            try {
+                AuthUser.Instance.createToken(fields);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.PARAMETER_MISSING);
+            }
+        });
+    });
+
+    describe("Verify credential", async () => {
+        it("Verify token", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                username: "bean"
+            });
+
+            const credential = AuthUser.Instance.verifyToken(token, CREDENTIAL_TYPE.USER);
+
+            expect(credential).has.property("userId").is.a("number").eq(1);
+            expect(credential).has.property("type").is.a("number").eq(CREDENTIAL_TYPE.USER);
+            expect(credential).has.property("username").is.a("string").eq("bean");
+        });
+
+        it("Accept all token type", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                username: "bean"
+            });
+
+            const credential = AuthUser.Instance.verifyToken(token, null);
+
+            expect(credential).has.property("userId").is.a("number").eq(1);
+            expect(credential).has.property("type").is.a("number").eq(CREDENTIAL_TYPE.USER);
+            expect(credential).has.property("username").is.a("string").eq("bean");
+        });
+
+        it("Verify broken token", async () => {
+            const token = jwt.sign({
+                hello: "world"
+            }, JWT_SECRET, { expiresIn: "1m" });
+
+            try {
+                AuthUser.Instance.verifyToken(token, CREDENTIAL_TYPE.USER);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.PARAMETER_MISSING);
+            }
+        });
+
+        it("Verify invalid token", async () => {
+            try {
+                AuthUser.Instance.verifyToken("Trust me.. I am good", CREDENTIAL_TYPE.USER);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.INVALID_SIGNATURE);
+            }
+        });
+
+        it("Verify mismatched token type", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                username: "bean"
+            });
+
+            try {
+                AuthUser.Instance.verifyToken(token, CREDENTIAL_TYPE.GUEST);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.INVALID_FORMAT);
+            }
+        });
+
+        it("Verify invalid token type", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const stub = sandbox.stub(AuthUser.Instance as any, "checkCredential").callsFake((cred: Credential, type?: CREDENTIAL_TYPE) => {
+                return cred;
+            });
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: 100,
+                username: "bean"
+            });
+
+            stub.restore();
+
+            try {
+                AuthUser.Instance.verifyToken(token, null);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.INVALID_FORMAT);
+            }
+        });
+
+        it("Verify expired token", async () => {
+            AuthUser.init(JWT_SECRET, "1m");
+
+            const token = AuthUser.Instance.createToken({
+                userId: 1,
+                type: CREDENTIAL_TYPE.USER,
+                username: "bean"
+            });
+
+            await clock.tickAsync(60000);
+
+            try {
+                const credential = AuthUser.Instance.verifyToken(token, CREDENTIAL_TYPE.USER);
+                expect.fail("It should be failed");
+            }
+            catch (error) {
+                expect(error).has.property("code").eq(errors.EXPIRED);
+            }
+        });
+
+    });
+
+});

package/dist/templates/mxw-base-api-express/src/auth/auth-user.ts

@@ -0,0 +1,86 @@
+"use strict";
+
+import { allowNull, allowNullOrEmpty, checkFormat, checkNumber, checkString, isUndefinedOrNull, isUndefinedOrNullOrEmpty, notAllowNullOrEmpty } from "mxw-libs-utils";
+import { errors, throwError } from "mxw-libs-errors";
+
+import { BearerToken, CREDENTIAL_TYPE } from "./auth";
+
+export * from "./auth";
+
+export class Credential {
+    id?: number;
+    userId: number;
+    type: CREDENTIAL_TYPE;
+    orgId?: number;
+    email?: string;
+    username: string;
+    iat?: number;
+    exp?: number;
+
+    static check(cred: Credential, type: CREDENTIAL_TYPE) {
+        if (isUndefinedOrNullOrEmpty(cred)) {
+            throwError(errors.NOT_INITIALIZED, "Missing credential");
+        }
+
+        return checkFormat({
+            id: allowNull(checkNumber),
+            userId: notAllowNullOrEmpty(checkNumber),
+            type: function (value) {
+                const credType = checkNumber(value);
+
+                if (type === credType) {
+                    return credType;
+                }
+                else {
+                    if (isUndefinedOrNull(type)) {
+                        for (const t in CREDENTIAL_TYPE) {
+                            if (Number(t) === credType) {
+                                return credType;
+                            }
+                        }
+                    }
+                }
+
+                throwError(errors.INVALID_PARAMETER, "Invalid credential type", { credType });
+            },
+            orgId: allowNull(checkNumber),
+            email: allowNullOrEmpty(checkString),
+            username: notAllowNullOrEmpty(checkString),
+            iat: allowNull(checkNumber, undefined),
+            exp: allowNull(checkNumber, undefined)
+        }, cred) as Credential;
+    }
+}
+
+export class GuestCredential extends Credential {
+    static check(cred: GuestCredential) {
+        return super.check(cred, CREDENTIAL_TYPE.GUEST) as GuestCredential;
+    }
+}
+
+export class UserCredential extends Credential {
+    static check(cred: UserCredential) {
+        return super.check(cred, CREDENTIAL_TYPE.USER) as UserCredential;
+    }
+}
+
+export default class BasicAuth extends BearerToken<GuestCredential | UserCredential> {
+    private static self: BasicAuth;
+
+    constructor(secret: string, expiresIn: string, options?: any) {
+        super(secret, expiresIn, options);
+    }
+
+    public static get Instance() {
+        return this.self || throwError(errors.NOT_INITIALIZED, "BasicAuth initialization is required");
+    }
+
+    public static init(secret: string, expiresIn: string, options?: any) {
+        this.self = new BasicAuth(secret, expiresIn, options);
+    }
+
+    protected checkCredential(cred: GuestCredential | UserCredential, type?: CREDENTIAL_TYPE) {
+        return Credential.check(cred, type);
+    }
+
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+
+import { allowNullOrEmpty, checkFormat, checkString, isUndefinedOrNullOrEmpty, notAllowNullOrEmpty } from "mxw-libs-utils";
+import jwt, { SignOptions, VerifyOptions } from "jsonwebtoken";
+import { describeError, errors, throwError } from "mxw-libs-errors";
+
+export enum CREDENTIAL_TYPE {
+    GUEST = 0,
+    USER = 1,
+}
+
+export interface AuthCredential<C> {
+    cred: C;
+    checkCredential(type?: CREDENTIAL_TYPE): C;
+    auth(cred: C): AuthCredential<C>;
+}
+
+export abstract class BearerToken<C> {
+    private jwtSecret: string;
+    private signOptions: SignOptions;
+    private verifyOptions: VerifyOptions;
+
+    constructor(jwtSecret: string, jwtExpiresIn?: string, options?: any) {
+        const params: {
+            jwtSecret: string,
+            jwtExpiresIn?: string,
+        } = checkFormat({
+            jwtSecret: notAllowNullOrEmpty(checkString),
+            jwtExpiresIn: allowNullOrEmpty(checkString)
+        }, { jwtSecret, jwtExpiresIn });
+
+        this.signOptions = {};
+
+        if (params.jwtExpiresIn) {
+            this.signOptions.expiresIn = params.jwtExpiresIn;
+        }
+
+        this.verifyOptions = {};
+
+        if (!isUndefinedOrNullOrEmpty(options?.JWT_SIGN_ALGO)) {
+            this.signOptions.algorithm = options?.JWT_SIGN_ALGO;
+            this.verifyOptions.algorithms = [options?.JWT_SIGN_ALGO];
+        }
+
+        this.jwtSecret = params.jwtSecret;
+    }
+
+    protected abstract checkCredential(cred: C, type?: CREDENTIAL_TYPE): C;
+
+    public createToken(cred: C, overrides?: any) {
+        const payload = this.checkCredential(cred);
+
+        if (!this.signOptions.expiresIn) {
+            throwError(errors.NOT_INITIALIZED, "Session expiry is not initialized");
+        }
+
+        return jwt.sign({
+            ...overrides, ...payload
+        }, this.jwtSecret, this.signOptions);
+    }
+
+    public verifyToken(token: string, type: CREDENTIAL_TYPE) {
+        try {
+            const cred: any = jwt.verify(token, this.jwtSecret, this.verifyOptions) || throwError(errors.UNEXPECTED_MESSAGE, "Missing session", { token });
+            return this.checkCredential(cred, type);
+        }
+        catch (error) {
+            const { code, message } = describeError(error);
+
+            if (errors.INVALID_FORMAT == code) {
+                throwError(errors.INVALID_FORMAT, message, { token, error });
+            }
+
+            switch (error.name) {
+                case "TokenExpiredError": throwError(errors.EXPIRED, "Session expired", { token });
+                case "JsonWebTokenError": throwError(errors.INVALID_SIGNATURE, "Invalid token", { token });
+            }
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+// for local development only
+if (process.env.NODE_ENV == "local") require('dotenv').config()
+import { CLogger, clog, levels } from "mxw-libs-clogger";
+import { errors, throwError } from "mxw-libs-errors";
+import { isUndefinedOrNull } from "mxw-libs-utils";
+import AppService from "./app-service";
+
+const { name, version } = require("../package.json");
+
+export default class CoreService {
+    private static self: CoreService;
+
+    public static get Instance(): CoreService {
+        return this.self || throwError(errors.NOT_INITIALIZED, "CoreService initialization is required");
+    }
+
+    public static init(logLevel?: string) {
+        CLogger.Instance.init(levels.NORMAL);
+
+        if (isUndefinedOrNull(logLevel)) {
+            for (const [index, argv] of process.argv.entries()) {
+                if ("logLevel" == argv)
+                    logLevel = process.argv[index + 1];
+            }
+        }
+
+        if (!isUndefinedOrNull(levels[logLevel])) {
+            CLogger.Instance.level = levels[logLevel];
+        }
+
+        const self = this.self = new this();
+
+        return self;
+    }
+
+    public static async term() {
+        try {
+            clog(levels.WARNING, "Service is terminating...");
+
+            if (this.self) {
+                // Terminate service
+                await AppService.term();
+
+                this.self = undefined;
+            }
+
+            clog(levels.WARNING, "Service is terminated");
+        }
+        catch (error) {
+            clog(levels.CRITICAL, "Service failed to terminate:", error);
+            throw error;
+        }
+    }
+
+    public async run() {
+        try {
+            clog(levels.WARNING, "Service", name, "(" + version + ") is starting...");
+
+            // Initialize service
+            const instance = await AppService.init();
+            const url = await instance.run();
+
+            clog(levels.WARNING, "Service is serving", url);
+            return this;
+        }
+        catch (error) {
+            clog(levels.CRITICAL, "Service failed to start:", error);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+
+import { allowNull, checkFormat, checkNumber, renameKey } from "mxw-libs-utils";
+import { AuthCredential, CREDENTIAL_TYPE } from "./auth/auth";
+
+export * from "./auth/auth";
+
+export class BaseList {
+    public static renameKey(obj: any, keys?: { [key: string]: string }) {
+        if (!keys) return { ...obj };
+
+        return renameKey({ ...obj }, (key) => {
+            if (keys[key]) {
+                return keys[key];
+            }
+            return key;
+        });
+    }
+
+    public static diff(rec: any, out: any) {
+        let diff = [];
+
+        for (const key in rec) {
+            if (undefined === out[key]) {
+                diff.push(key);
+            }
+        }
+        return diff;
+    }
+}
+
+class Pagination {
+    private _page: number;
+    private _pageSize: number;
+
+    constructor(page?: number, pageSize?: number) {
+        this.pagination(page, pageSize);
+    }
+
+    public pagination(page?: number, pageSize?: number) {
+        const params: {
+            page: number,
+            pageSize: number
+        } = checkFormat({
+            page: allowNull(checkNumber, this._page),
+            pageSize: allowNull(checkNumber, this._pageSize)
+        }, { page, pageSize });
+
+        this._page = params.page;
+        this._pageSize = params.pageSize;
+
+        return this;
+    }
+
+    public get page() {
+        return this._page;
+    }
+    public get pageSize() {
+        return this._pageSize;
+    }
+}
+
+export default abstract class CRUD<C, CI, UI, DI> extends Pagination implements AuthCredential<C>{
+    private _cred: C;
+
+    public abstract picklist(overrides?: any);
+    public abstract list(overrides?: any);
+    public abstract getDetail(id: number, overrides?: any);
+    public abstract create(params: CI);
+    public abstract update(params: UI);
+    public abstract delete(id: number | DI);
+    
+    public abstract checkCredential(type?: CREDENTIAL_TYPE): C;
+
+    public auth(cred: C, type = CREDENTIAL_TYPE.USER) {
+        this._cred = cred;
+        this.checkCredential(type);
+        return this;
+    }
+
+    public get cred() {
+        return this._cred;
+    }
+}

package/dist/templates/mxw-base-api-express/src/http-handler.ts

@@ -0,0 +1,71 @@
+"use strict";
+
+import { Request, Response, NextFunction } from "express";
+import { clog, levels } from "mxw-libs-clogger";
+import { errors, throwError } from "mxw-libs-errors";
+
+export const finalHandler = (req: Request, res: Response, next: NextFunction) => {
+    if (!res.headersSent) {
+        res.statusCode = 404;
+        throwError(errors.NOT_FOUND, "Resource not found");
+    }
+
+    resLog(null, req, res);
+};
+
+export const errorHandler = (error: any, req: Request, res: Response, next: NextFunction) => {
+    const { code, message } = errors.describeError(error);
+
+    let statusCode: number;
+
+    // Respect the status code that caller specified
+    if (200 !== res.statusCode) {
+        statusCode = res.statusCode;
+    }
+    else {
+        // Define the default status code that based on error code
+        switch (code) {
+            case errors.UNAUTHORISED:
+            case errors.EXPIRED:
+                statusCode = 401;
+                break;
+            case "TooManyRequests":
+                statusCode = 429;
+                break;
+            default:
+                statusCode = 500;
+        }
+    }
+
+    res.status(statusCode).send({
+        ret: code,
+        message
+    });
+
+    resLog(error, req, res);
+};
+
+const resLog = (error: any, req: Request, res: Response) => {
+    const ip = req.headers?.['x-forwarded-for'] || req.headers?.['x-real-ip'] || "0.0.0.0";
+
+    try {
+        const contentLength = res.getHeaders()["content-length"];
+
+        if (!error) {
+            if (!req["logExcluded"]) {
+                clog(levels.ERROR, `RES: ${req.method} ${req.url} HTTP/${req.httpVersion} @${ip}`,
+                    `OK ${contentLength || "-"}, elapsed: ${res["elapsed"] + "ms" || "--"}`);
+            }
+        }
+        else {
+            const { code, message, reason } = errors.describeError(error);
+
+            clog(levels.ERROR, `RES: ${req.method} ${req.url} HTTP/${req.httpVersion} @${ip}`,
+                `${res.statusCode}: ${code || "?"}, ${contentLength || "-"}, elapsed: ${res["elapsed"] + "ms" || "--"}, ${reason || message || "Unknown error"}`);
+        }
+    }
+    catch (err) {
+        clog(levels.ERROR, `RES: ${req.method} ${req.url} HTTP/${req.httpVersion} @${ip}`,
+            `${res.statusCode}: ${"?"} -, elapsed: ${res["elapsed"] + "ms" || "--"}, ${error}`);
+    }
+};

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

@@ -0,0 +1,54 @@
+"use strict";
+
+import { CLogger, clog, levels } from "mxw-libs-clogger";
+import CoreService from "./core-service"
+
+CoreService.init().run().catch(async () => {
+    await CoreService.term().catch(() => { });
+    process.exit(-1);
+});
+
+async function exitHandler(cleanup = false) {
+    if (cleanup) {
+        await CoreService.term().catch(() => { });
+    }
+}
+
+//do something when app is closing
+process.on("exit", exitHandler.bind(null, false));
+
+//catches ctrl+c event
+process.on("SIGINT", exitHandler.bind(null, true));
+
+//catches SIGHUP (1) event to increase log depth (circled)
+process.on("SIGHUP", () => {
+    CLogger.Instance.depth = null;
+    clog(levels.CRITICAL, "Logger depth:", CLogger.Instance.depth);
+});
+
+//catches SIGUSR1 (10) event to increase log width (circled)
+process.on("SIGUSR1", () => {
+    CLogger.Instance.width = null;
+    clog(levels.CRITICAL, "Logger width:", CLogger.Instance.width);
+});
+
+//catches SIGUSR2 (12) event to increase log severity (circled)
+process.on("SIGUSR2", () => {
+    CLogger.Instance.level = null;
+    clog(levels.CRITICAL, "Logger level:", CLogger.Instance.level);
+});
+
+//catches uncaught exceptions
+process.on("uncaughtException", (error) => {
+    exitHandler.bind(null, true);
+});
+
+//catches unhandled rejection
+process.on("unhandledRejection", (reason) => {
+    if (process.stderr.writable) {
+        process.stderr.write(`unhandledRejection: ${reason}`);
+    }
+});
+
+// listen for TERM signal .e.g. kill 
+process.on("SIGTERM", exitHandler.bind(null, true));

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

@@ -0,0 +1,38 @@
+"use strict";
+
+import { expect } from 'chai';
+
+export interface TARGET {
+    key: string;
+    type: string;
+    value: any;
+}
+
+export function assertValue(value: any, target: TARGET) {
+    if (null === target.value || undefined === target.value) {
+        if (!target.key) {
+            expect(value).is.not.exist;
+        }
+        else {
+            expect(value).has.property(target.key).is.not.exist;
+        }
+    }
+    else {
+        if ("object" === target.type) {
+            if (!target.key) {
+                expect(value).to.deep.equal(target.value);
+            }
+            else {
+                expect(value).has.property(target.key).to.deep.equal(target.value);
+            }
+        }
+        else {
+            if (!target.key) {
+                expect(value).is.a(target.type).is.eq(target.value);
+            }
+            else {
+                expect(value).has.property(target.key).is.a(target.type).is.eq(target.value);
+            }
+        }
+    }
+}