@xrystal/core 3.14.9 → 3.15.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.14.9",
+  "version": "3.15.1",
   "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,13 +15,12 @@ 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;
         if (!store)
             return {};
         if (store.ctx) {
@@ -50,9 +49,9 @@ class Controller {
     }
     get res() {
         const store = this.currentStore;
-        const currentProtocol = this.protocol;
         if (!store)
             return {};
+        const currentProtocol = this.protocol;
         if (store.ctx) {
             return {
                 locals: {},
@@ -61,9 +60,10 @@ class Controller {
                     return this;
                 },
                 send(data) {
+                    const plainData = JSON.parse(JSON.stringify(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' }
                     });
@@ -116,46 +116,37 @@ 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 });
             }
+            return JSON.parse(JSON.stringify(logicResult.payload || logicResult));
         }
         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;
         }
     }
 }