@digione/node-custom-api 0.0.1

package/constants/header.d.ts

@@ -0,0 +1,10 @@
+export declare const enum HEADER {
+    COUNT = "X-Total-Count",
+    PRICE_RANGE = "X-Price-Range",
+    TITLE = "X-Title",
+    TOTAL = "X-Total",
+    IMAGE = "X-Image",
+    CLIENT_SITE = "X-Client-Site",
+    ACCESS_TOKEN = "X-Access-Token",
+    REFRESH_TOKEN = "X-Refresh-Token"
+}

package/constants/header.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/constants/http.d.ts

@@ -0,0 +1,44 @@
+export declare const enum HTTP {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    MULTIPLE_CHOICES = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    USE_PROXY = 305,
+    TEMPORARY_REDIRECT = 307,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    REQUEST_ENTITY_TOO_LARGE = 413,
+    REQUEST_URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    UNPROCESSABLE_ENTITY = 422,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/constants/http.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/index.d.ts

@@ -0,0 +1,3 @@
+import { Sequelize } from 'sequelize';
+declare const _default: Sequelize;
+export default _default;

package/database/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const helper_1 = require("../utils/helper");
+const database = (0, helper_1.getENV)("DATABASE");
+const username = (0, helper_1.getENV)('DATABASE_USERNAME');
+const password = (0, helper_1.getENV)('DATABASE_PASSWORD');
+const host = (0, helper_1.getENV)('DATABASE_HOST');
+const port = (0, helper_1.getENV)('DATABASE_PORT');
+const charset = (0, helper_1.getENV)('DATABASE_CHARSET');
+const poolMax = Number((0, helper_1.getENV)('DATABASE_POOL_MAX', '10'));
+const poolMin = Number((0, helper_1.getENV)('DATABASE_POOL_MIN', '2'));
+const poolAcquire = Number((0, helper_1.getENV)('DATABASE_POOL_ACQUIRE', '60000'));
+const poolIdle = Number((0, helper_1.getENV)('DATABASE_POOL_IDLE', '10000'));
+const logging = ((0, helper_1.getENV)('DATABASE_LOGGING') === "true");
+exports.default = new sequelize_1.Sequelize(database, username, password, {
+    host,
+    port,
+    dialect: "mysql",
+    pool: {
+        max: poolMax,
+        min: poolMin,
+        acquire: poolAcquire,
+        idle: poolIdle
+    },
+    define: {
+        timestamps: false,
+        freezeTableName: true,
+        charset: charset,
+        omitNull: true
+    },
+    dialectOptions: { decimalNumbers: true },
+    logging
+});

package/database/redis.d.ts

@@ -0,0 +1,15 @@
+import { Redis } from 'ioredis';
+import { QueueOptions } from 'bull';
+declare let redisReady: boolean, redisError: any;
+declare const redisClient: Redis;
+declare const redisGet: any;
+declare const redisMGet: any;
+declare const redisHMGet: any;
+declare const redisSet: any;
+declare const redisHSet: any;
+declare const redisHDel: any;
+declare const redisDel: any;
+declare const redisHgetall: any;
+declare const redisFlushDb: any;
+declare const redisQueueOpts: QueueOptions;
+export { redisClient, redisQueueOpts, redisReady, redisError, redisGet, redisMGet, redisHMGet, redisSet, redisHSet, redisHDel, redisDel, redisHgetall, redisFlushDb };

package/database/redis.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisFlushDb = exports.redisHgetall = exports.redisDel = exports.redisHDel = exports.redisHSet = exports.redisSet = exports.redisHMGet = exports.redisMGet = exports.redisGet = exports.redisError = exports.redisReady = exports.redisQueueOpts = exports.redisClient = void 0;
+const ioredis_1 = require("ioredis");
+const helper_1 = require("../utils/helper");
+const EventEmitter = require("events");
+const host = (0, helper_1.getENV)('REDIS_HOST');
+const port = Number((0, helper_1.getENV)('REDIS_PORT', '6379'));
+let option = { host, port, maxRetriesPerRequest: null, enableReadyCheck: false }, redisReady = false, redisError;
+exports.redisReady = redisReady;
+if ((0, helper_1.getENV)("REDIS_PASSWORD")) {
+    option['password'] = (0, helper_1.getENV)("REDIS_PASSWORD");
+}
+EventEmitter.setMaxListeners(0);
+const redisClient = new ioredis_1.Redis(option);
+exports.redisClient = redisClient;
+redisClient.connect();
+redisClient.on("error", (err) => {
+    exports.redisReady = redisReady = false;
+    exports.redisError = redisError = err['code'];
+    console.log("Redis Error", err);
+    if ((0, helper_1.getENV)("NODE_ENV") != "production") {
+        redisClient.quit();
+    }
+});
+redisClient.on('connect', () => {
+    exports.redisReady = redisReady = true;
+    exports.redisError = redisError = undefined;
+    console.log('connected to redis');
+});
+const redisGet = redisClient.get.bind(redisClient);
+exports.redisGet = redisGet;
+const redisMGet = redisClient.mget.bind(redisClient);
+exports.redisMGet = redisMGet;
+const redisHMGet = redisClient.hmget.bind(redisClient);
+exports.redisHMGet = redisHMGet;
+const redisSet = redisClient.set.bind(redisClient);
+exports.redisSet = redisSet;
+const redisHSet = redisClient.hset.bind(redisClient);
+exports.redisHSet = redisHSet;
+const redisHDel = redisClient.hdel.bind(redisClient);
+exports.redisHDel = redisHDel;
+const redisDel = redisClient.del.bind(redisClient);
+exports.redisDel = redisDel;
+const redisHgetall = redisClient.hgetall.bind(redisClient);
+exports.redisHgetall = redisHgetall;
+const redisFlushDb = redisClient.flushdb.bind(redisClient);
+exports.redisFlushDb = redisFlushDb;
+let redisQueueSubscriber;
+const redisQueueOpts = {
+    createClient: function (type) {
+        switch (type) {
+            case 'client':
+                return redisClient;
+            case 'subscriber':
+                if (!redisQueueSubscriber) {
+                    redisQueueSubscriber = new ioredis_1.Redis(option);
+                }
+                return redisQueueSubscriber;
+            case 'bclient':
+                return new ioredis_1.Redis(option);
+            default:
+                throw new Error('Unexpected connection type: ' + type);
+        }
+    },
+    defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
+};
+exports.redisQueueOpts = redisQueueOpts;

package/errors/authError.d.ts

@@ -0,0 +1,55 @@
+import { HTTP } from '../constants/http';
+export declare const authError: {
+    DUPLICATE_EMAIL: {
+        code: HTTP;
+        message: string;
+    };
+    DUPLICATE_USERNAME: {
+        code: HTTP;
+        message: string;
+    };
+    DOMAIN_NOT_ALLOWED: {
+        code: HTTP;
+        message: string;
+    };
+    API_KEY_IS_INVALID: {
+        code: HTTP;
+        message: string;
+    };
+    SECRET_KEY_IS_INVALID: {
+        code: HTTP;
+        message: string;
+    };
+    TOKEN_IS_INVALID: {
+        code: HTTP;
+        message: string;
+    };
+    TOKEN_EXPIRED: {
+        code: HTTP;
+        message: string;
+    };
+    EMAIL_OR_PASSWORD_IS_WRONG: {
+        code: HTTP;
+        message: string;
+    };
+    DOMAIN_IS_WRONG: {
+        code: HTTP;
+        message: string;
+    };
+    MODULE_IS_NOT_INSTALLED: {
+        code: HTTP;
+        message: string;
+    };
+    TOKEN_SITE_IS_WRONG: {
+        code: HTTP;
+        message: string;
+    };
+    ACCESS_DENINED: {
+        code: HTTP;
+        message: string;
+    };
+    QUOTA_EXCEEDED: {
+        code: HTTP;
+        message: string;
+    };
+};

package/errors/authError.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authError = void 0;
+exports.authError = {
+    DUPLICATE_EMAIL: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'DUPLICATE_EMAIL'
+    },
+    DUPLICATE_USERNAME: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'DUPLICATE_USERNAME'
+    },
+    DOMAIN_NOT_ALLOWED: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'DOMAIN_NOT_ALLOWED'
+    },
+    API_KEY_IS_INVALID: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'API_KEY_IS_INVALID'
+    },
+    SECRET_KEY_IS_INVALID: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'SECRET_KEY_IS_INVALID'
+    },
+    TOKEN_IS_INVALID: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'TOKEN_IS_INVALID'
+    },
+    TOKEN_EXPIRED: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'TOKEN_EXPIRED'
+    },
+    EMAIL_OR_PASSWORD_IS_WRONG: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'EMAIL_OR_PASSWORD_IS_WRONG'
+    },
+    DOMAIN_IS_WRONG: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'DOMAIN_IS_WRONG'
+    },
+    MODULE_IS_NOT_INSTALLED: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'MODULE_IS_NOT_INSTALLED'
+    },
+    TOKEN_SITE_IS_WRONG: {
+        code: 401 /* HTTP.UNAUTHORIZED */,
+        message: 'SITE_REF_IS_NOT_AUTHORIZED'
+    },
+    ACCESS_DENINED: {
+        code: 403 /* HTTP.FORBIDDEN */,
+        message: 'ACCESS_DENINED'
+    },
+    QUOTA_EXCEEDED: {
+        code: 403 /* HTTP.FORBIDDEN */,
+        message: 'QUOTA_EXCEEDED'
+    }
+};

package/errors/index.d.ts

@@ -0,0 +1,32 @@
+export interface ErrorType {
+    [name: string]: {
+        code: any;
+        message: string;
+    };
+}
+interface ErrorPayload {
+    name?: string;
+    code: any;
+    message: string;
+    fields?: any;
+}
+export declare class CustomError extends Error {
+    code: any;
+    json: any;
+    message: any;
+    fields: any;
+    constructor(obj: ErrorPayload);
+}
+export declare const generalError: ErrorType;
+export declare const paramError: (message: string, { field, code, prefixMessage }?: {
+    field?: string;
+    code?: string;
+    prefixMessage?: string;
+}) => Promise<never>;
+export declare const errorHandler: (error: any, { defaultValue, prefixMessage }?: {
+    defaultValue?: string;
+    prefixMessage?: string;
+}) => {
+    error: string;
+};
+export {};

package/errors/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = exports.paramError = exports.generalError = exports.CustomError = void 0;
+const tslib_1 = require("tslib");
+const helper_1 = require("../utils/helper");
+const Raven = require("raven");
+class CustomError extends Error {
+    constructor(obj) {
+        if (obj.code && obj.code < 505 /* HTTP.HTTP_VERSION_NOT_SUPPORTED */) {
+            super(obj.message);
+            this.code = obj.code;
+            this.message = obj.message;
+            this.json = { code: obj.message };
+            if (obj.fields) {
+                this.fields = obj.fields;
+            }
+        }
+        else {
+            if ((0, helper_1.getENV)('NODE_ENV') == "production" && (0, helper_1.getENV)('SENTRY')) {
+                obj.name = 'INTERNAL_SERVER_ERROR';
+                Raven.captureException(obj);
+            }
+            super(exports.generalError.INTERNAL_SERVER_ERROR.message);
+            this.code = exports.generalError.INTERNAL_SERVER_ERROR.code;
+            this.message = obj.message;
+            this.json = { code: exports.generalError.INTERNAL_SERVER_ERROR.message };
+        }
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.CustomError = CustomError;
+exports.generalError = {
+    INTERNAL_SERVER_ERROR: {
+        code: 500 /* HTTP.INTERNAL_SERVER_ERROR */,
+        message: 'INTERNAL_SERVER_ERROR'
+    },
+    CACHE_NOT_READY: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'CACHE_NOT_READY'
+    },
+    NO_CONTENT: {
+        code: 204 /* HTTP.NO_CONTENT */,
+        message: 'NO_CONTENT'
+    },
+    NOT_FOUND: {
+        code: 404 /* HTTP.NOT_FOUND */,
+        message: 'NOT_FOUND'
+    },
+    NOT_FOUND_OR_NOT_UPDATED: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'NOT_FOUND_OR_NOT_UPDATED'
+    },
+    DATABASE_ERROR: {
+        code: 500 /* HTTP.INTERNAL_SERVER_ERROR */,
+        message: 'DATABASE_ERROR'
+    },
+    BAD_REQUEST: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'BAD_REQUEST'
+    },
+    EMAIL_DUPLICATE: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'EMAIL_DUPLICATE'
+    },
+    SLUG_DUPLICATE: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'SLUG_IS_DUPLICATE'
+    },
+    FILE_TYPE_NOT_ALLOW: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'FILE_TYPE_NOT_ALLOW'
+    },
+    DATA_DUPLICATE: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'DATA_IS_DUPLICATE'
+    },
+    DATA_RELATED: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'DATA_IS_RELATED'
+    },
+    LANG_CODE_NOT_FOUND: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'LANG_CODE_NOT_FOUND'
+    },
+    JSON_TYPE_REQUIRED: {
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'JSON_TYPE_REQUIRED'
+    }
+};
+const paramError = (message, { field = "default", code = "INVALID_PARAMS", prefixMessage = "" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const fields = { [field]: { code, message: `${prefixMessage}${message}` } };
+    return Promise.reject({
+        code: 400 /* HTTP.BAD_REQUEST */,
+        message: 'INVALID_PARAMS',
+        fields
+    });
+});
+exports.paramError = paramError;
+const errorHandler = (error, { defaultValue = "not available", prefixMessage = "" } = {}) => {
+    let res = { error: defaultValue };
+    if (error.fields && typeof error.fields == "object") {
+        res['error'] = Object.keys(error.fields).map(key => (error.fields[key]['message']))[0];
+    }
+    else if (error.message) {
+        res['error'] = error.message;
+    }
+    else if (typeof error == "string") {
+        res['error'] = error;
+    }
+    res['error'] = `${prefixMessage}${res['error']}`;
+    return res;
+};
+exports.errorHandler = errorHandler;

package/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utils"), exports);

package/interface/param.d.ts

@@ -0,0 +1,41 @@
+export interface CUDParamOption {
+    ref_core?: any;
+    type?: string;
+    auth_id?: any;
+    organ_id?: any;
+    parent_organ_id?: any;
+    permission?: any;
+    records?: Array<any>;
+}
+export interface StreamParamOption {
+    ref_core?: any;
+    require?: string;
+    lang_code?: string;
+    field_type?: object;
+    type?: string;
+    section?: any;
+    exclude?: Array<any>;
+    excludeObj?: object;
+    created_by?: string;
+    auth_id?: any;
+    organ_id?: any;
+    parent_organ_id?: any;
+    permission?: any;
+    [index: string]: any;
+}
+export interface QueryParamOption {
+    ref_core?: any;
+    category?: Array<any>;
+    limit?: number;
+    offset?: number;
+    lang_code?: string;
+    currency?: string;
+    price?: Array<any>;
+    order?: Array<any>;
+    auth_id?: any;
+    organ_id?: any;
+    parent_organ_id?: any;
+    permission?: any;
+    cc?: string;
+    no_image?: boolean;
+}

package/interface/param.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/middlewares/accessToken.d.ts

@@ -0,0 +1,13 @@
+import { Request, Response } from 'express';
+export declare const verifyAccessToken: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const verifyStaff: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const getGroupSetting: (req: Request, res: Response, next: any) => Promise<any>;
+export declare function getGroupPermission(value: any, { role, param_key }?: {
+    role?: string;
+    param_key?: string;
+}): (req: Request, res: Response, next: any) => Promise<any>;
+export declare function verifyPermissionGroup(value: any, { role, param_key }?: {
+    role?: string;
+    param_key?: string;
+}): (req: Request, res: Response, next: any) => Promise<any>;
+export declare const accessToken: (req: Request, res: Response, next: any) => Promise<any>;