@xrystal/core 3.22.7 → 3.22.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.22.7",
+  "version": "3.22.8",
   "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 smartTranslate;
     private parseMessage;
     schema<T = any>({ checks, logic, response }: {
         checks?: (args: any) => Promise<any>;

package/source/loader/controller/index.js

@@ -13,44 +13,34 @@ export class BaseController {
     get currentStore() { return getControllerCtx(); }
     get req() {
         const store = this.currentStore;
-        const identityT = (k) => k;
         const ctx = store?.ctx || {};
         const query = typeof ctx.query === 'string' ? qs.parse(ctx.query) : (ctx.query || {});
         return {
             url: ctx.url || '', method: ctx.method || '', headers: ctx.headers || {},
             body: ctx.body || {}, query: query, params: ctx.params || {},
-            lang: ctx.lang || 'en', t: ctx.t || identityT,
+            lang: ctx.lang || 'en', t: ctx.t || ((k) => k),
             accounts: ctx.accounts || store?.req?.accounts
         };
     }
     get res() {
         const store = this.currentStore;
         const self = this;
-        const fallbackRes = {
-            status: function () { return this; },
-            send: (d) => d,
-            json: function (d) { return this.send(d); },
-            locals: {}
-        };
+        const fallbackRes = { status: function () { return this; }, send: (d) => d, json: function (d) { return this.send(d); }, locals: {} };
         if (!store)
             return fallbackRes;
         if (!store.metadata)
             store.metadata = { locals: {} };
         return {
             get locals() { return store.metadata.locals; },
-            status(code) {
-                store.metadata._code = code;
-                return this;
-            },
+            status(code) { store.metadata._code = code; return this; },
             send(data) {
                 if (self.protocol === ProtocolEnum.WEBSOCKET)
                     return data;
                 if (data instanceof Response)
                     return data;
-                const isRaw = store.metadata?._isRaw || (data instanceof Blob || data instanceof Uint8Array || data instanceof ArrayBuffer);
                 const status = store.metadata?._code || 200;
-                const body = isRaw || typeof data === 'string' ? data : JSON.stringify(data?.getResponse ? data.getResponse : data);
-                return new Response(body, { status, headers: { 'content-type': isRaw ? 'application/octet-stream' : 'application/json' } });
+                const body = (store.metadata?._isRaw) ? data : JSON.stringify(data?.getResponse ? data.getResponse : data);
+                return new Response(body, { status, headers: { 'content-type': 'application/json' } });
             },
             json(data) { return this.send(data); }
         };
@@ -62,6 +52,14 @@ export default class Controller extends BaseController {
         const protocols = this.system?.tmp?.configs?.loaders?.controller?.protocols;
         this.supportedProtocols = Array.isArray(protocols) ? protocols : [protocols || ProtocolEnum.HTTP];
     }
+    smartTranslate(word, t) {
+        const keyPath = `keywords.${word}`;
+        const translated = t(keyPath);
+        if (translated !== keyPath)
+            return translated;
+        const direct = t(word);
+        return direct !== word ? direct : word;
+    }
     parseMessage(input, t) {
         if (!input || typeof input !== 'string' || !input.startsWith('@'))
             return input;
@@ -70,10 +68,7 @@ export default class Controller extends BaseController {
         const hasMethod = typeof responseMessageHelper[maybeMethod] === 'function';
         const methodName = hasMethod ? maybeMethod : 'successfully';
         const rawArgs = hasMethod ? parts.slice(1) : parts;
-        const translatedArgs = rawArgs.map(arg => {
-            const res = t(`keywords.${arg}`);
-            return res !== `keywords.${arg}` ? res : (t(arg) !== arg ? t(arg) : arg);
-        });
+        const translatedArgs = rawArgs.map(arg => this.smartTranslate(arg, t));
         return responseMessageHelper[methodName](translatedArgs[0] || '', translatedArgs.slice(1).join(' '), t);
     }
     async schema({ checks, logic, response }) {
@@ -83,6 +78,7 @@ export default class Controller extends BaseController {
             const store = this.currentStore;
             const t = currentReq.t;
             const p = { req: currentReq, res: currentRes, body: currentReq.body, query: currentReq.query, params: currentReq.params, locals: store?.metadata?.locals || {}, t };
+            // 1. CHECKS
             if (checks) {
                 const checkRes = await checks(p);
                 if (checkRes !== true) {
@@ -90,42 +86,60 @@ export default class Controller extends BaseController {
                     const code = isObj ? checkRes.code || 400 : 400;
                     const rawMsg = isObj ? checkRes.message : (typeof checkRes === 'string' ? checkRes : '@schemaMissingDataChecks');
                     const { message, status, code: _c, data, payload, ...extras } = isObj ? checkRes : {};
-                    const coreData = data || payload;
+                    const coreData = data !== undefined ? data : payload;
+                    const errPayload = {};
+                    if (coreData !== undefined)
+                        errPayload.data = coreData;
+                    if (Object.keys(extras).length > 0)
+                        errPayload.extraData = extras;
                     return currentRes.status(code).send(new ResponseSchema({
                         status: false,
                         message: this.parseMessage(rawMsg, t),
-                        payload: (coreData !== undefined || Object.keys(extras).length > 0) ? { data: coreData, extraData: extras } : undefined,
+                        payload: Object.keys(errPayload).length > 0 ? errPayload : undefined,
                         code
                     }).getResponse);
                 }
             }
+            // 2. LOGIC
             let logicRes = logic ? await logic(p) : null;
             if (logic && logicRes === false) {
                 return currentRes.status(400).send(new ResponseSchema({ status: false, message: this.parseMessage('@unsuccessful logic', t), code: 400 }).getResponse);
             }
+            // 3. RESPONSE
             let finalRes = response ? await response({ ...p, logicResult: logicRes }) : logicRes;
             if (typeof finalRes === 'function')
                 finalRes = await finalRes(p);
+            // Auto-success conversion
             if (Array.isArray(finalRes)) {
-                finalRes = { message: `@successfully ${finalRes.join(' ')}` };
+                finalRes = { message: `@successfully ${finalRes.join(' ')}`, data: logicRes };
             }
             else if (typeof finalRes === 'string' && !finalRes.startsWith('@')) {
-                finalRes = { message: `@successfully ${finalRes}` };
+                finalRes = { message: `@successfully ${finalRes}`, data: logicRes };
             }
             if (finalRes instanceof Response || finalRes?.constructor?.name === 'Response')
                 return finalRes;
+            // 4. FINAL PACKAGING (BU BÖLÜMÜ DÜZELTTİK)
             const isSuccess = finalRes?.status !== false;
             const finalCode = finalRes?.code || store?.metadata?._code || 200;
             let msgSource = finalRes?.message || (typeof finalRes === 'string' ? finalRes : '@successfully');
+            // Eğer finalRes bir obje değilse onu data olarak sarmala
             const rawOutput = (finalRes && typeof finalRes === 'object' && !Array.isArray(finalRes)) ? finalRes : { data: finalRes };
+            // Destructuring ile alanları ayır
             const { message, status, code, data, payload, ...extraData } = rawOutput;
+            // Data veya Payload'dan gelen asıl veriyi belirle
             const coreData = data !== undefined ? data : payload;
             const responseData = {
                 status: isSuccess,
                 message: this.parseMessage(msgSource, t)
             };
-            if (coreData !== undefined || Object.keys(extraData).length > 0) {
-                responseData.payload = { data: coreData, extraData: Object.keys(extraData).length > 0 ? extraData : undefined };
+            // Payload oluşturma mantığı
+            const finalPayload = {};
+            if (coreData !== undefined)
+                finalPayload.data = coreData;
+            if (Object.keys(extraData).length > 0)
+                finalPayload.extraData = extraData;
+            if (Object.keys(finalPayload).length > 0) {
+                responseData.payload = finalPayload;
             }
             responseData.code = finalCode;
             return currentRes.status(finalCode).send(new ResponseSchema(responseData).getResponse);