@xrystal/core 3.20.5 → 3.20.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.20.5",
+  "version": "3.20.9",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",
@@ -37,34 +37,27 @@
     "start": "bun --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env source/index.js"
   },
   "dependencies": {
-    "@types/lodash": "^4.17.23",
-    "@types/yaml": "^1.9.7",
+    "lodash": "^4.17.23",
     "awilix": "^12.0.5",
-    "chalk": "^5.6.2",
-    "commander": "^13.0.0",
-    "ejs": "^3.1.9",
+    "yaml": "^2.5.0",
     "handlebars": "^4.7.8",
-    "i": "^0.3.7",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "winston-mongodb": "^7.0.1",
+    "kafkajs": "^2.2.4",
     "i18next": "^25.6.3",
     "i18next-fs-backend": "^2.6.1",
     "i18next-http-middleware": "^3.8.2",
-    "kafkajs": "^2.2.4",
-    "lodash": "^4.17.23",
-    "moment-timezone": "^0.6.0",
-    "npm": "^11.7.0",
     "ora": "^9.0.0",
-    "picocolors": "^1.1.1",
     "qs": "^6.14.1",
     "soap": "^1.6.3",
-    "winston": "^3.19.0",
-    "winston-daily-rotate-file": "^5.0.0",
-    "winston-mongodb": "^7.0.1",
-    "yaml": "^2.5.0"
+    "chalk": "^5.6.2",
+    "commander": "^13.0.0",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@types/minimist": "^1.2.5",
-    "@types/bun": "^1.3.5",
-    "@types/node": "^25.0.6",
-    "typescript": "^5.5.3"
+    "@types/lodash": "^4.17.23",
+    "@types/yaml": "^1.9.7",
+    "@types/bun": "^1.3.5"
   }
 }

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

@@ -19,7 +19,7 @@ export interface IConfig {
     systemLoggerLayer: string;
     isKafkaPassive: boolean;
     kafkaBrokers: string;
-    kafkaTopics: string;
+    kafkaTopics: string[];
     kafkaLogsTopic: string;
     baseApiUri: string;
     port: number;

package/source/loader/configs/index.js

@@ -44,7 +44,7 @@ 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: process.env?.KAFKA_TOPICS,
+            kafkaTopics: [],
             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/logger/index.d.ts

@@ -26,7 +26,7 @@ export default class LoggerService implements IService<any> {
         systemService: SystemService;
         configsService: ConfigsService;
     });
-    load: ({}: {}) => Promise<void>;
+    load: () => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;
         loggerLevel: string;

package/source/loader/logger/index.js

@@ -43,18 +43,18 @@ export default class LoggerService {
     constructor({ systemService, configsService }) {
         this.#systemService = systemService;
         this.#configsService = configsService;
-        this.kafkaLogsTopic = this.#configsService?.all.kafkaLogsTopic;
+        this.serviceName = this.#systemService?.tmp?.configs?.service;
+        this.kafkaLogsTopic = this.#configsService?.all?.kafkaLogsTopic;
+    }
+    load = async () => {
         winston.addColors(customColors);
         this.winston = winston.createLogger({
-            level: this.#configsService.all.systemLoggerLayer || 'info',
+            level: this.#configsService?.all?.systemLoggerLayer || 'info',
             levels: customLevels,
             format: this.getConsoleFormat(),
             transports: [new winston.transports.Console()]
         });
-    }
-    load = async ({}) => {
-        const loggersConfigs = this.#systemService.tmp.configs.loaders.loggers;
-        this.serviceName = this.#systemService.tmp.configs.service;
+        const loggersConfigs = this.#systemService?.tmp?.configs?.loaders?.loggers;
         const { kafkaBrokers, isKafkaPassive } = this.#configsService.all;
         const brokers = kafkaBrokers ? String(kafkaBrokers).split(",").map((b) => b.trim()) : [];
         const isKafkaEnabled = isKafkaPassive === false && brokers.length > 0;
@@ -76,9 +76,11 @@ export default class LoggerService {
                 this.isKafkaReady = false;
             }
         }
+        const logPath = loggersConfigs?.loadPath || "logs";
+        const loggerLevel = loggersConfigs?.loggerLevel || "info";
         this.winstonLoader({
-            loadPath: path.join(this.#configsService.all.rootFolderPath, loggersConfigs?.loadPath),
-            loggerLevel: loggersConfigs?.loggerLevel
+            loadPath: path.join(this.#configsService.all.rootFolderPath, logPath),
+            loggerLevel: loggerLevel
         });
     };
     winstonLoader = ({ loadPath, loggerLevel }) => {

package/source/project/index.js

@@ -16,7 +16,9 @@ const coreLoader = async ({}) => {
         await (await x.load([
             path.join(__dirname, '..', 'loader', '**/*.{ts,js}'),
         ], {
-            exclude: [path.join(__dirname, '..', 'utils', '**/class.x.{ts,js}')]
+            exclude: [
+                path.join(__dirname, '..', 'utils', '**/class.x.{ts,js}'),
+            ]
         }))
             .initialize([
             {

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

@@ -1,19 +1,22 @@
 import { AwilixContainer, LifetimeType } from 'awilix';
+type Constructor<T> = new (...args: any[]) => T;
+type AbstractConstructor<T> = abstract new (...args: any[]) => T;
 declare abstract class XHelper {
     protected checkRegistration(container: AwilixContainer, name: string): boolean;
 }
 declare class X extends XHelper {
     private container;
     private initializedNames;
+    private loadedPaths;
+    private registeredClasses;
+    private isInitializing;
     constructor();
-    private getSource;
     load(patterns: string | string[], options?: {
         verbose?: boolean;
         exclude?: string | Function | (string | Function)[];
         lifetime?: LifetimeType;
     }): Promise<this>;
     register(Dependency: any, lifetime?: LifetimeType): this;
-    registerAll(dependencies: any[], lifetime?: LifetimeType): this;
     registerInstance(name: string, instance: any): this;
     initialize<T = any>(input?: {
         service: any;
@@ -22,8 +25,8 @@ declare class X extends XHelper {
         service: any;
         props?: T;
     }[], verbose?: boolean): Promise<this>;
-    shutdown(verbose?: boolean): Promise<void>;
-    get<T>(target: (new (...args: any[]) => T) | string): T;
+    get<T>(target: Constructor<T> | AbstractConstructor<T> | string): T;
+    shutdown(): Promise<void>;
     get cradle(): any;
 }
 declare const _default: X;

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

@@ -3,12 +3,15 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 class XHelper {
     checkRegistration(container, name) {
-        return !!container.registrations[name] && container.registrations[name].resolve !== undefined;
+        return !!container.registrations[name];
     }
 }
 class X extends XHelper {
     container;
     initializedNames = new Set();
+    loadedPaths = new Set();
+    registeredClasses = new Set();
+    isInitializing = false;
     constructor() {
         super();
         this.container = createContainer({
@@ -16,18 +19,13 @@ class X extends XHelper {
             strict: true
         });
     }
-    getSource(filePath) {
-        const projectRoot = process.cwd().replace(/\\/g, '/');
-        const normalizedPath = filePath.replace(/\\/g, '/');
-        return normalizedPath.includes('node_modules') || !normalizedPath.startsWith(projectRoot) ? 'LIB' : 'APP';
-    }
     async load(patterns, options = {}) {
         const { verbose = false, exclude = [], lifetime = Lifetime.SINGLETON } = options;
         const cwd = process.cwd();
         const excludeList = Array.isArray(exclude) ? exclude : [exclude];
         const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns]).map(p => {
             const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
-            return resolved.replace(/\\/g, '/');
+            return resolved.replace(/\\/g, '/').toLowerCase();
         });
         let modules = [];
         try {
@@ -37,18 +35,10 @@ class X extends XHelper {
             return this;
         }
         for (const m of modules) {
-            const source = this.getSource(m.path);
-            const normalizedMPath = m.path.replace(/\\/g, '/');
-            if (normalizedMPath === __filename.replace(/\\/g, '/') || normalizedMPath.endsWith('.d.ts'))
+            const normalizedMPath = m.path.replace(/\\/g, '/').toLowerCase();
+            if (this.loadedPaths.has(normalizedMPath))
                 continue;
-            const isPathExcluded = excludeList.some(ex => {
-                if (typeof ex === 'string') {
-                    const normalizedEx = ex.replace(/\\/g, '/');
-                    return normalizedMPath.includes(normalizedEx) || m.name === ex;
-                }
-                return false;
-            });
-            if (isPathExcluded)
+            if (normalizedMPath === __filename.replace(/\\/g, '/').toLowerCase() || normalizedMPath.endsWith('.d.ts'))
                 continue;
             try {
                 const fileUrl = pathToFileURL(m.path).href;
@@ -57,116 +47,98 @@ class X extends XHelper {
                 if (!dependency) {
                     dependency = Object.values(loaded).find(val => typeof val === 'function' && !!val.prototype && !!val.name);
                 }
-                const isClassExcluded = excludeList.some(ex => typeof ex === 'function' && dependency === ex);
-                if (isClassExcluded)
-                    continue;
-                const isClass = typeof dependency === 'function' && !!dependency.prototype && !!dependency.name;
-                if (isClass) {
-                    const className = dependency.name;
-                    const name = className.charAt(0).toLowerCase() + className.slice(1);
+                if (typeof dependency === 'function' && !!dependency.prototype && !!dependency.name) {
+                    if (this.registeredClasses.has(dependency))
+                        continue;
+                    const name = dependency.name.charAt(0).toLowerCase() + dependency.name.slice(1);
                     if (!this.checkRegistration(this.container, name)) {
                         this.container.register({
-                            [name]: asClass(dependency).setLifetime(lifetime)
+                            [name]: asClass(dependency).singleton()
                         });
+                        this.loadedPaths.add(normalizedMPath);
+                        this.registeredClasses.add(dependency);
                     }
                 }
             }
             catch (err) {
                 if (verbose)
-                    console.error(`[DI][${source}] Load Error:`, err.message);
+                    console.error(`[DI] Load Error:`, err.message);
             }
         }
         return this;
     }
     register(Dependency, lifetime = Lifetime.SINGLETON) {
-        if (!Dependency?.name)
+        if (!Dependency?.name || this.registeredClasses.has(Dependency))
             return this;
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.checkRegistration(this.container, name))
             return this;
-        this.container.register({ [name]: asClass(Dependency).setLifetime(lifetime) });
-        return this;
-    }
-    registerAll(dependencies, lifetime = Lifetime.SINGLETON) {
-        if (Array.isArray(dependencies))
-            dependencies.forEach(dep => this.register(dep, lifetime));
+        this.container.register({ [name]: asClass(Dependency).singleton() });
+        this.registeredClasses.add(Dependency);
         return this;
     }
     registerInstance(name, instance) {
         if (!name)
             return this;
         const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
-        if (this.checkRegistration(this.container, formattedName))
-            return this;
         this.container.register({ [formattedName]: asValue(instance) });
         return this;
     }
     async initialize(input, verbose = false) {
-        const cradle = this.container.cradle;
-        const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
-        const propsMap = new Map();
-        for (const item of inputList) {
-            if (!item?.service)
-                continue;
-            const name = typeof item.service === 'function' ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1) : item.service;
-            if (name)
-                propsMap.set(name, item.props);
-        }
-        const registrations = this.container.registrations;
-        const allKeys = new Set([...propsMap.keys(), ...Object.keys(registrations)]);
-        for (const key of allKeys) {
-            if (this.initializedNames.has(key))
-                continue;
-            const reg = registrations[key];
-            if (!reg || reg.lifetime !== Lifetime.SINGLETON)
-                continue;
-            const instance = cradle[key];
-            if (instance && typeof instance.load === 'function') {
+        if (this.isInitializing)
+            return this;
+        this.isInitializing = true;
+        try {
+            const cradle = this.container.cradle;
+            const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
+            const propsMap = new Map();
+            for (const item of inputList) {
+                if (!item?.service)
+                    continue;
+                const name = typeof item.service === 'function' ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1) : item.service;
+                if (name)
+                    propsMap.set(name, item.props);
+            }
+            const keys = Object.keys(this.container.registrations);
+            for (const key of keys) {
+                if (this.initializedNames.has(key))
+                    continue;
+                const reg = this.container.registrations[key];
+                if (reg.lifetime !== Lifetime.SINGLETON)
+                    continue;
                 try {
-                    const props = propsMap.get(key) || {};
-                    await instance.load(props);
+                    const instance = cradle[key];
+                    if (instance && typeof instance.load === 'function') {
+                        const props = propsMap.get(key) || {};
+                        await instance.load(props);
+                    }
                     this.initializedNames.add(key);
                 }
                 catch (err) {
                     if (verbose)
-                        console.error(`[DI] Initialization Failed: ${key} ->`, err.message);
+                        console.error(`[DI] Init Failed (${key}):`, err.message);
                 }
             }
         }
-        return this;
-    }
-    async shutdown(verbose = false) {
-        const registrations = this.container.registrations;
-        for (const key in registrations) {
-            const instance = this.container.cradle[key];
-            const shutdownMethod = instance?.dispose || instance?.destroy;
-            if (instance && typeof shutdownMethod === 'function') {
-                try {
-                    await shutdownMethod.call(instance);
-                    if (verbose)
-                        console.log(`[DI] Shutdown: ${key}`);
-                }
-                catch (err) {
-                    console.error(`[DI] Shutdown Error (${key}):`, err.message);
-                }
-            }
+        finally {
+            this.isInitializing = false;
         }
-        await this.container.dispose();
+        return this;
     }
     get(target) {
-        try {
-            const resolveName = typeof target === 'function'
-                ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
-                : target;
-            return this.container.resolve(resolveName);
-        }
-        catch (err) {
-            if (err.message.includes('Cyclic dependencies')) {
-                console.error(`\n❌ [DI][CRITICAL] Cyclic dependency detected!\n🔍 Path: ${err.resolutionStack}`);
-            }
-            throw err;
-        }
+        const resolveName = typeof target === 'function'
+            ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
+            : target;
+        return this.container.resolve(resolveName);
+    }
+    async shutdown() {
+        await this.container.dispose();
     }
     get cradle() { return this.container.cradle; }
 }
-export default new X();
+const X_SYMBOL = Symbol.for('X');
+const globalObj = global;
+if (!globalObj[X_SYMBOL]) {
+    globalObj[X_SYMBOL] = new X();
+}
+export default globalObj[X_SYMBOL];