@xrystal/core 3.25.5 → 3.26.0

package/package.json

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

package/source/loader/controller/index.js

@@ -21,10 +21,12 @@ export class BaseController {
         const req = store?.req || {};
         const identityT = (k) => k;
         const body = ctx.body || req.body || ctx.request?.body || {};
-        let query = ctx.query || req.query || {};
+        let query = ctx.query || req.query || ctx.request?.query || {};
         const urlStr = ctx.url || req.url || ctx.request?.url || '';
-        if (Object.keys(query).length === 0 && typeof urlStr === 'string' && urlStr.includes('?')) {
-            query = qs.parse(urlStr.split('?')[1]);
+        if ((!query || Object.keys(query).length === 0) && typeof urlStr === 'string' && urlStr.includes('?')) {
+            const parts = urlStr.split('?');
+            if (parts[1])
+                query = qs.parse(parts[1]);
         }
         const params = {
             ...(req.params || {}),
@@ -37,7 +39,7 @@ export class BaseController {
             method: ctx.method || req.method || ctx.request?.method || '',
             headers: ctx.headers || req.headers || ctx.request?.headers || {},
             body,
-            query,
+            query: query || {},
             params,
             lang: ctx.lang || req.lang || 'en',
             t: ctx.t || req.t || identityT,
@@ -104,41 +106,106 @@ export default class Controller extends BaseController {
         return isError ? responseMessageHelper.unsuccessful(p1, p2, t) : responseMessageHelper.successfully(p1, p2, t);
     }
     async schema({ checks, logic, response }) {
-        const currentReq = this.req;
         const currentRes = this.res;
         const store = this.currentStore;
         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);
+            let parsedBody = this.req.body;
+            let parsedQuery = this.req.query;
+            const contentType = (this.req.headers['content-type'] || '').toLowerCase();
+            const consumeBody = async (bodySource) => {
+                let text = '';
+                if (bodySource instanceof ReadableStream || (bodySource && typeof bodySource.getReader === 'function')) {
+                    text = await new Response(bodySource).text();
                 }
-                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();
+                else if (typeof bodySource === 'string') {
+                    text = bodySource;
+                }
+                else {
+                    return bodySource;
+                }
+                if (!text)
+                    return {};
+                if (contentType.includes('application/json')) {
+                    try {
+                        return JSON.parse(text);
+                    }
+                    catch {
+                        return text;
+                    }
+                }
+                else if (contentType.includes('application/x-www-form-urlencoded')) {
+                    return qs.parse(text);
                 }
-                catch (e) {
+                else {
                     try {
-                        parsedBody = await rawReq.text();
+                        return JSON.parse(text);
+                    }
+                    catch {
                         try {
-                            parsedBody = JSON.parse(parsedBody);
+                            return qs.parse(text);
+                        }
+                        catch {
+                            return text;
                         }
-                        catch (e) { }
                     }
-                    catch (e2) {
-                        parsedBody = {};
+                }
+            };
+            if (this.protocol !== ProtocolEnum.WEBSOCKET) {
+                const isStream = parsedBody instanceof ReadableStream || (parsedBody && typeof parsedBody.getReader === 'function');
+                const isProcessed = !isStream && parsedBody && typeof parsedBody === 'object' && Object.keys(parsedBody).length > 0 && parsedBody.constructor?.name !== 'ReadableStream';
+                if (!isProcessed) {
+                    if (isStream || typeof parsedBody === 'string') {
+                        parsedBody = await consumeBody(parsedBody);
+                    }
+                    else if (rawReq) {
+                        if (typeof rawReq.json === 'function') {
+                            try {
+                                const cloned = rawReq.clone ? rawReq.clone() : rawReq;
+                                parsedBody = await consumeBody(await cloned.text());
+                            }
+                            catch {
+                                parsedBody = {};
+                            }
+                        }
+                        else if (typeof rawReq.on === 'function') {
+                            parsedBody = await new Promise((resolve) => {
+                                let bodyStr = '';
+                                rawReq.on('data', (chunk) => { bodyStr += chunk; });
+                                rawReq.on('end', async () => resolve(await consumeBody(bodyStr)));
+                                rawReq.on('error', () => resolve({}));
+                            });
+                        }
                     }
                 }
             }
-            else if (parsedBody && typeof parsedBody === 'object' && parsedBody.constructor?.name === 'FormData') {
+            else if (typeof parsedBody === 'string') {
+                try {
+                    parsedBody = JSON.parse(parsedBody);
+                }
+                catch { }
+            }
+            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 };
+            const finalBody = parsedBody || {};
+            const finalQuery = parsedQuery || {};
+            if (store) {
+                if (store.ctx) {
+                    store.ctx.body = finalBody;
+                    store.ctx.query = finalQuery;
+                }
+                if (store.req) {
+                    store.req.body = finalBody;
+                    store.req.query = finalQuery;
+                }
+                if (store.ctx?.request) {
+                    store.ctx.request.body = finalBody;
+                    store.ctx.request.query = finalQuery;
+                }
+            }
+            const currentReq = this.req;
+            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;
@@ -220,7 +287,7 @@ export default class Controller extends BaseController {
         }
         catch (error) {
             this.logger?.log(LoggerLayerEnum.ERROR, `Controller Error: ${error.message}`);
-            const t = currentReq?.t || ((k) => k);
+            const t = this.req?.t || ((k) => k);
             return this.res.status(500).send(new ResponseSchema({ status: false, message: this.parseMessage(error.message, t, true), code: 500 }).getResponse);
         }
     }

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);
+    }
+};