@xrystal/core 3.20.9 → 3.21.1

package/package.json

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

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

@@ -26,26 +26,9 @@ export declare const getControllerCtx: () => {
         _isRaw?: boolean;
     };
 };
-export declare const protocol: (callback: () => Promise<any>, protocol?: ProtocolEnum) => Promise<any>;
-export interface CustomRequest {
-    accounts?: any;
-    url: string;
-    method: string;
-    headers: Record<string, any>;
-    body?: any;
-    params: Record<string, any>;
-    query: Record<string, any>;
-    lang: string;
-    t: (k: string, args?: any) => string;
-}
-export interface CustomResponse {
-    status: (code: number) => CustomResponse;
-    send: (data: any) => any;
-    json: (data: any) => any;
-    locals: Record<string, any>;
-}
-declare abstract class Controller {
+export declare abstract class Controller {
     protected logger: LoggerService;
+    protected systemService: SystemService;
     protected supportedProtocols: ProtocolEnum[];
     protected get protocol(): ProtocolEnum;
     protected get currentStore(): {
@@ -64,9 +47,9 @@ declare abstract class Controller {
     protected get res(): CustomResponse;
 }
 export declare abstract class ControllerService extends Controller implements IService<any> {
-    protected systemService: SystemService;
-    constructor({ systemService }: {
+    constructor({ systemService, loggerService }: {
         systemService: SystemService;
+        loggerService: LoggerService;
     });
     load(): Promise<void>;
     schema({ checks, logic, response }: {
@@ -75,4 +58,20 @@ export declare abstract class ControllerService extends Controller implements IS
         response?: (args: any) => Promise<any>;
     }): Promise<any>;
 }
-export { Controller };
+export interface CustomRequest {
+    accounts?: any;
+    url: string;
+    method: string;
+    headers: Record<string, any>;
+    body?: any;
+    params: Record<string, any>;
+    query: Record<string, any>;
+    lang: string;
+    t: (k: string, args?: any) => string;
+}
+export interface CustomResponse {
+    status: (code: number) => CustomResponse;
+    send: (data: any) => any;
+    json: (data: any) => any;
+    locals: Record<string, any>;
+}

package/source/loader/controller/index.js

@@ -1,17 +1,10 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../utils/index';
-import LoggerService from '../logger';
+import { LoggerLayerEnum, ProtocolEnum, responseMessageHelper, ResponseSchema } from '../../utils/index';
 export const controllerContextStorage = new AsyncLocalStorage();
 export const getControllerCtx = () => controllerContextStorage.getStore();
-export const protocol = async (callback, protocol = ProtocolEnum.HTTP) => {
-    const store = controllerContextStorage.getStore();
-    if (store) {
-        store.protocol = protocol;
-    }
-    return await callback();
-};
-class Controller {
-    logger = x.get(LoggerService);
+export class Controller {
+    logger;
+    systemService;
     supportedProtocols = [ProtocolEnum.HTTP, ProtocolEnum.WEBSOCKET];
     get protocol() {
         return this.currentStore?.protocol || ProtocolEnum.HTTP;
@@ -79,14 +72,14 @@ class Controller {
     }
 }
 export class ControllerService extends Controller {
-    systemService;
-    constructor({ systemService }) {
+    constructor({ systemService, loggerService }) {
         super();
         this.systemService = systemService;
+        this.logger = loggerService;
     }
     async load() {
-        const protocols = this.systemService.tmp.configs.loaders.controller.protocols;
-        this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols];
+        const protocols = this.systemService?.tmp?.configs?.loaders?.controller?.protocols;
+        this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols || ProtocolEnum.HTTP];
     }
     async schema({ checks, logic, response }) {
         try {
@@ -153,10 +146,7 @@ export class ControllerService extends Controller {
             }).getResponse);
         }
         catch (error) {
-            this.logger.winston.log({
-                level: 'error',
-                message: `Controller Error: ${error.message}`
-            });
+            this.logger?.log(LoggerLayerEnum.ERROR, `Controller Error: ${error.message}`);
             return this.res.status(500).send(new ResponseSchema({
                 status: false,
                 message: error.message,
@@ -165,4 +155,3 @@ export class ControllerService extends Controller {
         }
     }
 }
-export { Controller };

package/source/loader/logger/index.js

@@ -43,10 +43,10 @@ export default class LoggerService {
     constructor({ systemService, configsService }) {
         this.#systemService = systemService;
         this.#configsService = configsService;
-        this.serviceName = this.#systemService?.tmp?.configs?.service;
-        this.kafkaLogsTopic = this.#configsService?.all?.kafkaLogsTopic;
     }
     load = async () => {
+        this.serviceName = this.#systemService?.tmp?.configs?.service;
+        this.kafkaLogsTopic = this.#configsService?.all?.kafkaLogsTopic;
         winston.addColors(customColors);
         this.winston = winston.createLogger({
             level: this.#configsService?.all?.systemLoggerLayer || 'info',

package/source/loader/system/index.js

@@ -7,8 +7,8 @@ export default class SystemService {
     load = async ({ core }) => {
         this._core = core;
         this._tmp = this._core._;
-        await this.initializeKafkaInfrastructure();
         await this._systemLoader({});
+        await this.initializeKafkaInfrastructure();
     };
     initializeKafkaInfrastructure = async () => {
         const { kafkaBrokers, kafkaTopics, isKafkaPassive, serviceName } = {

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

@@ -1,5 +1,6 @@
 export declare abstract class ILifeCycle<T = any> {
     load(props?: T | {}): Promise<void>;
+    ready?(_context?: any): Promise<void> | 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,6 +1,8 @@
 export class ILifeCycle {
     async load(props = {}) {
     }
+    ready(_context) {
+    }
     dispose(_context) {
     }
 }

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

@@ -1,16 +1,18 @@
 import { AwilixContainer, LifetimeType } from 'awilix';
+export declare const xSymbol: unique symbol;
 type Constructor<T> = new (...args: any[]) => T;
 type AbstractConstructor<T> = abstract new (...args: any[]) => T;
-declare abstract class XHelper {
+declare abstract class X {
     protected checkRegistration(container: AwilixContainer, name: string): boolean;
 }
-declare class X extends XHelper {
+declare class DIM extends X {
     private container;
     private initializedNames;
     private loadedPaths;
     private registeredClasses;
     private isInitializing;
     constructor();
+    private getName;
     load(patterns: string | string[], options?: {
         verbose?: boolean;
         exclude?: string | Function | (string | Function)[];
@@ -29,5 +31,5 @@ declare class X extends XHelper {
     shutdown(): Promise<void>;
     get cradle(): any;
 }
-declare const _default: X;
+declare const _default: DIM;
 export default _default;

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

@@ -1,12 +1,13 @@
 import { createContainer, asClass, asValue, InjectionMode, listModules, Lifetime } from 'awilix';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-class XHelper {
+export const xSymbol = Symbol.for('@xrystal/core/di-container');
+class X {
     checkRegistration(container, name) {
         return !!container.registrations[name];
     }
 }
-class X extends XHelper {
+class DIM extends X {
     container;
     initializedNames = new Set();
     loadedPaths = new Set();
@@ -19,10 +20,16 @@ class X extends XHelper {
             strict: true
         });
     }
+    getName(target) {
+        if (typeof target === 'string')
+            return target.charAt(0).toLowerCase() + target.slice(1);
+        if (typeof target === 'function' && target.name)
+            return target.name.charAt(0).toLowerCase() + target.name.slice(1);
+        return '';
+    }
     async load(patterns, options = {}) {
         const { verbose = false, exclude = [], lifetime = Lifetime.SINGLETON } = options;
         const cwd = process.cwd();
-        const excludeList = Array.isArray(exclude) ? exclude : [exclude];
         const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns]).map(p => {
             const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
             return resolved.replace(/\\/g, '/').toLowerCase();
@@ -50,10 +57,10 @@ class X extends XHelper {
                 if (typeof dependency === 'function' && !!dependency.prototype && !!dependency.name) {
                     if (this.registeredClasses.has(dependency))
                         continue;
-                    const name = dependency.name.charAt(0).toLowerCase() + dependency.name.slice(1);
-                    if (!this.checkRegistration(this.container, name)) {
+                    const name = this.getName(dependency);
+                    if (name && !this.checkRegistration(this.container, name)) {
                         this.container.register({
-                            [name]: asClass(dependency).singleton()
+                            [name]: asClass(dependency).setLifetime(lifetime)
                         });
                         this.loadedPaths.add(normalizedMPath);
                         this.registeredClasses.add(dependency);
@@ -68,19 +75,19 @@ class X extends XHelper {
         return this;
     }
     register(Dependency, lifetime = Lifetime.SINGLETON) {
-        if (!Dependency?.name || this.registeredClasses.has(Dependency))
+        const name = this.getName(Dependency);
+        if (!name || this.registeredClasses.has(Dependency))
             return this;
-        const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.checkRegistration(this.container, name))
             return this;
-        this.container.register({ [name]: asClass(Dependency).singleton() });
+        this.container.register({ [name]: asClass(Dependency).setLifetime(lifetime) });
         this.registeredClasses.add(Dependency);
         return this;
     }
     registerInstance(name, instance) {
         if (!name)
             return this;
-        const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
+        const formattedName = this.getName(name);
         this.container.register({ [formattedName]: asValue(instance) });
         return this;
     }
@@ -89,34 +96,55 @@ class X extends XHelper {
             return this;
         this.isInitializing = true;
         try {
-            const cradle = this.container.cradle;
             const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
-            const propsMap = new Map();
             for (const item of inputList) {
-                if (!item?.service)
+                const name = this.getName(item.service);
+                if (!name || this.initializedNames.has(name))
+                    continue;
+                const reg = this.container.registrations[name];
+                if (!reg || reg.lifetime !== Lifetime.SINGLETON)
                     continue;
-                const name = typeof item.service === 'function' ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1) : item.service;
-                if (name)
-                    propsMap.set(name, item.props);
+                try {
+                    const instance = this.container.cradle[name];
+                    if (instance && typeof instance.load === 'function') {
+                        await instance.load(item.props || {});
+                    }
+                    this.initializedNames.add(name);
+                }
+                catch (err) {
+                    if (verbose)
+                        console.error(`[DI] Priority Init Failed (${name}):`, err.message);
+                }
             }
-            const keys = Object.keys(this.container.registrations);
-            for (const key of keys) {
+            const allKeys = Object.keys(this.container.registrations);
+            for (const key of allKeys) {
                 if (this.initializedNames.has(key))
                     continue;
                 const reg = this.container.registrations[key];
                 if (reg.lifetime !== Lifetime.SINGLETON)
                     continue;
                 try {
-                    const instance = cradle[key];
+                    const instance = this.container.cradle[key];
                     if (instance && typeof instance.load === 'function') {
-                        const props = propsMap.get(key) || {};
-                        await instance.load(props);
+                        await instance.load({});
                     }
                     this.initializedNames.add(key);
                 }
                 catch (err) {
                     if (verbose)
-                        console.error(`[DI] Init Failed (${key}):`, err.message);
+                        console.error(`[DI] Auto Init Failed (${key}):`, err.message);
+                }
+            }
+            for (const name of this.initializedNames) {
+                try {
+                    const instance = this.container.cradle[name];
+                    if (instance && typeof instance.ready === 'function') {
+                        await instance.afterInit();
+                    }
+                }
+                catch (err) {
+                    if (verbose)
+                        console.error(`[DI] afterInit Hook Failed (${name}):`, err.message);
                 }
             }
         }
@@ -126,9 +154,7 @@ class X extends XHelper {
         return this;
     }
     get(target) {
-        const resolveName = typeof target === 'function'
-            ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
-            : target;
+        const resolveName = this.getName(target);
         return this.container.resolve(resolveName);
     }
     async shutdown() {
@@ -136,9 +162,7 @@ class X extends XHelper {
     }
     get cradle() { return this.container.cradle; }
 }
-const X_SYMBOL = Symbol.for('X');
-const globalObj = global;
-if (!globalObj[X_SYMBOL]) {
-    globalObj[X_SYMBOL] = new X();
+if (!global[xSymbol]) {
+    global[xSymbol] = new DIM();
 }
-export default globalObj[X_SYMBOL];
+export default global[xSymbol];