@xrystal/core 3.25.5 → 3.25.7

package/package.json

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

package/source/loader/controller/index.js

@@ -110,35 +110,72 @@ export default class Controller extends BaseController {
         try {
             let parsedBody = currentReq.body;
             const rawReq = store?.req || store?.ctx?.request || store?.ctx?.req;
-            if (this.protocol === ProtocolEnum.WEBSOCKET && typeof parsedBody === 'string') {
-                try {
-                    parsedBody = JSON.parse(parsedBody);
-                }
-                catch (e) { }
-            }
-            else if (rawReq && (parsedBody instanceof ReadableStream || (parsedBody && typeof parsedBody.getReader === 'function'))) {
-                try {
-                    const cloned = rawReq.clone ? rawReq.clone() : rawReq;
-                    parsedBody = await cloned.json();
-                }
-                catch (e) {
-                    try {
-                        parsedBody = await rawReq.text();
+            const contentType = (currentReq.headers['content-type'] || '').toLowerCase();
+            const hasData = parsedBody && typeof parsedBody === 'object' && Object.keys(parsedBody).length > 0;
+            if (!hasData && this.protocol !== ProtocolEnum.WEBSOCKET && rawReq) {
+                if (typeof parsedBody === 'string' && parsedBody.length > 0) {
+                    if (contentType.includes('application/json')) {
                         try {
                             parsedBody = JSON.parse(parsedBody);
                         }
                         catch (e) { }
                     }
-                    catch (e2) {
+                    else if (contentType.includes('application/x-www-form-urlencoded')) {
+                        parsedBody = qs.parse(parsedBody);
+                    }
+                }
+                else if (typeof rawReq.json === 'function') {
+                    try {
+                        const cloned = rawReq.clone ? rawReq.clone() : rawReq;
+                        const text = await cloned.text();
+                        if (contentType.includes('application/x-www-form-urlencoded')) {
+                            parsedBody = qs.parse(text);
+                        }
+                        else {
+                            try {
+                                parsedBody = JSON.parse(text);
+                            }
+                            catch {
+                                parsedBody = qs.parse(text);
+                            }
+                        }
+                    }
+                    catch (e) {
                         parsedBody = {};
                     }
                 }
+                else if (typeof rawReq.on === 'function') {
+                    parsedBody = await new Promise((resolve) => {
+                        let bodyStr = '';
+                        rawReq.on('data', (chunk) => { bodyStr += chunk; });
+                        rawReq.on('end', () => {
+                            try {
+                                if (contentType.includes('application/json'))
+                                    resolve(JSON.parse(bodyStr));
+                                else if (contentType.includes('application/x-www-form-urlencoded'))
+                                    resolve(qs.parse(bodyStr));
+                                else {
+                                    try {
+                                        resolve(JSON.parse(bodyStr));
+                                    }
+                                    catch {
+                                        resolve(qs.parse(bodyStr));
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                resolve({});
+                            }
+                        });
+                        rawReq.on('error', () => resolve({}));
+                    });
+                }
             }
             else if (parsedBody && typeof parsedBody === 'object' && parsedBody.constructor?.name === 'FormData') {
                 parsedBody = Object.fromEntries(parsedBody.entries());
             }
-            currentReq.body = parsedBody;
-            const p = { req: currentReq, res: currentRes, body: parsedBody, query: currentReq.query, params: currentReq.params, t: currentReq.t, accounts: currentReq.accounts };
+            currentReq.body = parsedBody || {};
+            const p = { req: currentReq, res: currentRes, body: currentReq.body, query: currentReq.query, params: currentReq.params, t: currentReq.t, accounts: currentReq.accounts };
             const extractMeta = (obj) => {
                 if (!obj || typeof obj !== 'object')
                     return;

package/source/utils/helpers/middlewares/index.d.ts

@@ -0,0 +1 @@
+export declare const toExpress: (action: () => Promise<any>) => (req: any, res: any, next: any) => Promise<any>;

package/source/utils/helpers/middlewares/index.js

@@ -0,0 +1,26 @@
+import { controllerContextStorage } from "source/loader/controller";
+import { ProtocolEnum } from "source/utils/models";
+// => Use case - app.post('/example', toExpress(() => exampleCtrl.example()))
+export const toExpress = (action) => async (req, res, next) => {
+    try {
+        const result = await controllerContextStorage.run({
+            req,
+            res,
+            protocol: ProtocolEnum.HTTP,
+            metadata: { locals: res.locals || {} }
+        }, action);
+        if (result instanceof Response) {
+            res.status(result.status);
+            result.headers.forEach((v, k) => res.setHeader(k, v));
+            const contentType = result.headers.get('content-type') || '';
+            if (contentType.includes('application/json') || contentType.includes('text/')) {
+                return res.send(await result.text());
+            }
+            return res.send(Buffer.from(await result.arrayBuffer()));
+        }
+        return res.send(result);
+    }
+    catch (e) {
+        next(e);
+    }
+};