@xrystal/core 3.15.1 → 3.15.3

package/package.json

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

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

@@ -41,7 +41,7 @@ declare abstract class Controller {
     protected get protocol(): ProtocolEnum;
     protected get req(): CustomRequest;
     protected get res(): CustomResponse;
-    protected responseProtocolSwitch: ({ res, resStatus, context, req }: any) => Promise<any>;
+    protected responseProtocolSwitch: ({ res, resStatus, context }: any) => Promise<any>;
     protected parsedQuerys: (url: string) => Record<string, any>;
 }
 export declare abstract class ControllerService extends Controller {

package/source/loader/controller/index.js

@@ -9,9 +9,7 @@ class Controller {
     constructor({ loggerService }) {
         this.loggerService = loggerService;
     }
-    get currentStore() {
-        return getControllerCtx();
-    }
+    get currentStore() { return getControllerCtx(); }
     get protocol() {
         const incomingProtocol = this.currentStore?.protocol || ProtocolEnum.HTTP;
         if (!this.supportedProtocols.includes(incomingProtocol)) {
@@ -21,46 +19,45 @@ class Controller {
     }
     get req() {
         const store = this.currentStore;
+        const identityT = (k) => k;
         if (!store)
-            return {};
-        if (store.ctx) {
-            const { ctx } = store;
+            return { url: '', method: '', headers: {}, params: {}, query: {}, t: identityT };
+        const { ctx, req } = store;
+        if (ctx) {
+            const request = ctx.request || (ctx.data?.request);
             return {
-                url: ctx.request?.url || '',
-                method: ctx.request?.method || '',
+                url: request?.url || '',
+                method: request?.method || '',
                 headers: ctx.headers || {},
                 body: ctx.body,
                 params: ctx.params || {},
                 query: ctx.query || {},
-                accounts: ctx.user || ctx.accounts,
-                t: ctx.t
+                accounts: ctx.user || ctx.data?.user || ctx.accounts,
+                t: ctx.t || identityT
             };
         }
         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
+            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 || identityT
         };
     }
     get res() {
         const store = this.currentStore;
         if (!store)
-            return {};
-        const currentProtocol = this.protocol;
+            return { status: () => { }, send: () => { }, json: () => { }, locals: {} };
+        const currentProtocol = this.controllerType || ProtocolEnum.HTTP;
         if (store.ctx) {
             return {
                 locals: {},
-                status(code) {
-                    this.locals._code = code;
-                    return this;
-                },
+                status(code) { this.locals._code = code; return this; },
                 send(data) {
-                    const plainData = JSON.parse(JSON.stringify(data));
+                    const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
                     if (currentProtocol === ProtocolEnum.WEBSOCKET)
                         return plainData;
                     return new Response(JSON.stringify(plainData), {
@@ -71,27 +68,10 @@ class Controller {
                 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;
-            }
-        };
+        return store.res;
     }
-    responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
-        const responseData = context({ localeLanguageConverter: req.t });
+    responseProtocolSwitch = async ({ res, resStatus = 200, context }) => {
+        const responseData = context({ localeLanguageConverter: this.req?.t });
         return res.status(resStatus).send(responseData);
     };
     parsedQuerys = (url) => {
@@ -117,7 +97,7 @@ export class ControllerService extends Controller {
                 const checkResult = await checks({ payload, convertedPayload });
                 if (checkResult?.message) {
                     const errorObj = new ResponseSchema(checkResult).getResponse;
-                    return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, context: () => errorObj });
+                    return await this.responseProtocolSwitch({ res: currentRes, context: () => errorObj });
                 }
             }
             const logicResult = await logic({ payload, convertedPayload });
@@ -125,7 +105,7 @@ export class ControllerService extends Controller {
                 return logicResult.response(logicResult.payload);
             if (logicResult.message) {
                 const logicErrorObj = new ResponseSchema(logicResult).getResponse;
-                return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, resStatus: 400, context: () => logicErrorObj });
+                return await this.responseProtocolSwitch({ res: currentRes, resStatus: 400, context: () => logicErrorObj });
             }
             if (response) {
                 const resResult = await response({ payload, convertedPayload, logicResult });
@@ -136,9 +116,10 @@ export class ControllerService extends Controller {
                         : resResult.message,
                     payload: logicResult.payload
                 }).getResponse;
-                return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, resStatus: 200, context: () => successObj });
+                return await this.responseProtocolSwitch({ res: currentRes, resStatus: 200, context: () => successObj });
             }
-            return JSON.parse(JSON.stringify(logicResult.payload || logicResult));
+            const finalPayload = logicResult.payload !== undefined ? logicResult.payload : logicResult;
+            return finalPayload && typeof finalPayload === 'object' ? JSON.parse(JSON.stringify(finalPayload)) : finalPayload;
         }
         catch (error) {
             const errorPayload = { status: false, message: error.message };