@xrystal/core 3.23.3 → 3.23.4

package/package.json

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

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

@@ -49,6 +49,7 @@ export declare abstract class BaseController {
 export default abstract class Controller extends BaseController implements IProvide<any> {
     constructor();
     onInit(): Promise<void>;
+    private parseMessage;
     schema({ checks, logic, response }: {
         checks?: (args: any) => Promise<any>;
         logic?: (args: any) => Promise<any>;

package/source/loader/controller/index.js

@@ -1,3 +1,4 @@
+import qs from 'qs';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import Logger from '../logger';
 import System from '../system';
@@ -16,18 +17,23 @@ export class BaseController {
     }
     get req() {
         const store = this.currentStore;
-        const identityT = (k) => k;
         const ctx = store?.ctx || {};
+        const req = store?.req || {};
+        const identityT = (k) => k;
+        const body = ctx.body || req.body || {};
+        const query = ctx.query || req.query || (typeof req.url === 'string' && req.url.includes('?') ? qs.parse(req.url.split('?')[1]) : {});
+        const params = ctx.params || req.params || {};
+        const headers = ctx.headers || req.headers || {};
         return {
-            url: ctx.url || '',
-            method: ctx.method || '',
-            headers: ctx.headers || {},
-            body: ctx.body || {},
-            query: ctx.query || {},
-            params: ctx.params || {},
-            lang: ctx.lang || 'en',
-            t: ctx.t || identityT,
-            accounts: ctx.accounts || store?.req?.accounts
+            url: ctx.url || req.url || '',
+            method: ctx.method || req.method || '',
+            headers,
+            body,
+            query,
+            params,
+            lang: ctx.lang || req.lang || 'en',
+            t: ctx.t || req.t || identityT,
+            accounts: ctx.accounts || req.accounts
         };
     }
     get res() {
@@ -54,7 +60,7 @@ export class BaseController {
                     return data;
                 if (data instanceof Response)
                     return data;
-                const isBinary = data instanceof Blob || data instanceof Uint8Array || data instanceof ArrayBuffer;
+                const isBinary = data instanceof Blob || data instanceof Uint8Array || data instanceof ArrayBuffer || (typeof data?.pipe === 'function');
                 const isRaw = store.metadata?._isRaw || isBinary;
                 let contentType = store.metadata?._contentType;
                 if (!contentType) {
@@ -81,6 +87,28 @@ export default class Controller extends BaseController {
         const protocols = this.system?.tmp?.configs?.loaders?.controller?.protocols;
         this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols || ProtocolEnum.HTTP];
     }
+    parseMessage(msg, t, isError = false) {
+        if (!msg)
+            return '';
+        if (typeof msg !== 'string' && !Array.isArray(msg))
+            return '';
+        let cleanMsg = msg;
+        let useDirect = isError;
+        if (typeof cleanMsg === 'string' && cleanMsg.startsWith('@')) {
+            cleanMsg = cleanMsg.substring(1);
+            useDirect = true;
+        }
+        const parts = Array.isArray(cleanMsg) ? cleanMsg : cleanMsg.split(' ');
+        const key = parts[0];
+        const rawParams = parts.slice(1);
+        const translatedParams = rawParams.map((p) => t(p));
+        if (useDirect) {
+            return t(key, translatedParams);
+        }
+        else {
+            return responseMessageHelper.successFully(key, translatedParams.join(' '), t);
+        }
+    }
     async schema({ checks, logic, response }) {
         try {
             const currentReq = this.req;
@@ -91,64 +119,77 @@ export default class Controller extends BaseController {
                 body: currentReq.body,
                 query: currentReq.query,
                 params: currentReq.params,
-                t: currentReq.t
+                t: currentReq.t,
+                accounts: currentReq.accounts
             };
             if (checks) {
                 const checkResult = await checks(p);
-                if (checkResult === false || (checkResult && typeof checkResult === 'object' && !Array.isArray(checkResult))) {
+                if (checkResult !== true) {
                     const checkCode = checkResult?.code || 400;
+                    const rawMsg = checkResult?.message || checkResult || 'error_validation';
+                    const finalMsg = this.parseMessage(rawMsg, currentReq.t, true);
                     return currentRes.status(checkCode).send(new ResponseSchema({
                         status: false,
-                        message: checkResult?.message || '',
+                        message: finalMsg,
                         code: checkCode
                     }).getResponse);
                 }
             }
-            let logicResult = logic ? await logic(p) : null;
+            let logicResult = logic ? await logic(p) : {};
+            if (logicResult instanceof Response || logicResult?.constructor?.name === 'Response') {
+                return logicResult;
+            }
             if (logicResult && typeof logicResult === 'object' && typeof logicResult.response === 'function') {
                 logicResult = await logicResult.response();
             }
-            if (logicResult instanceof Response || (logicResult?.constructor?.name === 'Response')) {
-                return logicResult;
-            }
             if (logicResult?.status === false) {
                 const errorCode = logicResult.code || 400;
+                const finalMsg = this.parseMessage(logicResult.message, currentReq.t, true);
                 return currentRes.status(errorCode).send(new ResponseSchema({
                     status: false,
-                    message: logicResult.message || '',
+                    message: finalMsg,
                     code: errorCode
                 }).getResponse);
             }
             const resResult = response ? await response({ ...p, logicResult }) : logicResult;
-            if (resResult instanceof Response || (resResult?.constructor?.name === 'Response')) {
-                return resResult;
+            if (resResult instanceof Response || resResult instanceof Blob || resResult instanceof Uint8Array || resResult instanceof ArrayBuffer) {
+                return currentRes.status(200).send(resResult);
             }
-            let finalMessage = '';
-            let rawMessageValue = '';
-            const messageSource = resResult?.message || (typeof resResult === 'string' || Array.isArray(resResult) ? resResult : '');
-            if (Array.isArray(messageSource)) {
-                finalMessage = responseMessageHelper.successFully(messageSource[0], messageSource[1], currentReq.t);
-                rawMessageValue = messageSource[0];
+            let source = resResult;
+            if (source === undefined || source === null)
+                source = logicResult || {};
+            let messageSource = source?.message;
+            if (!messageSource) {
+                if (typeof source === 'string')
+                    messageSource = source;
+                else if (Array.isArray(source))
+                    messageSource = source;
+                else
+                    messageSource = 'success_process';
             }
-            else if (typeof messageSource === 'string' && messageSource !== '') {
-                if (messageSource.startsWith('@')) {
-                    const cleanMsg = messageSource.substring(1);
-                    finalMessage = currentReq.t(cleanMsg, {});
-                    rawMessageValue = cleanMsg;
-                }
-                else {
-                    finalMessage = responseMessageHelper.successFully(messageSource, '', currentReq.t);
-                    rawMessageValue = messageSource;
-                }
+            if (messageSource === source) {
+                source = {};
+            }
+            let dataVal = source.data;
+            let extraDataVal = source.extraData;
+            if (source.payload) {
+                if (source.payload.data !== undefined)
+                    dataVal = source.payload.data;
+                else if (!source.payload.extraData && !source.data)
+                    dataVal = source.payload;
+                if (source.payload.extraData !== undefined)
+                    extraDataVal = source.payload.extraData;
             }
-            let finalPayload = undefined;
-            if (logic) {
-                finalPayload = logicResult?.payload !== undefined ? logicResult.payload : logicResult;
-                if (finalPayload === messageSource || (finalPayload && typeof finalPayload === 'object' && (finalPayload.message === rawMessageValue || finalPayload.message === finalMessage))) {
-                    finalPayload = undefined;
+            else {
+                if (dataVal === undefined && Object.keys(source).length > 0 && !source.status && !source.message && !source.code) {
+                    dataVal = source;
                 }
             }
-            const successCode = this.currentStore?.metadata?._code || 200;
+            const finalPayload = (dataVal !== undefined || extraDataVal !== undefined)
+                ? { data: dataVal, extraData: extraDataVal }
+                : undefined;
+            const finalMessage = this.parseMessage(messageSource, currentReq.t, false);
+            const successCode = this.currentStore?.metadata?._code || source?.code || 200;
             return currentRes.status(successCode).send(new ResponseSchema({
                 status: true,
                 message: finalMessage,
@@ -160,7 +201,7 @@ export default class Controller extends BaseController {
             this.logger?.log(LoggerLayerEnum.ERROR, `Controller Error: ${error.message}`);
             return this.res.status(500).send(new ResponseSchema({
                 status: false,
-                message: error.message,
+                message: error.message || 'error_internal',
                 code: 500
             }).getResponse);
         }