@nathapp/na-cli 1.0.0-rc.29 → 1.0.0-rc.40

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

@@ -1,215 +0,0 @@
-'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/templates/mxw-base-api-express/src/auth/auth-user.ts

@@ -1,86 +0,0 @@
-"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/templates/mxw-base-api-express/src/auth/auth.ts

@@ -1,81 +0,0 @@
-"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/templates/mxw-base-api-express/src/core-service.ts

@@ -1,72 +0,0 @@
-"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/templates/mxw-base-api-express/src/crud.ts

@@ -1,84 +0,0 @@
-"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/templates/mxw-base-api-express/src/http-handler.ts

@@ -1,71 +0,0 @@
-"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/templates/mxw-base-api-express/src/server.ts

@@ -1,54 +0,0 @@
-"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/templates/mxw-base-api-express/src/test.ts

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