@xrystal/core 3.12.2 → 3.12.3

package/package.json

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

package/source/loader/configs/index.js

@@ -20,6 +20,7 @@ export default class ConfigsService {
             baseApiUri: process.env.HTTPS === 'true' ? process.env.SYSTEM_HTTPS_BASE_API_URI : process.env.SYSTEM_BASE_API_URI,
             internalSecret: process.env.INTERNAL_SECRET,
             secret: process.env.SECRET,
+            cwd: process.cwd(),
             env: process.env.NODE_ENV,
             ...rawConfigs
         };

package/source/project/index.js

@@ -11,6 +11,7 @@ export const coreInit = async (params) => {
         globalThis.__LOCAL_MESSAGES__ = locales;
 };
 const coreLoader = async ({}) => {
+    const cwd = process.cwd();
     if (coreHasRun)
         return {};
     try {
@@ -18,8 +19,7 @@ const coreLoader = async ({}) => {
         const rootFolderPath = configs.rootFolderPath;
         x
             .load([
-            path.join(__dirname, 'source', 'loader', '**/*.{ts,js}'),
-            path.join(__dirname, 'source', 'utils', '**/class.*.{ts,js}')
+            path.join(cwd, 'source', 'loader', '**/*.{ts,js}'),
         ])
             .initialize([
             {

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

@@ -1,7 +1,7 @@
 export declare class X {
     private container;
     constructor();
-    load(patterns: string | string[]): this;
+    load(patterns: string | string[], verbose?: boolean): this;
     register(Dependency: any): this;
     registerAll(dependencies: any[]): this;
     registerInstance(name: string, instance: any): this;
@@ -14,6 +14,7 @@ export declare class X {
     }[]): Promise<this>;
     get<T>(target: string | any): T;
     get cradle(): any;
+    private isRegistered;
 }
 declare const _default: X;
 export default _default;

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

@@ -1,4 +1,5 @@
-import { createContainer, asClass, asValue, InjectionMode, Lifetime } from 'awilix';
+import { createContainer, asClass, asValue, InjectionMode, listModules } from 'awilix';
+import path from 'node:path';
 export class X {
     container;
     constructor() {
@@ -7,19 +8,45 @@ export class X {
             strict: true
         });
     }
-    load(patterns) {
-        const resolvedPatterns = Array.isArray(patterns) ? patterns : [patterns];
-        this.container.loadModules(resolvedPatterns, {
-            formatName: 'camelCase',
-            resolverOptions: {
-                lifetime: Lifetime.SINGLETON,
-                register: asClass
-            }
+    load(patterns, verbose = false) {
+        const cwd = process.cwd();
+        const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns]).map(p => {
+            const resolved = path.isAbsolute(p) ? p : path.join(cwd, p);
+            return resolved.replace(/\\/g, '/');
         });
+        const modules = listModules(resolvedPatterns);
+        for (const m of modules) {
+            if (m.path === __filename || m.path.includes('.d.ts'))
+                continue;
+            try {
+                const loaded = require(m.path);
+                let dependency = loaded.default;
+                if (!dependency) {
+                    dependency = Object.values(loaded).find(val => typeof val === 'function' && !!val.prototype && !!val.name);
+                }
+                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 (!this.container.registrations[name]) {
+                        this.container.register({
+                            [name]: asClass(dependency).singleton()
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                continue;
+            }
+        }
+        if (verbose)
+            console.log('[DI] Registered Keys:', Object.keys(this.container.registrations));
         return this;
     }
     register(Dependency) {
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
+        if (this.isRegistered(name))
+            return this;
         this.container.register({
             [name]: asClass(Dependency).singleton()
         });
@@ -30,6 +57,8 @@ export class X {
         return this;
     }
     registerInstance(name, instance) {
+        if (this.isRegistered(name))
+            return this;
         this.container.register({
             [name]: asValue(instance)
         });
@@ -67,5 +96,8 @@ export class X {
     get cradle() {
         return this.container.cradle;
     }
+    isRegistered(name) {
+        return !!this.container.registrations[name];
+    }
 }
 export default new X();