@xrystal/core 3.14.2 → 3.14.4

package/package.json

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

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

@@ -1,13 +1,11 @@
 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;
@@ -32,26 +30,24 @@ declare abstract class Controller {
     protected loggerService: any;
     constructor({ loggerService }: any);
     protected get currentStore(): {
-        protocol: ProtocolEnum;
         ctx?: any;
         req?: any;
         res?: 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 abstract class ControllerService extends Controller {
-    protected controllerType: string;
-    load({ type }: {
-        type?: string;
+    protected controllerType: ProtocolEnum;
+    load(props?: {
+        type?: ProtocolEnum;
     }): Promise<void>;
-    schema({ checks, logic, response, }: {
+    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

@@ -11,13 +11,10 @@ class Controller {
     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: {} };
+            return {};
         if (store.ctx) {
             const { ctx } = store;
             return {
@@ -31,24 +28,23 @@ class Controller {
                 t: ctx.t
             };
         }
-        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
+            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;
-        const protocol = this.protocol;
         if (!store)
-            return { status: () => { }, send: () => { }, json: () => { }, locals: {} };
+            return {};
         if (store.ctx) {
+            const protocol = this.controllerType || ProtocolEnum.HTTP;
             return {
                 locals: {},
                 status(code) {
@@ -63,27 +59,24 @@ class Controller {
                         headers: { 'content-type': 'application/json' }
                     });
                 },
-                json(data) {
-                    return this.send(data);
-                }
+                json(data) { return this.send(data); }
             };
         }
-        const { res } = store;
         return {
-            locals: res?.locals || {},
+            locals: store.res?.locals || {},
             status(code) {
-                if (res?.status)
-                    res.status(code);
+                if (store.res?.status)
+                    store.res.status(code);
                 return this;
             },
             send(data) {
-                if (res?.send)
-                    return res.send(data);
+                if (store.res?.send)
+                    return store.res.send(data);
                 return data;
             },
             json(data) {
-                if (res?.json)
-                    return res.json(data);
+                if (store.res?.json)
+                    return store.res.json(data);
                 return data;
             }
         };
@@ -98,74 +91,42 @@ class Controller {
     };
 }
 export class ControllerService extends Controller {
-    controllerType = 'default';
-    async load({ type }) {
-        if (type)
-            this.controllerType = type;
+    controllerType = ProtocolEnum.HTTP;
+    async load(props = {}) {
+        if (props.type)
+            this.controllerType = props.type;
     }
-    async schema({ checks, logic, response, }) {
+    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)
-        };
+        const convertedPayload = { ...payload, parsedQuerys: this.parsedQuerys(currentReq.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: currentReq,
-                        res: currentRes,
-                        context: () => new ResponseSchema({
-                            status: checkResult.status || false,
-                            message: checkResult.message,
-                            payload: checkResult.payload,
-                            code: checkResult.code
-                        }).getResponse
-                    });
-                }
-                if (isInvalid) {
+                if (checkResult?.message) {
                     return await this.responseProtocolSwitch({
                         req: currentReq,
                         res: currentRes,
-                        resStatus: 400,
-                        context: ({ localeLanguageConverter }) => new ResponseSchema({
-                            status: false,
-                            message: responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)
-                        }).getResponse
+                        context: () => new ResponseSchema(checkResult).getResponse
                     });
                 }
             }
             const logicResult = await logic({ payload, convertedPayload });
-            if (logicResult.response instanceof Function) {
+            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({
-                        status: logicResult.status || false,
-                        message: logicResult.message,
-                        payload: logicResult.payload,
-                        code: logicResult.code
-                    }).getResponse
+                    context: () => new ResponseSchema(logicResult).getResponse
                 });
             }
             if (response) {
                 const resResult = await response({ payload, convertedPayload });
-                if (resResult.response instanceof Function) {
-                    return resResult.response(resResult);
-                }
                 return await this.responseProtocolSwitch({
                     req: currentReq,
                     res: currentRes,
@@ -183,4 +144,3 @@ export class ControllerService extends Controller {
         }
     }
 }
-export { Controller };

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, ControllerService, ProtocolEnum, } 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();
@@ -16,14 +16,11 @@ const coreLoader = async ({}) => {
     try {
         const { configs } = core._;
         const rootFolderPath = configs.rootFolderPath;
-        x
-            .load([
+        await (await x.load([
             path.join(__dirname, '..', 'loader', '**/*.{ts,js}'),
         ], {
-            exclude: [
-                path.join(__dirname, '..', 'utils', '**/class.x.{ts,js}'),
-            ]
-        })
+            exclude: [path.join(__dirname, '..', 'utils', '**/class.x.{ts,js}')]
+        }))
             .initialize([
             {
                 service: SystemService,

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

@@ -1,4 +1,4 @@
-import { AwilixContainer, LifetimeType } from 'awilix';
+import { LifetimeType } from 'awilix';
 export declare class X {
     private container;
     private initializedNames;
@@ -6,9 +6,9 @@ export declare class X {
     private getSource;
     load(patterns: string | string[], options?: {
         verbose?: boolean;
-        exclude?: string | Function | (string | Function)[];
+        exclude?: (string | Function)[];
         lifetime?: LifetimeType;
-    }): this;
+    }): Promise<this>;
     register(Dependency: any, lifetime?: LifetimeType): this;
     registerAll(dependencies: any[], lifetime?: LifetimeType): this;
     registerInstance(name: string, instance: any): this;
@@ -20,10 +20,8 @@ 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

@@ -14,7 +14,8 @@ export class X {
         const normalizedPath = filePath.replace(/\\/g, '/');
         return normalizedPath.includes('node_modules') || !normalizedPath.startsWith(projectRoot) ? 'LIB' : 'APP';
     }
-    load(patterns, options = {}) {
+    // 1. ASYNC YAPTIK (await import desteği için)
+    async load(patterns, options = {}) {
         const { verbose = false, exclude = [], lifetime = Lifetime.SINGLETON } = options;
         const cwd = process.cwd();
         const excludeList = Array.isArray(exclude) ? exclude : [exclude];
@@ -32,26 +33,33 @@ export class X {
         }
         for (const m of modules) {
             const source = this.getSource(m.path);
-            if (m.path === __filename || m.path.endsWith('.d.ts') || m.path.endsWith('.map'))
+            const normalizedMPath = m.path.replace(/\\/g, '/');
+            if (normalizedMPath === __filename.replace(/\\/g, '/') || normalizedMPath.endsWith('.d.ts'))
                 continue;
+            // --- KRİTİK DÜZELTME 1: DOSYAYI YÜKLEMEDEN ÖNCE EXCLUDE KONTROLÜ ---
+            const isPathExcluded = excludeList.some(ex => {
+                if (typeof ex === 'string') {
+                    const normalizedEx = ex.replace(/\\/g, '/');
+                    return normalizedMPath.includes(normalizedEx) || m.name === ex;
+                }
+                return false;
+            });
+            if (isPathExcluded) {
+                if (verbose)
+                    console.log(`[DI][${source}] Pre-load Excluded: ${m.name}`);
+                continue;
+            }
             try {
-                const loaded = require(m.path);
+                // --- KRİTİK DÜZELTME 2: REQUIRE YERİNE IMPORT (Async Module Hatası İçin) ---
+                const loaded = await import(m.path);
                 let dependency = loaded.default;
                 if (!dependency) {
                     dependency = Object.values(loaded).find(val => typeof val === 'function' && !!val.prototype && !!val.name);
                 }
-                const isExcluded = excludeList.some(ex => {
-                    if (typeof ex === 'string')
-                        return m.path.includes(ex) || m.name === ex;
-                    if (typeof ex === 'function')
-                        return dependency === ex;
-                    return false;
-                });
-                if (isExcluded) {
-                    if (verbose)
-                        console.log(`[DI][${source}] Excluded: ${m.name}`);
+                // Class referansı üzerinden exclude (Eğer class yüklendiyse)
+                const isClassExcluded = excludeList.some(ex => typeof ex === 'function' && dependency === ex);
+                if (isClassExcluded)
                     continue;
-                }
                 const isClass = typeof dependency === 'function' && !!dependency.prototype && !!dependency.name;
                 if (isClass) {
                     const className = dependency.name;
@@ -61,25 +69,26 @@ export class X {
                             [name]: asClass(dependency).setLifetime(lifetime)
                         });
                         if (verbose)
-                            console.log(`[DI][${source}] Registered (${lifetime}): ${name}`);
+                            console.log(`[DI][${source}] Registered: ${name}`);
                     }
                 }
             }
             catch (err) {
-                console.error(`[DI][${source}] Load Error in ${m.name}:`, err.message);
+                // Burada hata alıyorsan dosya bozuktur veya import edilemiyordur
+                if (verbose)
+                    console.error(`[DI][${source}] Load Error in ${m.name}:`, err.message);
             }
         }
         return this;
     }
+    // ... (register, initialize, get metodları aynı kalıyor)
     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).setLifetime(lifetime)
-        });
+        this.container.register({ [name]: asClass(Dependency).setLifetime(lifetime) });
         return this;
     }
     registerAll(dependencies, lifetime = Lifetime.SINGLETON) {
@@ -117,16 +126,15 @@ export class X {
                 continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
-                const source = this.getSourceByInstance(instance);
                 try {
                     const props = propsMap.get(key) || {};
                     await instance.load(props);
                     this.initializedNames.add(key);
                     if (verbose)
-                        console.log(`[DI][${source}] Initialized: ${key}`);
+                        console.log(`[DI] Initialized: ${key}`);
                 }
                 catch (err) {
-                    console.error(`[DI][${source}] Initialization Failed: ${key} ->`, err.message);
+                    console.error(`[DI] Initialization Failed: ${key} ->`, err.message);
                 }
             }
         }
@@ -134,28 +142,19 @@ export class X {
     }
     get(target) {
         try {
-            const resolveName = typeof target === 'function'
-                ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
-                : target;
+            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!');
-                console.error(`🔍 Resolution Path: ${err.resolutionStack}`);
+                console.error(`\n❌ [DI][CRITICAL] Cyclic dependency detected!\n🔍 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 '../../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,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 '../../loader/controller';
 export * from './classes/class.response';
 export * from './classes/class.services';
 export * from './classes/class.interfaces';