jr-common-micro 0.6.1-dev

package/README.md

@@ -0,0 +1,33 @@
+# Common Classes & Items & Proto Files
+
+Grpc module configurations, necessary types etc. Also proto files and
+generated typescript files.
+
+### Note about VSCode integration for proto files
+
+You need to add these lines to `.vscode/settings.json` file:
+
+```json
+{
+  "protoc": {
+    "options": ["--proto_path=${workspaceRoot}/proto"]
+  }
+}
+```
+
+### Important links
+
+- Npm dependency line for this package:
+  `"@bergx/jr-common-micro": "git+ssh://git@github.com/BergX-Team/jr-common-micro.git#main"`
+
+- Buf configs: https://buf.build/docs/configuration/v1/buf-gen-yaml
+
+- Buf and Nodejs blog: https://slavovojacek.medium.com/grpc-on-node-js-with-buf-and-typescript-part-1-5aad61bab03b
+
+- ❗ Never upgrade bufbuild and its plugins versions. Because they made significant changes and it breaking our structure.
+
+  - https://github.com/bufbuild/buf/issues/2987
+  - https://github.com/bufbuild/buf/releases
+
+- This library is creating awesome types: `type-fest`
+  - https://github.com/sindresorhus/type-fest

package/dist/common/dto/by_id_request_dto.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+declare const ByIdRequestDto_base: import("nestjs-zod").ZodDto<{
+    id: string;
+}, z.ZodObjectDef<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny>, {
+    id: string;
+}>;
+export declare class ByIdRequestDto extends ByIdRequestDto_base {
+}
+export {};

package/dist/common/dto/by_id_request_dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByIdRequestDto = void 0;
+const nestjs_zod_1 = require("nestjs-zod");
+const zod_1 = require("zod");
+class ByIdRequestDto extends (0, nestjs_zod_1.createZodDto)(zod_1.z.object({
+    id: zod_1.z.string().min(1),
+})) {
+}
+exports.ByIdRequestDto = ByIdRequestDto;

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

@@ -0,0 +1,3 @@
+export * as by_id_request_dto from './by_id_request_dto';
+export * as paginate_from_request_dto from './paginate_from_request_dto';
+export * as paginate_request_dto from './paginate_request_dto';

package/dist/common/dto/index.js

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

package/dist/common/dto/paginate_from_request_dto.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+declare const PaginateFromRequestDto_base: import("nestjs-zod").ZodDto<{
+    id: string;
+    perPage: string;
+    sort?: {
+        name: string;
+        direction: "asc" | "desc";
+    }[] | undefined;
+    filters?: {
+        name: string;
+        value: string;
+        operator: string;
+    }[] | undefined;
+    columns?: string[] | undefined;
+}, z.ZodObjectDef<{
+    id: z.ZodString;
+    perPage: z.ZodString;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        operator: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        value: string;
+        operator: string;
+    }, {
+        name: string;
+        value: string;
+        operator: string;
+    }>, "many">>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        direction: z.ZodEnum<["asc", "desc"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        direction: "asc" | "desc";
+    }, {
+        name: string;
+        direction: "asc" | "desc";
+    }>, "many">>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny>, {
+    id: string;
+    perPage: string;
+    sort?: {
+        name: string;
+        direction: "asc" | "desc";
+    }[] | undefined;
+    filters?: {
+        name: string;
+        value: string;
+        operator: string;
+    }[] | undefined;
+    columns?: string[] | undefined;
+}>;
+export declare class PaginateFromRequestDto extends PaginateFromRequestDto_base {
+}
+export {};

package/dist/common/dto/paginate_from_request_dto.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateFromRequestDto = void 0;
+const nestjs_zod_1 = require("nestjs-zod");
+const zod_1 = require("zod");
+class PaginateFromRequestDto extends (0, nestjs_zod_1.createZodDto)(zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    perPage: zod_1.z.string().min(1),
+    filters: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        value: zod_1.z.string(),
+        operator: zod_1.z.string(),
+    }))
+        .optional(),
+    sort: zod_1.z
+        .array(zod_1.z.object({ name: zod_1.z.string(), direction: zod_1.z.enum(['asc', 'desc']) }))
+        .optional(),
+    columns: zod_1.z.array(zod_1.z.string()).optional(),
+})) {
+}
+exports.PaginateFromRequestDto = PaginateFromRequestDto;

package/dist/common/dto/paginate_request_dto.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+declare const PaginateRequestDto_base: import("nestjs-zod").ZodDto<{
+    sort: string;
+    perPage: string;
+    filters: string;
+    page: string;
+    columns?: string[] | undefined;
+}, z.ZodObjectDef<{
+    page: z.ZodString;
+    perPage: z.ZodString;
+    filters: z.ZodString;
+    sort: z.ZodString;
+    columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny>, {
+    sort: string;
+    perPage: string;
+    filters: string;
+    page: string;
+    columns?: string[] | undefined;
+}>;
+export declare class PaginateRequestDto extends PaginateRequestDto_base {
+}
+export {};

package/dist/common/dto/paginate_request_dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateRequestDto = void 0;
+const nestjs_zod_1 = require("nestjs-zod");
+const zod_1 = require("zod");
+class PaginateRequestDto extends (0, nestjs_zod_1.createZodDto)(zod_1.z.object({
+    page: zod_1.z.string().min(1),
+    perPage: zod_1.z.string().min(1),
+    filters: zod_1.z.string().min(1),
+    sort: zod_1.z.string().min(1),
+    columns: zod_1.z.array(zod_1.z.string()).optional(),
+})) {
+}
+exports.PaginateRequestDto = PaginateRequestDto;

package/dist/common/exception/base_exception.d.ts

@@ -0,0 +1,4 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export declare class BaseException extends HttpException {
+    constructor(message: string, status: HttpStatus, additionalData?: string | Record<string, unknown> | unknown);
+}

package/dist/common/exception/base_exception.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseException = void 0;
+const common_1 = require("@nestjs/common");
+class BaseException extends common_1.HttpException {
+    constructor(message, status, additionalData = null) {
+        super({
+            message,
+            statusCode: status,
+            data: additionalData,
+        }, status);
+    }
+}
+exports.BaseException = BaseException;

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

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

package/dist/common/exception/index.js

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

package/dist/common/factory/grpc_options_factory.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common';
+import { NestMicroserviceOptions } from '@nestjs/common/interfaces/microservices/nest-microservice-options.interface';
+import { ConfigService } from '@nestjs/config';
+import { ClientGrpcProxy, GrpcOptions } from '@nestjs/microservices';
+export type GrpcClientCreatorFnType = () => DynamicModule;
+export declare const GRPC_CLIENT_CREATOR = "GRPC_CLIENT_CREATOR";
+type GrpcProvideName = `${Uppercase<string>}_MICRO`;
+type GrpcPackageName = `micro.${Lowercase<string>}`;
+export declare const grpcClientFactory: (provide: GrpcProvideName, grpcPackage: GrpcPackageName, hostKey: string, portKey: string) => {
+    provide: `${Uppercase<string>}_MICRO`;
+    inject: (typeof ConfigService)[];
+    useFactory: (config: ConfigService) => Promise<ClientGrpcProxy>;
+};
+export declare const grpcServerOptions: (grpcPackage: GrpcPackageName, grpcHost: string, grpcPort: string) => GrpcOptions & NestMicroserviceOptions;
+export {};

package/dist/common/factory/grpc_options_factory.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcServerOptions = exports.grpcClientFactory = exports.GRPC_CLIENT_CREATOR = void 0;
+const config_1 = require("@nestjs/config");
+const microservices_1 = require("@nestjs/microservices");
+const path_1 = require("path");
+const walk_sync_1 = require("../../utils/walk_sync");
+exports.GRPC_CLIENT_CREATOR = 'GRPC_CLIENT_CREATOR';
+const grpcClientFactory = (provide, grpcPackage, hostKey, portKey) => {
+    return {
+        provide,
+        inject: [config_1.ConfigService],
+        useFactory: async (config) => {
+            return new microservices_1.ClientGrpcProxy({
+                url: config.get(hostKey) + ':' + config.get(portKey),
+                channelOptions: {
+                    'grpc.min_reconnect_backoff_ms': 1000,
+                    'grpc.max_reconnect_backoff_ms': 10000,
+                },
+                keepalive: {
+                    keepaliveTimeMs: 1e3 * 60 * 2,
+                    keepaliveTimeoutMs: 1e3 * 20,
+                    http2MinTimeBetweenPingsMs: 1e3 * 60 * 2,
+                    http2MaxPingsWithoutData: 0,
+                    keepalivePermitWithoutCalls: 1,
+                },
+                package: grpcPackage,
+                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'),
+                    ],
+                },
+            });
+        },
+    };
+};
+exports.grpcClientFactory = grpcClientFactory;
+const grpcServerOptions = (grpcPackage, grpcHost, grpcPort) => {
+    return {
+        logger: process.env.NODE_ENV === 'development'
+            ? ['log', 'debug', 'error', 'verbose', 'warn', 'fatal']
+            : ['log', 'debug', 'error', 'verbose', 'warn', 'fatal'],
+        transport: microservices_1.Transport.GRPC,
+        options: {
+            url: grpcHost + ':' + grpcPort,
+            package: grpcPackage,
+            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'),
+                ],
+            },
+        },
+    };
+};
+exports.grpcServerOptions = grpcServerOptions;

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

@@ -0,0 +1,5 @@
+export * as grpc_options_factory from './grpc_options_factory';
+export * as logger from './logger';
+export * as module_metadata_factory from './module_metadata_factory';
+export * as redis_client_factory from './redis_client_factory';
+export * as redis_cluster_factory from './redis_cluster_factory';

package/dist/common/factory/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redis_cluster_factory = exports.redis_client_factory = exports.module_metadata_factory = exports.logger = exports.grpc_options_factory = void 0;
+const tslib_1 = require("tslib");
+exports.grpc_options_factory = tslib_1.__importStar(require("./grpc_options_factory"));
+exports.logger = tslib_1.__importStar(require("./logger"));
+exports.module_metadata_factory = tslib_1.__importStar(require("./module_metadata_factory"));
+exports.redis_client_factory = tslib_1.__importStar(require("./redis_client_factory"));
+exports.redis_cluster_factory = tslib_1.__importStar(require("./redis_cluster_factory"));

package/dist/common/factory/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * as kafka_transport from './kafka_transport';
+export * as winston_config from './winston_config';

package/dist/common/factory/logger/index.js

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

package/dist/common/factory/logger/kafka_transport.d.ts

@@ -0,0 +1,16 @@
+import { Kafka, LogEntry, ProducerConfig } from 'kafkajs';
+import Transport from 'winston-transport';
+interface KafkaTransportOptions extends Transport.TransportStreamOptions {
+    kafka: Kafka;
+    topic: string;
+    producerConfig?: ProducerConfig;
+}
+export declare class KafkaTransport extends Transport {
+    private producer;
+    private topic;
+    constructor(opts: KafkaTransportOptions);
+    private initProducer;
+    log(info: LogEntry, callback: () => void): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/dist/common/factory/logger/kafka_transport.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaTransport = void 0;
+const tslib_1 = require("tslib");
+const winston_transport_1 = tslib_1.__importDefault(require("winston-transport"));
+class KafkaTransport extends winston_transport_1.default {
+    producer;
+    topic;
+    constructor(opts) {
+        super(opts);
+        this.producer = opts.kafka.producer(opts.producerConfig);
+        this.topic = opts.topic;
+        this.initProducer();
+    }
+    async initProducer() {
+        try {
+            await this.producer.connect();
+        }
+        catch (error) {
+            console.error('Failed to connect to Kafka:', error);
+        }
+    }
+    async log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+        const messagePayload = {
+            topic: this.topic,
+            messages: [{ value: JSON.stringify(info) }],
+        };
+        try {
+            await this.producer.send(messagePayload);
+        }
+        catch (error) {
+            if (error?.message?.includes('disconnected')) {
+                try {
+                    await this.producer.connect();
+                    await this.producer.send(messagePayload);
+                }
+                catch (reconnectError) {
+                    console.error('Error sending log to Kafka after reconnect attempt:', reconnectError);
+                }
+            }
+            else {
+                console.error('Error sending log to Kafka:', error);
+            }
+        }
+        callback();
+    }
+    async close() {
+        await this.producer.disconnect();
+    }
+}
+exports.KafkaTransport = KafkaTransport;

package/dist/common/factory/logger/winston_config.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from '@nestjs/common';
+interface SystemMetadata {
+    hostname: string;
+    ip: string;
+    cpu_usage: number;
+    memory_used_mb: number;
+    memory_total_mb: number;
+    memory_usage_percent: number;
+    platform: string;
+    uptime_seconds: number;
+}
+interface Metadata extends SystemMetadata {
+    [key: string]: any;
+}
+export interface LogMessage {
+    text: string;
+    metadata?: Metadata;
+    data?: any;
+    misc?: Record<string, any>;
+}
+export declare const createLogger: (serviceName: string, brokers?: string[]) => Logger;
+export {};

package/dist/common/factory/logger/winston_config.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const kafkajs_1 = require("kafkajs");
+const nest_winston_1 = require("nest-winston");
+const os = tslib_1.__importStar(require("os"));
+const os_1 = require("os");
+const winston = tslib_1.__importStar(require("winston"));
+const functions_1 = require("../../../utils/functions");
+const kafka_transport_1 = require("./kafka_transport");
+const net = require('net');
+const tls = require('tls');
+const getPrimaryIp = () => {
+    const interfaces = os.networkInterfaces();
+    for (const interfaceName of Object.keys(interfaces)) {
+        const interface_ = interfaces[interfaceName];
+        if (interface_) {
+            const nonInternalIpv4 = interface_.find((addr) => addr.family === 'IPv4' && !addr.internal);
+            if (nonInternalIpv4) {
+                return nonInternalIpv4.address;
+            }
+        }
+    }
+    return 'unknown';
+};
+const getCpuUsage = () => {
+    const cpus = os.cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+    cpus.forEach((cpu) => {
+        for (const type in cpu.times) {
+            totalTick += cpu.times[type];
+        }
+        totalIdle += cpu.times.idle;
+    });
+    return Number(((1 - totalIdle / totalTick) * 100).toFixed(2));
+};
+const getSystemMetadata = () => {
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    const usedMemory = totalMemory - freeMemory;
+    return {
+        hostname: os.hostname(),
+        ip: getPrimaryIp(),
+        cpu_usage: getCpuUsage(),
+        memory_used_mb: Math.round(usedMemory / (1024 * 1024)),
+        memory_total_mb: Math.round(totalMemory / (1024 * 1024)),
+        memory_usage_percent: Number(((usedMemory / totalMemory) * 100).toFixed(2)),
+        platform: os.platform(),
+        uptime_seconds: Math.round(os.uptime()),
+    };
+};
+const formatMessage = (message, ...args) => {
+    const systemMetadata = getSystemMetadata();
+    if (typeof message === 'object' &&
+        ('text' in message || 'metadata' in message || 'data' in message)) {
+        return {
+            ...message,
+            metadata: {
+                ...systemMetadata,
+                ...message.metadata,
+            },
+        };
+    }
+    if (typeof message === 'string') {
+        const result = {
+            text: message,
+            metadata: systemMetadata,
+        };
+        if (args.length === 1 && typeof args[0] === 'object') {
+            result.metadata = {
+                ...systemMetadata,
+                ...args[0],
+            };
+        }
+        else if (args.length > 0) {
+            result.data = args.length === 1 ? args[0] : args;
+        }
+        return result;
+    }
+    if (typeof message === 'object') {
+        return {
+            text: JSON.stringify(message),
+            data: message,
+            metadata: systemMetadata,
+        };
+    }
+    return {
+        text: String(message),
+        metadata: systemMetadata,
+    };
+};
+const createLogger = (serviceName, brokers) => {
+    const instanceId = `${serviceName}-${(0, os_1.hostname)()}`;
+    const kafka = (0, functions_1.createKafka)(instanceId);
+    const winstonLogger = nest_winston_1.WinstonModule.createLogger({
+        format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+        defaultMeta: {
+            service: serviceName,
+            instance: instanceId,
+        },
+        transports: [
+            new winston.transports.Console({
+                format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
+            }),
+            new kafka_transport_1.KafkaTransport({
+                kafka,
+                topic: 'logs',
+                level: 'info',
+                producerConfig: {
+                    createPartitioner: kafkajs_1.Partitioners.DefaultPartitioner,
+                },
+            }),
+        ],
+    });
+    const logger = new common_1.Logger(serviceName);
+    logger.log = (message, ...args) => winstonLogger.log({
+        level: 'info',
+        message: formatMessage(message, ...args),
+    });
+    logger.error = (message, ...args) => winstonLogger.log({
+        level: 'error',
+        message: formatMessage(message, ...args),
+    });
+    logger.warn = (message, ...args) => winstonLogger.log({
+        level: 'warn',
+        message: formatMessage(message, ...args),
+    });
+    logger.debug = (message, ...args) => winstonLogger.log({
+        level: 'debug',
+        message: formatMessage(message, ...args),
+    });
+    logger.fatal = (message, ...args) => winstonLogger.log({
+        level: 'error',
+        message: formatMessage(message, ...args),
+    });
+    return logger;
+};
+exports.createLogger = createLogger;

package/dist/common/factory/module_metadata_factory.d.ts

@@ -0,0 +1,24 @@
+import { DynamicModule, ModuleMetadata } from '@nestjs/common';
+import { ConfigFactory } from '@nestjs/config';
+import { GrpcOptions } from '@nestjs/microservices';
+import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
+export type AppBaseConfig = {
+    environment: string;
+    jwt_secret: string;
+    redis_host: string;
+    redis_port: number;
+    redis_db: number;
+    redis_username: string;
+    redis_password: string;
+    [key: string]: any;
+};
+export declare const getDefaultConfigModule: (appConfig: Array<ConfigFactory>) => Promise<DynamicModule>;
+export declare const getTestingConfigModule: (appConfig: Array<ConfigFactory>) => Promise<DynamicModule>;
+export declare const getDefaultCacheModule: () => DynamicModule;
+export declare const moduleMetadataFactory: (inputMeta: ModuleMetadata, appConfig: Array<ConfigFactory>) => ModuleMetadata;
+export declare const moduleMetadataTestingFactory: (inputMeta: ModuleMetadata, appConfig: Array<ConfigFactory>) => ModuleMetadata;
+export declare class AppMicroModule {
+}
+export declare const createGrpcMicro: (moduleMetadata: ModuleMetadata, config: AppBaseConfig, grpcOptions: GrpcOptions) => Promise<import("@nestjs/common").INestMicroservice>;
+export declare const createTestingModule: (moduleMetadata: ModuleMetadata, config: AppBaseConfig) => Promise<import("@nestjs/testing").TestingModule>;
+export declare const createHttpServer: (moduleMetadata: ModuleMetadata, config: AppBaseConfig, fastifyAdapter: FastifyAdapter) => Promise<NestFastifyApplication<import("fastify").RawServerDefault>>;