@digione/node-custom-api 0.0.1

package/models/user/user_organ.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUserOrganModel = exports.UserUserAssociation = exports.UserUserOrganAssociation = exports.UserUserOrganAttr = exports.UserUserOrganTable = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const user_1 = require("../../models/user/user");
+const organ_1 = require("../../models/user/organ");
+exports.UserUserOrganTable = "users_organs";
+exports.UserUserOrganAttr = {
+    user_id: {
+        type: sequelize.INTEGER,
+        allowNull: false,
+        primaryKey: true
+    },
+    organ_id: {
+        type: sequelize.INTEGER,
+        allowNull: false,
+        primaryKey: true
+    },
+    created: sequelize.DATE,
+    group_id: {
+        type: sequelize.INTEGER,
+        allowNull: false
+    }
+};
+const UserUserOrganModel = database_1.default.define("UserUserOrgan", exports.UserUserOrganAttr, {
+    tableName: exports.UserUserOrganTable
+});
+exports.UserUserOrganModel = UserUserOrganModel;
+UserUserOrganModel.removeAttribute('id');
+exports.UserUserOrganAssociation = {
+    organ: {
+        model: organ_1.UserOrganModel,
+        alias: "organ",
+        join: (ref, { required = false, where = {}, attributes = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: exports.UserUserOrganAssociation.organ.model.schema(ref, "_"),
+                as: exports.UserUserOrganAssociation.organ.alias
+            };
+        })
+    },
+    user: {
+        model: user_1.UserModel,
+        alias: "user",
+        join: (ref, { attributes = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                attributes,
+                model: exports.UserUserOrganAssociation.user.model.schema(ref, "_"),
+                as: exports.UserUserOrganAssociation.user.alias
+            };
+        })
+    }
+};
+exports.UserUserAssociation = {
+    organ: {
+        model: UserUserOrganModel,
+        alias: "user_organ",
+        join: (ref, { where = {}, required = false, attributes = undefined, organ = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let include = [];
+            if (organ) {
+                include.push({
+                    required: true,
+                    attributes,
+                    model: organ_1.UserOrganModel.schema(ref, "_"),
+                    as: "organ"
+                });
+            }
+            return {
+                where,
+                required,
+                attributes,
+                model: exports.UserUserAssociation.organ.model.schema(ref, "_"),
+                as: exports.UserUserAssociation.organ.alias,
+                include
+            };
+        })
+    }
+};
+// organ
+UserUserOrganModel.belongsTo(exports.UserUserOrganAssociation.organ.model, { as: exports.UserUserOrganAssociation.organ.alias, targetKey: "id", foreignKey: "organ_id" });
+// user
+UserUserOrganModel.belongsTo(exports.UserUserOrganAssociation.user.model, { as: exports.UserUserOrganAssociation.user.alias, targetKey: "id", foreignKey: "user_id" });
+user_1.UserModel.hasOne(exports.UserUserAssociation.organ.model, { as: exports.UserUserAssociation.organ.alias, foreignKey: "user_id" });

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@digione/node-custom-api",
+  "version": "0.0.1",
+  "description": "Typescript node digione-api",
+  "author": "Monchai Jirayupong <monchai.j@seven.co.th>",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "start": "ts-node dist/index.ts",
+    "serve": "nodemon",
+    "build": "rm -rf lib -R && tsc && cp package.json ./lib",
+    "lint": "tslint --project tsconfig.json --format stylish"
+  },
+  "keywords": [
+    "typescript"
+  ],
+  "dependencies": {
+    "@joi/date": "2.1.0",
+    "aws-sdk": "2.288.0",
+    "bull": "4.12.2",
+    "dotenv": "16.4.5",
+    "express": "4.18.2",
+    "i18n": "0.15.1",
+    "jimp": "0.22.10",
+    "joi": "17.11.0",
+    "js-sha1": "0.7.0",
+    "jsonwebtoken": "9.0.2",
+    "lodash": "4.17.21",
+    "moment": "2.30.1",
+    "multer": "1.4.5-lts.1",
+    "mysql2": "3.9.1",
+    "numeral": "2.0.6",
+    "php-serialize": "4.1.1",
+    "raven": "2.6.4",
+    "sequelize": "6.35.2",
+    "short-unique-id": "5.0.3",
+    "uuid": "9.0.1"
+  },
+  "devDependencies": {
+    "@types/aws-sdk": "2.7.0",
+    "@types/express": "4.17.21",
+    "@types/i18n": "0.13.10",
+    "@types/ioredis": "5.0.0",
+    "@types/jimp": "0.2.28",
+    "@types/jsonwebtoken": "9.0.5",
+    "@types/lodash": "4.14.202",
+    "@types/moment": "2.13.0",
+    "@types/multer": "1.4.11",
+    "@types/node": "20.10.6",
+    "@types/numeral": "2.0.5",
+    "@types/raven": "2.5.7",
+    "@types/sequelize": "4.28.20",
+    "@types/uuid": "9.0.8",
+    "nodemon": "3.0.2",
+    "ts-node": "10.9.2",
+    "tslint": "6.1.3",
+    "typescript": "5.3.3"
+  }
+}

package/utils/auth.d.ts

@@ -0,0 +1,25 @@
+export declare const getIdFromReq: (req: any) => any;
+export declare const getTokenFromReq: (req: any) => any;
+export declare class AuthUtil {
+    ref: string;
+    constructor(ref: string);
+    create(id: any, { include }?: {
+        include?: {};
+    }): Promise<{
+        refresh_token: string;
+        access_token: string;
+    }>;
+    revokeTokenByToken(token: any): Promise<{
+        success: number;
+        token: any;
+    }>;
+    refreshAccessTokenByToken(token: any): Promise<{
+        access_token: string;
+    }>;
+    signNotificationTokenByToken(token: any, input?: any): Promise<{
+        success: number;
+    }>;
+    revokeNotificationTokenByToken(token: any): Promise<{
+        success: number;
+    }>;
+}

package/utils/auth.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthUtil = exports.getTokenFromReq = exports.getIdFromReq = void 0;
+const tslib_1 = require("tslib");
+const access_token_1 = require("../models/user/access_token");
+const refresh_token_1 = require("../models/user/refresh_token");
+const notification_token_1 = require("../models/user/notification_token");
+const helper_1 = require("./helper");
+const errors_1 = require("../errors");
+const authError_1 = require("../errors/authError");
+const jwt = require("jsonwebtoken");
+const signToken = (id, expIn, opt = {}) => {
+    const date = (0, helper_1.getDateTime)();
+    return jwt.sign(Object.assign({ id: id, createAt: date, expAt: date.add(expIn, 'days') }, opt), (0, helper_1.getENV)('JWT_SECRET'));
+};
+const getIdFromReq = (req) => {
+    try {
+        const token = req.headers['authorization'].split(' ')[1];
+        const decode = jwt.verify(token, (0, helper_1.getENV)('JWT_SECRET'));
+        return decode.id;
+    }
+    catch (e) {
+        throw new errors_1.CustomError(authError_1.authError.TOKEN_IS_INVALID);
+    }
+};
+exports.getIdFromReq = getIdFromReq;
+const getTokenFromReq = (req) => req.headers['authorization'].split(' ')[1];
+exports.getTokenFromReq = getTokenFromReq;
+class AuthUtil {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    create(id, { include = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let refreshTokenUUID = (0, helper_1.getUUID)();
+            let include_access = {};
+            if (Object.keys(include).length) {
+                include_access['setting'] = JSON.stringify(include);
+            }
+            let input = Object.assign({ id: refreshTokenUUID, user_id: id, expired_at: (0, helper_1.getDateTime)().add((0, helper_1.getENV)('REFRESH_TOKEN_AGE'), 'days'), token: signToken(id, (0, helper_1.getENV)('REFRESH_TOKEN_AGE'), { refresh_token_id: refreshTokenUUID }), accessToken: Object.assign({ user_id: id, expired_at: (0, helper_1.getDateTime)().add((0, helper_1.getENV)('ACCESS_TOKEN_AGE'), 'days'), token: signToken(id, (0, helper_1.getENV)('ACCESS_TOKEN_AGE'), { refresh_token_id: refreshTokenUUID }) }, include_access) }, include);
+            yield refresh_token_1.RefreshTokenModel.schema(this.ref, "_").create(input, {
+                include: [
+                    {
+                        as: 'accessToken',
+                        model: access_token_1.AccessTokenModel.schema(this.ref, ("_"))
+                    }
+                ]
+            });
+            return {
+                refresh_token: input.token,
+                access_token: input.accessToken.token
+            };
+        });
+    }
+    revokeTokenByToken(token) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenData = yield (0, helper_1.getTokenDataFromTokenBySecret)(token, (0, helper_1.getENV)('JWT_SECRET'));
+                const refreshTokenId = tokenData.refresh_token_id;
+                let data = yield refresh_token_1.RefreshTokenModel.schema(this.ref, "_").destroy({
+                    where: { id: refreshTokenId }
+                });
+                if (!data) {
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+                }
+                return { success: 1, token };
+            }
+            catch (err) {
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+        });
+    }
+    refreshAccessTokenByToken(token) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenData = yield (0, helper_1.getTokenDataFromTokenBySecret)(token, (0, helper_1.getENV)('JWT_SECRET'));
+                const refreshTokenId = tokenData.refresh_token_id;
+                const userId = tokenData.id;
+                yield access_token_1.AccessTokenModel.schema(this.ref, "_").destroy({
+                    where: { refresh_token_id: refreshTokenId }
+                });
+                let include_access = {}, attributes = (this.ref == 'core') ? ['group_id'] : ['organ_id', 'group_id', 'b2b_group_id', 'team_id'];
+                let refresh = yield refresh_token_1.RefreshTokenModel.schema(this.ref, "_").findOne({
+                    where: { id: refreshTokenId }, attributes, raw: true
+                });
+                if (!refresh)
+                    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+                include_access['setting'] = JSON.stringify(refresh);
+                const newAccessToken = signToken(userId, (0, helper_1.getENV)('ACCESS_TOKEN_AGE'), { refresh_token_id: refreshTokenId });
+                yield access_token_1.AccessTokenModel.schema(this.ref, "_").create(Object.assign({ user_id: userId, refresh_token_id: refreshTokenId, expired_at: (0, helper_1.getDateTime)().add((0, helper_1.getENV)('ACCESS_TOKEN_AGE'), 'days').format("YYYY-MM-DD HH:mm:ss"), token: newAccessToken }, include_access));
+                return {
+                    access_token: newAccessToken
+                };
+            }
+            catch (err) {
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+        });
+    }
+    signNotificationTokenByToken(token, input = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenData = yield (0, helper_1.getTokenDataFromTokenBySecret)(token, (0, helper_1.getENV)('JWT_SECRET'));
+                const refreshTokenId = tokenData.refresh_token_id;
+                const userId = tokenData.id;
+                if (refreshTokenId) {
+                    yield notification_token_1.NotificationTokenModel.schema(this.ref, "_").destroy({
+                        where: { refresh_token_id: refreshTokenId }
+                    });
+                    yield notification_token_1.NotificationTokenModel.schema(this.ref, "_").create(Object.assign({ user_id: userId, refresh_token_id: refreshTokenId }, input));
+                }
+                return { success: 1 };
+            }
+            catch (err) {
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+        });
+    }
+    revokeNotificationTokenByToken(token) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenData = yield (0, helper_1.getTokenDataFromTokenBySecret)(token, (0, helper_1.getENV)('JWT_SECRET'));
+                const refreshTokenId = tokenData.refresh_token_id;
+                if (refreshTokenId) {
+                    yield notification_token_1.NotificationTokenModel.schema(this.ref, "_").destroy({
+                        where: { refresh_token_id: refreshTokenId }
+                    });
+                }
+                return { success: 1 };
+            }
+            catch (err) {
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+        });
+    }
+}
+exports.AuthUtil = AuthUtil;

package/utils/config.d.ts

@@ -0,0 +1,8 @@
+interface ConfigOpt {
+    fileDestination?: string;
+    fileDelete?: boolean;
+    [key: string]: any;
+}
+export declare let config: ConfigOpt;
+export declare const setConfig: (opt: ConfigOpt) => ConfigOpt;
+export {};

package/utils/config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfig = exports.config = void 0;
+exports.config = {};
+const setConfig = (opt) => exports.config = opt;
+exports.setConfig = setConfig;

package/utils/core.d.ts

@@ -0,0 +1,6 @@
+export declare const verifyDomainCors: (origin: any, { where }?: {
+    where?: {};
+}) => Promise<boolean>;
+export declare const refreshDomainCors: ({ where }?: {
+    where?: {};
+}) => Promise<{}>;

package/utils/core.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshDomainCors = exports.verifyDomainCors = void 0;
+const tslib_1 = require("tslib");
+const domain_1 = require("../models/core/domain");
+const redis_1 = require("../database/redis");
+const verifyDomainCors = (origin, { where = {} } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let index = "core_domain_cors";
+    where = Object.assign(Object.assign({}, where), { type: "cors", site_id: 0 });
+    if (redis_1.redisReady) {
+        let setting = yield (0, redis_1.redisGet)(index);
+        if (!setting) {
+            setting = yield (0, exports.refreshDomainCors)();
+        }
+        else {
+            setting = JSON.parse(setting);
+        }
+        return (typeof setting[origin] != "undefined");
+    }
+    let count = yield domain_1.CoreDomainModel.schema("core", "_").count({ where: Object.assign({ domain: origin }, where) });
+    return count > 0;
+});
+exports.verifyDomainCors = verifyDomainCors;
+const refreshDomainCors = ({ where = {} } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let index = "core_domain_cors", setting = {};
+    where = Object.assign(Object.assign({}, where), { type: "cors", site_id: 0 });
+    if (redis_1.redisReady) {
+        let query = (yield domain_1.CoreDomainModel.schema("core", "_").findAll({
+            where, raw: true, attributes: ['domain']
+        }));
+        setting = query.reduce((total, item) => {
+            total[item['domain']] = 1;
+            return total;
+        }, {});
+        yield (0, redis_1.redisSet)(index, JSON.stringify(setting));
+    }
+    return setting;
+});
+exports.refreshDomainCors = refreshDomainCors;

package/utils/currency.d.ts

@@ -0,0 +1,16 @@
+interface OptionCurrency {
+    organ_id?: string | number;
+    [index: string]: any;
+}
+export declare class CurrencyUtil {
+    ref: string;
+    option: OptionCurrency;
+    constructor(ref: string, option?: OptionCurrency);
+    getCurrency({ where, attr_include, attr_vat, vat_value }?: {
+        where?: {};
+        attr_include?: any[];
+        attr_vat?: any[];
+        vat_value?: boolean;
+    }): Promise<any>;
+}
+export {};

package/utils/currency.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyUtil = void 0;
+const tslib_1 = require("tslib");
+const currency_1 = require("../models/system/currency");
+const organ_1 = require("../models/user/organ");
+const sequelize_1 = require("sequelize");
+class CurrencyUtil {
+    constructor(ref, option) {
+        this.ref = ref;
+        this.option = option || {};
+    }
+    getCurrency({ where = {}, attr_include = [], attr_vat = [], vat_value = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            where['enabled'] = '1';
+            let attributes = ['id', 'title', 'exch_rate', 'cur_decimal', 'cur_comma', 'cur_format_num', 'cur_format'].concat(attr_include);
+            let query = yield currency_1.SystemCurrencyModel.schema(this.ref, "_").findOne({
+                attributes, where, raw: true
+            });
+            if (query) {
+                if (this.option.organ_id) {
+                    if (vat_value) {
+                        let setting = (yield organ_1.UserOrganModel.schema(this.ref, "_").findOne({
+                            raw: true,
+                            where: { id: this.option.organ_id },
+                            attributes: [...attr_vat, [(0, sequelize_1.literal)(`vat.tax_value`), 'vat_value']],
+                            include: [yield organ_1.UserOrganAssociation.vat.join(this.ref, { attributes: [], required: true })]
+                        })) || {};
+                        setting['vat_value'] = setting['vat_value'] || 0;
+                        query = Object.assign(Object.assign({}, query), setting);
+                    }
+                }
+            }
+            return query;
+        });
+    }
+}
+exports.CurrencyUtil = CurrencyUtil;

package/utils/db.d.ts

@@ -0,0 +1,94 @@
+import * as sequelize from 'sequelize';
+import { ModelAttributeColumnOptions } from 'sequelize';
+export declare const genWhere: (where?: {}, { as, delimiter, prefix, bracket }?: {
+    as?: string;
+    delimiter?: string;
+    prefix?: boolean;
+    bracket?: boolean;
+}) => string;
+export declare const select: (table: string, { where, attributes, association, limit, offset, order }?: {
+    where?: {};
+    attributes?: any[];
+    association?: any[];
+    limit?: number;
+    offset?: number;
+    order?: any[];
+}) => Promise<string>;
+export declare const genValue: (value: any) => any;
+export declare const count: (table: string, { where, primaryKey }?: {
+    where?: {};
+    primaryKey?: string;
+}) => Promise<any>;
+export declare const findOne: (table: string, { where, attributes, association, order }?: {
+    where?: {};
+    attributes?: any[];
+    association?: any[];
+    order?: any[];
+}) => Promise<object>;
+export declare const findAll: (table: string, { where, attributes, association, limit, offset, order }?: {
+    where?: {};
+    attributes?: any[];
+    association?: any[];
+    limit?: number;
+    offset?: number;
+    order?: any[];
+}) => Promise<Array<any>>;
+export declare const update: (ref: string, table: string, input: any, { where, default_lang, index }?: {
+    where?: {};
+    default_lang?: string;
+    index?: string;
+}) => Promise<[undefined, number] | {
+    [x: string]: any;
+}>;
+export declare const insert: (ref: string, table: string, input: any, { index }?: {
+    index?: string;
+}) => Promise<{
+    [x: string]: any;
+}>;
+export declare const remove: (ref: string, table: string, { where }?: {
+    where?: {};
+}) => Promise<number>;
+export declare const max: (ref: string, table: string, field: any, { where }?: {
+    where?: {};
+}) => Promise<object[]>;
+export declare const getNextId: (ref: string, table: any) => Promise<any>;
+export declare const getFieldAll: (table: string, { type }?: {
+    type?: boolean;
+}) => Promise<any[]>;
+export declare const truncate: (table: string) => Promise<[unknown[], unknown]>;
+export declare const cloneTable: (old_table: string, new_table: string, { withRow }?: {
+    withRow?: boolean;
+}) => Promise<boolean>;
+export declare const createTable: (table: string, attributes: any, { removePrimary, field }?: {
+    removePrimary?: boolean;
+    field?: string;
+}) => Promise<void>;
+export declare const dropTable: (table: string) => Promise<void>;
+export declare const renameTable: (before: string, after: string) => Promise<void>;
+export declare const removeAttrReference: (obj: any, { field, removePrimary }?: {
+    field?: string;
+    removePrimary?: boolean;
+}) => any;
+export declare const getListTable: (search: string, { postfix }?: {
+    postfix?: boolean;
+}) => Promise<any[]>;
+export declare const getExistTable: (table: string) => Promise<boolean>;
+export declare const getExistField: (table: string, field: string) => Promise<boolean>;
+export declare const getChildren: (table: string, value: any, { level, max, where, array, key_index, key, init, lang_code }?: {
+    level?: number;
+    max?: number;
+    where?: {};
+    array?: any[];
+    key_index?: string;
+    key?: string;
+    init?: boolean;
+    lang_code?: boolean;
+}) => Promise<Array<any>>;
+export declare const addColumn: (table: string, field: string, schema: ModelAttributeColumnOptions) => Promise<any>;
+export declare const addConstraint: (table: string, options: sequelize.AddConstraintOptions) => Promise<void>;
+export declare const changeColumn: (table: string, field: string, schema: ModelAttributeColumnOptions, { remove_primarykey, remove_index }?: {
+    remove_primarykey?: boolean;
+    remove_index?: boolean;
+}) => Promise<void>;
+export declare const removeColumn: (table: string, field: string) => Promise<[unknown[], unknown]>;
+export declare const cloneColumn: (table: string, old_field: string, new_field: string) => Promise<[undefined, number]>;