@xrystal/core 3.14.1 → 3.14.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.14.1",
+  "version": "3.14.3",
   "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,15 @@
-import { ProtocolEnum } from '../../index';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ProtocolEnum } from '../../utils/index';
+export declare const controllerContextStorage: AsyncLocalStorage<{
+    ctx?: any;
+    req?: any;
+    res?: any;
+}>;
+export declare const getControllerCtx: () => {
+    ctx?: any;
+    req?: any;
+    res?: any;
+};
 export interface CustomRequest {
     accounts?: any;
     url: string;
@@ -17,23 +28,26 @@ 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, }: {
-        protocol: ProtocolEnum;
+    constructor({ loggerService }: any);
+    protected get currentStore(): {
+        ctx?: any;
         req?: any;
         res?: any;
-        ctx?: any;
-    });
+    };
+    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 {
-    schema({ checks, logic, response, }: {
+export declare abstract class ControllerService extends Controller {
+    protected controllerType: ProtocolEnum;
+    load(props?: {
+        type?: ProtocolEnum;
+    }): Promise<void>;
+    schema({ checks, logic, response }: {
         checks?: (args: any) => Promise<any>;
         logic: (args: any) => Promise<any>;
         response?: (args: any) => Promise<any>;
     }): Promise<any>;
 }
-export { Controller };
+export {};

package/source/loader/controller/index.js

@@ -0,0 +1,146 @@
+import qs from 'qs';
+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;
+    constructor({ loggerService }) {
+        this.loggerService = loggerService;
+    }
+    get currentStore() {
+        return getControllerCtx();
+    }
+    get req() {
+        const store = this.currentStore;
+        if (!store)
+            return {};
+        if (store.ctx) {
+            const { ctx } = store;
+            return {
+                url: ctx.request?.url || '',
+                method: ctx.request?.method || '',
+                headers: ctx.headers || {},
+                body: ctx.body,
+                params: ctx.params || {},
+                query: ctx.query || {},
+                accounts: ctx.user || ctx.accounts,
+                t: ctx.t
+            };
+        }
+        return {
+            url: store.req?.originalUrl || store.req?.url || '',
+            method: store.req?.method || 'GET',
+            headers: store.req?.headers || {},
+            body: store.req?.body,
+            params: store.req?.params || {},
+            query: store.req?.query || {},
+            accounts: store.req?.accounts,
+            t: store.req?.t
+        };
+    }
+    get res() {
+        const store = this.currentStore;
+        if (!store)
+            return {};
+        if (store.ctx) {
+            const protocol = this.controllerType || ProtocolEnum.HTTP;
+            return {
+                locals: {},
+                status(code) {
+                    this.locals._code = code;
+                    return this;
+                },
+                send(data) {
+                    if (protocol === ProtocolEnum.WEBSOCKET)
+                        return data;
+                    return new Response(JSON.stringify(data), {
+                        status: this.locals._code || 200,
+                        headers: { 'content-type': 'application/json' }
+                    });
+                },
+                json(data) { return this.send(data); }
+            };
+        }
+        return {
+            locals: store.res?.locals || {},
+            status(code) {
+                if (store.res?.status)
+                    store.res.status(code);
+                return this;
+            },
+            send(data) {
+                if (store.res?.send)
+                    return store.res.send(data);
+                return data;
+            },
+            json(data) {
+                if (store.res?.json)
+                    return store.res.json(data);
+                return data;
+            }
+        };
+    }
+    responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
+        const responseData = context({ localeLanguageConverter: req.t });
+        return res.status(resStatus).send(responseData);
+    };
+    parsedQuerys = (url) => {
+        const queryString = url.includes('?') ? url.split('?')[1] : '';
+        return queryString ? qs.parse(queryString, { decoder: decodeURIComponent }) : {};
+    };
+}
+export class ControllerService extends Controller {
+    controllerType = ProtocolEnum.HTTP;
+    async load(props = {}) {
+        if (props.type)
+            this.controllerType = props.type;
+    }
+    async schema({ checks, logic, response }) {
+        const currentReq = this.req;
+        const currentRes = this.res;
+        if (!currentReq || !currentRes)
+            return;
+        const payload = { req: currentReq, res: currentRes };
+        const convertedPayload = { ...payload, parsedQuerys: this.parsedQuerys(currentReq.url) };
+        try {
+            if (checks) {
+                const checkResult = await checks({ payload, convertedPayload });
+                if (checkResult?.message) {
+                    return await this.responseProtocolSwitch({
+                        req: currentReq,
+                        res: currentRes,
+                        context: () => new ResponseSchema(checkResult).getResponse
+                    });
+                }
+            }
+            const logicResult = await logic({ payload, convertedPayload });
+            if (logicResult.response instanceof Function)
+                return logicResult.response(logicResult.payload);
+            if (logicResult.message) {
+                return await this.responseProtocolSwitch({
+                    req: currentReq,
+                    res: currentRes,
+                    resStatus: 400,
+                    context: () => new ResponseSchema(logicResult).getResponse
+                });
+            }
+            if (response) {
+                const resResult = await response({ payload, convertedPayload });
+                return await this.responseProtocolSwitch({
+                    req: currentReq,
+                    res: currentRes,
+                    resStatus: 200,
+                    context: ({ localeLanguageConverter }) => new ResponseSchema({
+                        status: true,
+                        message: responseMessageHelper.successFully(resResult.message[0], resResult.message[1], localeLanguageConverter),
+                        payload: logicResult.payload
+                    }).getResponse
+                });
+            }
+        }
+        catch (error) {
+            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 { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader/index';
+import { packageName, x, kafkaBrokers, systemLoggerLayer, getTmp, 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,6 @@
 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 './classes/class.response';
 export * from './classes/class.services';
 export * from './classes/class.interfaces';

package/source/utils/models/index.js

@@ -1,7 +1,6 @@
 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 './classes/class.response';
 export * from './classes/class.services';
 export * from './classes/class.interfaces';

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

@@ -1,160 +0,0 @@
-import qs from 'qs';
-import { LoggerService } from '../../../loader';
-import { ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../index';
-class Controller {
-    loggerService = x.get(LoggerService);
-    protocol = null;
-    req = null;
-    res = null;
-    constructor({ protocol, req, res, ctx, }) {
-        this.protocol = protocol;
-        if (ctx) {
-            this.req = {
-                url: ctx.request?.url || '',
-                method: ctx.request?.method || '',
-                headers: ctx.headers || {},
-                body: ctx.body,
-                params: ctx.params || {},
-                query: ctx.query || {},
-                accounts: ctx.user || ctx.accounts,
-                t: ctx.t
-            };
-            this.res = {
-                locals: {},
-                status(code) {
-                    this.locals._code = code;
-                    return this;
-                },
-                send(data) {
-                    if (protocol === ProtocolEnum.WEBSOCKET)
-                        return data;
-                    return new Response(JSON.stringify(data), {
-                        status: this.locals._code || 200,
-                        headers: { 'content-type': 'application/json' }
-                    });
-                },
-                json(data) {
-                    return this.send(data);
-                }
-            };
-        }
-        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;
-                }
-            };
-        }
-    }
-    responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
-        const responseData = context({ localeLanguageConverter: req.t });
-        return res.status(resStatus).send(responseData);
-    };
-    parsedQuerys = (url) => {
-        const queryString = url.includes('?') ? url.split('?')[1] : '';
-        return queryString ? qs.parse(queryString, { decoder: decodeURIComponent }) : {};
-    };
-}
-export class ControllerSchema extends Controller {
-    async schema({ checks, logic, response, }) {
-        if (!this.req || !this.res)
-            return;
-        const payload = { req: this.req, res: this.res };
-        const convertedPayload = {
-            ...payload,
-            parsedQuerys: this.parsedQuerys(this.req.url)
-        };
-        try {
-            if (checks) {
-                const checkResult = await checks({ payload, convertedPayload });
-                let isInvalid = false;
-                if (Array.isArray(checkResult)) {
-                    isInvalid = !checkResult.every(c => c !== undefined && c !== null && c !== "");
-                }
-                else if (typeof checkResult === 'object' && checkResult.message) {
-                    return await this.responseProtocolSwitch({
-                        req: this.req,
-                        res: this.res,
-                        context: () => new ResponseSchema({
-                            status: checkResult.status || false,
-                            message: checkResult.message,
-                            payload: checkResult.payload,
-                            code: checkResult.code
-                        }).getResponse
-                    });
-                }
-                if (isInvalid) {
-                    return await this.responseProtocolSwitch({
-                        req: this.req,
-                        res: this.res,
-                        resStatus: 400,
-                        context: ({ localeLanguageConverter }) => new ResponseSchema({
-                            status: false,
-                            message: responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)
-                        }).getResponse
-                    });
-                }
-            }
-            const logicResult = await logic({ payload, convertedPayload });
-            if (logicResult.response instanceof Function) {
-                return logicResult.response(logicResult.payload);
-            }
-            if (logicResult.message) {
-                return await this.responseProtocolSwitch({
-                    req: this.req,
-                    res: this.res,
-                    resStatus: 400,
-                    context: () => new ResponseSchema({
-                        status: logicResult.status || false,
-                        message: logicResult.message,
-                        payload: logicResult.payload,
-                        code: logicResult.code
-                    }).getResponse
-                });
-            }
-            if (response) {
-                const resResult = await response({ payload, convertedPayload });
-                if (resResult.response instanceof Function) {
-                    return resResult.response(resResult);
-                }
-                return await this.responseProtocolSwitch({
-                    req: this.req,
-                    res: this.res,
-                    resStatus: 200,
-                    context: ({ localeLanguageConverter }) => new ResponseSchema({
-                        status: true,
-                        message: responseMessageHelper.successFully(resResult.message[0], resResult.message[1], localeLanguageConverter),
-                        payload: logicResult.payload
-                    }).getResponse
-                });
-            }
-        }
-        catch (error) {
-            return this.res.status(500).send({ status: false, message: error.message });
-        }
-    }
-}
-export { Controller };