jr-common-micro 0.6.1-dev

package/dist/common/interceptors/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = exports.grpc = void 0;
+const tslib_1 = require("tslib");
+exports.grpc = tslib_1.__importStar(require("./grpc"));
+exports.http = tslib_1.__importStar(require("./http"));

package/dist/common/kafka/index.d.ts

@@ -0,0 +1,3 @@
+export * as kafka_admin_service from './kafka_admin_service';
+export * as kafka_consumer_service from './kafka_consumer_service';
+export * as kafka_producer_service from './kafka_producer_service';

package/dist/common/kafka/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafka_producer_service = exports.kafka_consumer_service = exports.kafka_admin_service = void 0;
+const tslib_1 = require("tslib");
+exports.kafka_admin_service = tslib_1.__importStar(require("./kafka_admin_service"));
+exports.kafka_consumer_service = tslib_1.__importStar(require("./kafka_consumer_service"));
+exports.kafka_producer_service = tslib_1.__importStar(require("./kafka_producer_service"));

package/dist/common/kafka/kafka_admin_service.d.ts

@@ -0,0 +1,13 @@
+import { OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+export declare class KafkaAdminService implements OnModuleInit, OnApplicationShutdown {
+    private readonly configService;
+    private kafka;
+    private admin;
+    constructor(configService: ConfigService);
+    onModuleInit(): void;
+    ensureTopicExists(topic: string): Promise<void>;
+    checkTopicFeatures(topic: string): Promise<void>;
+    getCurrentPartitionCount(topic: string): Promise<number>;
+    onApplicationShutdown(): Promise<void>;
+}

package/dist/common/kafka/kafka_admin_service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaAdminService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const functions_1 = require("../../utils/functions");
+let KafkaAdminService = class KafkaAdminService {
+    configService;
+    kafka;
+    admin;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    onModuleInit() {
+        this.kafka = (0, functions_1.createKafka)('kafka-admin-service');
+        this.admin = this.kafka.admin();
+    }
+    async ensureTopicExists(topic) {
+        const topics = await this.admin.listTopics();
+        const numPartitions = this.configService.get('number_of_partitions');
+        if (!topics.includes(topic)) {
+            await this.admin.createTopics({
+                topics: [
+                    {
+                        topic: topic,
+                        numPartitions: numPartitions,
+                    },
+                ],
+            });
+            return;
+        }
+        const currentPartitions = await this.getCurrentPartitionCount(topic);
+        if (currentPartitions !== numPartitions &&
+            currentPartitions < numPartitions) {
+            await this.admin.createPartitions({
+                topicPartitions: [
+                    {
+                        topic: topic,
+                        count: numPartitions,
+                    },
+                ],
+            });
+        }
+    }
+    async checkTopicFeatures(topic) {
+        await this.admin.connect();
+        await this.ensureTopicExists(topic);
+        await this.admin.disconnect();
+    }
+    async getCurrentPartitionCount(topic) {
+        const metadata = await this.admin.fetchTopicMetadata({ topics: [topic] });
+        const topicMetadata = metadata.topics.find((t) => t.name === topic);
+        return topicMetadata?.partitions.length || 0;
+    }
+    async onApplicationShutdown() {
+        await this.admin.disconnect();
+    }
+};
+exports.KafkaAdminService = KafkaAdminService;
+exports.KafkaAdminService = KafkaAdminService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [config_1.ConfigService])
+], KafkaAdminService);

package/dist/common/kafka/kafka_consumer_service.d.ts

@@ -0,0 +1,19 @@
+import { ConfigService } from '@nestjs/config';
+import { ConsumerRunConfig, ConsumerSubscribeTopics } from '@nestjs/microservices/external/kafka.interface';
+export declare class KafkaConsumerService {
+    private readonly configService;
+    private readonly groupId;
+    private readonly clientId;
+    private kafka?;
+    private consumer?;
+    private isRunning;
+    private objectId;
+    constructor(configService: ConfigService, groupId: string, clientId: string);
+    private initializeConsumer;
+    consume(topic: ConsumerSubscribeTopics, config: ConsumerRunConfig): Promise<void>;
+    commitOffset(topic: string, partition: number, offset: string): Promise<void>;
+    shutdown(): Promise<void>;
+    stop(): Promise<void>;
+    pause(topic: string): Promise<void>;
+    resume(topic: string): Promise<void>;
+}

package/dist/common/kafka/kafka_consumer_service.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumerService = void 0;
+const crypto_1 = require("crypto");
+const functions_1 = require("../../utils/functions");
+class KafkaConsumerService {
+    configService;
+    groupId;
+    clientId;
+    kafka;
+    consumer;
+    isRunning = false;
+    objectId;
+    constructor(configService, groupId, clientId) {
+        this.configService = configService;
+        this.groupId = groupId;
+        this.clientId = clientId;
+        this.objectId = (0, crypto_1.randomUUID)();
+    }
+    async initializeConsumer() {
+        if (!this.consumer) {
+            this.kafka = (0, functions_1.createKafka)(this.clientId);
+            this.consumer = this.kafka.consumer({
+                groupId: this.groupId,
+                allowAutoTopicCreation: true,
+            });
+            await this.consumer.connect();
+        }
+    }
+    async consume(topic, config) {
+        if (!this.consumer) {
+            await this.initializeConsumer();
+        }
+        if (this.isRunning) {
+            return;
+        }
+        if (!this.consumer) {
+            return;
+        }
+        await this.consumer.subscribe(topic);
+        await this.consumer.run(config);
+        this.isRunning = true;
+    }
+    async commitOffset(topic, partition, offset) {
+        if (this.consumer) {
+            await this.consumer.commitOffsets([{ topic, partition, offset }]);
+        }
+    }
+    async shutdown() {
+        console.log('Shutting down ' + this.clientId);
+        if (!this.consumer) {
+            return;
+        }
+        await this.consumer.disconnect();
+        delete this.consumer;
+        delete this.kafka;
+        this.consumer = undefined;
+        this.kafka = undefined;
+        this.isRunning = false;
+    }
+    async stop() {
+        if (!this.consumer) {
+            return;
+        }
+        this.consumer.stop();
+    }
+    async pause(topic) {
+        if (!this.consumer) {
+            return;
+        }
+        this.consumer.pause([{ topic }]);
+    }
+    async resume(topic) {
+        if (!this.consumer) {
+            return;
+        }
+        this.consumer.resume([{ topic }]);
+    }
+}
+exports.KafkaConsumerService = KafkaConsumerService;

package/dist/common/kafka/kafka_producer_service.d.ts

@@ -0,0 +1,14 @@
+import { OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ProducerRecord } from '@nestjs/microservices/external/kafka.interface';
+import { KafkaAdminService } from './kafka_admin_service';
+export declare class KafkaProducerService implements OnModuleInit, OnApplicationShutdown {
+    private readonly configService;
+    private readonly adminKafkaService;
+    private kafka;
+    private producer;
+    constructor(configService: ConfigService, adminKafkaService: KafkaAdminService);
+    onModuleInit(): Promise<void>;
+    produce(record: ProducerRecord): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}

package/dist/common/kafka/kafka_producer_service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducerService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const crypto_1 = require("crypto");
+const kafkajs_1 = require("kafkajs");
+const functions_1 = require("../../utils/functions");
+const kafka_admin_service_1 = require("./kafka_admin_service");
+let KafkaProducerService = class KafkaProducerService {
+    configService;
+    adminKafkaService;
+    kafka;
+    producer;
+    constructor(configService, adminKafkaService) {
+        this.configService = configService;
+        this.adminKafkaService = adminKafkaService;
+    }
+    async onModuleInit() {
+        this.kafka = (0, functions_1.createKafka)('kafka-producer-service');
+        this.producer = this.kafka.producer({
+            createPartitioner: kafkajs_1.Partitioners.LegacyPartitioner,
+        });
+        await this.producer.connect();
+    }
+    async produce(record) {
+        await this.adminKafkaService.checkTopicFeatures(record.topic);
+        const messagesWithKeys = record.messages.map((message) => {
+            if (!message.key) {
+                message.key = (0, crypto_1.randomUUID)();
+            }
+            return message;
+        });
+        await this.producer.send({
+            ...record,
+            messages: messagesWithKeys,
+        });
+    }
+    async onApplicationShutdown() {
+        await this.producer.disconnect();
+    }
+};
+exports.KafkaProducerService = KafkaProducerService;
+exports.KafkaProducerService = KafkaProducerService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [config_1.ConfigService,
+        kafka_admin_service_1.KafkaAdminService])
+], KafkaProducerService);

package/dist/common/service/crud/crud_service_interface.d.ts

@@ -0,0 +1,20 @@
+import { Filter, Sort } from '../../../proto/micro/v1/general_nest';
+export type PaginationResult<T> = {
+    draw?: number;
+    records_total: number;
+    records_filtered: number;
+    data: T[];
+};
+export type PaginateResponseType<T> = {
+    rows: T[];
+    count: number;
+};
+export type EmbraceBigInt = string | bigint | number;
+export interface CrudServiceInterface<T> {
+    store(data: any): Promise<T>;
+    read(id: EmbraceBigInt): Promise<T>;
+    update(id: EmbraceBigInt, data: any): Promise<T>;
+    remove(id: EmbraceBigInt): Promise<boolean>;
+    paginate(rpp: number, page: number, filters?: Filter[], sort?: Sort[]): Promise<PaginateResponseType<T>>;
+    paginateFrom(rpp: number, fromId: EmbraceBigInt, filters?: Filter[], sort?: Sort[]): Promise<PaginateResponseType<T>>;
+}

package/dist/common/service/crud/crud_service_interface.js

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

package/dist/common/service/crud/index.d.ts

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

package/dist/common/service/crud/index.js

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

package/dist/common/service/index.d.ts

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

package/dist/common/service/index.js

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as common from './common';
+export * as proto from './proto';
+export * as utils from './utils';

package/dist/index.js

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

package/dist/proto/index.d.ts

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

package/dist/proto/index.js

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

package/dist/proto/micro/index.d.ts

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

package/dist/proto/micro/index.js

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

package/dist/proto/micro/v1/coin/analytics_messages_nest.d.ts

@@ -0,0 +1,335 @@
+import { Filter, PaginateRequest, PaginationMetaResult, ResponseStatus, Sort } from "../general_nest";
+export declare const protobufPackage = "micro.v1.coin";
+export declare enum AnalyticsHighlightTypeEnum {
+    trending_coins = "trending_coins",
+    top_gainers = "top_gainers",
+    top_losers = "top_losers",
+    new_coins = "new_coins",
+    most_viewed = "most_viewed",
+    highest_volume = "highest_volume",
+    price_change = "price_change",
+    most_voted = "most_voted",
+    upcoming_coins = "upcoming_coins",
+    UNRECOGNIZED = "UNRECOGNIZED"
+}
+export interface CoinDetailDto {
+    id: string;
+    name: string;
+    symbol: string;
+    rank: number;
+    price: string;
+    price_change_percentage24h: string;
+    price_change_percentage1h: string;
+    price_change_percentage7d: string;
+    price_change_percentage14d: string;
+    price_change_percentage30d: string;
+    price_change_percentage1y: string;
+    market_cap: string;
+    fully_diluted_valuation: string;
+    trading_volume24h: string;
+    circulating_supply: string;
+    total_supply: string;
+    max_supply: string;
+    all_time_high: CoinDetailDto_AllTimePrice | undefined;
+    all_time_low: CoinDetailDto_AllTimePrice | undefined;
+    range24h: CoinDetailDto_Range | undefined;
+    range7d: CoinDetailDto_Range | undefined;
+    links: CoinDetailDto_Links | undefined;
+    categories: CoinDetailDto_Categories[];
+    converter: CoinDetailDto_Converter | undefined;
+    exchanges: string[];
+    api_id: string;
+    categories_json: {
+        [key: string]: CategoriesArr;
+    };
+    chart_image: string;
+    name_json: {
+        [key: string]: string;
+    };
+    coingecko_id?: string | undefined;
+    coinglass_spot_id?: string | undefined;
+    coinglass_futures_id?: string | undefined;
+    coinmarketcap_id?: string | undefined;
+    title: Title[];
+    about: About[];
+    info: Info | undefined;
+}
+export interface CoinDetailDto_AllTimePrice {
+    price: string;
+    date: string;
+    percentage_change: number;
+}
+export interface CoinDetailDto_Range {
+    low: string;
+    high: string;
+}
+export interface CoinDetailDto_UrlItem {
+    name: string;
+    url: string;
+}
+export interface CoinDetailDto_Links {
+    website: string;
+    whitepaper: string;
+    explorers: CoinDetailDto_UrlItem[];
+    wallets: CoinDetailDto_UrlItem[];
+    community: CoinDetailDto_UrlItem[];
+    source_code: CoinDetailDto_UrlItem[];
+    search_on: CoinDetailDto_UrlItem[];
+    api_id: string;
+}
+export interface CoinDetailDto_Categories {
+    name: string;
+    url: string;
+}
+export interface CoinDetailDto_Converter {
+    base_currency: string;
+    quote_currency: string;
+    base_amount: number;
+    quote_amount: number;
+}
+export interface CoinDetailDto_CategoriesJsonEntry {
+    key: string;
+    value: CategoriesArr | undefined;
+}
+export interface CoinDetailDto_NameJsonEntry {
+    key: string;
+    value: string;
+}
+export interface Info {
+    website: string[];
+    twitter: string[];
+    message_board: string[];
+    chat: string[];
+    facebook: string[];
+    explorer: string[];
+    reddit: string[];
+    technical_doc: string[];
+    announcement: string[];
+    source_code: string[];
+    contract: Contract[];
+}
+export interface Contract {
+    cmc_id: string;
+    name: string;
+    address: string;
+}
+export interface Title {
+    data: {
+        [key: string]: string;
+    };
+}
+export interface Title_DataEntry {
+    key: string;
+    value: string;
+}
+export interface About {
+    data: {
+        [key: string]: string;
+    };
+}
+export interface About_DataEntry {
+    key: string;
+    value: string;
+}
+export interface CategoriesArr {
+    data: string[];
+}
+export interface AnalyticsCurrencyItem {
+    symbol: string;
+    name: string;
+    price: string;
+    rate_1h: number;
+    rate_24h: number;
+    rate_7d: number;
+    volume_24h: string;
+    market_cap: string;
+    chart_image: string;
+}
+export interface AnalyticsCurrenciesResponseData {
+    items: CoinDetailDto[];
+}
+export interface AnalyticsCurrenciesResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: AnalyticsCurrenciesResponseData | undefined;
+}
+export interface CurrenciesByChainResponseData {
+    chain: ChainDto | undefined;
+    items: CoinDetailDto[];
+}
+export interface CurrenciesByChainResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: CurrenciesByChainResponseData | undefined;
+}
+export interface ChainDto {
+    id: string;
+    name: string;
+    symbol: string;
+    protocols: string;
+    change1d: string;
+    change7d: string;
+    change30d: string;
+    tvl: string;
+    mcap: string;
+    mcap_tvl: string;
+    sequence_no: number;
+    coingecko_id: string;
+}
+export interface AnalyticsChainsResponseData {
+    items: ChainDto[];
+}
+export interface AnalyticsChainsResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: AnalyticsChainsResponseData | undefined;
+}
+export interface CurrenciesByCategoryResponseData {
+    category: CoinDetailDto | undefined;
+    items: CoinDetailDto[];
+}
+export interface CurrenciesByCategoryResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: CurrenciesByCategoryResponseData | undefined;
+}
+export interface AnalyticsCategoriesResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: AnalyticsCurrenciesResponseData | undefined;
+}
+export interface BlockchainGlobalDataResponseData {
+    volume: string;
+    market_cap: string;
+    open_interest: string;
+    liquidation_24: string;
+    longshort_24: string;
+    market_cap_change: number;
+}
+export interface BlockchainGlobalDataResponse {
+    status: ResponseStatus | undefined;
+    data: BlockchainGlobalDataResponseData | undefined;
+}
+export interface HighlightsItem {
+    symbol: string;
+    name: string;
+    change: number;
+    price: number;
+    volume: string;
+}
+export interface AnalyticsHighlightsDto {
+    type: AnalyticsHighlightTypeEnum;
+    items: HighlightsItem[];
+}
+export interface AnalyticsHighlightsResponseData {
+    items: AnalyticsHighlightsDto[];
+}
+export interface AnalyticsHighlightsResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: AnalyticsHighlightsResponseData | undefined;
+}
+export interface AnalyticsExchangeDto {
+    id: string;
+    exchange_name: string;
+    exchange_score: string;
+    coin: string;
+    price: string;
+    volume: string;
+    target: string;
+}
+export interface AnalyticsExchangeResponse {
+    status: ResponseStatus | undefined;
+    data: AnalyticsExchangeDto[];
+}
+export interface CoinWeeklyDataDto {
+    id: string;
+    symbol: string;
+    name: string;
+    change_24h_usd: string;
+    change_24h_try: string;
+    change_24h_usd_percent: string;
+    change_24h_try_percent: string;
+    market_cap_change_24h: string;
+    market_cap_change_24h_percent: string;
+    weekly_data: string[];
+    daily_data: string[];
+}
+export interface AnalyticsCoinWeeklyDataResponse {
+    status: ResponseStatus | undefined;
+    data: CoinWeeklyDataDto | undefined;
+}
+export interface NavbarDataDto {
+    id: string;
+    volume: string;
+    volume_percent: string;
+    oi: string;
+    oi_percent: string;
+    liquidation: string;
+    liquidation_percent: string;
+    long_short: string;
+}
+export interface NavbarDataResponse {
+    status: ResponseStatus | undefined;
+    data: NavbarDataDto | undefined;
+}
+export interface CurrenciesByCategoryRequest {
+    id: string;
+    pagination: PaginateRequest | undefined;
+}
+export interface CurrenciesByChainRequest {
+    id: string;
+    pagination: PaginateRequest | undefined;
+}
+export interface CurrenciesNewDto {
+    id: string;
+    symbol: string;
+    name: string;
+    chart_image: string;
+    market_cap: string;
+    price: string;
+    price_change_percentage1h: string;
+    price_change_percentage24h: string;
+    price_change_percentage7d: string;
+    trading_volume24h: string;
+    rank: number;
+    coingecko_id: string;
+    coinmarketcap_id: string;
+    coinglass_spot_id: string;
+    coinglass_futures_id: string;
+}
+export interface CurrenciesNewResponse {
+    status: ResponseStatus | undefined;
+    pagination: PaginationMetaResult | undefined;
+    data: CurrenciesNewDto[];
+}
+export interface CurrenciesNewsChangeDto {
+    symbol: string;
+    change: string;
+}
+export interface CurrenciesNewsChangeRequestData {
+    symbol: string;
+}
+export interface CurrenciesNewsChangeRequest {
+    data: CurrenciesNewsChangeRequestData[];
+}
+export interface CurrenciesNewsChangeResponse {
+    status: ResponseStatus | undefined;
+    data: CurrenciesNewsChangeDto[];
+}
+export interface PaginateRequestCurrency {
+    page: number;
+    per_page: number;
+    draw?: number | undefined;
+    filters: Filter[];
+    sort: Sort[];
+    columns: string[];
+    fulltextSearch?: string | undefined;
+    searchByMarketCap?: string | undefined;
+    searchBy24hrChange?: string | undefined;
+    searchByPrice?: string | undefined;
+    first100?: boolean | undefined;
+    first300?: boolean | undefined;
+    optimization?: boolean | undefined;
+}
+export declare const MICRO_V1_COIN_PACKAGE_NAME = "micro.v1.coin";