@triproject/nestjs-core 1.0.5

package/dist/drivers/db/repository.js

@@ -0,0 +1,255 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const common_1 = require("@nestjs/common");
+const helpers_1 = require("@triproject/helpers");
+const moment_1 = __importDefault(require("moment"));
+const sequelize_1 = require("sequelize");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const logger_1 = require("../logger");
+class Repository {
+    logger = new logger_1.AppLogger(this.constructor.name);
+    Model;
+    db;
+    excludeParamsFromFilter = [
+        'attributes',
+        'include',
+        'where',
+        'orWhere',
+        'andWhere',
+        'q',
+        'searchKey',
+        'page',
+        'perPage',
+        'orderBy',
+        'sort',
+        'groupBy',
+        'order',
+    ];
+    get attributes() {
+        return Object.keys(this.Model.getAttributes());
+    }
+    get attributesTypes() {
+        const attributes = this.Model.getAttributes();
+        return Object.keys(attributes).map((attr) => ({
+            name: attr,
+            type: attributes[attr].type,
+        }));
+    }
+    getTrueKey(key) {
+        return key.replace('min_', '').replace('max_', '').replace('start_', '').replace('end_', '');
+    }
+    parsedBetweenData(where, key, value) {
+        const col = this.getTrueKey(key);
+        const operation = key.startsWith('start_') || key.startsWith('min_') ? 'gte' : 'lte';
+        value =
+            key.startsWith('_start') || key.startsWith('end_') ? (0, moment_1.default)(value).utc().format('YYYY-MM-DD HH:mm:ss') : value;
+        // @ts-ignore
+        if (typeof where[col] === 'undefined')
+            return { [sequelize_1.Op[operation]]: value };
+        // @ts-ignore
+        let beforeValue = where[col][sequelize_1.Op[operation == 'gte' ? 'lte' : 'gte']];
+        beforeValue =
+            key.startsWith('_start') || key.startsWith('end_')
+                ? (0, moment_1.default)(beforeValue).utc().format('YYYY-MM-DD HH:mm:ss')
+                : beforeValue;
+        return {
+            [sequelize_1.Op.between]: operation === 'gte' ? [value, beforeValue] : [beforeValue, value],
+        };
+    }
+    mapFilter(filter, cols) {
+        const where = {};
+        for (const key of Object.keys(filter)) {
+            const isSpecialKey = key.includes('$') || key.includes('.');
+            if (!cols.includes(this.getTrueKey(key)) && !isSpecialKey)
+                continue;
+            const value = filter[key];
+            const col = this.getTrueKey(key);
+            if (value === undefined || value === '')
+                continue;
+            if (key.startsWith('min_') || key.startsWith('start_') || key.startsWith('max_') || key.startsWith('end_')) {
+                // @ts-ignore
+                where[col] = this.parsedBetweenData(where, key, value);
+                continue;
+            }
+            if (typeof value === 'string' && value.includes(',')) {
+                // @ts-ignore
+                where[col] = value.split(',');
+                continue;
+            }
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                // @ts-ignore
+                where[col] = { ...value };
+                continue;
+            }
+            // @ts-ignore
+            where[col] = value;
+        }
+        return where;
+    }
+    _getOptions(params) {
+        const fields = this.attributes;
+        let where = this.mapFilter({ ...params.where, ...(0, helpers_1.omit)(params, this.excludeParamsFromFilter) }, fields);
+        if (params.q && params.searchKey) {
+            const searchConditions = Array.isArray(params.searchKey)
+                ? params.searchKey.map((key) => ({
+                    [key]: { [sequelize_1.Op.like]: `%${params.q}%` },
+                }))
+                : [{ [params.searchKey]: { [sequelize_1.Op.like]: `%${params.q}%` } }];
+            where = {
+                ...where,
+                [sequelize_1.Op.and]: [...(params.andWhere || []), { [sequelize_1.Op.or]: [...searchConditions, ...(params.orWhere || [])] }],
+            };
+        }
+        if (params.orWhere || params.andWhere) {
+            where = {
+                ...where,
+                [sequelize_1.Op.and]: [...(params.andWhere || []), { [sequelize_1.Op.or]: params.orWhere || [] }],
+            };
+        }
+        const order = [];
+        if (params?.orderBy && fields.includes(params?.orderBy)) {
+            order.push([params?.orderBy, params?.sort ?? 'DESC']);
+        }
+        if (params?.order)
+            order.push(...params.order, ['id', 'ASC']);
+        const attributes = params.attributes
+            ? params.attributes.filter((d) => (typeof d === 'string' ? fields.includes(d) : true))
+            : undefined;
+        return {
+            where,
+            order,
+            group: params?.groupBy,
+            ...(attributes && { attributes }),
+            include: params.include,
+        };
+    }
+    async findForPublic(params, mapInto) {
+        const options = this._getOptions(params);
+        const limit = +(params?.perPage ?? 20);
+        const data = await this.findAll({ ...options, limit });
+        return data.map((d) => mapInto(d));
+    }
+    async paginate(params, mapInto) {
+        const options = this._getOptions(params);
+        const limit = +(params?.perPage ?? 20);
+        const page = +(params?.page ?? 1);
+        const offset = page > 1 ? limit * (page - 1) : 0;
+        const data = await this.findAndCountAll({
+            limit,
+            offset,
+            ...options,
+            distinct: true,
+        });
+        data.count = Array.isArray(data.count) ? data.count.length : data.count;
+        const totalPage = Math.ceil(data.count / limit);
+        return {
+            data: mapInto ? data.rows.map((d) => mapInto(d)) : data.rows,
+            timestamp: (0, moment_1.default)().utc().toISOString(true),
+            meta: {
+                perPage: limit,
+                page: page,
+                totalPage: totalPage,
+                total: data.count,
+                prevPage: page > 1 ? page - 1 : null,
+                nextPage: page < totalPage ? page + 1 : null,
+            },
+        };
+    }
+    async export(params, mapInto) {
+        const options = this._getOptions(params);
+        const data = await this.findAll(options);
+        if (!mapInto)
+            return data;
+        return data.map((d) => mapInto(d));
+    }
+    async updateOrCreate(values, whereOptions, options) {
+        const data = await this.findOne({ where: whereOptions });
+        if (!data) {
+            return await this.create(values, options);
+        }
+        await this.update(data, values, options);
+        return data;
+    }
+    async findAll(options) {
+        return await this.Model.findAll(options);
+    }
+    async findAndCountAll(options) {
+        return await this.Model.findAndCountAll(options);
+    }
+    async findOne(options) {
+        return await this.Model.findOne(options);
+    }
+    async create(values, options) {
+        return await this.Model.create(values, options);
+    }
+    async update(entity, values, options) {
+        // @ts-ignore
+        if (typeof entity === 'string')
+            entity = (await this.findOne({ where: { id: entity }, attributes: ['id'] }));
+        if (!entity)
+            throw new common_1.NotFoundException();
+        return await entity.update(values, { ...options });
+    }
+    async upsert(values, options) {
+        return await this.Model.upsert(values, { ...options });
+    }
+    async bulkUpdate(values, options) {
+        return await this.Model.update(values, { ...options });
+    }
+    async bulkCreate(values, options) {
+        const idAttribute = this.attributesTypes.find((attr) => attr.name === 'id');
+        if (idAttribute && idAttribute.type !== 'BIGINT') {
+            values = values.map((val) => {
+                // @ts-ignore
+                if (!val['id'])
+                    val['id'] = generateId();
+                return val;
+            });
+        }
+        return await this.Model.bulkCreate(values, options);
+    }
+    async destroy(options) {
+        return await this.Model.destroy(options);
+    }
+    async sum(field, options) {
+        return await this.Model.sum(field, options);
+    }
+    async sumField(params, field) {
+        const options = this._getOptions(params);
+        return await this.sum(field, options);
+    }
+    async sumCol(params, fieldToSum, expectedField) {
+        const options = this._getOptions(params);
+        options.attributes = [[(0, sequelize_1.fn)('sum', (0, sequelize_1.col)(fieldToSum)), expectedField]];
+        const result = await this.Model.findAll(options);
+        return result.reduce((total, row) => {
+            const value = row.get(expectedField);
+            return total + parseFloat(String(value) || '0');
+        }, 0);
+    }
+    async count(options) {
+        return await this.Model.count(options);
+    }
+    async filteredFindAll(params) {
+        const options = this._getOptions(params);
+        return await this.Model.findAll(options);
+    }
+}
+exports.Repository = Repository;
+__decorate([
+    (0, common_1.Inject)(sequelize_typescript_1.Sequelize),
+    __metadata("design:type", sequelize_typescript_1.Sequelize)
+], Repository.prototype, "db", void 0);

package/dist/drivers/encryptions/encryption.d.ts

@@ -0,0 +1,8 @@
+export declare class Encryption {
+    private keyEncoding;
+    private encoding;
+    private algorithm;
+    private _generateEncryptionIV;
+    encrypt(text: string): string;
+    decrypt(encryptedData: string): string;
+}

package/dist/drivers/encryptions/encryption.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encryption = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const config_1 = require("../../config");
+const exception_helper_1 = require("../../helpers/exception.helper");
+let Encryption = class Encryption {
+    keyEncoding = 'hex';
+    encoding = 'hex';
+    algorithm = 'aes-256-gcm';
+    _generateEncryptionIV() {
+        return (0, crypto_1.randomBytes)(16).toString(this.keyEncoding);
+    }
+    encrypt(text) {
+        if (!config_1.ENCRYPTION_KEY)
+            throw new exception_helper_1.AppUnprocessableEntityException('ENCRYPTION_KEY is not defined');
+        const iv = this._generateEncryptionIV();
+        const cipher = (0, crypto_1.createCipheriv)(this.algorithm, Buffer.from(config_1.ENCRYPTION_KEY, this.keyEncoding), Buffer.from(iv, this.keyEncoding));
+        const encrypted = cipher.update(text, 'utf8', this.encoding) + cipher.final(this.encoding);
+        const tag = cipher.getAuthTag();
+        const data = [iv, tag.toString(this.encoding), encrypted].join(';;');
+        return Buffer.from(data).toString('base64');
+    }
+    decrypt(encryptedData) {
+        if (!config_1.ENCRYPTION_KEY)
+            throw new exception_helper_1.AppUnprocessableEntityException('ENCRYPTION_KEY is not defined');
+        try {
+            const bufferData = Buffer.from(encryptedData, 'base64').toString();
+            const [iv, tag, encrypted] = bufferData.split(';;');
+            const decipher = (0, crypto_1.createDecipheriv)(this.algorithm, Buffer.from(config_1.ENCRYPTION_KEY, this.keyEncoding), Buffer.from(iv, this.keyEncoding));
+            decipher.setAuthTag(Buffer.from(tag, this.encoding));
+            const decrypted = decipher.update(encrypted, this.encoding, 'utf8') + decipher.final('utf8');
+            return decrypted;
+        }
+        catch (error) {
+            throw new exception_helper_1.AppInternalServerErrorException('Error while decrypting data');
+        }
+    }
+};
+exports.Encryption = Encryption;
+exports.Encryption = Encryption = __decorate([
+    (0, common_1.Injectable)()
+], Encryption);

package/dist/drivers/encryptions/encryption.module.d.ts

@@ -0,0 +1,2 @@
+export declare class EncryptionModule {
+}

package/dist/drivers/encryptions/encryption.module.js

@@ -0,0 +1,24 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionModule = void 0;
+const common_1 = require("@nestjs/common");
+const encryption_1 = require("./encryption");
+const jwt_1 = require("./jwt");
+const password_hash_1 = require("./password-hash");
+const snap_signature_1 = require("./snap.signature");
+let EncryptionModule = class EncryptionModule {
+};
+exports.EncryptionModule = EncryptionModule;
+exports.EncryptionModule = EncryptionModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [password_hash_1.PasswordHash, jwt_1.Jwt, encryption_1.Encryption, snap_signature_1.SnapSignature],
+        exports: [password_hash_1.PasswordHash, jwt_1.Jwt, encryption_1.Encryption, snap_signature_1.SnapSignature],
+    })
+], EncryptionModule);

package/dist/drivers/encryptions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './encryption.module';
+export * from './jwt';
+export * from './password-hash';

package/dist/drivers/encryptions/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./encryption.module"), exports);
+__exportStar(require("./jwt"), exports);
+__exportStar(require("./password-hash"), exports);

package/dist/drivers/encryptions/jwt.d.ts

@@ -0,0 +1,6 @@
+import { Algorithm } from 'jsonwebtoken';
+export declare class Jwt {
+    protected jwtAlgorithms: Algorithm[];
+    verify<T>(token: string): T;
+    sign(data: object, expiresIn?: number): string;
+}

package/dist/drivers/encryptions/jwt.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwt = void 0;
+const common_1 = require("@nestjs/common");
+const jsonwebtoken_1 = require("jsonwebtoken");
+const config_1 = require("../../config");
+const exception_helper_1 = require("../../helpers/exception.helper");
+let Jwt = class Jwt {
+    jwtAlgorithms = ['RS512'];
+    verify(token) {
+        try {
+            return (0, jsonwebtoken_1.verify)(token, config_1.JWT_PUBLIC_KEY, {
+                algorithms: this.jwtAlgorithms,
+            });
+        }
+        catch (error) {
+            throw new exception_helper_1.AppUnprocessableEntityException('Invalid or expired JWT token.');
+        }
+    }
+    sign(data, expiresIn = 15_000) {
+        try {
+            const key = typeof config_1.JWT_PRIVATE_KEY === 'string' && config_1.JWT_PRIVATE_KEY
+                ? Buffer.from(config_1.JWT_PRIVATE_KEY)
+                : { key: config_1.JWT_PRIVATE_KEY, passphrase: '' };
+            return (0, jsonwebtoken_1.sign)({ ...data }, key, {
+                algorithm: this.jwtAlgorithms[0],
+                expiresIn,
+                allowInsecureKeySizes: false,
+                encoding: 'utf-8',
+            });
+        }
+        catch (error) {
+            throw new exception_helper_1.AppUnprocessableEntityException('Failed to sign JWT token.');
+        }
+    }
+};
+exports.Jwt = Jwt;
+exports.Jwt = Jwt = __decorate([
+    (0, common_1.Injectable)()
+], Jwt);

package/dist/drivers/encryptions/password-hash.d.ts

@@ -0,0 +1,11 @@
+export declare class PasswordHash {
+    private DIGEST;
+    private ITERATIONS;
+    private KEYLEN;
+    private SALT_LENGTH;
+    private HASH_ENCODING;
+    private HASH_DELIMITER;
+    private _hash;
+    sign(password: string): string;
+    verify(password: string, passwordHash: string): boolean;
+}

package/dist/drivers/encryptions/password-hash.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordHash = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const config_1 = require("../../config");
+let PasswordHash = class PasswordHash {
+    DIGEST = 'sha512';
+    ITERATIONS = 100000;
+    KEYLEN = 64;
+    SALT_LENGTH = 8;
+    HASH_ENCODING = 'base64';
+    HASH_DELIMITER = '.';
+    _hash(password, salt) {
+        return (0, crypto_1.pbkdf2Sync)(config_1.PASSWORD_HASH_SECRET + password, salt, this.ITERATIONS, this.KEYLEN, this.DIGEST);
+    }
+    sign(password) {
+        const salt = (0, crypto_1.randomBytes)(this.SALT_LENGTH).toString('hex');
+        const key = this._hash(password, salt).toString(this.HASH_ENCODING);
+        return `$${salt}${this.HASH_DELIMITER}$${key}`;
+    }
+    verify(password, passwordHash) {
+        const [salt, key] = passwordHash.replace('$', '').split(this.HASH_DELIMITER);
+        const derivedKey = this._hash(password, salt);
+        const storedHashBuffer = Buffer.from(key, this.HASH_ENCODING);
+        return (0, crypto_1.timingSafeEqual)(storedHashBuffer, derivedKey);
+    }
+};
+exports.PasswordHash = PasswordHash;
+exports.PasswordHash = PasswordHash = __decorate([
+    (0, common_1.Injectable)()
+], PasswordHash);

package/dist/drivers/encryptions/snap.signature.d.ts

@@ -0,0 +1,32 @@
+import { BinaryToTextEncoding } from 'crypto';
+import { Request } from 'express';
+export interface SnapBodySignatureParams {
+    url: string;
+    body: object;
+    timestamp: string;
+    method?: 'POST' | 'GET';
+    accessToken?: string;
+}
+export interface VerifyGetTokenSignature {
+    client_id: string;
+    signature?: string;
+    timestamp: string;
+}
+export declare class SnapSignature {
+    sha256Encoding: BinaryToTextEncoding;
+    sha512Encoding: BinaryToTextEncoding;
+    minifiedObjectEncoding: BinaryToTextEncoding;
+    private _signSHA256;
+    private _verifySHA256WithRSA;
+    private _verifySHA256;
+    private _signSHA512;
+    private _verifySHA512;
+    private _reqBodySignatureString;
+    private _minifyParams;
+    signBodySignature(params: SnapBodySignatureParams, secret: string): string;
+    private _verifyBodySignature;
+    signAccessTokenSignature(params: VerifyGetTokenSignature, secretKey: string): string;
+    private _verifyAccessTokenSignature;
+    middleware(secret: string, req: Request): void;
+}
+export declare const snapSignature: SnapSignature;

package/dist/drivers/encryptions/snap.signature.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapSignature = exports.SnapSignature = void 0;
+const helpers_1 = require("@triproject/helpers");
+const crypto_1 = require("crypto");
+class SnapSignature {
+    sha256Encoding = 'base64';
+    sha512Encoding = 'hex';
+    minifiedObjectEncoding = 'hex';
+    _signSHA256(stringToSign, privateKey) {
+        const signer = (0, crypto_1.createSign)('SHA256');
+        signer.update(stringToSign);
+        return signer.sign((0, helpers_1.parsedKeyPair)(privateKey), this.sha256Encoding);
+    }
+    _verifySHA256WithRSA(stringToVerify, signature, publicKey) {
+        const verifier = (0, crypto_1.createVerify)('SHA256');
+        verifier.update(stringToVerify);
+        return verifier.verify({
+            key: (0, helpers_1.parsedKeyPair)(publicKey),
+            padding: crypto_1.constants.RSA_PKCS1_PSS_PADDING,
+            saltLength: 32,
+        }, signature, this.sha256Encoding);
+    }
+    _verifySHA256(stringToVerify, signature, publicKey) {
+        try {
+            const verifier = (0, crypto_1.createVerify)('SHA256');
+            verifier.update(stringToVerify);
+            const isValid = verifier.verify((0, helpers_1.parsedKeyPair)(publicKey), signature, this.sha256Encoding);
+            if (isValid)
+                return true;
+            return this._verifySHA256WithRSA(stringToVerify, signature, publicKey);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    _signSHA512(stringToSign, secret) {
+        try {
+            const hmac = (0, crypto_1.createHmac)('sha512', secret);
+            hmac.update(stringToSign);
+            return hmac.digest(this.sha256Encoding);
+        }
+        catch (error) {
+            throw new Error('Error while signing data');
+        }
+    }
+    _verifySHA512(stringToVerify, signature, secret) {
+        const hmac = (0, crypto_1.createHmac)('sha512', secret);
+        hmac.update(stringToVerify);
+        const calculatedSignature = hmac.digest(this.sha512Encoding);
+        return calculatedSignature === signature;
+    }
+    _reqBodySignatureString(params) {
+        const stringToSign = [
+            params?.method ?? 'POST',
+            params.url,
+            params.accessToken,
+            this._minifyParams(params.body),
+            params.timestamp,
+        ].filter((d) => d);
+        return stringToSign.join(':');
+    }
+    _minifyParams(object) {
+        const minifiedRequestBody = typeof object === 'object' ? JSON.stringify(object) : object?.toString() ?? '';
+        const sha256Hash = (0, crypto_1.createHash)('SHA256');
+        sha256Hash.update(minifiedRequestBody);
+        const sha256HashString = sha256Hash.digest(this.minifiedObjectEncoding);
+        return sha256HashString.toLowerCase();
+    }
+    signBodySignature(params, secret) {
+        return this._signSHA512(this._reqBodySignatureString(params), secret);
+    }
+    _verifyBodySignature(params, signature, secret) {
+        return this._verifySHA512(this._reqBodySignatureString(params), signature, secret);
+    }
+    signAccessTokenSignature(params, secretKey) {
+        const { client_id, timestamp } = params;
+        const stringToSing = [client_id, timestamp];
+        return this._signSHA256(stringToSing.join('|'), secretKey);
+    }
+    _verifyAccessTokenSignature(params, publicKey) {
+        const { client_id, timestamp, signature } = params;
+        if (!signature)
+            return false;
+        const stringToSing = [client_id, timestamp];
+        return this._verifySHA256(stringToSing.join('|'), signature, publicKey);
+    }
+    middleware(secret, req) {
+        if (!['POST', 'GET'].includes(req.method))
+            throw new Error('Invalid request method');
+        if (req.path?.includes('/access-token/b2b')) {
+            const { 'client-id': client_id, 'x-timestamp': timestamp, 'x-signature': signature } = req.headers;
+            const isValid = this._verifyAccessTokenSignature({ client_id, timestamp, signature }, secret);
+            if (!isValid)
+                throw new Error('Invalid signature');
+        }
+        const { 'x-timestamp': timestamp, 'x-signature': signature, accessToken } = req.headers;
+        const isValid = this._verifyBodySignature({
+            url: req.path,
+            body: req.body,
+            timestamp,
+            method: req.method,
+            accessToken: (accessToken ?? '')?.replace('Bearer ', ''),
+        }, signature, secret);
+        if (!isValid)
+            throw new Error('Invalid signature');
+    }
+}
+exports.SnapSignature = SnapSignature;
+exports.snapSignature = new SnapSignature();

package/dist/drivers/logger/app.logger.d.ts

@@ -0,0 +1,23 @@
+import { ConsoleLogger } from '@nestjs/common';
+type LogMessageType = string | object | Error | undefined | null | number | boolean;
+export declare class AppLogger extends ConsoleLogger {
+    protected readonly context: string;
+    private LOG_STACKS;
+    constructor(context?: string);
+    private _notifyError;
+    private excludeContexts;
+    private _excludeContext;
+    private _sanitizePolicyData;
+    private _formatBgLevel;
+    private _formatException;
+    private _parseMessage;
+    private _mapLog;
+    private _formatConsoleError;
+    private _console;
+    log(...args: LogMessageType[]): void;
+    error(...args: LogMessageType[]): void;
+    fatal(...args: LogMessageType[]): void;
+    warn(...args: LogMessageType[]): void;
+    debug(...args: LogMessageType[]): void;
+}
+export {};