@xrystal/core 3.12.1 → 3.12.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.12.1",
+  "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,21 +11,16 @@ export const coreInit = async (params) => {
         globalThis.__LOCAL_MESSAGES__ = locales;
 };
 const coreLoader = async ({}) => {
+    const cwd = process.cwd();
     if (coreHasRun)
         return {};
     try {
         const { configs } = core._;
         const rootFolderPath = configs.rootFolderPath;
-        const services = [
-            SystemService,
-            ConfigsService,
-            LoggerService,
-            EventsService,
-            LocalizationsService,
-            ClientsService
-        ];
         x
-            .registerServices(services)
+            .load([
+            path.join(cwd, 'source', 'loader', '**/*.{ts,js}'),
+        ])
             .initialize([
             {
                 service: SystemService,

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

@@ -1,18 +1,20 @@
 export declare class X {
     private container;
     constructor();
-    registerService(ServiceClass: any): this;
-    registerServices(services: any[]): this;
+    load(patterns: string | string[], verbose?: boolean): this;
+    register(Dependency: any): this;
+    registerAll(dependencies: any[]): this;
     registerInstance(name: string, instance: any): this;
-    initialize(input: {
+    initialize(input?: {
         service: any;
         props?: any;
     } | {
         service: any;
         props?: any;
     }[]): Promise<this>;
-    get<T>(name: string | any): T;
+    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 } from 'awilix';
+import { createContainer, asClass, asValue, InjectionMode, listModules } from 'awilix';
+import path from 'node:path';
 export class X {
     container;
     constructor() {
@@ -7,43 +8,96 @@ export class X {
             strict: true
         });
     }
-    registerService(ServiceClass) {
-        const name = ServiceClass.name.charAt(0).toLowerCase() + ServiceClass.name.slice(1);
-        this.container.register({
-            [name]: asClass(ServiceClass).singleton()
+    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;
     }
-    registerServices(services) {
-        services.forEach(ServiceClass => {
-            this.registerService(ServiceClass);
+    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()
         });
         return this;
     }
+    registerAll(dependencies) {
+        dependencies.forEach(dep => this.register(dep));
+        return this;
+    }
     registerInstance(name, instance) {
+        if (this.isRegistered(name))
+            return this;
         this.container.register({
             [name]: asValue(instance)
         });
         return this;
     }
     async initialize(input) {
-        const items = Array.isArray(input) ? input : [input];
-        for (const item of items) {
-            const instance = this.get(item.service);
+        const cradle = this.container.cradle;
+        const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
+        const propsMap = new Map();
+        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);
+        });
+        for (const key of Object.keys(cradle)) {
+            const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
-                await instance.load(item.props);
+                if (propsMap.has(key)) {
+                    await instance.load(propsMap.get(key));
+                }
+                else {
+                    await instance.load();
+                }
             }
         }
         return this;
     }
-    get(name) {
-        const resolveName = typeof name === 'function'
-            ? name.name.charAt(0).toLowerCase() + name.name.slice(1)
-            : name;
+    get(target) {
+        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];
+    }
 }
 export default new X();