@xrystal/core 3.13.3 → 3.13.5

package/package.json

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

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

@@ -9,16 +9,25 @@ export class X {
         });
     }
     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,76 +39,91 @@ export class X {
                 if (isClass) {
                     const className = dependency.name;
                     const name = className.charAt(0).toLowerCase() + className.slice(1);
-                    if (!this.container.registrations[name]) {
-                        this.container.register({
-                            [name]: asClass(dependency).singleton()
-                        });
+                    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));
         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;
-        this.container.register({
-            [name]: asClass(Dependency).singleton()
-        });
+        this.container.register({ [name]: asClass(Dependency).singleton() });
         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;
-        this.container.register({
-            [name]: asValue(instance)
-        });
+        const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
+        this.container.register({ [formattedName]: asValue(instance) });
         return this;
     }
-    async initialize(input, verbose = true) {
+    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 initializedNames = new Set();
+        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;
-            propsMap.set(name, item.props);
-        });
+            const instance = cradle[name];
+            if (instance && typeof instance.load === 'function') {
+                try {
+                    await instance.load(item.props || {});
+                    initializedNames.add(name);
+                    if (verbose)
+                        console.log(`[DI] Initialized (Priority): ${name}`);
+                }
+                catch (err) {
+                    console.error(`[DI] Critical: Priority service "${name}" failed:`, err.message);
+                }
+            }
+        }
         for (const key of Object.keys(this.container.registrations)) {
+            if (initializedNames.has(key))
+                continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
-                const props = propsMap.get(key) || {};
-                await instance.load(props);
-                initializedNames.push(key);
+                try {
+                    await instance.load({});
+                    initializedNames.add(key);
+                    if (verbose)
+                        console.log(`[DI] Initialized (Auto): ${key}`);
+                }
+                catch (err) {
+                    console.error(`[DI] Critical: Auto service "${key}" failed:`, err.message);
+                }
             }
         }
-        if (verbose && initializedNames.length > 0)
-            console.log('[DI] Initialized Services:', initializedNames);
         return this;
     }
     get(target) {
+        if (!target)
+            throw new Error('[DI] Target is required');
         const resolveName = typeof target === 'function'
             ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
             : target;
         return this.container.resolve(resolveName);
     }
-    get cradle() {
-        return this.container.cradle;
-    }
-    isRegistered(name) {
-        return !!this.container.registrations[name];
-    }
+    get cradle() { return this.container.cradle; }
+    isRegistered(name) { return !!this.container.registrations[name]; }
 }
 export default new X();