@xrystal/core 3.26.8 → 3.26.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.26.8",
+  "version": "3.26.9",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

package/source/loader/configs/index.d.ts

@@ -41,7 +41,6 @@ export default class Configs implements IProvide<any> {
         system: System;
     });
     onInit: ({}: {}) => Promise<void>;
-    private initializeKafkaInfrastructure;
     setConfig(newConfigs: any): void;
     _<K extends keyof IConfig>(key: K): IConfig[K];
     get all(): IConfig;

package/source/loader/configs/index.js

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import { merge } from 'lodash';
 import { pathToFileURL } from 'node:url';
-import { Kafka, logLevel } from 'kafkajs';
 import { Constants } from '../../utils';
 export default class Configs {
     publicFolderName = Constants.publicFolderName;
@@ -68,54 +67,6 @@ export default class Configs {
         catch (e) {
             // error
         }
-        await this.initializeKafkaInfrastructure();
-    };
-    initializeKafkaInfrastructure = async () => {
-        const { kafkaBrokers, kafkaTopics, isKafkaPassive, serviceName } = {
-            isKafkaPassive: process.env.IS_KAFKA_PASSIVE === 'true' ? true : false,
-            kafkaBrokers: process.env?.KAFKA_BROKERS,
-            kafkaTopics: [
-                ...new Set([
-                    ...this.#config.kafkaTopics
-                ])
-            ],
-            serviceName: this.#system.tmp.configs.service
-        };
-        if (isKafkaPassive === true || !kafkaBrokers)
-            return;
-        const brokers = String(kafkaBrokers).split(",").map(b => b.trim());
-        const topicsToCreate = Array.isArray(kafkaTopics) ? kafkaTopics : [];
-        if (topicsToCreate.length === 0)
-            return;
-        const kafka = new Kafka({
-            clientId: `${serviceName}`,
-            brokers,
-            logLevel: logLevel.NOTHING
-        });
-        const admin = kafka.admin();
-        try {
-            await admin.connect();
-            const existingTopics = await admin.listTopics();
-            const newTopics = topicsToCreate
-                .filter(topic => !existingTopics.includes(topic))
-                .map(topic => ({
-                topic,
-                numPartitions: 1,
-                replicationFactor: 1
-            }));
-            if (newTopics.length > 0) {
-                await admin.createTopics({
-                    waitForLeaders: true,
-                    topics: newTopics
-                });
-            }
-        }
-        catch (error) {
-            // => Error
-        }
-        finally {
-            await admin.disconnect();
-        }
     };
     setConfig(newConfigs) {
         const mergedDObj = Object.assign(this.#config, newConfigs);

package/source/loader/kafka/index.d.ts

@@ -0,0 +1,29 @@
+import Configs from "../configs";
+import System from "../system";
+import { IProvide } from "source/utils";
+type KafkaInstanceType = {
+    clientId: string;
+    brokers: string[];
+    username?: string | null;
+    password?: string | null;
+};
+export default class KafkaForCore implements IProvide<any> {
+    #private;
+    private _instance;
+    private _producer;
+    private clientId;
+    private brokers;
+    private username;
+    private password;
+    constructor({ system, configs, }: {
+        system: System;
+        configs: Configs;
+    });
+    onInit: ({}: {}) => Promise<void>;
+    kafkaLoader: ({ clientId, brokers, username, password }: KafkaInstanceType) => Promise<any>;
+    private initializeKafkaInfrastructure;
+    sendMessage: (topic: string, message: any) => Promise<void>;
+    get producer(): any;
+    get instance(): any;
+}
+export {};

package/source/loader/kafka/index.js

@@ -0,0 +1,128 @@
+import { Kafka as KafkaClient, logLevel } from "kafkajs";
+import { LoggerLayerEnum } from "source/utils";
+export default class KafkaForCore {
+    _instance;
+    _producer;
+    clientId = "";
+    brokers = "";
+    username = null;
+    password = null;
+    #system;
+    #configs;
+    constructor({ system, configs, }) {
+        this.#system = system;
+        this.#configs = configs;
+    }
+    onInit = async ({}) => {
+        this.clientId = this.#configs.all?.kafkaClientId;
+        this.brokers = this.#configs.all?.kafkaBrokers;
+        this.username = this.#configs.all?.kafkaUsername;
+        this.password = this.#configs.all?.kafkaPassword;
+        if (this.#configs.all.isKafkaPassive) {
+            return;
+        }
+        const brokersArray = (Array.isArray(this.brokers) ? this.brokers : (this.brokers?.split(',') ?? []))
+            .map(b => b?.trim())
+            .filter(Boolean);
+        if (brokersArray?.length === 0) {
+            throw new Error('Broker list error');
+        }
+        await this.kafkaLoader({
+            clientId: this.clientId,
+            brokers: brokersArray,
+            username: this.username,
+            password: this.password
+        });
+        await this.initializeKafkaInfrastructure();
+    };
+    kafkaLoader = async ({ clientId, brokers, username, password }) => {
+        const kafkaConfig = {
+            clientId,
+            brokers,
+            sasl: (username && password) ? { mechanism: 'plain', username, password } : undefined,
+            ssl: false,
+            logLevel: logLevel.ERROR,
+            logCreator: () => {
+                return ({ level, log }) => {
+                    const winstonLevel = level === 1 ? LoggerLayerEnum.CRITICAL :
+                        level === 2 ? LoggerLayerEnum.INFO :
+                            level === 4 ? LoggerLayerEnum.INFO :
+                                level === 5 ? LoggerLayerEnum.DEBUG :
+                                    LoggerLayerEnum.CRITICAL;
+                    console.error(`Kafka ${log.message}`);
+                };
+            },
+            retry: {
+                initialRetryTime: 100,
+                retries: 8
+            }
+        };
+        try {
+            const kafka = new KafkaClient(kafkaConfig);
+            this._instance = kafka;
+            this._producer = kafka.producer();
+            await this.producer.connect();
+            return kafka;
+        }
+        catch (error) {
+            console.error(`Kafka ${error}`);
+        }
+    };
+    initializeKafkaInfrastructure = async () => {
+        const { kafkaBrokers, kafkaTopics, isKafkaPassive, } = {
+            isKafkaPassive: process.env.IS_KAFKA_PASSIVE === 'true' ? true : false,
+            kafkaBrokers: process.env?.KAFKA_BROKERS,
+            kafkaTopics: [
+                ...new Set([
+                    ...this.#configs.all.kafkaTopics
+                ])
+            ],
+        };
+        if (isKafkaPassive === true || !kafkaBrokers)
+            return;
+        const brokers = String(kafkaBrokers).split(",").map(b => b.trim());
+        const topicsToCreate = Array.isArray(kafkaTopics) ? kafkaTopics : [];
+        if (topicsToCreate.length === 0)
+            return;
+        const admin = this._instance.admin();
+        try {
+            await admin.connect();
+            const existingTopics = await admin.listTopics();
+            const newTopics = topicsToCreate
+                .filter(topic => !existingTopics.includes(topic))
+                .map(topic => ({
+                topic,
+                numPartitions: 1,
+                replicationFactor: 1
+            }));
+            if (newTopics.length > 0) {
+                await admin.createTopics({
+                    waitForLeaders: true,
+                    topics: newTopics
+                });
+            }
+        }
+        catch (error) {
+            // => Error
+        }
+        finally {
+            await admin.disconnect();
+        }
+    };
+    // => Helpers
+    sendMessage = async (topic, message) => {
+        if (!this.producer)
+            throw new Error("Producer not ready");
+        await this.producer.send({
+            topic,
+            messages: [{ value: JSON.stringify(message) }],
+            acks: 0
+        });
+    };
+    get producer() {
+        return this._producer;
+    }
+    get instance() {
+        return this._instance;
+    }
+}

package/source/loader/logger/index.d.ts

@@ -5,6 +5,7 @@ import System from "../system";
 import Configs from "../configs";
 import { LoggerLayerEnum } from '../../utils/models/enums/index';
 import { IProvide } from "../../utils";
+import KafkaForCore from "../kafka";
 export interface ICustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
@@ -23,9 +24,10 @@ export default class Logger implements IProvide<any> {
     private kafkaLogsTopic;
     private isKafkaReady;
     winston: ICustomLogger;
-    constructor({ system, configs }: {
+    constructor({ system, configs, kafka, }: {
         system: System;
         configs: Configs;
+        kafka: KafkaForCore;
     });
     onInit: () => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {

package/source/loader/logger/index.js

@@ -3,7 +3,7 @@ import Transport from "winston-transport";
 import "winston-daily-rotate-file";
 import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { Kafka, Partitioners, logLevel } from "kafkajs";
+import { Partitioners } from "kafkajs";
 import { LoggerLayerEnum } from '../../utils/models/enums/index';
 class KafkaTransport extends Transport {
     service;
@@ -41,9 +41,11 @@ export default class Logger {
     winston;
     #system;
     #configs;
-    constructor({ system, configs }) {
+    #kafka;
+    constructor({ system, configs, kafka, }) {
         this.#system = system;
         this.#configs = configs;
+        this.#kafka = kafka;
     }
     onInit = async () => {
         this.serviceName = this.#system?.tmp?.configs?.service;
@@ -60,18 +62,7 @@ export default class Logger {
         const brokers = kafkaBrokers ? String(kafkaBrokers).split(",").map((b) => b.trim()) : [];
         const isKafkaEnabled = isKafkaPassive === false && brokers.length > 0;
         if (isKafkaEnabled) {
-            const kafka = new Kafka({
-                clientId: kafkaClientId,
-                brokers,
-                logLevel: logLevel.NOTHING,
-                sasl: {
-                    mechanism: 'plain',
-                    username: kafkaUsername,
-                    password: kafkaPassword
-                },
-                ssl: false,
-            });
-            this.kafkaProducer = kafka.producer({
+            this.kafkaProducer = this.#kafka.producer({
                 createPartitioner: Partitioners.DefaultPartitioner,
                 retry: { initialRetryTime: 500, retries: 5 }
             });

package/source/project/index.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { System, Configs, Logger, Events, Localizations, Clients, Controller } from '../loader';
 import { Constants, getCore, x, } from '../utils';
+import KafkaForCore from 'source/loader/kafka';
 //
 export const core = getCore();
 export const coreInit = async (params) => {
@@ -31,6 +32,10 @@ const coreLoader = async ({}) => {
                 service: Configs,
                 props: {}
             },
+            {
+                service: KafkaForCore,
+                props: {}
+            },
             {
                 service: Logger,
                 props: {}