@xrystal/core 3.15.2 → 3.15.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.15.2",
+  "version": "3.15.6",
   "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,35 +9,34 @@ 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)) {
-            throw new Error(`[DI] Protocol ${incomingProtocol} not supported. Supported: ${this.supportedProtocols.join(', ')}`);
+            throw new Error(`[DI] Protocol ${incomingProtocol} not supported.`);
         }
         return incomingProtocol;
     }
     get req() {
         const store = this.currentStore;
-        const defaultT = (k) => k;
+        const identityT = (k) => k;
         if (!store)
-            return { url: '', method: '', headers: {}, params: {}, query: {}, t: defaultT };
-        if (store.ctx) {
-            const { ctx } = store;
+            return { url: '', method: '', headers: {}, params: {}, query: {}, t: identityT };
+        const ctx = store.ctx;
+        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 || defaultT
+                accounts: ctx.user || ctx.data?.user || ctx.accounts,
+                t: ctx.t || ctx.data?.t || identityT
             };
         }
-        const { req } = store;
+        const req = store.req;
         return {
             url: req?.originalUrl || req?.url || '',
             method: req?.method || 'GET',
@@ -46,7 +45,7 @@ class Controller {
             params: req?.params || {},
             query: req?.query || {},
             accounts: req?.accounts,
-            t: req?.t || defaultT
+            t: req?.t || identityT
         };
     }
     get res() {
@@ -57,10 +56,7 @@ class Controller {
         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 = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
                     if (currentProtocol === ProtocolEnum.WEBSOCKET)
@@ -73,30 +69,19 @@ class Controller {
                 json(data) { return this.send(data); }
             };
         }
-        const { res } = store;
         return {
-            locals: res?.locals || {},
-            status(code) {
-                if (res?.status)
-                    res.status(code);
-                return this;
-            },
+            locals: store.res?.locals || {},
+            status(code) { if (store.res?.status)
+                store.res.status(code); return this; },
             send(data) {
                 const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
-                if (res?.send)
-                    return res.send(plainData);
-                return plainData;
+                return store.res?.send ? store.res.send(plainData) : plainData;
             },
-            json(data) {
-                const plainData = data && typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : data;
-                if (res?.json)
-                    return res.json(plainData);
-                return plainData;
-            }
+            json(data) { return this.send(data); }
         };
     }
-    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) => {
@@ -106,53 +91,42 @@ class Controller {
 }
 export class ControllerService extends Controller {
     async load(props = {}) {
-        if (props.type) {
+        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 || !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) {
-                    const errorObj = new ResponseSchema(checkResult).getResponse;
-                    return await this.responseProtocolSwitch({ req: currentReq, res: currentRes, context: () => errorObj });
+                    return await this.responseProtocolSwitch({ res: currentRes, context: () => new ResponseSchema(checkResult).getResponse });
                 }
             }
             const logicResult = await logic({ payload, convertedPayload });
             if (logicResult.response instanceof Function)
                 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: () => new ResponseSchema(logicResult).getResponse });
             }
             if (response) {
                 const resResult = await response({ payload, convertedPayload, logicResult });
-                const successObj = new ResponseSchema({
+                const successObj = {
                     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 await this.responseProtocolSwitch({ res: currentRes, resStatus: 200, context: () => new ResponseSchema(successObj).getResponse });
             }
-            const finalPayload = logicResult.payload !== undefined ? logicResult.payload : logicResult;
-            return finalPayload && typeof finalPayload === 'object' ? JSON.parse(JSON.stringify(finalPayload)) : finalPayload;
+            return JSON.parse(JSON.stringify(logicResult.payload !== undefined ? logicResult.payload : logicResult));
         }
         catch (error) {
-            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;
+            return { status: false, message: error.message };
         }
     }
 }