@xrystal/core 3.13.2 → 3.13.4

package/package.json

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

package/source/loader/logger/index.js

@@ -70,8 +70,8 @@ export default class LoggerService {
             connectKafka();
         }
         this.winstonLoader({
-            loadPath: config?.loadPath || "./logs",
-            loggerLevel: config?.loggerLevel || "debug"
+            loadPath: config?.loadPath,
+            loggerLevel: config?.loggerLevel
         });
     };
     safeReplacer = (key, value) => {

package/source/project/index.js

@@ -50,7 +50,7 @@ const coreLoader = async ({}) => {
             {
                 service: LocalizationsService,
                 props: {
-                    loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
+                    loadPath: path.join(rootFolderPath, configs.loaders.localization.loadPath),
                     fallbackLang: configs.loaders.localization.fallbackLang,
                     preloadLang: configs.loaders.localization.preloadLangs
                 }

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

@@ -11,7 +11,7 @@ export declare class X {
     } | {
         service: any;
         props?: any;
-    }[]): Promise<this>;
+    }[], verbose?: boolean): Promise<this>;
     get<T>(target: string | any): T;
     get cradle(): any;
     private isRegistered;

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

@@ -8,17 +8,26 @@ export class X {
             strict: true
         });
     }
-    load(patterns, verbose = true) {
+    load(patterns, verbose = false) {
+        if (!patterns || (Array.isArray(patterns) && patterns.length === 0))
+            return this;
         const cwd = process.cwd();
-        const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns]).map(p => {
+        const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns])
+            .filter(p => typeof p === 'string')
+            .map(p => {
             const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
             return resolved.replace(/\\/g, '/');
         });
-        const modules = listModules(resolvedPatterns);
+        let modules = [];
+        try {
+            modules = listModules(resolvedPatterns);
+        }
+        catch (err) {
+            console.error(`[DI] Critical: Path resolution failed: ${err.message}`);
+            return this;
+        }
         for (const m of modules) {
-            if (m.path.endsWith('.d.ts') ||
-                m.path.endsWith('.map') ||
-                m.path === __filename)
+            if (m.path === __filename || m.path.endsWith('.d.ts') || m.path.endsWith('.map'))
                 continue;
             try {
                 const loaded = require(m.path);
@@ -30,22 +39,26 @@ export class X {
                 if (isClass) {
                     const className = dependency.name;
                     const name = className.charAt(0).toLowerCase() + className.slice(1);
-                    if (!this.container.registrations[name]) {
+                    if (!this.isRegistered(name)) {
                         this.container.register({
                             [name]: asClass(dependency).singleton()
                         });
+                        if (verbose)
+                            console.log(`[DI] Registered: ${name}`);
                     }
                 }
             }
             catch (err) {
-                continue;
+                console.error(`[DI] Critical: Failed to load module at ${m.path}:`, err.message);
             }
         }
         if (verbose)
-            console.log('[DI] Registered Keys:', Object.keys(this.container.registrations));
+            console.log('[DI] Load completed. Total registrations:', Object.keys(this.container.registrations).length);
         return this;
     }
     register(Dependency) {
+        if (!Dependency?.name)
+            return this;
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.isRegistered(name))
             return this;
@@ -55,41 +68,54 @@ export class X {
         return this;
     }
     registerAll(dependencies) {
+        if (!Array.isArray(dependencies))
+            return this;
         dependencies.forEach(dep => this.register(dep));
         return this;
     }
     registerInstance(name, instance) {
-        if (this.isRegistered(name))
+        if (!name || this.isRegistered(name))
             return this;
+        const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
         this.container.register({
-            [name]: asValue(instance)
+            [formattedName]: asValue(instance)
         });
         return this;
     }
-    async initialize(input) {
+    async initialize(input, verbose = false) {
         const cradle = this.container.cradle;
         const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
         const propsMap = new Map();
+        const initializedNames = [];
         inputList.forEach(item => {
-            const name = typeof item.service === 'function'
-                ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1)
-                : item.service;
-            propsMap.set(name, item.props);
+            if (item?.service) {
+                const name = typeof item.service === 'function'
+                    ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1)
+                    : item.service;
+                propsMap.set(name, item.props);
+            }
         });
-        for (const key of Object.keys(cradle)) {
+        for (const key of Object.keys(this.container.registrations)) {
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
-                if (propsMap.has(key)) {
-                    await instance.load(propsMap.get(key));
+                try {
+                    const props = propsMap.get(key) || {};
+                    await instance.load(props);
+                    initializedNames.push(key);
                 }
-                else {
-                    await instance.load();
+                catch (err) {
+                    console.error(`[DI] Critical: Service "${key}" failed to initialize:`, err.message);
                 }
             }
         }
+        if (verbose && initializedNames.length > 0) {
+            console.log('[DI] Successfully initialized:', initializedNames);
+        }
         return this;
     }
     get(target) {
+        if (!target)
+            throw new Error('[DI] Target is required for resolution');
         const resolveName = typeof target === 'function'
             ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
             : target;