@xrystal/core 3.19.8 → 3.20.1

package/package.json

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

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

@@ -1,7 +1,8 @@
 import SystemService from '../system/index';
-import { IService } from '../../utils';
+import { IService, ModeEnum } from '../../utils';
 export interface IConfig {
     worker: boolean;
+    mode: ModeEnum;
     nodeEnv: string;
     debug: string;
     https: string;
@@ -16,7 +17,9 @@ export interface IConfig {
     projectNameSuffixEnv: string;
     systemStaticFolderPath: string;
     systemLoggerLayer: string;
+    isKafkaPassive: boolean;
     kafkaBrokers: string;
+    kafkaTopics: string;
     kafkaLogsTopic: string;
     baseApiUri: string;
     port: number;

package/source/loader/configs/index.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { merge } from 'lodash';
-import { Constants } from '../../utils';
 import { pathToFileURL } from 'node:url';
+import { Constants } from '../../utils';
 export default class ConfigsService {
     publicFolderName = Constants.publicFolderName;
     kafkaLogsTopic = Constants.kafkaLogsTopic;
@@ -27,6 +27,7 @@ export default class ConfigsService {
         const modulePromise = import(fileUrl);
         this.#config = {
             worker: process.env.WORKER === 'true' ? true : false || false,
+            mode: process.env.MODE,
             nodeEnv: process.env.NODE_ENV,
             debug: process.env.SYSTEM_LOGGER_LAYER,
             https: process.env.HTTPS,
@@ -41,7 +42,9 @@ export default class ConfigsService {
             projectNameSuffixEnv: process.env.PROJECT_NAME_SUFFIX || '',
             systemStaticFolderPath: path.resolve(tmp.configs.rootFolderPath, this.publicFolderName),
             systemLoggerLayer: process.env.SYSTEM_LOGGER_LAYER,
+            isKafkaPassive: process.env.IS_KAFKA_PASSIVE === 'true' ? true : false,
             kafkaBrokers: process.env?.KAFKA_BROKERS,
+            kafkaTopics: process.env?.KAFKA_TOPICS,
             kafkaLogsTopic: this.kafkaLogsTopic,
             baseApiUri: process.env.HTTPS === 'true' ? process.env.SYSTEM_HTTPS_BASE_API_URI : process.env.SYSTEM_BASE_API_URI,
             port: Number(process.env.PORT),

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

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { ProtocolEnum } from '../../utils/index';
 import LoggerService from '../logger';
+import SystemService from '../system';
 export declare const controllerContextStorage: AsyncLocalStorage<{
     protocol?: ProtocolEnum;
     ctx?: any;
@@ -25,6 +26,7 @@ export declare const getControllerCtx: () => {
         _isRaw?: boolean;
     };
 };
+export declare const protocol: (callback: () => Promise<any>, protocol?: ProtocolEnum) => Promise<any>;
 export interface CustomRequest {
     accounts?: any;
     url: string;
@@ -62,9 +64,11 @@ declare abstract class Controller {
     protected get res(): CustomResponse;
 }
 export declare abstract class ControllerService extends Controller {
-    load(props?: {
-        type?: ProtocolEnum | ProtocolEnum[];
-    }): Promise<void>;
+    protected systemService: SystemService;
+    constructor({ systemService }: {
+        systemService: SystemService;
+    });
+    load(): Promise<void>;
     schema({ checks, logic, response }: {
         checks?: (args: any) => Promise<any>;
         logic?: (args: any) => Promise<any>;

package/source/loader/controller/index.js

@@ -3,6 +3,13 @@ import { ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../ut
 import LoggerService from '../logger';
 export const controllerContextStorage = new AsyncLocalStorage();
 export const getControllerCtx = () => controllerContextStorage.getStore();
+export const protocol = async (callback, protocol = ProtocolEnum.HTTP) => {
+    const store = controllerContextStorage.getStore();
+    if (store) {
+        store.protocol = protocol;
+    }
+    return await callback();
+};
 class Controller {
     logger = x.get(LoggerService);
     supportedProtocols = [ProtocolEnum.HTTP, ProtocolEnum.WEBSOCKET];
@@ -72,9 +79,14 @@ class Controller {
     }
 }
 export class ControllerService extends Controller {
-    async load(props = {}) {
-        if (props.type)
-            this.supportedProtocols = Array.isArray(props.type) ? props.type : [props.type];
+    systemService;
+    constructor({ systemService }) {
+        super();
+        this.systemService = systemService;
+    }
+    async load() {
+        const protocols = this.systemService.tmp.configs.loaders.controller.protocols;
+        this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols];
     }
     async schema({ checks, logic, response }) {
         try {

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

@@ -1,11 +1,14 @@
+import ConfigsService from "../configs";
 import { IService } from "../../utils";
+import SystemService from "../system";
 export default class LocalizationsService implements IService {
+    #private;
     _instance: any;
-    load: ({ loadPath, fallbackLang, preloadLang, }: {
-        loadPath: string;
-        fallbackLang: string;
-        preloadLang: string;
-    }) => any;
+    constructor({ systemService, configsService, }: {
+        systemService: SystemService;
+        configsService: ConfigsService;
+    });
+    load: ({}: {}) => any;
     i18next: ({ loadPath, fallbackLang, preloadLang, }: {
         loadPath?: string;
         fallbackLang?: string;

package/source/loader/localizations/index.js

@@ -3,11 +3,18 @@ import Backend from 'i18next-fs-backend';
 import * as middleware from 'i18next-http-middleware';
 export default class LocalizationsService {
     _instance = null;
-    load = ({ loadPath, fallbackLang, preloadLang, }) => {
+    #systemService;
+    #configsService;
+    constructor({ systemService, configsService, }) {
+        this.#systemService = systemService;
+        this.#configsService = configsService;
+    }
+    load = ({}) => {
+        const localization = this.#systemService.tmp.configs.loaders.localization;
         this.i18next({
-            loadPath,
-            fallbackLang,
-            preloadLang,
+            loadPath: localization.loadPath,
+            fallbackLang: localization.fallbackLang,
+            preloadLang: localization.preloadLang,
         });
     };
     i18next = ({ loadPath, fallbackLang, preloadLang, }) => {

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

@@ -1,7 +1,9 @@
 import winston from "winston";
 import "winston-daily-rotate-file";
 import { AsyncLocalStorage } from "node:async_hooks";
+import ConfigsService from "../configs";
 import { LoggerLayerEnum, IService } from "../../utils";
+import SystemService from "../system";
 export interface ICustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
@@ -20,10 +22,11 @@ export default class LoggerService implements IService {
     private kafkaLogsTopic;
     private isKafkaReady;
     winston: ICustomLogger;
-    constructor({ configsService }: {
-        configsService: any;
+    constructor({ systemService, configsService }: {
+        systemService: SystemService;
+        configsService: ConfigsService;
     });
-    load: (config: Record<string, any>) => Promise<void>;
+    load: ({}: {}) => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;
         loggerLevel: string;

package/source/loader/logger/index.js

@@ -38,23 +38,27 @@ export default class LoggerService {
     kafkaLogsTopic = "";
     isKafkaReady = false;
     winston;
+    #systemService;
     #configsService;
-    constructor({ configsService }) {
+    constructor({ systemService, configsService }) {
+        this.#systemService = systemService;
         this.#configsService = configsService;
         this.kafkaLogsTopic = this.#configsService?.all.kafkaLogsTopic;
         winston.addColors(customColors);
         this.winston = winston.createLogger({
-            level: this.#configsService.all.systemLoggerLayer,
+            level: this.#configsService.all.systemLoggerLayer || 'info',
             levels: customLevels,
             format: this.getConsoleFormat(),
             transports: [new winston.transports.Console()]
         });
     }
-    load = async (config) => {
-        this.serviceName = config?.serviceName;
-        const rawBrokers = this.#configsService.all.kafkaBrokers;
-        const brokers = rawBrokers ? String(rawBrokers).split(",").map((b) => b.trim()) : [];
-        if (brokers.length > 0) {
+    load = async ({}) => {
+        const loggersConfigs = this.#systemService.tmp.configs.loaders.loggers;
+        this.serviceName = this.#systemService.tmp.configs?.serviceName;
+        const { kafkaBrokers, isKafkaPassive } = this.#configsService.all;
+        const brokers = kafkaBrokers ? String(kafkaBrokers).split(",").map((b) => b.trim()) : [];
+        const isKafkaEnabled = isKafkaPassive === false && brokers.length > 0;
+        if (isKafkaEnabled) {
             const kafka = new Kafka({
                 clientId: this.serviceName,
                 brokers: brokers,
@@ -73,8 +77,8 @@ export default class LoggerService {
             }
         }
         this.winstonLoader({
-            loadPath: config?.loadPath,
-            loggerLevel: config?.loggerLevel
+            loadPath: path.join(this.#configsService.all.rootFolderPath, loggersConfigs?.loadPath),
+            loggerLevel: loggersConfigs?.loggerLevel
         });
     };
     winstonLoader = ({ loadPath, loggerLevel }) => {
@@ -100,7 +104,7 @@ export default class LoggerService {
                 maxFiles: "14d"
             })
         ];
-        if (this.kafkaProducer) {
+        if (this.isKafkaReady && this.kafkaProducer) {
             transports.push(new KafkaTransport({ level: loggerLevel }, this));
         }
         this.winston = winston.createLogger({
@@ -123,11 +127,6 @@ export default class LoggerService {
         if (store && store.has("correlationId")) {
             info.id = store.get("correlationId");
         }
-        Object.keys(info).forEach(key => {
-            if (info[key] instanceof Headers) {
-                info[key] = Object.fromEntries(info[key].entries());
-            }
-        });
         return info;
     });
     getConsoleFormat() {

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

@@ -1,10 +1,14 @@
 import { IService } from "../../utils";
 export default class SystemService implements IService {
-    _tmp: Record<string, any>;
+    private _tmp;
     cwd: string;
-    load: ({ tmp, }: {
+    core: {
+        _: any;
+    };
+    load: ({}: {
         tmp: any;
     }) => Promise<void>;
+    private initializeKafkaInfrastructure;
     private _systemLoader;
     get tmp(): Record<string, any>;
 }

package/source/loader/system/index.js

@@ -1,14 +1,65 @@
+import { Kafka, logLevel } from "kafkajs";
+import { Constants, getTmp } from "../../utils";
 export default class SystemService {
     _tmp = {};
     cwd = process.cwd();
-    load = async ({ tmp, }) => {
-        this._tmp = tmp;
+    core = getTmp();
+    load = async ({}) => {
+        this._tmp = this.core._;
+        await this.initializeKafkaInfrastructure();
         await this._systemLoader({});
     };
+    initializeKafkaInfrastructure = async () => {
+        const { kafkaBrokers, kafkaTopics, isKafkaPassive, serviceName } = {
+            isKafkaPassive: process.env.IS_KAFKA_PASSIVE === 'true' ? true : false,
+            kafkaBrokers: process.env?.KAFKA_BROKERS,
+            kafkaTopics: [
+                ...new Set([
+                    Constants.kafkaLogsTopic,
+                    ...(process.env.KAFKA_TOPICS?.split(',').map(t => t.trim()).filter(Boolean) || [])
+                ])
+            ],
+            serviceName: this._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();
+        }
+    };
     _systemLoader = async ({}) => {
-        //console.log(this._tmp)
+        return;
     };
-    // => getters
     get tmp() {
         return this._tmp;
     }

package/source/project/index.d.ts

@@ -1,6 +1,3 @@
-export declare const core: {
-    _: any;
-};
 export declare const coreInit: (params: {
     locales?: Record<string, any>;
 }) => Promise<void>;

package/source/project/index.js

@@ -1,9 +1,8 @@
 import path from 'path';
 import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader';
-import { Constants, x, getTmp, } from '../utils';
+import { Constants, x, } from '../utils';
 //
 let coreHasRun = false;
-export const core = getTmp();
 export const coreInit = async (params) => {
     const { locales } = params;
     if (locales)
@@ -13,8 +12,6 @@ const coreLoader = async ({}) => {
     if (coreHasRun)
         return {};
     try {
-        const { configs } = core._;
-        const rootFolderPath = configs.rootFolderPath;
         await (await x.load([
             path.join(__dirname, '..', 'loader', '**/*.{ts,js}'),
         ], {
@@ -23,23 +20,15 @@ const coreLoader = async ({}) => {
             .initialize([
             {
                 service: SystemService,
-                props: {
-                    tmp: core._
-                }
+                props: {}
             },
             {
                 service: ConfigsService,
-                props: {
-                    ...(configs.loaders.configs.globalEnvFileName && { globalEnvFileName: configs.loaders.configs.globalEnvFileName })
-                }
+                props: {}
             },
             {
                 service: LoggerService,
-                props: {
-                    loadPath: path.join(rootFolderPath, configs.loaders.loggers.loadPath),
-                    loggerLevel: configs.loaders.loggers.logLevel,
-                    serviceName: configs.service,
-                }
+                props: {}
             },
             {
                 service: EventsService,
@@ -47,17 +36,11 @@ const coreLoader = async ({}) => {
             },
             {
                 service: LocalizationsService,
-                props: {
-                    loadPath: path.join(rootFolderPath, configs.loaders.localization.loadPath),
-                    fallbackLang: configs.loaders.localization.fallbackLang,
-                    preloadLang: configs.loaders.localization.preloadLangs
-                }
+                props: {}
             },
             {
                 service: ControllerService,
-                props: {
-                    type: configs.loaders.controller.protocols,
-                }
+                props: {}
             },
             {
                 service: ClientsService,

package/source/utils/models/enums/index.d.ts

@@ -76,15 +76,9 @@ export declare enum TimezoneEnum {
     EtcUTC = "Etc/UTC",
     EtcGMT = "Etc/GMT"
 }
-export declare enum WsActionsEnum {
-    REGISTER = "register",
-    JOIN = "join",
-    MESSAGE = "message"
-}
-export declare enum WsKeyEnum {
-    BUS = "WS_BUS",
-    USER = "ws:user",
-    ROOM = "ws:room"
+export declare enum ModeEnum {
+    MONOLITIC = "monolitic",
+    MICRO_SERVICE = "micro_service"
 }
 export declare enum TokensEnum {
     INTERNAL_API_TOKEN = "internal_api_key",

package/source/utils/models/enums/index.js

@@ -90,18 +90,11 @@ export var TimezoneEnum;
     TimezoneEnum["EtcUTC"] = "Etc/UTC";
     TimezoneEnum["EtcGMT"] = "Etc/GMT";
 })(TimezoneEnum || (TimezoneEnum = {}));
-export var WsActionsEnum;
-(function (WsActionsEnum) {
-    WsActionsEnum["REGISTER"] = "register";
-    WsActionsEnum["JOIN"] = "join";
-    WsActionsEnum["MESSAGE"] = "message";
-})(WsActionsEnum || (WsActionsEnum = {}));
-export var WsKeyEnum;
-(function (WsKeyEnum) {
-    WsKeyEnum["BUS"] = "WS_BUS";
-    WsKeyEnum["USER"] = "ws:user";
-    WsKeyEnum["ROOM"] = "ws:room";
-})(WsKeyEnum || (WsKeyEnum = {}));
+export var ModeEnum;
+(function (ModeEnum) {
+    ModeEnum["MONOLITIC"] = "monolitic";
+    ModeEnum["MICRO_SERVICE"] = "micro_service";
+})(ModeEnum || (ModeEnum = {}));
 export var TokensEnum;
 (function (TokensEnum) {
     TokensEnum["INTERNAL_API_TOKEN"] = "internal_api_key";

package/x/tmp.yml

@@ -21,7 +21,7 @@ configs:
         - tr
 
     controller:
-      protocol: http
+      protocols: http
 
 end:
   version: 1