@xrystal/core 3.16.4 → 3.16.8

package/package.json

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

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

@@ -5,14 +5,24 @@ export declare const controllerContextStorage: AsyncLocalStorage<{
     ctx?: any;
     req?: any;
     res?: any;
-    metadata?: Record<string, any>;
+    metadata?: {
+        locals: Record<string, any>;
+        _code?: number;
+        _contentType?: string;
+        _isRaw?: boolean;
+    };
 }>;
 export declare const getControllerCtx: () => {
     protocol?: ProtocolEnum;
     ctx?: any;
     req?: any;
     res?: any;
-    metadata?: Record<string, any>;
+    metadata?: {
+        locals: Record<string, any>;
+        _code?: number;
+        _contentType?: string;
+        _isRaw?: boolean;
+    };
 };
 export interface CustomRequest {
     accounts?: any;
@@ -22,7 +32,8 @@ export interface CustomRequest {
     body?: any;
     params: Record<string, any>;
     query: Record<string, any>;
-    t?: any;
+    lang: string;
+    t: (k: string, args?: any) => string;
 }
 export interface CustomResponse {
     status: (code: number) => CustomResponse;
@@ -34,20 +45,25 @@ declare abstract class Controller {
     protected loggerService: any;
     protected supportedProtocols: ProtocolEnum[];
     constructor({ loggerService }: any);
+    protected get protocol(): ProtocolEnum;
     protected get currentStore(): {
         protocol?: ProtocolEnum;
         ctx?: any;
         req?: any;
         res?: any;
-        metadata?: Record<string, any>;
+        metadata?: {
+            locals: Record<string, any>;
+            _code?: number;
+            _contentType?: string;
+            _isRaw?: boolean;
+        };
     };
-    protected get protocol(): ProtocolEnum;
     protected get req(): CustomRequest;
     protected get res(): CustomResponse;
-    protected responseProtocolSwitch: ({ res, resStatus, context }: any) => Promise<any>;
     protected parsedQuerys: (url: string) => Record<string, any>;
 }
 export declare abstract class ControllerService extends Controller {
+    constructor({ loggerService }: any);
     load(props?: {
         type?: ProtocolEnum | ProtocolEnum[];
     }): Promise<void>;

package/source/loader/controller/index.js

@@ -9,86 +9,79 @@ class Controller {
     constructor({ loggerService }) {
         this.loggerService = loggerService;
     }
-    get currentStore() { return getControllerCtx(); }
     get protocol() {
-        const incomingProtocol = this.currentStore?.protocol || ProtocolEnum.HTTP;
-        if (!this.supportedProtocols.includes(incomingProtocol)) {
-            throw new Error(`[DI] Protocol ${incomingProtocol} not supported.`);
-        }
-        return incomingProtocol;
+        return this.currentStore?.protocol || ProtocolEnum.HTTP;
+    }
+    get currentStore() {
+        return getControllerCtx();
     }
     get req() {
         const store = this.currentStore;
         const identityT = (k) => k;
         if (!store)
-            return { url: '', method: '', headers: {}, params: {}, query: {}, t: identityT };
+            return { url: '', method: '', headers: {}, params: {}, query: {}, lang: 'en', t: identityT };
         const { ctx, req: nativeReq } = store;
-        const reqSource = nativeReq || ctx?.request || ctx?.data?.request;
+        const source = nativeReq || ctx?.request || ctx;
         return {
-            url: reqSource?.url || '',
-            method: reqSource?.method || 'GET',
-            headers: reqSource?.headers && typeof reqSource.headers.entries === 'function'
-                ? Object.fromEntries(reqSource.headers.entries())
-                : (ctx?.headers || nativeReq?.headers || {}),
-            body: ctx?.body || nativeReq?.body,
-            params: ctx?.params || nativeReq?.params || {},
-            query: ctx?.query || nativeReq?.query || {},
-            accounts: ctx?.user || ctx?.data?.user || nativeReq?.accounts,
-            t: ctx?.t || ctx?.data?.t || nativeReq?.t || identityT
+            url: source?.url || '',
+            method: source?.method || 'GET',
+            headers: source?.headers && typeof source.headers.entries === 'function'
+                ? Object.fromEntries(source.headers.entries())
+                : (source?.headers || {}),
+            body: ctx?.body || nativeReq?.body || source?.body,
+            params: ctx?.params || nativeReq?.params || source?.params || {},
+            query: ctx?.query || nativeReq?.query || source?.query || {},
+            accounts: ctx?.user || nativeReq?.accounts || source?.accounts,
+            lang: ctx?.lang || nativeReq?.lang || 'en',
+            t: ctx?.t || nativeReq?.t || identityT
         };
     }
     get res() {
         const store = this.currentStore;
+        const self = this;
         const fallbackRes = {
             status: function () { return this; },
-            send: (d) => new Response(typeof d === 'string' ? d : JSON.stringify(d), { status: 500, headers: { 'content-type': 'application/json' } }),
+            send: (d) => d instanceof Response ? d : new Response(JSON.stringify(d), { status: 500 }),
             json: function (d) { return this.send(d); },
             locals: {}
         };
         if (!store)
             return fallbackRes;
-        if (store.ctx || store.req) {
-            if (!store.metadata)
-                store.metadata = { locals: {} };
-            const currentProtocol = this.protocol;
-            return {
-                locals: store.metadata.locals,
-                status(code) {
-                    store.metadata._code = code;
-                    return this;
-                },
-                send: (data) => {
-                    if (currentProtocol === ProtocolEnum.WEBSOCKET)
-                        return data;
-                    const isBinary = data instanceof Blob || data instanceof Uint8Array || data instanceof ArrayBuffer;
-                    const isRaw = store.metadata?._isRaw || isBinary;
-                    const contentType = store.metadata?._contentType || (isRaw ? 'application/octet-stream' : 'application/json');
-                    let body;
-                    if (isRaw || typeof data === 'string') {
-                        body = data;
-                    }
-                    else {
-                        const rawData = data?.getResponse ? data.getResponse : data;
-                        body = JSON.stringify(rawData);
-                    }
-                    return new Response(body, {
-                        status: store.metadata?._code || 200,
-                        headers: { 'content-type': contentType }
-                    });
-                },
-                json(data) { return this.send(data); }
-            };
-        }
-        return store.res || fallbackRes;
+        if (!store.metadata)
+            store.metadata = { locals: {} };
+        return {
+            get locals() { return store.metadata.locals; },
+            status(code) {
+                store.metadata._code = code;
+                return this;
+            },
+            send(data) {
+                if (self.protocol === ProtocolEnum.WEBSOCKET)
+                    return data;
+                if (data instanceof Response)
+                    return data;
+                const isBinary = data instanceof Blob || data instanceof Uint8Array || data instanceof ArrayBuffer;
+                const isRaw = store.metadata?._isRaw || isBinary;
+                let contentType = store.metadata?._contentType;
+                if (!contentType) {
+                    contentType = isRaw ? 'application/octet-stream' : 'application/json';
+                }
+                const status = store.metadata?._code || 200;
+                const body = isRaw || typeof data === 'string'
+                    ? data
+                    : JSON.stringify(data?.getResponse ? data.getResponse : data);
+                return new Response(body, {
+                    status,
+                    headers: { 'content-type': contentType }
+                });
+            },
+            json(data) { return this.send(data); }
+        };
     }
-    responseProtocolSwitch = async ({ res, resStatus = 200, context }) => {
-        const responseData = context({ localeLanguageConverter: this.req?.t });
-        return res.status(resStatus).send(responseData);
-    };
     parsedQuerys = (url) => {
         try {
-            const queryString = url.includes('?') ? url.split('?')[1] : '';
-            return queryString ? qs.parse(queryString, { decoder: decodeURIComponent }) : {};
+            const queryPart = url.split('?')[1];
+            return queryPart ? qs.parse(queryPart, { decoder: decodeURIComponent }) : {};
         }
         catch {
             return {};
@@ -96,43 +89,49 @@ class Controller {
     };
 }
 export class ControllerService extends Controller {
+    constructor({ loggerService }) {
+        super({ loggerService });
+    }
     async load(props = {}) {
         if (props.type)
             this.supportedProtocols = Array.isArray(props.type) ? props.type : [props.type];
     }
     async schema({ checks, logic, response }) {
         try {
-            const currentReq = this.req;
-            const currentRes = this.res;
-            if (!currentReq.url)
-                throw new Error("Request URL is missing from context");
-            const payload = { req: currentReq, res: currentRes };
-            const convertedPayload = { ...payload, parsedQuerys: this.parsedQuerys(currentReq.url) };
+            const req = this.req;
+            const res = this.res;
+            const payload = { req, res };
+            const convertedPayload = { ...payload, query: this.parsedQuerys(req.url) };
             if (checks) {
                 const checkResult = await checks({ payload, convertedPayload });
-                if (checkResult?.message) {
-                    return await this.responseProtocolSwitch({ res: currentRes, context: () => new ResponseSchema(checkResult).getResponse });
+                if (checkResult) {
+                    return res.status(checkResult.code || 400).send(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({ res: currentRes, resStatus: 400, context: () => new ResponseSchema(logicResult).getResponse });
-            }
+            if (logicResult instanceof Response)
+                return logicResult;
             if (response) {
                 const resResult = await response({ payload, convertedPayload, logicResult });
                 const successObj = {
                     status: true,
-                    message: Array.isArray(resResult.message) ? responseMessageHelper.successFully(resResult.message[0], resResult.message[1], currentReq.t) : resResult.message,
-                    payload: logicResult?.payload || logicResult
+                    message: Array.isArray(resResult.message)
+                        ? responseMessageHelper.successFully(resResult.message[0], resResult.message[1], req.lang)
+                        : resResult.message,
+                    payload: logicResult?.payload !== undefined ? logicResult.payload : logicResult
                 };
-                return await this.responseProtocolSwitch({ res: currentRes, resStatus: 200, context: () => new ResponseSchema(successObj).getResponse });
+                return res.status(200).send(new ResponseSchema(successObj).getResponse);
             }
-            return currentRes.send(logicResult?.payload !== undefined ? logicResult.payload : logicResult);
+            return res.send(logicResult?.payload !== undefined ? logicResult.payload : logicResult);
         }
         catch (error) {
-            return this.res.status(500).send({ status: false, message: error.message });
+            this.loggerService.error(`Controller Error: ${error.message}`, { stack: error.stack });
+            return this.res.status(500).send({
+                status: false,
+                message: error.message || "Internal Server Error"
+            });
         }
     }
 }