@xrystal/core 3.14.9 → 3.15.2

package/package.json

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

package/source/loader/controller/index.js

@@ -5,7 +5,7 @@ export const controllerContextStorage = new AsyncLocalStorage();
 export const getControllerCtx = () => controllerContextStorage.getStore();
 class Controller {
     loggerService;
-    supportedProtocols = [ProtocolEnum.HTTP];
+    supportedProtocols = [ProtocolEnum.HTTP, ProtocolEnum.WEBSOCKET];
     constructor({ loggerService }) {
         this.loggerService = loggerService;
     }
@@ -15,15 +15,15 @@ class Controller {
     get protocol() {
         const incomingProtocol = this.currentStore?.protocol || ProtocolEnum.HTTP;
         if (!this.supportedProtocols.includes(incomingProtocol)) {
-            throw new Error(`[DI] Protocol ${incomingProtocol} is not supported by ${this.constructor.name}. Supported: ${this.supportedProtocols.join(', ')}`);
+            throw new Error(`[DI] Protocol ${incomingProtocol} not supported. Supported: ${this.supportedProtocols.join(', ')}`);
         }
         return incomingProtocol;
     }
     get req() {
         const store = this.currentStore;
-        const currentProtocol = this.protocol;
+        const defaultT = (k) => k;
         if (!store)
-            return {};
+            return { url: '', method: '', headers: {}, params: {}, query: {}, t: defaultT };
         if (store.ctx) {
             const { ctx } = store;
             return {
@@ -34,25 +34,26 @@ class Controller {
                 params: ctx.params || {},
                 query: ctx.query || {},
                 accounts: ctx.user || ctx.accounts,
-                t: ctx.t
+                t: ctx.t || defaultT
             };
         }
+        const { req } = store;
         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 || defaultT
         };
     }
     get res() {
         const store = this.currentStore;
-        const currentProtocol = this.protocol;
         if (!store)
-            return {};
+            return { status: () => { }, send: () => { }, json: () => { }, locals: {} };
+        const currentProtocol = this.protocol;
         if (store.ctx) {
             return {
                 locals: {},
@@ -61,9 +62,10 @@ class Controller {
                     return this;
                 },
                 send(data) {
+                    const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
                     if (currentProtocol === ProtocolEnum.WEBSOCKET)
-                        return data;
-                    return new Response(JSON.stringify(data), {
+                        return plainData;
+                    return new Response(JSON.stringify(plainData), {
                         status: this.locals._code || 200,
                         headers: { 'content-type': 'application/json' }
                     });
@@ -71,27 +73,30 @@ class Controller {
                 json(data) { return this.send(data); }
             };
         }
+        const { res } = store;
         return {
-            locals: store.res?.locals || {},
+            locals: res?.locals || {},
             status(code) {
-                if (store.res?.status)
-                    store.res.status(code);
+                if (res?.status)
+                    res.status(code);
                 return this;
             },
             send(data) {
-                if (store.res?.send)
-                    return store.res.send(data);
-                return data;
+                const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
+                if (res?.send)
+                    return res.send(plainData);
+                return plainData;
             },
             json(data) {
-                if (store.res?.json)
-                    return store.res.json(data);
-                return data;
+                const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
+                if (res?.json)
+                    return res.json(plainData);
+                return plainData;
             }
         };
     }
     responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
-        const responseData = context({ localeLanguageConverter: req.t });
+        const responseData = context({ localeLanguageConverter: req?.t });
         return res.status(resStatus).send(responseData);
     };
     parsedQuerys = (url) => {
@@ -116,46 +121,38 @@ export class ControllerService extends Controller {
             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 errorObj = new ResponseSchema(checkResult).getResponse;
+                    return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, context: () => errorObj });
                 }
             }
             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
-                });
+                const logicErrorObj = new ResponseSchema(logicResult).getResponse;
+                return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, resStatus: 400, context: () => logicErrorObj });
             }
             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
-                });
+                const resResult = await response({ payload, convertedPayload, logicResult });
+                const successObj = new ResponseSchema({
+                    status: true,
+                    message: Array.isArray(resResult.message)
+                        ? responseMessageHelper.successFully(resResult.message[0], resResult.message[1], currentReq.t)
+                        : resResult.message,
+                    payload: logicResult.payload
+                }).getResponse;
+                return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, resStatus: 200, context: () => successObj });
             }
+            const finalPayload = logicResult.payload !== undefined ? logicResult.payload : logicResult;
+            return finalPayload && typeof finalPayload === 'object' ? JSON.parse(JSON.stringify(finalPayload)) : finalPayload;
         }
         catch (error) {
-            const currentRes = this.currentStore?.res || this.currentStore?.ctx?.set;
-            if (currentRes) {
-                return typeof currentRes.status === 'function'
-                    ? currentRes.status(500).send({ status: false, message: error.message })
-                    : { status: false, message: error.message };
+            const errorPayload = { status: false, message: error.message };
+            const storeRes = this.currentStore?.res || this.currentStore?.ctx?.set;
+            if (storeRes && typeof storeRes.status === 'function') {
+                return storeRes.status(500).send(errorPayload);
             }
-            return { status: false, message: error.message };
+            return errorPayload;
         }
     }
 }