@xrystal/core 3.20.3 → 3.20.5

package/package.json

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

package/source/loader/clients/index.d.ts

@@ -1,6 +1,6 @@
 import { IService } from "../../utils";
 import ConfigsService from "../configs";
-export default class ClientsService implements IService {
+export default class ClientsService implements IService<any> {
     #private;
     private _instances;
     constructor({ configsService }: {

package/source/loader/configs/index.d.ts

@@ -30,7 +30,7 @@ export interface IConfig {
 }
 export interface IConfigsService extends IConfig {
 }
-export default class ConfigsService implements IService {
+export default class ConfigsService implements IService<any> {
     #private;
     readonly publicFolderName: string;
     readonly kafkaLogsTopic: string;

package/source/loader/controller/index.d.ts

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { ProtocolEnum } from '../../utils/index';
+import { IService, ProtocolEnum } from '../../utils/index';
 import LoggerService from '../logger';
 import SystemService from '../system';
 export declare const controllerContextStorage: AsyncLocalStorage<{
@@ -63,7 +63,7 @@ declare abstract class Controller {
     protected get req(): CustomRequest;
     protected get res(): CustomResponse;
 }
-export declare abstract class ControllerService extends Controller {
+export declare abstract class ControllerService extends Controller implements IService<any> {
     protected systemService: SystemService;
     constructor({ systemService }: {
         systemService: SystemService;

package/source/loader/events/index.d.ts

@@ -1,6 +1,6 @@
 import { IService } from '../../utils/index';
 import LoggerService from '../logger/index';
-export default class EventsService implements IService {
+export default class EventsService implements IService<any> {
     #private;
     constructor({ loggerService }: {
         loggerService: LoggerService;
@@ -9,5 +9,6 @@ export default class EventsService implements IService {
         logger: LoggerService;
     }) => any;
     private _globalLoader;
+    private _DILoader;
     get global(): any;
 }

package/source/loader/events/index.js

@@ -1,4 +1,4 @@
-import { LoggerLayerEnum } from '../../utils/index';
+import { LoggerLayerEnum, x } from '../../utils/index';
 export default class EventsService {
     #loggerService;
     constructor({ loggerService }) {
@@ -6,25 +6,38 @@ export default class EventsService {
     }
     load = ({}) => {
         this._globalLoader();
+        this._DILoader();
     };
     _globalLoader = () => {
         process.on("uncaughtException", (error, origin) => {
-            this.#loggerService.winston.log({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `UncaughtException: ${error.message}`,
-                stack: error.stack,
-                origin: origin
+            this.#loggerService.log({
+                level: LoggerLayerEnum.CRITICAL,
+                message: `Uncaught Exception: ${error.message}`,
+                payload: {
+                    stack: error.stack,
+                    origin: origin
+                }
             });
         });
         process.on("unhandledRejection", (reason, promise) => {
             const error = reason instanceof Error ? reason : new Error(String(reason));
-            this.#loggerService.winston.log({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `UnhandledRejection: ${error.message}`,
-                stack: error.stack
+            this.#loggerService.log({
+                level: LoggerLayerEnum.CRITICAL,
+                message: `Unhandled Rejection: ${error.message}`,
+                payload: {
+                    stack: error.stack,
+                }
             });
         });
     };
+    _DILoader = () => {
+        process.on('SIGTERM', () => {
+            x.shutdown();
+        });
+        process.on('SIGINT', () => {
+            x.shutdown();
+        });
+    };
     get global() {
         return this._globalLoader();
     }

package/source/loader/localizations/index.d.ts

@@ -1,7 +1,7 @@
 import ConfigsService from "../configs";
 import { IService } from "../../utils";
 import SystemService from "../system";
-export default class LocalizationsService implements IService {
+export default class LocalizationsService implements IService<any> {
     #private;
     _instance: any;
     constructor({ systemService, configsService, }: {

package/source/loader/logger/index.d.ts

@@ -14,7 +14,7 @@ export interface ILog {
     payload?: any;
     code?: string | number;
 }
-export default class LoggerService implements IService {
+export default class LoggerService implements IService<any> {
     #private;
     static readonly storage: AsyncLocalStorage<Map<string, string>>;
     private serviceName;

package/source/loader/system/index.d.ts

@@ -1,5 +1,5 @@
 import { IService } from "../../utils";
-export default class SystemService implements IService {
+export default class SystemService implements IService<any> {
     protected _core: Record<string, any>;
     protected _tmp: Record<string, any>;
     cwd: string;

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

@@ -1,3 +1,6 @@
-export declare class IService {
-    load({}: {}): void;
+export declare abstract class ILifeCycle<T = any> {
+    load(props?: T | {}): Promise<void>;
+    dispose?(_context?: any): Promise<void> | void;
+}
+export declare abstract class IService<T = any> extends ILifeCycle<T> {
 }

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

@@ -1,4 +1,8 @@
-export class IService {
-    load({}) {
+export class ILifeCycle {
+    async load(props = {}) {
     }
+    dispose(_context) {
+    }
+}
+export class IService extends ILifeCycle {
 }

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

@@ -1,5 +1,8 @@
-import { LifetimeType } from 'awilix';
-declare class X<T = {}> {
+import { AwilixContainer, LifetimeType } from 'awilix';
+declare abstract class XHelper {
+    protected checkRegistration(container: AwilixContainer, name: string): boolean;
+}
+declare class X extends XHelper {
     private container;
     private initializedNames;
     constructor();
@@ -19,9 +22,9 @@ declare class X<T = {}> {
         service: any;
         props?: T;
     }[], verbose?: boolean): Promise<this>;
-    private isRegistered;
+    shutdown(verbose?: boolean): Promise<void>;
     get<T>(target: (new (...args: any[]) => T) | string): T;
     get cradle(): any;
 }
-declare const _default: X<{}>;
+declare const _default: X;
 export default _default;

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

@@ -1,10 +1,16 @@
 import { createContainer, asClass, asValue, InjectionMode, listModules, Lifetime } from 'awilix';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-class X {
+class XHelper {
+    checkRegistration(container, name) {
+        return !!container.registrations[name] && container.registrations[name].resolve !== undefined;
+    }
+}
+class X extends XHelper {
     container;
     initializedNames = new Set();
     constructor() {
+        super();
         this.container = createContainer({
             injectionMode: InjectionMode.PROXY,
             strict: true
@@ -58,7 +64,7 @@ class X {
                 if (isClass) {
                     const className = dependency.name;
                     const name = className.charAt(0).toLowerCase() + className.slice(1);
-                    if (!this.isRegistered(name)) {
+                    if (!this.checkRegistration(this.container, name)) {
                         this.container.register({
                             [name]: asClass(dependency).setLifetime(lifetime)
                         });
@@ -76,7 +82,7 @@ class X {
         if (!Dependency?.name)
             return this;
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
-        if (this.isRegistered(name))
+        if (this.checkRegistration(this.container, name))
             return this;
         this.container.register({ [name]: asClass(Dependency).setLifetime(lifetime) });
         return this;
@@ -90,7 +96,7 @@ class X {
         if (!name)
             return this;
         const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
-        if (this.isRegistered(formattedName))
+        if (this.checkRegistration(this.container, formattedName))
             return this;
         this.container.register({ [formattedName]: asValue(instance) });
         return this;
@@ -122,20 +128,44 @@ class X {
                     this.initializedNames.add(key);
                 }
                 catch (err) {
-                    console.error(`[DI] Initialization Failed: ${key} ->`, err.message);
+                    if (verbose)
+                        console.error(`[DI] Initialization Failed: ${key} ->`, err.message);
                 }
             }
         }
         return this;
     }
-    isRegistered(name) {
-        return !!this.container.registrations[name] && this.container.registrations[name].resolve !== undefined;
+    async shutdown(verbose = false) {
+        const registrations = this.container.registrations;
+        for (const key in registrations) {
+            const instance = this.container.cradle[key];
+            const shutdownMethod = instance?.dispose || instance?.destroy;
+            if (instance && typeof shutdownMethod === 'function') {
+                try {
+                    await shutdownMethod.call(instance);
+                    if (verbose)
+                        console.log(`[DI] Shutdown: ${key}`);
+                }
+                catch (err) {
+                    console.error(`[DI] Shutdown Error (${key}):`, err.message);
+                }
+            }
+        }
+        await this.container.dispose();
     }
     get(target) {
-        const resolveName = typeof target === 'function'
-            ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
-            : target;
-        return this.container.resolve(resolveName);
+        try {
+            const resolveName = typeof target === 'function'
+                ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
+                : target;
+            return this.container.resolve(resolveName);
+        }
+        catch (err) {
+            if (err.message.includes('Cyclic dependencies')) {
+                console.error(`\n❌ [DI][CRITICAL] Cyclic dependency detected!\n🔍 Path: ${err.resolutionStack}`);
+            }
+            throw err;
+        }
     }
     get cradle() { return this.container.cradle; }
 }