@xrystal/core 3.12.1 → 3.12.2

package/package.json

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

package/source/project/index.js

@@ -16,16 +16,11 @@ const coreLoader = async ({}) => {
     try {
         const { configs } = core._;
         const rootFolderPath = configs.rootFolderPath;
-        const services = [
-            SystemService,
-            ConfigsService,
-            LoggerService,
-            EventsService,
-            LocalizationsService,
-            ClientsService
-        ];
         x
-            .registerServices(services)
+            .load([
+            path.join(__dirname, 'source', 'loader', '**/*.{ts,js}'),
+            path.join(__dirname, 'source', 'utils', '**/class.*.{ts,js}')
+        ])
             .initialize([
             {
                 service: SystemService,

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

@@ -1,17 +1,18 @@
 export declare class X {
     private container;
     constructor();
-    registerService(ServiceClass: any): this;
-    registerServices(services: any[]): this;
+    load(patterns: string | string[]): 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;
 }
 declare const _default: X;

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

@@ -1,4 +1,4 @@
-import { createContainer, asClass, asValue, InjectionMode } from 'awilix';
+import { createContainer, asClass, asValue, InjectionMode, Lifetime } from 'awilix';
 export class X {
     container;
     constructor() {
@@ -7,19 +7,28 @@ 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) {
+        const resolvedPatterns = Array.isArray(patterns) ? patterns : [patterns];
+        this.container.loadModules(resolvedPatterns, {
+            formatName: 'camelCase',
+            resolverOptions: {
+                lifetime: Lifetime.SINGLETON,
+                register: asClass
+            }
         });
         return this;
     }
-    registerServices(services) {
-        services.forEach(ServiceClass => {
-            this.registerService(ServiceClass);
+    register(Dependency) {
+        const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
+        this.container.register({
+            [name]: asClass(Dependency).singleton()
         });
         return this;
     }
+    registerAll(dependencies) {
+        dependencies.forEach(dep => this.register(dep));
+        return this;
+    }
     registerInstance(name, instance) {
         this.container.register({
             [name]: asValue(instance)
@@ -27,19 +36,32 @@ export class X {
         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() {