@xrystal/core 3.22.1 → 3.22.2

package/package.json

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

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

@@ -1,10 +1,10 @@
-import { IService } from "../../utils";
-import ConfigsService from "../configs";
-export default class ClientsService implements IService<any> {
+import { IProvide } from "../../utils";
+import Configs from "../configs";
+export default class Clients implements IProvide<any> {
     #private;
     private _instances;
-    constructor({ configsService }: {
-        configsService: ConfigsService;
+    constructor({ configs }: {
+        configs: Configs;
     });
     onInit(): Promise<void>;
     get instances(): Record<string, any>;

package/source/loader/clients/index.js

@@ -1,16 +1,16 @@
-import { BaseApiClient, CoreServiceEnum } from "../../utils";
-export default class ClientsService {
+import { BaseApiClient, CoreClientsEnum } from "../../utils";
+export default class Clients {
     _instances = {};
-    #configsService;
-    constructor({ configsService }) {
-        this.#configsService = configsService;
+    #configs;
+    constructor({ configs }) {
+        this.#configs = configs;
     }
     async onInit() {
         const baseClient = new BaseApiClient({
-            clientName: CoreServiceEnum.BASE_API_CLIENT,
-            baseURL: this.#configsService.all.baseApiUri || ''
+            clientName: CoreClientsEnum.BASE_API_CLIENT,
+            baseURL: this.#configs.all.baseApiUri || ''
         });
-        this._instances[CoreServiceEnum.BASE_API_CLIENT] = baseClient;
+        this._instances[CoreClientsEnum.BASE_API_CLIENT] = baseClient;
     }
     get instances() {
         return this._instances;

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

@@ -1,5 +1,5 @@
-import SystemService from '../system/index';
-import { IService, ModeEnum } from '../../utils';
+import System from '../system/index';
+import { IProvide, ModeEnum } from '../../utils';
 export interface IConfig {
     worker: boolean;
     mode: ModeEnum;
@@ -28,14 +28,14 @@ export interface IConfig {
     cwd: string;
     env: string;
 }
-export interface IConfigsService extends IConfig {
+export interface IConfigs extends IConfig {
 }
-export default class ConfigsService implements IService<any> {
+export default class Configs implements IProvide<any> {
     #private;
     readonly publicFolderName: string;
     readonly kafkaLogsTopic: string;
     constructor({ systemService }: {
-        systemService: SystemService;
+        systemService: System;
     });
     onInit: ({}: {}) => Promise<void>;
     private initializeKafkaInfrastructure;

package/source/loader/configs/index.js

@@ -3,7 +3,7 @@ import { merge } from 'lodash';
 import { pathToFileURL } from 'node:url';
 import { Kafka, logLevel } from 'kafkajs';
 import { Constants } from '../../utils';
-export default class ConfigsService {
+export default class Configs {
     publicFolderName = Constants.publicFolderName;
     kafkaLogsTopic = Constants.kafkaLogsTopic;
     #systemService;
@@ -45,7 +45,9 @@ export default class ConfigsService {
             systemLoggerLayer: process.env.SYSTEM_LOGGER_LAYER,
             isKafkaPassive: process.env.IS_KAFKA_PASSIVE === 'true' ? true : false,
             kafkaBrokers: process.env?.KAFKA_BROKERS,
-            kafkaTopics: [],
+            kafkaTopics: [
+                this.kafkaLogsTopic,
+            ],
             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),
@@ -71,7 +73,6 @@ export default class ConfigsService {
             kafkaBrokers: process.env?.KAFKA_BROKERS,
             kafkaTopics: [
                 ...new Set([
-                    Constants.kafkaLogsTopic,
                     ...this.#config.kafkaTopics
                 ])
             ],

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

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import LoggerService from '../logger';
-import SystemService from '../system';
-import { IService, ProtocolEnum } from '../../utils/index';
+import Logger from '../logger';
+import System from '../system';
+import { IProvide, ProtocolEnum } from '../../utils/index';
 export declare const controllerContextStorage: AsyncLocalStorage<{
     protocol?: ProtocolEnum;
     ctx?: any;
@@ -26,9 +26,9 @@ export declare const getControllerCtx: () => {
         _isRaw?: boolean;
     };
 };
-export declare abstract class Controller {
-    protected systemService: SystemService;
-    protected loggerService: LoggerService;
+export declare abstract class BaseController {
+    protected system: System;
+    protected logger: Logger;
     protected supportedProtocols: ProtocolEnum[];
     protected get protocol(): ProtocolEnum;
     protected get currentStore(): {
@@ -46,7 +46,7 @@ export declare abstract class Controller {
     protected get req(): CustomRequest;
     protected get res(): CustomResponse;
 }
-export declare abstract class ControllerService extends Controller implements IService<any> {
+export default abstract class Controller extends BaseController implements IProvide<any> {
     constructor({}: {});
     onInit(): Promise<void>;
     schema({ checks, logic, response }: {

package/source/loader/controller/index.js

@@ -1,12 +1,12 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import LoggerService from '../logger';
-import SystemService from '../system';
+import Logger from '../logger';
+import System from '../system';
 import { LoggerLayerEnum, ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../utils/index';
 export const controllerContextStorage = new AsyncLocalStorage();
 export const getControllerCtx = () => controllerContextStorage.getStore();
-export class Controller {
-    systemService = x.get(SystemService);
-    loggerService = x.get(LoggerService);
+export class BaseController {
+    system = x.get(System);
+    logger = x.get(Logger);
     supportedProtocols = [ProtocolEnum.HTTP, ProtocolEnum.WEBSOCKET];
     get protocol() {
         return this.currentStore?.protocol || ProtocolEnum.HTTP;
@@ -73,12 +73,12 @@ export class Controller {
         };
     }
 }
-export class ControllerService extends Controller {
+export default class Controller extends BaseController {
     constructor({}) {
         super();
     }
     async onInit() {
-        const protocols = this.systemService?.tmp?.configs?.loaders?.controller?.protocols;
+        const protocols = this.system?.tmp?.configs?.loaders?.controller?.protocols;
         this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols || ProtocolEnum.HTTP];
     }
     async schema({ checks, logic, response }) {
@@ -149,16 +149,15 @@ export class ControllerService extends Controller {
                 }
             }
             const successCode = this.currentStore?.metadata?._code || 200;
-            // Sıralama güncellendi: Code en alta alındı
             return currentRes.status(successCode).send(new ResponseSchema({
                 status: true,
                 message: finalMessage,
-                payload: finalPayload,
+                ...(finalPayload && { payload: finalPayload }),
                 code: successCode
             }).getResponse);
         }
         catch (error) {
-            this.loggerService?.log(LoggerLayerEnum.ERROR, `Controller Error: ${error.message}`);
+            this.logger?.log(LoggerLayerEnum.ERROR, `Controller Error: ${error.message}`);
             return this.res.status(500).send(new ResponseSchema({
                 status: false,
                 message: error.message,

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

@@ -1,12 +1,12 @@
-import { IService } from '../../utils/index';
-import LoggerService from '../logger/index';
-export default class EventsService implements IService<any> {
+import Logger from '../logger';
+import { IProvide } from '../../utils/index';
+export default class Events implements IProvide<any> {
     #private;
-    constructor({ loggerService }: {
-        loggerService: LoggerService;
+    constructor({ logger }: {
+        logger: Logger;
     });
     onInit: ({}: {
-        logger: LoggerService;
+        logger: Logger;
     }) => any;
     private _globalLoader;
     private _DILoader;

package/source/loader/events/index.js

@@ -1,8 +1,8 @@
 import { LoggerLayerEnum, x } from '../../utils/index';
-export default class EventsService {
-    #loggerService;
-    constructor({ loggerService }) {
-        this.#loggerService = loggerService;
+export default class Events {
+    #logger;
+    constructor({ logger }) {
+        this.#logger = logger;
     }
     onInit = ({}) => {
         this._globalLoader();
@@ -10,7 +10,7 @@ export default class EventsService {
     };
     _globalLoader = () => {
         process.on("uncaughtException", (error, origin) => {
-            this.#loggerService.log({
+            this.#logger.log({
                 level: LoggerLayerEnum.CRITICAL,
                 message: `Uncaught Exception: ${error.message}`,
                 payload: {
@@ -21,7 +21,7 @@ export default class EventsService {
         });
         process.on("unhandledRejection", (reason, promise) => {
             const error = reason instanceof Error ? reason : new Error(String(reason));
-            this.#loggerService.log({
+            this.#logger.log({
                 level: LoggerLayerEnum.CRITICAL,
                 message: `Unhandled Rejection: ${error.message}`,
                 payload: {

package/source/loader/index.d.ts

@@ -1,8 +1,9 @@
-import SystemService from "./system";
-import ConfigsService from "./configs";
-import LoggerService from "./logger";
-import EventsService from "./events";
-import LocalizationsService from "./localizations";
-import { ControllerService } from "./controller";
-import ClientsService from "./clients";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ControllerService, ClientsService };
+import System from "./system";
+import Configs from "./configs";
+import Logger from "./logger";
+import Events from "./events";
+import Localizations from "./localizations";
+import Controller from "./controller";
+import Service from "./service";
+import Clients from "./clients";
+export { System, Configs, Logger, Events, Localizations, Controller, Service, Clients };

package/source/loader/index.js

@@ -1,8 +1,9 @@
-import SystemService from "./system";
-import ConfigsService from "./configs";
-import LoggerService from "./logger";
-import EventsService from "./events";
-import LocalizationsService from "./localizations";
-import { ControllerService } from "./controller";
-import ClientsService from "./clients";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ControllerService, ClientsService };
+import System from "./system";
+import Configs from "./configs";
+import Logger from "./logger";
+import Events from "./events";
+import Localizations from "./localizations";
+import Controller from "./controller";
+import Service from "./service";
+import Clients from "./clients";
+export { System, Configs, Logger, Events, Localizations, Controller, Service, Clients };

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

@@ -1,12 +1,12 @@
-import ConfigsService from "../configs";
-import { IService } from "../../utils";
-import SystemService from "../system";
-export default class LocalizationsService implements IService<any> {
+import Configs from "../configs";
+import System from "../system";
+import { IProvide } from "../../utils";
+export default class Localizations implements IProvide<any> {
     #private;
     _instance: any;
-    constructor({ systemService, configsService, }: {
-        systemService: SystemService;
-        configsService: ConfigsService;
+    constructor({ system, configs, }: {
+        system: System;
+        configs: Configs;
     });
     onInit: ({}: {}) => any;
     i18next: ({ loadPath, fallbackLang, preloadLang, }: {

package/source/loader/localizations/index.js

@@ -2,18 +2,18 @@ import path from "path";
 import i18next from "i18next";
 import Backend from 'i18next-fs-backend';
 import * as middleware from 'i18next-http-middleware';
-export default class LocalizationsService {
+export default class Localizations {
     _instance = null;
-    #systemService;
-    #configsService;
-    constructor({ systemService, configsService, }) {
-        this.#systemService = systemService;
-        this.#configsService = configsService;
+    #system;
+    #configs;
+    constructor({ system, configs, }) {
+        this.#system = system;
+        this.#configs = configs;
     }
     onInit = ({}) => {
-        const localization = this.#systemService.tmp.configs.loaders.localization;
+        const localization = this.#system.tmp.configs.loaders.localization;
         this.i18next({
-            loadPath: path.join(this.#systemService.tmp.configs.rootFolderPath, localization.loadPath),
+            loadPath: path.join(this.#system.tmp.configs.rootFolderPath, localization.loadPath),
             fallbackLang: localization.fallbackLang,
             preloadLang: localization.preloadLangs,
         });

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

@@ -1,10 +1,10 @@
 import winston from "winston";
 import "winston-daily-rotate-file";
 import { AsyncLocalStorage } from "node:async_hooks";
-import SystemService from "../system";
-import ConfigsService from "../configs";
+import System from "../system";
+import Configs from "../configs";
 import { LoggerLayerEnum } from '../../utils/models/enums/index';
-import { IService } from "../../utils";
+import { IProvide } from "../../utils";
 export interface ICustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
@@ -15,7 +15,7 @@ export interface ILog {
     payload?: any;
     code?: string | number;
 }
-export default class LoggerService implements IService<any> {
+export default class Logger implements IProvide<any> {
     #private;
     static readonly storage: AsyncLocalStorage<Map<string, string>>;
     private serviceName;
@@ -23,9 +23,9 @@ export default class LoggerService implements IService<any> {
     private kafkaLogsTopic;
     private isKafkaReady;
     winston: ICustomLogger;
-    constructor({ systemService, configsService }: {
-        systemService: SystemService;
-        configsService: ConfigsService;
+    constructor({ system, configs }: {
+        system: System;
+        configs: Configs;
     });
     onInit: () => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {

package/source/loader/logger/index.js

@@ -31,31 +31,31 @@ const customColors = {
     http: "cyan",
     debug: "blue"
 };
-export default class LoggerService {
+export default class Logger {
     static storage = new AsyncLocalStorage();
     serviceName = "";
     kafkaProducer = null;
     kafkaLogsTopic = "";
     isKafkaReady = false;
     winston;
-    #systemService;
-    #configsService;
-    constructor({ systemService, configsService }) {
-        this.#systemService = systemService;
-        this.#configsService = configsService;
+    #system;
+    #configs;
+    constructor({ system, configs }) {
+        this.#system = system;
+        this.#configs = configs;
     }
     onInit = async () => {
-        this.serviceName = this.#systemService?.tmp?.configs?.service;
-        this.kafkaLogsTopic = this.#configsService?.all?.kafkaLogsTopic;
+        this.serviceName = this.#system?.tmp?.configs?.service;
+        this.kafkaLogsTopic = this.#configs?.all?.kafkaLogsTopic;
         winston.addColors(customColors);
         this.winston = winston.createLogger({
-            level: this.#configsService?.all?.systemLoggerLayer || 'info',
+            level: this.#configs?.all?.systemLoggerLayer || 'info',
             levels: customLevels,
             format: this.getConsoleFormat(),
             transports: [new winston.transports.Console()]
         });
-        const loggersConfigs = this.#systemService?.tmp?.configs?.loaders?.loggers;
-        const { kafkaBrokers, isKafkaPassive } = this.#configsService.all;
+        const loggersConfigs = this.#system?.tmp?.configs?.loaders?.loggers;
+        const { kafkaBrokers, isKafkaPassive } = this.#configs.all;
         const brokers = kafkaBrokers ? String(kafkaBrokers).split(",").map((b) => b.trim()) : [];
         const isKafkaEnabled = isKafkaPassive === false && brokers.length > 0;
         if (isKafkaEnabled) {
@@ -79,7 +79,7 @@ export default class LoggerService {
         const logPath = loggersConfigs?.loadPath || "logs";
         const loggerLevel = loggersConfigs?.loggerLevel || "info";
         this.winstonLoader({
-            loadPath: path.join(this.#configsService.all.rootFolderPath, logPath),
+            loadPath: path.join(this.#configs.all.rootFolderPath, logPath),
             loggerLevel: loggerLevel
         });
     };
@@ -125,7 +125,7 @@ export default class LoggerService {
         return value;
     };
     getTracingFormat = format((info) => {
-        const store = LoggerService.storage.getStore();
+        const store = Logger.storage.getStore();
         if (store && store.has("correlationId")) {
             info.id = store.get("correlationId");
         }
@@ -145,7 +145,7 @@ export default class LoggerService {
     runWithId = (id, callback) => {
         const store = new Map();
         store.set("correlationId", id);
-        return LoggerService.storage.run(store, callback);
+        return Logger.storage.run(store, callback);
     };
     async logToKafka(info) {
         if (!this.kafkaProducer || !this.isKafkaReady)
@@ -163,7 +163,7 @@ export default class LoggerService {
                             code,
                             timestamp: new Date().toISOString(),
                             id: id || null,
-                            env: this.#configsService.all.env
+                            env: this.#configs.all.env
                         }, this.safeReplacer)
                     }],
                 acks: 1

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

@@ -0,0 +1,12 @@
+import Logger from '../logger';
+import System from '../system';
+import { IProvide } from '../../utils';
+export declare abstract class BaseService {
+    protected system: System;
+    protected logger: Logger;
+    constructor();
+}
+export default abstract class Service extends BaseService implements IProvide<any> {
+    constructor({}: {});
+    onInit(): Promise<void>;
+}

package/source/loader/service/index.js

@@ -0,0 +1,16 @@
+import Logger from '../logger';
+import System from '../system';
+import { x } from '../../utils';
+export class BaseService {
+    system = x.get(System);
+    logger = x.get(Logger);
+    constructor() {
+    }
+}
+export default class Service extends BaseService {
+    constructor({}) {
+        super();
+    }
+    async onInit() {
+    }
+}

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

@@ -1,5 +1,5 @@
-import { IService } from "../../utils";
-export default class SystemService implements IService<any> {
+import { IProvide } from "../../utils";
+export default class System implements IProvide<any> {
     protected _core: Record<string, any>;
     protected _tmp: Record<string, any>;
     cwd: string;

package/source/loader/system/index.js

@@ -1,4 +1,4 @@
-export default class SystemService {
+export default class System {
     _core = {};
     _tmp = {};
     cwd = process.cwd();

package/source/project/index.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader';
+import { System, Configs, Logger, Events, Localizations, Clients, Controller } from '../loader';
 import { Constants, getCore, x, } from '../utils';
 //
 export const core = getCore();
@@ -22,33 +22,33 @@ const coreLoader = async ({}) => {
         }))
             .initialize([
             {
-                service: SystemService,
+                service: System,
                 props: {
                     core
                 }
             },
             {
-                service: ConfigsService,
+                service: Configs,
                 props: {}
             },
             {
-                service: LoggerService,
+                service: Logger,
                 props: {}
             },
             {
-                service: EventsService,
+                service: Events,
                 props: {}
             },
             {
-                service: LocalizationsService,
+                service: Localizations,
                 props: {}
             },
             {
-                service: ControllerService,
+                service: Controller,
                 props: {}
             },
             {
-                service: ClientsService,
+                service: Clients,
                 props: {}
             },
         ]);

package/source/utils/models/classes/class.interfaces.d.ts

@@ -3,5 +3,5 @@ export declare abstract class ILifeCycle<T = any> {
     onAfterInit?(_context?: any): Promise<void> | void;
     onDispose?(_context?: any): Promise<void> | void;
 }
-export declare abstract class IService<T = any> extends ILifeCycle<T> {
+export declare abstract class IProvide<T = any> extends ILifeCycle<T> {
 }

package/source/utils/models/classes/class.interfaces.js

@@ -6,5 +6,5 @@ export class ILifeCycle {
     onDispose(_context) {
     }
 }
-export class IService extends ILifeCycle {
+export class IProvide extends ILifeCycle {
 }

package/source/utils/models/classes/class.services.d.ts

@@ -10,8 +10,8 @@ export declare class ClientStore {
     static set(clientName: string, data: Record<string, any>): void;
 }
 export declare abstract class Client {
-    protected loggerService: any;
-    protected configsService: any;
+    protected logger: any;
+    protected configs: any;
     clientName: string;
     protected baseURL: string;
     protected version: string | null;

package/source/utils/models/classes/class.services.js

@@ -1,6 +1,6 @@
 import { createHash, createHmac } from 'node:crypto';
 import soap from 'soap';
-import { ConfigsService, LoggerService } from '../../../loader';
+import { Configs, Logger } from '../../../loader';
 import { LoggerLayerEnum, x } from '../../index';
 export class ClientStore {
     static _store = {};
@@ -10,13 +10,13 @@ export class ClientStore {
     }
 }
 export class Client {
-    loggerService = x.get(LoggerService);
-    configsService = x.get(ConfigsService);
+    logger = x.get(Logger);
+    configs = x.get(Configs);
     clientName;
     baseURL;
     version = null;
     timeout = 15000;
-    debug = Number(this.configsService.all.debug) >= LoggerLayerEnum.DEBUG;
+    debug = Number(this.configs.all.debug) >= LoggerLayerEnum.DEBUG;
     authConfigs;
     breaker = {
         failures: 0,
@@ -88,13 +88,13 @@ export class BaseApiClient extends Client {
         const activeVersion = options.version !== undefined ? options.version : this.version;
         const ver = activeVersion ? `/${activeVersion.replace(/^\//, '')}` : '';
         const url = `${base}${ver}${path}`;
-        const store = LoggerService.storage.getStore();
+        const store = Logger.storage.getStore();
         const correlationId = store?.get('correlationId');
         const headers = new Headers(options.headers || {});
         headers.set('Content-Type', 'application/json');
         if (correlationId)
             headers.set('x-correlation-id', correlationId);
-        const systemSecret = this.configsService.all.internalSecret || process.env.INTERNAL_SECRET;
+        const systemSecret = this.configs.all.internalSecret || process.env.INTERNAL_SECRET;
         if (systemSecret) {
             const timestamp = Date.now().toString();
             const signature = createHmac('sha256', systemSecret)
@@ -116,7 +116,7 @@ export class BaseApiClient extends Client {
                 headers: Object.fromEntries(headers.entries()),
                 body: options.body
             };
-            this.loggerService.winston.info(`${this.clientName} Request Details: ${JSON.stringify(logPayload, null, 2)}`);
+            this.logger.winston.info(`${this.clientName} Request Details: ${JSON.stringify(logPayload, null, 2)}`);
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -189,7 +189,7 @@ export class SoapClient extends Client {
             return result[0];
         }
         catch (error) {
-            this.loggerService.winston.error(`${this.clientName} SOAP Error: ${error.message}`);
+            this.logger.winston.error(`${this.clientName} SOAP Error: ${error.message}`);
             return null;
         }
     }

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

@@ -88,7 +88,7 @@ export declare enum TokensEnum {
     REFERENCE_TOKEN = "reference_token",
     PERSONAL_ACCESS_TOKEN = "personal_access_token"
 }
-export declare enum CoreServiceEnum {
+export declare enum CoreClientsEnum {
     BASE_API_CLIENT = "base_client_name",
     SOAP_API_CLIENT = "soap_api_client"
 }

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

@@ -104,11 +104,11 @@ export var TokensEnum;
     TokensEnum["REFERENCE_TOKEN"] = "reference_token";
     TokensEnum["PERSONAL_ACCESS_TOKEN"] = "personal_access_token";
 })(TokensEnum || (TokensEnum = {}));
-export var CoreServiceEnum;
-(function (CoreServiceEnum) {
-    CoreServiceEnum["BASE_API_CLIENT"] = "base_client_name";
-    CoreServiceEnum["SOAP_API_CLIENT"] = "soap_api_client";
-})(CoreServiceEnum || (CoreServiceEnum = {}));
+export var CoreClientsEnum;
+(function (CoreClientsEnum) {
+    CoreClientsEnum["BASE_API_CLIENT"] = "base_client_name";
+    CoreClientsEnum["SOAP_API_CLIENT"] = "soap_api_client";
+})(CoreClientsEnum || (CoreClientsEnum = {}));
 export var EndpointResourceEnum;
 (function (EndpointResourceEnum) {
     EndpointResourceEnum["EXAMPLE"] = "example";