@xrystal/core 3.14.8 → 3.15.1

package/package.json

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

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

@@ -1,11 +1,13 @@
 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;
@@ -28,21 +30,23 @@ export interface CustomResponse {
 }
 declare abstract class Controller {
     protected loggerService: any;
+    protected supportedProtocols: ProtocolEnum[];
     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: ProtocolEnum;
     load(props?: {
-        type?: ProtocolEnum;
+        type?: ProtocolEnum | ProtocolEnum[];
     }): Promise<void>;
     schema({ checks, logic, response }: {
         checks?: (args: any) => Promise<any>;
@@ -50,4 +54,4 @@ export declare abstract class ControllerService extends Controller {
         response?: (args: any) => Promise<any>;
     }): Promise<any>;
 }
-export {};
+export { Controller };

package/source/loader/controller/index.js

@@ -5,12 +5,20 @@ export const controllerContextStorage = new AsyncLocalStorage();
 export const getControllerCtx = () => controllerContextStorage.getStore();
 class Controller {
     loggerService;
+    supportedProtocols = [ProtocolEnum.HTTP, ProtocolEnum.WEBSOCKET];
     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. Supported: ${this.supportedProtocols.join(', ')}`);
+        }
+        return incomingProtocol;
+    }
     get req() {
         const store = this.currentStore;
         if (!store)
@@ -43,8 +51,8 @@ class Controller {
         const store = this.currentStore;
         if (!store)
             return {};
+        const currentProtocol = this.protocol;
         if (store.ctx) {
-            const protocol = this.controllerType || ProtocolEnum.HTTP;
             return {
                 locals: {},
                 status(code) {
@@ -52,9 +60,10 @@ class Controller {
                     return this;
                 },
                 send(data) {
-                    if (protocol === ProtocolEnum.WEBSOCKET)
-                        return data;
-                    return new Response(JSON.stringify(data), {
+                    const plainData = JSON.parse(JSON.stringify(data));
+                    if (currentProtocol === ProtocolEnum.WEBSOCKET)
+                        return plainData;
+                    return new Response(JSON.stringify(plainData), {
                         status: this.locals._code || 200,
                         headers: { 'content-type': 'application/json' }
                     });
@@ -91,56 +100,54 @@ class Controller {
     };
 }
 export class ControllerService extends Controller {
-    controllerType = ProtocolEnum.HTTP;
     async load(props = {}) {
-        if (props.type)
-            this.controllerType = props.type;
+        if (props.type) {
+            this.supportedProtocols = Array.isArray(props.type) ? props.type : [props.type];
+        }
     }
     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) };
         try {
+            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) };
             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) {
-            return currentRes.status(500).send({ 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 errorPayload;
         }
     }
 }
+export { Controller };

package/source/project/index.js

@@ -59,7 +59,7 @@ const coreLoader = async ({}) => {
             {
                 service: ControllerService,
                 props: {
-                    type: configs.loaders.controller.protocol,
+                    type: configs.loaders.controller.protocol?.[0],
                 }
             },
             {