@xrystal/core 3.14.1 → 3.14.2

package/package.json

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

package/source/{utils/models/classes/class.controller.d.ts → loader/controller/index.d.ts}

@@ -1,4 +1,17 @@
-import { ProtocolEnum } from '../../index';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ProtocolEnum } from '../../utils/index';
+export declare const controllerContextStorage: AsyncLocalStorage<{
+    protocol: ProtocolEnum;
+    ctx?: any;
+    req?: any;
+    res?: any;
+}>;
+export declare const getControllerCtx: () => {
+    protocol: ProtocolEnum;
+    ctx?: any;
+    req?: any;
+    res?: any;
+};
 export interface CustomRequest {
     accounts?: any;
     url: string;
@@ -17,19 +30,24 @@ export interface CustomResponse {
 }
 declare abstract class Controller {
     protected loggerService: any;
-    protected protocol: ProtocolEnum | null;
-    protected req: CustomRequest | null;
-    protected res: CustomResponse | null;
-    constructor({ protocol, req, res, ctx, }: {
+    constructor({ loggerService }: any);
+    protected get currentStore(): {
         protocol: ProtocolEnum;
+        ctx?: any;
         req?: any;
         res?: any;
-        ctx?: any;
-    });
+    };
+    protected get protocol(): ProtocolEnum;
+    protected get req(): CustomRequest;
+    protected get res(): CustomResponse;
     protected responseProtocolSwitch: ({ res, resStatus, context, req }: any) => Promise<any>;
     protected parsedQuerys: (url: string) => Record<string, any>;
 }
-export declare class ControllerSchema extends Controller {
+export declare abstract class ControllerService extends Controller {
+    protected controllerType: string;
+    load({ type }: {
+        type?: string;
+    }): Promise<void>;
     schema({ checks, logic, response, }: {
         checks?: (args: any) => Promise<any>;
         logic: (args: any) => Promise<any>;

package/source/{utils/models/classes/class.controller.js → loader/controller/index.js}

@@ -1,15 +1,26 @@
 import qs from 'qs';
-import { LoggerService } from '../../../loader';
-import { ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../index';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ProtocolEnum, responseMessageHelper, ResponseSchema } from '../../utils/index';
+export const controllerContextStorage = new AsyncLocalStorage();
+export const getControllerCtx = () => controllerContextStorage.getStore();
 class Controller {
-    loggerService = x.get(LoggerService);
-    protocol = null;
-    req = null;
-    res = null;
-    constructor({ protocol, req, res, ctx, }) {
-        this.protocol = protocol;
-        if (ctx) {
-            this.req = {
+    loggerService;
+    constructor({ loggerService }) {
+        this.loggerService = loggerService;
+    }
+    get currentStore() {
+        return getControllerCtx();
+    }
+    get protocol() {
+        return this.currentStore?.protocol || ProtocolEnum.HTTP;
+    }
+    get req() {
+        const store = this.currentStore;
+        if (!store)
+            return { url: '', method: '', headers: {}, params: {}, query: {} };
+        if (store.ctx) {
+            const { ctx } = store;
+            return {
                 url: ctx.request?.url || '',
                 method: ctx.request?.method || '',
                 headers: ctx.headers || {},
@@ -19,7 +30,26 @@ class Controller {
                 accounts: ctx.user || ctx.accounts,
                 t: ctx.t
             };
-            this.res = {
+        }
+        const { req } = store;
+        return {
+            url: req?.originalUrl || req?.url || '',
+            method: req?.method || 'GET',
+            headers: req?.headers || {},
+            body: req?.body,
+            params: req?.params || {},
+            query: req?.query || {},
+            accounts: req?.accounts,
+            t: req?.t
+        };
+    }
+    get res() {
+        const store = this.currentStore;
+        const protocol = this.protocol;
+        if (!store)
+            return { status: () => { }, send: () => { }, json: () => { }, locals: {} };
+        if (store.ctx) {
+            return {
                 locals: {},
                 status(code) {
                     this.locals._code = code;
@@ -38,36 +68,25 @@ class Controller {
                 }
             };
         }
-        else {
-            this.req = {
-                url: req?.originalUrl || req?.url || '',
-                method: req?.method || 'GET',
-                headers: req?.headers || {},
-                body: req?.body,
-                params: req?.params || {},
-                query: req?.query || {},
-                accounts: req?.accounts,
-                t: req?.t
-            };
-            this.res = {
-                locals: res?.locals || {},
-                status(code) {
-                    if (res?.status)
-                        res.status(code);
-                    return this;
-                },
-                send(data) {
-                    if (res?.send)
-                        return res.send(data);
-                    return data;
-                },
-                json(data) {
-                    if (res?.json)
-                        return res.json(data);
-                    return data;
-                }
-            };
-        }
+        const { res } = store;
+        return {
+            locals: res?.locals || {},
+            status(code) {
+                if (res?.status)
+                    res.status(code);
+                return this;
+            },
+            send(data) {
+                if (res?.send)
+                    return res.send(data);
+                return data;
+            },
+            json(data) {
+                if (res?.json)
+                    return res.json(data);
+                return data;
+            }
+        };
     }
     responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
         const responseData = context({ localeLanguageConverter: req.t });
@@ -78,14 +97,21 @@ class Controller {
         return queryString ? qs.parse(queryString, { decoder: decodeURIComponent }) : {};
     };
 }
-export class ControllerSchema extends Controller {
+export class ControllerService extends Controller {
+    controllerType = 'default';
+    async load({ type }) {
+        if (type)
+            this.controllerType = type;
+    }
     async schema({ checks, logic, response, }) {
-        if (!this.req || !this.res)
+        const currentReq = this.req;
+        const currentRes = this.res;
+        if (!currentReq || !currentRes)
             return;
-        const payload = { req: this.req, res: this.res };
+        const payload = { req: currentReq, res: currentRes };
         const convertedPayload = {
             ...payload,
-            parsedQuerys: this.parsedQuerys(this.req.url)
+            parsedQuerys: this.parsedQuerys(currentReq.url)
         };
         try {
             if (checks) {
@@ -96,8 +122,8 @@ export class ControllerSchema extends Controller {
                 }
                 else if (typeof checkResult === 'object' && checkResult.message) {
                     return await this.responseProtocolSwitch({
-                        req: this.req,
-                        res: this.res,
+                        req: currentReq,
+                        res: currentRes,
                         context: () => new ResponseSchema({
                             status: checkResult.status || false,
                             message: checkResult.message,
@@ -108,8 +134,8 @@ export class ControllerSchema extends Controller {
                 }
                 if (isInvalid) {
                     return await this.responseProtocolSwitch({
-                        req: this.req,
-                        res: this.res,
+                        req: currentReq,
+                        res: currentRes,
                         resStatus: 400,
                         context: ({ localeLanguageConverter }) => new ResponseSchema({
                             status: false,
@@ -124,8 +150,8 @@ export class ControllerSchema extends Controller {
             }
             if (logicResult.message) {
                 return await this.responseProtocolSwitch({
-                    req: this.req,
-                    res: this.res,
+                    req: currentReq,
+                    res: currentRes,
                     resStatus: 400,
                     context: () => new ResponseSchema({
                         status: logicResult.status || false,
@@ -141,8 +167,8 @@ export class ControllerSchema extends Controller {
                     return resResult.response(resResult);
                 }
                 return await this.responseProtocolSwitch({
-                    req: this.req,
-                    res: this.res,
+                    req: currentReq,
+                    res: currentRes,
                     resStatus: 200,
                     context: ({ localeLanguageConverter }) => new ResponseSchema({
                         status: true,
@@ -153,7 +179,7 @@ export class ControllerSchema extends Controller {
             }
         }
         catch (error) {
-            return this.res.status(500).send({ status: false, message: error.message });
+            return currentRes.status(500).send({ status: false, message: error.message });
         }
     }
 }

package/source/loader/index.d.ts

@@ -3,5 +3,6 @@ import ConfigsService from "./configs";
 import LoggerService from "./logger";
 import EventsService from "./events";
 import LocalizationsService from "./localizations";
+import { ControllerService } from "./controller";
 import ClientsService from "./clients";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService };
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ControllerService, ClientsService };

package/source/loader/index.js

@@ -3,5 +3,6 @@ import ConfigsService from "./configs";
 import LoggerService from "./logger";
 import EventsService from "./events";
 import LocalizationsService from "./localizations";
+import { ControllerService } from "./controller";
 import ClientsService from "./clients";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService };
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ControllerService, ClientsService };

package/source/project/index.js

@@ -1,7 +1,7 @@
 // => import dependencies
 import path from 'path';
 import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService } from '../loader/index';
-import { packageName, x, kafkaBrokers, systemLoggerLayer, getTmp, } from '../utils/index';
+import { packageName, x, kafkaBrokers, systemLoggerLayer, getTmp, ControllerService, ProtocolEnum, } from '../utils/index';
 //
 let coreHasRun = false;
 export const core = getTmp();
@@ -59,6 +59,12 @@ const coreLoader = async ({}) => {
                     preloadLang: configs.loaders.localization.preloadLangs
                 }
             },
+            {
+                service: ControllerService,
+                props: {
+                    type: ProtocolEnum.HTTP
+                }
+            },
             {
                 service: ClientsService,
                 props: {}

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

@@ -1,3 +1,4 @@
+import { AwilixContainer, LifetimeType } from 'awilix';
 export declare class X {
     private container;
     private initializedNames;
@@ -6,9 +7,10 @@ export declare class X {
     load(patterns: string | string[], options?: {
         verbose?: boolean;
         exclude?: string | Function | (string | Function)[];
+        lifetime?: LifetimeType;
     }): this;
-    register(Dependency: any): this;
-    registerAll(dependencies: any[]): this;
+    register(Dependency: any, lifetime?: LifetimeType): this;
+    registerAll(dependencies: any[], lifetime?: LifetimeType): this;
     registerInstance(name: string, instance: any): this;
     initialize(input?: {
         service: any;
@@ -18,8 +20,10 @@ export declare class X {
         props?: any;
     }[], verbose?: boolean): Promise<this>;
     get<T>(target: string | any): T;
+    createScope(): AwilixContainer<any>;
     get cradle(): any;
     private isRegistered;
+    private getSourceByInstance;
 }
 declare const _default: X;
 export default _default;

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

@@ -1,4 +1,4 @@
-import { createContainer, asClass, asValue, InjectionMode, listModules } from 'awilix';
+import { createContainer, asClass, asValue, InjectionMode, listModules, Lifetime } from 'awilix';
 import path from 'node:path';
 export class X {
     container;
@@ -15,7 +15,7 @@ export class X {
         return normalizedPath.includes('node_modules') || !normalizedPath.startsWith(projectRoot) ? 'LIB' : 'APP';
     }
     load(patterns, options = {}) {
-        const { verbose = false, exclude = [] } = 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 => {
@@ -41,12 +41,10 @@ export class X {
                     dependency = Object.values(loaded).find(val => typeof val === 'function' && !!val.prototype && !!val.name);
                 }
                 const isExcluded = excludeList.some(ex => {
-                    if (typeof ex === 'string') {
+                    if (typeof ex === 'string')
                         return m.path.includes(ex) || m.name === ex;
-                    }
-                    if (typeof ex === 'function') {
+                    if (typeof ex === 'function')
                         return dependency === ex;
-                    }
                     return false;
                 });
                 if (isExcluded) {
@@ -59,9 +57,11 @@ export class X {
                     const className = dependency.name;
                     const name = className.charAt(0).toLowerCase() + className.slice(1);
                     if (!this.isRegistered(name)) {
-                        this.container.register({ [name]: asClass(dependency).singleton() });
+                        this.container.register({
+                            [name]: asClass(dependency).setLifetime(lifetime)
+                        });
                         if (verbose)
-                            console.log(`[DI][${source}] Registered: ${name}`);
+                            console.log(`[DI][${source}] Registered (${lifetime}): ${name}`);
                     }
                 }
             }
@@ -71,18 +71,20 @@ export class X {
         }
         return this;
     }
-    register(Dependency) {
+    register(Dependency, lifetime = Lifetime.SINGLETON) {
         if (!Dependency?.name)
             return this;
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.isRegistered(name))
             return this;
-        this.container.register({ [name]: asClass(Dependency).singleton() });
+        this.container.register({
+            [name]: asClass(Dependency).setLifetime(lifetime)
+        });
         return this;
     }
-    registerAll(dependencies) {
+    registerAll(dependencies, lifetime = Lifetime.SINGLETON) {
         if (Array.isArray(dependencies))
-            dependencies.forEach(dep => this.register(dep));
+            dependencies.forEach(dep => this.register(dep, lifetime));
         return this;
     }
     registerInstance(name, instance) {
@@ -105,14 +107,17 @@ export class X {
             if (name)
                 propsMap.set(name, item.props);
         }
-        const registrationKeys = Object.keys(this.container.registrations);
-        const allKeys = new Set([...propsMap.keys(), ...registrationKeys]);
+        const registrations = this.container.registrations;
+        const allKeys = new Set([...propsMap.keys(), ...Object.keys(registrations)]);
         for (const key of allKeys) {
             if (this.initializedNames.has(key))
                 continue;
+            const reg = registrations[key];
+            if (!reg || reg.lifetime !== Lifetime.SINGLETON)
+                continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
-                const source = instance.constructor && instance.constructor.name ? 'APP' : 'LIB';
+                const source = this.getSourceByInstance(instance);
                 try {
                     const props = propsMap.get(key) || {};
                     await instance.load(props);
@@ -136,15 +141,21 @@ export class X {
         }
         catch (err) {
             if (err.message.includes('Cyclic dependencies')) {
-                console.error('\n❌ [DI] addiction detected!');
-                console.error(`🔍 Hata Yolu: ${err.resolutionStack}`);
+                console.error('\n❌ [DI][CRITICAL] Cyclic dependency detected!');
+                console.error(`🔍 Resolution Path: ${err.resolutionStack}`);
             }
             throw err;
         }
     }
+    createScope() {
+        return this.container.createScope();
+    }
     get cradle() { return this.container.cradle; }
     isRegistered(name) {
         return !!this.container.registrations[name] && this.container.registrations[name].resolve !== undefined;
     }
+    getSourceByInstance(instance) {
+        return instance.constructor?.name?.includes('Service') || instance.constructor?.name?.includes('Controller') ? 'APP' : 'LIB';
+    }
 }
 export default new X();

package/source/utils/models/index.d.ts

@@ -1,7 +1,7 @@
 import x, { X } from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
-export * from './classes/class.controller';
+export * from '../../loader/controller';
 export * from './classes/class.response';
 export * from './classes/class.services';
 export * from './classes/class.interfaces';

package/source/utils/models/index.js

@@ -1,7 +1,7 @@
 import x, { X } from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
-export * from './classes/class.controller';
+export * from '../../loader/controller';
 export * from './classes/class.response';
 export * from './classes/class.services';
 export * from './classes/class.interfaces';