jr-common-micro 0.6.1-dev

package/dist/utils/constants.d.ts

@@ -0,0 +1,45 @@
+export declare const COIN_MICRO = "COIN_MICRO";
+export declare const NEWS_MICRO = "NEWS_MICRO";
+export declare const NOTIFICATION_MICRO = "NOTIFICATION_MICRO";
+export declare const USER_MICRO = "USER_MICRO";
+export declare const PORTFOLIO_MICRO = "PORTFOLIO_MICRO";
+export declare const DATA_MICRO = "DATA_MICRO";
+export declare const EDUCATION_MICRO = "EDUCATION_MICRO";
+export declare const PUPPETEER_MICRO = "PUPPETEER_MICRO";
+export declare const MEDIA_MICRO = "MEDIA_MICRO";
+export declare const X_INTERNAL_HASH = "x-internal-hash";
+export declare const FILTER_SEPARATOR = "_|_";
+export declare const KAFKA_KEYS: {
+    TOPIC: {
+        FORGOT_PASSWORD: string;
+        LOGS: string;
+        RESEND_VERIFICATIONS: string;
+        USER_CREATED: string;
+        SEND_MAIL: string;
+    };
+    GROUP_ID: {
+        NOTIFICATION_EMAIL: string;
+        MAIL_SENDER: string;
+    };
+};
+export declare const KEYS: {
+    QUEUE: {
+        NOTIFICATION: string;
+    };
+    PUBSUB: {
+        USER: {
+            CREATED: string;
+        };
+        REF: {
+            USER_REF_SUBMITTED: string;
+            USER_VERIFIED: string;
+            USER_REJECTED: string;
+        };
+    };
+};
+export declare const MEDIA_UPLOADS_PATH: {
+    IMAGES: string;
+    VIDEOS: string;
+    DOCUMENTS: string;
+    OTHER: string;
+};

package/dist/utils/constants.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_UPLOADS_PATH = exports.KEYS = exports.KAFKA_KEYS = exports.FILTER_SEPARATOR = exports.X_INTERNAL_HASH = exports.MEDIA_MICRO = exports.PUPPETEER_MICRO = exports.EDUCATION_MICRO = exports.DATA_MICRO = exports.PORTFOLIO_MICRO = exports.USER_MICRO = exports.NOTIFICATION_MICRO = exports.NEWS_MICRO = exports.COIN_MICRO = void 0;
+exports.COIN_MICRO = 'COIN_MICRO';
+exports.NEWS_MICRO = 'NEWS_MICRO';
+exports.NOTIFICATION_MICRO = 'NOTIFICATION_MICRO';
+exports.USER_MICRO = 'USER_MICRO';
+exports.PORTFOLIO_MICRO = 'PORTFOLIO_MICRO';
+exports.DATA_MICRO = 'DATA_MICRO';
+exports.EDUCATION_MICRO = 'EDUCATION_MICRO';
+exports.PUPPETEER_MICRO = 'PUPPETEER_MICRO';
+exports.MEDIA_MICRO = 'MEDIA_MICRO';
+exports.X_INTERNAL_HASH = 'x-internal-hash';
+exports.FILTER_SEPARATOR = '_|_';
+exports.KAFKA_KEYS = {
+    TOPIC: {
+        FORGOT_PASSWORD: 'forgot-password',
+        LOGS: 'logs',
+        RESEND_VERIFICATIONS: 'resend-verifications',
+        USER_CREATED: 'user-created',
+        SEND_MAIL: 'send-mail',
+    },
+    GROUP_ID: {
+        NOTIFICATION_EMAIL: 'notification-email',
+        MAIL_SENDER: 'mail-sender',
+    },
+};
+exports.KEYS = {
+    QUEUE: {
+        NOTIFICATION: 'queue_notification',
+    },
+    PUBSUB: {
+        USER: {
+            CREATED: 'pubsub_user_created',
+        },
+        REF: {
+            USER_REF_SUBMITTED: 'pubsub_ref_user_ref_submitted',
+            USER_VERIFIED: 'pubsub_ref_user_verified',
+            USER_REJECTED: 'pubsub_ref_user_rejected',
+        },
+    },
+};
+exports.MEDIA_UPLOADS_PATH = {
+    IMAGES: 'images',
+    VIDEOS: 'videos',
+    DOCUMENTS: 'documents',
+    OTHER: 'other',
+};

package/dist/utils/functions.d.ts

@@ -0,0 +1,70 @@
+import 'dotenv/config';
+import { Metadata } from '@grpc/grpc-js';
+import { Kafka } from 'kafkajs';
+import { LogMessage } from '../common/factory/logger/winston_config';
+import { EmptyResponse, Filter, Sort } from '../proto/micro/v1/general_nest';
+import { CurrencyParity, JwtUser, ObjectLiteral, PrismaOrderType, PrismaWhereType } from './types';
+export declare const sleep: (time: number) => Promise<unknown>;
+export declare const password: (pwd: string) => string;
+export declare const isPasswordEqual: (pwd: string, hash: string) => boolean;
+export declare const getJwtOptions: () => {
+    privateKey: string;
+    expiresIn: number;
+};
+export declare const uniqueArray: (arr: any[]) => any[];
+export declare function dateFormat(date: string): string;
+export declare function randomHash(salt?: string): string;
+export declare function createErrorResponse(code: number, errorMessage: string, inputs: Record<string, any>): {
+    status: {
+        code: number;
+        error: {
+            errors: string[];
+            inputs: Record<string, any>;
+        };
+    };
+};
+export declare const getMetadata: (clientJwt: string, jwtSecret: string) => Metadata;
+export declare const getEnv: (key: string, defaultVal?: any) => string;
+export declare const getBearerUser: (header: string) => JwtUser | null;
+export declare function prismaWhere(filters: Filter[], fulltextColumns?: string[], fulltextSearch?: string): PrismaWhereType;
+export declare function prismaOrderBy(sort: Sort[]): PrismaOrderType;
+export declare function findSymbolItem<T = any>(haystack: T[], symbol: CurrencyParity | string): T | undefined;
+export declare function normalizeSymbol(symbol: CurrencyParity | string): CurrencyParity;
+export declare function isSymbolsEquals(symbol1: CurrencyParity, symbol2: CurrencyParity): boolean;
+export declare function asyncMap<T, V>(items: T[], mapper: (item: T, index: number) => V | Promise<V>, parallel?: boolean): Promise<V[]>;
+export declare function dateMysql(date: Date): string;
+export declare function grpcErrorResponse(code: number, err: string | string[] | ObjectLiteral<string>): EmptyResponse;
+export declare const moveArrItem: (arr: any[], fromIndex: number, toIndex: number) => void;
+export declare function isEmptyArray(arr: any[]): boolean;
+export declare function isEmptyString(str: string): boolean;
+export declare function isEmptyObject(obj: any): boolean;
+export declare function getKafkaBrokers(): string[];
+export declare function createKafkaLogger(serviceName: string): {
+    provide: string;
+    useFactory: () => import("@nestjs/common").Logger;
+};
+export declare function createKafka(clientId: string): Kafka;
+export declare function isEmptyAtAll(value: any): boolean;
+export declare function fetchScrappingData<T>(fetchFn: (params: any) => Promise<{
+    data: string;
+}>): Promise<T>;
+export declare function getGrpcClient(packageName: string, grpcHost: string, grpcPort: string): import("@nestjs/microservices").ClientGrpcProxy;
+export declare function getStatus(codeSuccess: number, codeError: number, logger: any, data: any, text: string, logOnSuccess?: boolean): {
+    code: number;
+};
+export declare const getPrismaLogMessage: (functionName: string, options?: {
+    metadata?: Metadata;
+    data?: any;
+    misc?: Record<string, any>;
+}) => LogMessage;
+export declare const getRedisLogMessage: (functionName: string, redis: {
+    key: string;
+    field?: string;
+}, options?: {
+    metadata?: Metadata;
+    data?: any;
+    misc?: Record<string, any>;
+}) => LogMessage;
+export declare function executeWithReturn<T extends (...args: any[]) => any>(logger: any, logMessage: LogMessage, func: T, ...args: Parameters<T>): Promise<ReturnType<T>>;
+export declare function executeWithoutReturn<T extends (...args: any[]) => any>(logger: any, logMessage: LogMessage, func: T, ...args: Parameters<T>): Promise<ReturnType<T>>;
+export declare function jsonStringify(val: any): string;

package/dist/utils/functions.js

@@ -0,0 +1,425 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRedisLogMessage = exports.getPrismaLogMessage = exports.moveArrItem = exports.getBearerUser = exports.getEnv = exports.getMetadata = exports.uniqueArray = exports.getJwtOptions = exports.isPasswordEqual = exports.password = exports.sleep = void 0;
+exports.dateFormat = dateFormat;
+exports.randomHash = randomHash;
+exports.createErrorResponse = createErrorResponse;
+exports.prismaWhere = prismaWhere;
+exports.prismaOrderBy = prismaOrderBy;
+exports.findSymbolItem = findSymbolItem;
+exports.normalizeSymbol = normalizeSymbol;
+exports.isSymbolsEquals = isSymbolsEquals;
+exports.asyncMap = asyncMap;
+exports.dateMysql = dateMysql;
+exports.grpcErrorResponse = grpcErrorResponse;
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyString = isEmptyString;
+exports.isEmptyObject = isEmptyObject;
+exports.getKafkaBrokers = getKafkaBrokers;
+exports.createKafkaLogger = createKafkaLogger;
+exports.createKafka = createKafka;
+exports.isEmptyAtAll = isEmptyAtAll;
+exports.fetchScrappingData = fetchScrappingData;
+exports.getGrpcClient = getGrpcClient;
+exports.getStatus = getStatus;
+exports.executeWithReturn = executeWithReturn;
+exports.executeWithoutReturn = executeWithoutReturn;
+exports.jsonStringify = jsonStringify;
+const tslib_1 = require("tslib");
+require("dotenv/config");
+const grpc_js_1 = require("@grpc/grpc-js");
+const microservices_1 = require("@nestjs/microservices");
+const bcrypt = tslib_1.__importStar(require("bcrypt"));
+const crypto_1 = tslib_1.__importStar(require("crypto"));
+const jwt = tslib_1.__importStar(require("jsonwebtoken"));
+const kafkajs_1 = require("kafkajs");
+const path_1 = require("path");
+const winston_config_1 = require("../common/factory/logger/winston_config");
+const general_nest_1 = require("../proto/micro/v1/general_nest");
+const constants_1 = require("./constants");
+const walk_sync_1 = require("./walk_sync");
+const net = require('net');
+const tls = require('tls');
+const sleep = async (time) => new Promise((resolve) => setTimeout(resolve, time));
+exports.sleep = sleep;
+const password = (pwd) => {
+    const saltOrRounds = 10;
+    return bcrypt.hashSync(pwd, saltOrRounds);
+};
+exports.password = password;
+const isPasswordEqual = (pwd, hash) => {
+    return bcrypt.compareSync(pwd, hash);
+};
+exports.isPasswordEqual = isPasswordEqual;
+const getJwtOptions = () => {
+    return {
+        privateKey: (0, exports.getEnv)('JWT_SECRET'),
+        expiresIn: 60 * 60 * 2,
+    };
+};
+exports.getJwtOptions = getJwtOptions;
+const uniqueArray = (arr) => {
+    return Array.from(new Set(arr));
+};
+exports.uniqueArray = uniqueArray;
+function dateFormat(date) {
+    return new Date(date).toISOString().replace(' ', 'T');
+}
+function randomHash(salt = '') {
+    return (0, crypto_1.createHash)('sha256')
+        .update(crypto_1.default.randomUUID() + salt)
+        .digest('hex')
+        .toLowerCase();
+}
+function createErrorResponse(code, errorMessage, inputs) {
+    return {
+        status: {
+            code,
+            error: {
+                errors: [errorMessage],
+                inputs,
+            },
+        },
+    };
+}
+const getMetadata = (clientJwt, jwtSecret) => {
+    if (clientJwt.startsWith('Bearer ')) {
+        clientJwt = clientJwt.substring(7).trim();
+    }
+    const metadata = new grpc_js_1.Metadata();
+    metadata.set('authorization', `Bearer ${clientJwt}`);
+    metadata.set(constants_1.X_INTERNAL_HASH, crypto_1.default.createHash('md5').update(jwtSecret).digest('hex').toLowerCase());
+    return metadata;
+};
+exports.getMetadata = getMetadata;
+const getEnv = (key, defaultVal) => {
+    const result = process.env[key];
+    if (typeof result === 'undefined') {
+        if (defaultVal) {
+            return defaultVal;
+        }
+        else {
+            throw new Error(key + ' not defined in env.');
+        }
+    }
+    return result;
+};
+exports.getEnv = getEnv;
+const getBearerUser = (header) => {
+    const prefix = 'Bearer ';
+    if (!header || !header?.startsWith(prefix)) {
+        return null;
+    }
+    const token = header.slice(header.indexOf(' ') + 1);
+    const user = jwt.verify(token, (0, exports.getEnv)('JWT_SECRET'));
+    return user;
+};
+exports.getBearerUser = getBearerUser;
+function prismaWhere(filters, fulltextColumns, fulltextSearch) {
+    const whereQuery = {};
+    filters.forEach((item) => {
+        whereQuery[item.name] = whereQuery[item.name] ?? {};
+        let operator = item.operator;
+        if (operator === general_nest_1.FilterOperator.isNull) {
+            whereQuery[item.name] = null;
+        }
+        else if (operator === general_nest_1.FilterOperator.isNotNull) {
+            whereQuery[item.name] = { not: null };
+        }
+        else if (operator === general_nest_1.FilterOperator.in) {
+            whereQuery[item.name] = {
+                in: item.value ? item.value.split(constants_1.FILTER_SEPARATOR) : [],
+            };
+        }
+        else if (operator === general_nest_1.FilterOperator.notIn) {
+            whereQuery[item.name] = {
+                notIn: item.value ? item.value.split(constants_1.FILTER_SEPARATOR) : [],
+            };
+        }
+        else {
+            let detectedVal = '';
+            if (typeof item.value !== 'undefined') {
+                detectedVal = item.value;
+            }
+            else if (typeof item.value_bool !== 'undefined') {
+                detectedVal = item.value_bool;
+            }
+            else if (typeof item.value_float !== 'undefined') {
+                detectedVal = item.value_float;
+            }
+            else if (typeof item.value_int !== 'undefined') {
+                detectedVal = item.value_int;
+            }
+            if (whereQuery[item.name] !== null) {
+                whereQuery[item.name][item.operator] = detectedVal;
+            }
+        }
+    });
+    if (fulltextSearch && fulltextSearch.length > 0) {
+        fulltextColumns = fulltextColumns ?? [];
+        const fulltextWhere = fulltextColumns.map((item) => {
+            let retObj = {};
+            retObj[item] = { contains: fulltextSearch };
+            return retObj;
+        });
+        whereQuery['AND'] = [
+            {
+                OR: fulltextWhere,
+            },
+        ];
+    }
+    return whereQuery;
+}
+function prismaOrderBy(sort) {
+    const result = {};
+    sort.forEach((item) => {
+        result[item.name] = item.direction === general_nest_1.SortDirection.asc ? 'asc' : 'desc';
+    });
+    return result;
+}
+function findSymbolItem(haystack, symbol) {
+    let normalizedSymbol = normalizeSymbol(symbol);
+    const result = haystack.find((item) => {
+        if (!item['symbol']) {
+            return false;
+        }
+        let itemSymbol = normalizeSymbol(item['symbol']);
+        return isSymbolsEquals(normalizedSymbol, itemSymbol);
+    });
+    return result;
+}
+function normalizeSymbol(symbol) {
+    if (typeof symbol === 'string') {
+        symbol = symbol.trim();
+        if (symbol.includes('/')) {
+            symbol = {
+                base: symbol.split('/')[0],
+                quote: symbol.split('/')[1],
+            };
+        }
+        else {
+            symbol = symbol === '' ? 'btc' : symbol;
+            symbol = { base: symbol, quote: 'usdt' };
+        }
+    }
+    else if (!symbol) {
+        symbol = { base: 'btc', quote: 'usdt' };
+    }
+    return symbol;
+}
+function isSymbolsEquals(symbol1, symbol2) {
+    return (symbol1.base.toLowerCase() === symbol2.base.toLowerCase() &&
+        symbol1.quote.toLowerCase() === symbol2.quote.toLowerCase());
+}
+async function asyncMap(items, mapper, parallel = true) {
+    if (parallel) {
+        let promises = items.map((item, index) => mapper(item, index));
+        return Promise.all(promises);
+    }
+    else {
+        const ret = [];
+        let index = 0;
+        for (const item of items) {
+            ret.push(await mapper(item, index));
+            index++;
+        }
+        return ret;
+    }
+}
+function dateMysql(date) {
+    return date.toISOString().slice(0, 19).replace('T', ' ');
+}
+function grpcErrorResponse(code, err) {
+    const error = {
+        errors: [],
+        inputs: {},
+    };
+    if (typeof err === 'string') {
+        error.errors.push(err);
+    }
+    else if (Array.isArray(err)) {
+        error.errors = err;
+    }
+    else {
+        error.inputs = err;
+    }
+    return {
+        status: {
+            code,
+            error,
+        },
+    };
+}
+const moveArrItem = (arr, fromIndex, toIndex) => {
+    const element = arr[fromIndex];
+    arr.splice(fromIndex, 1);
+    arr.splice(toIndex, 0, element);
+};
+exports.moveArrItem = moveArrItem;
+function isEmptyArray(arr) {
+    return arr.length === 0;
+}
+function isEmptyString(str) {
+    return str.length === 0;
+}
+function isEmptyObject(obj) {
+    return Object.keys(obj).length === 0;
+}
+function getKafkaBrokers() {
+    const brokers = (0, exports.getEnv)('KAFKA_BROKERS')
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (brokers.length === 0) {
+        throw new Error('KAFKA_BROKERS has wrong value: ' + (0, exports.getEnv)('KAFKA_BROKERS'));
+    }
+    return brokers;
+}
+function createKafkaLogger(serviceName) {
+    return {
+        provide: 'LOGGER',
+        useFactory: () => {
+            return (0, winston_config_1.createLogger)(serviceName, getKafkaBrokers());
+        },
+    };
+}
+function createKafka(clientId) {
+    const brokers = getKafkaBrokers();
+    return new kafkajs_1.Kafka({
+        clientId,
+        brokers,
+        socketFactory: ({ host, port, ssl, onConnect }) => {
+            if (brokers.findIndex((item) => item === `${host}:${port}`) < 0) {
+                const [validHost, validPort] = brokers[0].split(':');
+                host = validHost;
+                port = parseInt(validPort);
+            }
+            const socket = ssl
+                ? tls.connect(Object.assign({ host, port }, ssl), onConnect)
+                : net.connect({ host, port }, onConnect);
+            return socket;
+        },
+    });
+}
+function isEmptyAtAll(value) {
+    return (value === null ||
+        value === undefined ||
+        value === '' ||
+        value === 0 ||
+        Number.isNaN(value) ||
+        (Array.isArray(value) && isEmptyArray(value)) ||
+        (typeof value === 'object' && isEmptyObject(value)) ||
+        (typeof value === 'string' && isEmptyString(value)) ||
+        (typeof value === 'string' && value.trim().length === 0) ||
+        (value instanceof Set && value.size === 0) ||
+        (value instanceof Map && value.size === 0) ||
+        (Buffer.isBuffer(value) && value.length === 0) ||
+        (value instanceof Date && isNaN(value.getTime())) ||
+        (typeof value === 'number' && !Number.isFinite(value)) ||
+        (value instanceof Promise && !value.then) ||
+        (typeof value === 'boolean' && value === false));
+}
+async function fetchScrappingData(fetchFn) {
+    let data = await fetchFn({});
+    let dataString = data.data;
+    const stringToJsonTryCount = 10;
+    for (let i = 0; i < stringToJsonTryCount; i++) {
+        dataString = JSON.parse(dataString);
+        if (typeof dataString !== 'string') {
+            break;
+        }
+    }
+    return dataString;
+}
+function getGrpcClient(packageName, grpcHost, grpcPort) {
+    return microservices_1.ClientProxyFactory.create({
+        transport: microservices_1.Transport.GRPC,
+        options: {
+            url: `${grpcHost}:${grpcPort}`,
+            package: packageName,
+            protoPath: (0, walk_sync_1.walkSync)((0, path_1.join)(process.cwd(), 'node_modules/@bergx/jr-common-micro/proto'), { includeBasePath: true, globs: ['**/*.proto'] }),
+            loader: {
+                keepCase: true,
+                enums: String,
+                oneofs: true,
+                includeDirs: [
+                    (0, path_1.join)(process.cwd(), 'node_modules/@bergx/jr-common-micro/proto'),
+                ],
+            },
+        },
+    });
+}
+function getStatus(codeSuccess, codeError, logger, data, text, logOnSuccess = false) {
+    if (isEmptyAtAll(data)) {
+        logger.error(`getStatus function Error: ${text} `);
+        return {
+            code: codeError,
+        };
+    }
+    if (logOnSuccess) {
+        logger.log(`getStatus function Success: ${text} `);
+    }
+    return {
+        code: codeSuccess,
+    };
+}
+const getPrismaLogMessage = (functionName, options) => {
+    const miscInput = options?.misc ? options.misc : {};
+    const miscInitial = { type: 'prisma', function: functionName };
+    return {
+        text: `Prisma function: ${functionName}`,
+        ...(options?.metadata && { metadata: options.metadata }),
+        ...(options?.data && { data: options.data }),
+        misc: { ...miscInitial, ...miscInput },
+    };
+};
+exports.getPrismaLogMessage = getPrismaLogMessage;
+const getRedisLogMessage = (functionName, redis, options) => {
+    const miscInput = options?.misc ? options.misc : {};
+    const miscInitial = {
+        type: 'redis',
+        function: functionName,
+        ...(redis.key && { redisKey: redis.key }),
+        ...(redis.field && { redisField: redis.field }),
+    };
+    return {
+        text: `Redis function: ${functionName}`,
+        ...(options?.metadata && { metadata: options.metadata }),
+        ...(options?.data && { data: options.data }),
+        misc: { ...miscInitial, ...miscInput },
+    };
+};
+exports.getRedisLogMessage = getRedisLogMessage;
+async function executeWithReturn(logger, logMessage, func, ...args) {
+    try {
+        const result = await func(...args);
+        if (isEmptyAtAll(result)) {
+            logger.warn({ ...logMessage, data: 'data occured' });
+            return null;
+        }
+        if (JSON.stringify(result).length > 10000) {
+        }
+        else {
+        }
+        return result;
+    }
+    catch (error) {
+        logMessage.misc = { ...logMessage.misc, error };
+        logger.error(logMessage);
+        return null;
+    }
+}
+async function executeWithoutReturn(logger, logMessage, func, ...args) {
+    try {
+        const result = await func(...args);
+        return result;
+    }
+    catch (error) {
+        logMessage.misc = { ...logMessage.misc, error };
+        logger.error(logMessage);
+        return null;
+    }
+}
+function jsonStringify(val) {
+    return JSON.stringify(val, null, 2);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * as constants from './constants';
+export * as functions from './functions';
+export * as logger_names from './logger_names';
+export * as types from './types';
+export * as walk_sync from './walk_sync';

package/dist/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walk_sync = exports.types = exports.logger_names = exports.functions = exports.constants = void 0;
+const tslib_1 = require("tslib");
+exports.constants = tslib_1.__importStar(require("./constants"));
+exports.functions = tslib_1.__importStar(require("./functions"));
+exports.logger_names = tslib_1.__importStar(require("./logger_names"));
+exports.types = tslib_1.__importStar(require("./types"));
+exports.walk_sync = tslib_1.__importStar(require("./walk_sync"));

package/dist/utils/logger_names.d.ts

@@ -0,0 +1,8 @@
+export declare const coinLoggerServiceName: (name: string) => string;
+export declare const dataLoggerServiceName: (name: string) => string;
+export declare const newsLoggerServiceName: (name: string) => string;
+export declare const userLoggerServiceName: (name: string) => string;
+export declare const notificationLoggerServiceName: (name: string) => string;
+export declare const portfolioLoggerServiceName: (name: string) => string;
+export declare const generalLoggerServiceName: (name: string) => string;
+export declare const gatewayLoggerServiceName: (name: string) => string;

package/dist/utils/logger_names.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayLoggerServiceName = exports.generalLoggerServiceName = exports.portfolioLoggerServiceName = exports.notificationLoggerServiceName = exports.userLoggerServiceName = exports.newsLoggerServiceName = exports.dataLoggerServiceName = exports.coinLoggerServiceName = void 0;
+const analytics_messages_nest_1 = require("../proto/micro/v1/coin/analytics_messages_nest");
+const daily_market_data_messages_nest_1 = require("../proto/micro/v1/data/daily_market_data_messages_nest");
+const app_version_message_nest_1 = require("../proto/micro/v1/news/app_version_message_nest");
+const mail_messages_nest_1 = require("../proto/micro/v1/notification/mail_messages_nest");
+const portfolio_messages_nest_1 = require("../proto/micro/v1/portfolio/portfolio_messages_nest");
+const authorization_messages_nest_1 = require("../proto/micro/v1/user/authorization_messages_nest");
+const coinLoggerServiceName = (name) => {
+    return `${analytics_messages_nest_1.MICRO_V1_COIN_PACKAGE_NAME}_${name}`;
+};
+exports.coinLoggerServiceName = coinLoggerServiceName;
+const dataLoggerServiceName = (name) => {
+    return `${daily_market_data_messages_nest_1.MICRO_V1_DATA_PACKAGE_NAME}_${name}`;
+};
+exports.dataLoggerServiceName = dataLoggerServiceName;
+const newsLoggerServiceName = (name) => {
+    return `${app_version_message_nest_1.MICRO_V1_NEWS_PACKAGE_NAME}_${name}`;
+};
+exports.newsLoggerServiceName = newsLoggerServiceName;
+const userLoggerServiceName = (name) => {
+    return `${authorization_messages_nest_1.MICRO_V1_USER_PACKAGE_NAME}_${name}`;
+};
+exports.userLoggerServiceName = userLoggerServiceName;
+const notificationLoggerServiceName = (name) => {
+    return `${mail_messages_nest_1.MICRO_V1_NOTIFICATION_PACKAGE_NAME}_${name}`;
+};
+exports.notificationLoggerServiceName = notificationLoggerServiceName;
+const portfolioLoggerServiceName = (name) => {
+    return `${portfolio_messages_nest_1.MICRO_V1_PORTFOLIO_PACKAGE_NAME}_${name}`;
+};
+exports.portfolioLoggerServiceName = portfolioLoggerServiceName;
+const generalLoggerServiceName = (name) => {
+    return `${'general'}_${name}`;
+};
+exports.generalLoggerServiceName = generalLoggerServiceName;
+const gatewayLoggerServiceName = (name) => {
+    return `${'gateway'}_${name}`;
+};
+exports.gatewayLoggerServiceName = gatewayLoggerServiceName;

package/dist/utils/minimatch/assert_valid_pattern.d.ts

@@ -0,0 +1 @@
+export declare const assertValidPattern: (pattern: any) => void;

package/dist/utils/minimatch/assert_valid_pattern.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidPattern = void 0;
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+    if (typeof pattern !== 'string') {
+        throw new TypeError('invalid pattern');
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError('pattern is too long');
+    }
+};
+exports.assertValidPattern = assertValidPattern;