@xrystal/core 3.5.1 → 3.5.2

package/source/utils/models/classes/class.controller.js

@@ -1,448 +1,164 @@
 import qs from 'qs';
 import { LoggerService } from '../../../loader';
-import { LoggerLayerEnum, ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../index';
+import { responseMessageHelper, ResponseSchema, x } from '../../index';
 class Controller {
     logger = x.get(LoggerService);
     protocol = null;
-    socket = null;
     req = null;
     res = null;
-    accounts = null;
-    startDate = null;
-    date = null;
-    dateStart = null;
-    endDate = null;
-    sort = null;
-    offset = null;
-    limit = null;
-    defaultLimitSize = 20;
-    maxLimitSize = 100;
-    constructor({ protocol, socket, req, res, ctx }) {
-        // Eğer ctx varsa, otomatik req/res'e çevir
+    constructor({ protocol, req, res, ctx }) {
+        this.protocol = protocol;
         if (ctx) {
-            req = {
+            this.req = {
                 url: ctx.request.url,
                 method: ctx.request.method,
                 headers: Object.fromEntries(ctx.request.headers),
                 body: ctx.body,
                 params: ctx.params,
-                query: ctx.query,
-                accounts: ctx.accounts || ctx.user,
+                query: ctx.query || {},
+                accounts: ctx.user || ctx.accounts,
                 t: ctx.t
             };
-            res = {
-                status: (code) => res,
-                send: (data) => data,
-                json: (data) => data,
-                locals: {}
-            };
-        }
-        this.protocol = protocol;
-        this.socket = socket;
-        this.req = req;
-        this.res = res;
-    }
-    createResponse(data, statusCode = 200) {
-        return new Response(JSON.stringify(data), {
-            status: statusCode,
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
-    }
-    payloadProtocolSwitch = async ({ protocol, socket, req, res }) => {
-        let payload = {};
-        switch (protocol) {
-            case ProtocolEnum.HTTP:
-            case ProtocolEnum.HTTPS:
-                if ((protocol === ProtocolEnum.HTTP || protocol === ProtocolEnum.HTTPS) && (!req || !res)) {
-                    throw new Error('Req and res required');
+            this.res = {
+                locals: {},
+                status(code) {
+                    this.locals._code = code;
+                    return this;
+                },
+                send(data) {
+                    return new Response(JSON.stringify(data), {
+                        status: this.locals._code || 200,
+                        headers: { 'content-type': 'application/json' }
+                    });
+                },
+                json(data) {
+                    return this.send(data);
                 }
-                this.req = req;
-                this.res = res;
-                const parsedQuerys = this.parsedQuerys(req?.url ? req.url : '');
-                payload = {
-                    req: this.req,
-                    res: this.res,
-                    accounts: this.req?.accounts && this.req.accounts,
-                    parsedQuerys: parsedQuerys,
-                };
-                break;
-            case ProtocolEnum.SOCKETIO:
-                payload = {};
-                break;
-            case ProtocolEnum.NONE:
-                payload = {};
-                break;
-            default:
-                throw new Error('Protocol not match.');
-        }
-        return payload;
-    };
-    convertedPayloadProtocolSwitch = async ({ protocol, socket, req, res, }) => {
-        let convertedPayload = {};
-        switch (protocol) {
-            case ProtocolEnum.HTTP:
-            case ProtocolEnum.HTTPS:
-                const parsedQuerys = this.parsedQuerys(req?.url ? req.url : '');
-                const parsedQuerysWithTrueType = this.parsedQuerysWithTrueType(req?.url ? req.url : '');
-                convertedPayload = {
-                    req: this.req,
-                    res: this.res,
-                    accounts: this.req?.accounts,
-                    parsedQuerys: parsedQuerys,
-                    parsedQuerysWithTrueType: parsedQuerysWithTrueType,
-                    startDate: parsedQuerysWithTrueType?.['start-date']
-                        ? this.dateNativeUTCToUTCConverter(parsedQuerysWithTrueType['start-date'])
-                        : this.startDate,
-                    startDateTimezone: parsedQuerysWithTrueType?.['start-date']
-                        ? parsedQuerysWithTrueType['start-date'].split('+')[1]
-                        : this.startDate,
-                    date: this.date ? this.dateNativeUTCToUTCConverter(parsedQuerysWithTrueType.date) : this.date,
-                    dateTimezone: this.date ? parsedQuerysWithTrueType.date.split('+')[1] : this.date,
-                    endDate: parsedQuerysWithTrueType?.['end-date']
-                        ? this.dateNativeUTCToUTCConverter(parsedQuerysWithTrueType['end-date'])
-                        : this.endDate,
-                    endDateTimezone: parsedQuerysWithTrueType?.['end-date']
-                        ? parsedQuerysWithTrueType['end-date'].split('+')[1]
-                        : this.endDate,
-                    sort: parsedQuerysWithTrueType.sort ? this.sortParser(parsedQuerys.sort) : this.sort,
-                    offset: parsedQuerysWithTrueType.offset ? parsedQuerys.offset : this.offset,
-                    limit: parsedQuerysWithTrueType.limit
-                        ? parsedQuerysWithTrueType.limit > this.maxLimitSize
-                            ? String(this.maxLimitSize)
-                            : parsedQuerys.limit
-                        : this.defaultLimitSize
-                };
-                break;
-            case ProtocolEnum.WEBSOCKET:
-                convertedPayload = {};
-                break;
-            case ProtocolEnum.SOCKETIO:
-                convertedPayload = {};
-                break;
-            case ProtocolEnum.NONE:
-                convertedPayload = {};
-                break;
-            default:
-                throw new Error('Protocol not match.');
+            };
         }
-        return convertedPayload;
-    };
-    responseProtocolSwitch = async ({ protocol, socket, req, res, resStatus = 200, context }) => {
-        switch (protocol) {
-            case ProtocolEnum.HTTP:
-            case ProtocolEnum.HTTPS:
-                if (!req || !res) {
-                    throw new Error(`req or res not found`);
+        else {
+            this.req = {
+                url: req?.originalUrl || req?.url,
+                method: req?.method,
+                headers: req?.headers || {},
+                body: req?.body,
+                params: req?.params,
+                query: req?.query || {},
+                accounts: req?.accounts,
+                t: req?.t
+            };
+            this.res = {
+                locals: res?.locals || {},
+                status(code) {
+                    res.status(code);
+                    return this;
+                },
+                send(data) {
+                    return res.send(data);
+                },
+                json(data) {
+                    return res.json(data);
                 }
-                const responseData = context({
-                    localeLanguageConverter: req.t
-                });
-                return this.createResponse(responseData, resStatus);
-            case ProtocolEnum.WEBSOCKET:
-                return context({});
-            case ProtocolEnum.SOCKETIO:
-                return context({});
-            case ProtocolEnum.NONE:
-                return context({});
-            default:
-                throw new Error('Protocol not match.');
+            };
         }
+    }
+    responseProtocolSwitch = async ({ protocol, req, res, resStatus = 200, context }) => {
+        const responseData = context({ localeLanguageConverter: req.t });
+        return res.status(resStatus).send(responseData);
     };
     parsedQuerys = (url) => {
-        const parseUrlForQuerys = url.split('?')?.[1];
-        let convertedQuerys;
-        if (parseUrlForQuerys) {
-            convertedQuerys = qs.parse(parseUrlForQuerys, { decoder: decodeURIComponent });
-        }
-        else {
-            convertedQuerys = {};
-        }
-        return convertedQuerys;
-    };
-    parsedQuerysWithTrueType = (url) => {
-        const parsedParams = {};
-        Object.entries(this.parsedQuerys(url))?.forEach(([key, value]) => {
-            if (value === 'undefined') {
-                parsedParams[key] = undefined;
-            }
-            else if (value === 'null') {
-                parsedParams[key] = null;
-            }
-            else if (value === '') {
-                parsedParams[key] = '';
-            }
-            else if (!isNaN(value)) {
-                parsedParams[key] = Number(value);
-            }
-            else if (value?.toLowerCase() === 'true' || value?.toLowerCase() === 'false') {
-                parsedParams[key] = value?.toLowerCase() === 'true';
-            }
-            else {
-                parsedParams[key] = value;
-            }
-        });
-        return parsedParams;
+        const queryString = url.includes('?') ? url.split('?')[1] : '';
+        if (!queryString)
+            return {};
+        return qs.parse(queryString, { decoder: decodeURIComponent });
     };
-    dateNativeUTCToUTCConverter = (date) => {
-        const convertedDate = (new Date(date)).toISOString();
-        return convertedDate;
+    log = async (level, message) => {
+        this.logger.winston.log({ level, message });
     };
-    sortParser = (sort) => {
-        if (String(sort)) {
-            const parsed = sort.split('+');
-            if (!parsed[0] || !parsed[1]) {
-                this.log({
-                    level: LoggerLayerEnum[LoggerLayerEnum.ERROR].toLowerCase(),
-                    message: 'sort query parameter invalid.'
-                });
-                return null;
-            }
-            return {
-                key: parsed[0],
-                value: Number(parsed[1])
-            };
-        }
-        else {
-            return null;
-        }
-    };
-    aprotator(value) {
-        return value === 0 ? true : !!value;
-    }
-    log = async ({ level, message }) => {
-        this.logger.winston.log({
-            level: level,
-            message,
-        });
-    };
-    getErrorMessage(error) {
-        if (error instanceof Error)
-            return error.message;
-        return String(error);
-    }
 }
-class ControllerSchema extends Controller {
-    constructor({ protocol, socket, req, res, ctx }) {
-        super({
-            protocol,
-            socket,
-            req,
-            res,
-            ctx
-        });
-    }
+export class ControllerSchema extends Controller {
     async schema({ checks, logic, response, }) {
-        const { res, req } = this;
+        const payload = { req: this.req, res: this.res };
+        const convertedPayload = {
+            ...payload,
+            parsedQuerys: this.parsedQuerys(this.req.url)
+        };
         try {
-            let logicCallbackFunc;
-            // Checks
-            try {
-                if (checks) {
-                    const checksCallbackFunc = await checks({
-                        payload: this.payloadProtocolSwitch,
-                        convertedPayload: await this.convertedPayloadProtocolSwitch({
-                            protocol: this.protocol,
-                            socket: this.socket,
-                            req: req,
-                            res: res
-                        })
-                    });
-                    let checked = false;
-                    if (Array.isArray(checksCallbackFunc)) {
-                        checked = checksCallbackFunc.every((check) => check !== undefined && check !== null && check !== "");
-                    }
-                    else if (!Array.isArray(checksCallbackFunc) && checksCallbackFunc?.message) {
-                        return this.responseProtocolSwitch({
-                            protocol: this.protocol,
-                            req: this.req,
-                            res: this.res,
-                            resStatus: 200,
-                            context: ({ localeLanguageConverter }) => new ResponseSchema({
-                                status: checksCallbackFunc.status || false,
-                                message: checksCallbackFunc?.message,
-                                ...(this.aprotator(checksCallbackFunc?.payload) && { payload: checksCallbackFunc?.payload }),
-                                code: checksCallbackFunc?.code
-                            }).getResponse
-                        });
-                    }
-                    else if (typeof checksCallbackFunc === 'object' && typeof checksCallbackFunc?.response === 'function') {
-                        if (typeof checksCallbackFunc.response() === 'boolean') {
-                            checked = checksCallbackFunc.response();
-                        }
-                        else {
-                            return checksCallbackFunc.response();
-                        }
-                    }
-                    if (!checked) {
-                        return this.responseProtocolSwitch({
-                            protocol: this.protocol,
-                            socket: this.socket,
-                            req: this.req,
-                            res: this.res,
-                            resStatus: 400,
-                            context: ({ localeLanguageConverter }) => new ResponseSchema({
-                                status: false,
-                                message: Array.isArray(checksCallbackFunc)
-                                    ? `${responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)}`
-                                    : checksCallbackFunc?.invalid
-                                        ? `${responseMessageHelper.schemaInvalidDataChecks(localeLanguageConverter)}`
-                                        : `${responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)}`,
-                            }).getResponse
-                        });
-                    }
+            if (checks) {
+                const checkResult = await checks({ payload, convertedPayload });
+                let isInvalid = false;
+                if (Array.isArray(checkResult)) {
+                    isInvalid = !checkResult.every(c => c !== undefined && c !== null && c !== "");
                 }
-            }
-            catch (error) {
-                this.log({
-                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                    message: this.getErrorMessage(`Schema check controller handler: ${error.message}. Extra: ${JSON.stringify(error.response?.data)}`),
-                });
-                return this.responseProtocolSwitch({
-                    protocol: this.protocol,
-                    socket: this.socket,
-                    req: this.req,
-                    res: this.res,
-                    resStatus: 500,
-                    context: ({ localeLanguageConverter }) => new ResponseSchema({
-                        status: false,
-                        message: `${responseMessageHelper.schemaUnknowErrorChecks(error.message, JSON.stringify(error.response?.data), localeLanguageConverter)}`,
-                    }).getResponse
-                });
-            }
-            // Logic
-            try {
-                logicCallbackFunc = await logic({
-                    payload: this.payloadProtocolSwitch,
-                    convertedPayload: await this.convertedPayloadProtocolSwitch({
+                else if (typeof checkResult === 'object' && checkResult.message) {
+                    return await this.responseProtocolSwitch({
                         protocol: this.protocol,
-                        socket: this.socket,
-                        req: req,
-                        res: res
-                    })
-                });
-                if (logicCallbackFunc?.response) {
-                    if (logicCallbackFunc.response instanceof Function) {
-                        return logicCallbackFunc.response(logicCallbackFunc?.payload);
-                    }
-                    else {
-                        throw new Error('Invalid type for logicCallbackFunc.response');
-                    }
+                        req: this.req,
+                        res: this.res,
+                        context: () => new ResponseSchema({
+                            status: checkResult.status || false,
+                            message: checkResult.message,
+                            payload: checkResult.payload,
+                            code: checkResult.code
+                        }).getResponse
+                    });
                 }
-                if (logicCallbackFunc?.message) {
-                    return this.responseProtocolSwitch({
+                if (isInvalid) {
+                    return await this.responseProtocolSwitch({
                         protocol: this.protocol,
-                        socket: this.socket,
                         req: this.req,
                         res: this.res,
                         resStatus: 400,
                         context: ({ localeLanguageConverter }) => new ResponseSchema({
-                            status: logicCallbackFunc?.status || false,
-                            message: logicCallbackFunc?.message,
-                            ...(this.aprotator(logicCallbackFunc?.payload) && { payload: logicCallbackFunc?.payload }),
-                            code: logicCallbackFunc?.code
+                            status: false,
+                            message: responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)
                         }).getResponse
                     });
                 }
             }
-            catch (error) {
-                this.log({
-                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                    message: this.getErrorMessage(`Schema logic controller handler: ${error.message}. Extra: ${JSON.stringify(error?.response?.data)}`),
-                });
-                return this.responseProtocolSwitch({
+            const logicResult = await logic({ payload, convertedPayload });
+            if (logicResult.response instanceof Function) {
+                return logicResult.response(logicResult.payload);
+            }
+            if (logicResult.message) {
+                return await this.responseProtocolSwitch({
                     protocol: this.protocol,
-                    socket: this.socket,
                     req: this.req,
                     res: this.res,
-                    resStatus: 500,
-                    context: ({ localeLanguageConverter }) => new ResponseSchema({
-                        status: false,
-                        message: `${responseMessageHelper.schemaUnknowErrorLogic(error.message, JSON.stringify(error?.response?.data), localeLanguageConverter)}`,
+                    resStatus: 400,
+                    context: () => new ResponseSchema({
+                        status: logicResult.status || false,
+                        message: logicResult.message,
+                        payload: logicResult.payload,
+                        code: logicResult.code
                     }).getResponse
                 });
             }
-            // Response
-            try {
-                if (response) {
-                    const responseCallbackFunc = await response({
-                        payload: this.payloadProtocolSwitch,
-                        convertedPayload: await this.convertedPayloadProtocolSwitch({
-                            protocol: this.protocol,
-                            socket: this.socket,
-                            req: req,
-                            res: res
-                        })
-                    });
-                    if (!responseCallbackFunc?.message) {
-                        throw new Error('Message required: Please add the responseObj.message');
-                    }
-                    if (responseCallbackFunc?.response) {
-                        if (responseCallbackFunc.response instanceof Function) {
-                            return responseCallbackFunc.response(responseCallbackFunc);
-                        }
-                        else {
-                            throw new Error('Invalid type for responseCallbackFunc.response');
-                        }
-                    }
-                    if (logicCallbackFunc) {
-                        return this.responseProtocolSwitch({
-                            protocol: this.protocol,
-                            socket: this.socket,
-                            req: this.req,
-                            res: this.res,
-                            resStatus: 200,
-                            context: ({ localeLanguageConverter }) => new ResponseSchema({
-                                status: true,
-                                message: `${responseMessageHelper.successFully(responseCallbackFunc.message?.[0], responseCallbackFunc.message?.[1], localeLanguageConverter)}`,
-                                ...(this.aprotator(logicCallbackFunc?.payload) && { payload: logicCallbackFunc?.payload })
-                            }).getResponse
-                        });
-                    }
-                    else {
-                        throw new Error("logicCallbackFunc values not found.");
-                    }
+            if (response) {
+                const resResult = await response({ payload, convertedPayload });
+                if (resResult.response instanceof Function) {
+                    return resResult.response(resResult);
                 }
-                else {
-                    throw new Error('Please use response scope.');
-                }
-            }
-            catch (error) {
-                this.log({
-                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                    message: this.getErrorMessage(`Schema response controller handler: ${error.message}. Extra: ${JSON.stringify(error?.response?.data)}`),
-                });
-                return this.responseProtocolSwitch({
+                return await this.responseProtocolSwitch({
                     protocol: this.protocol,
-                    socket: this.socket,
                     req: this.req,
                     res: this.res,
-                    resStatus: 500,
+                    resStatus: 200,
                     context: ({ localeLanguageConverter }) => new ResponseSchema({
-                        status: false,
-                        message: `${responseMessageHelper.schemaUnknowErrorResponse(error.message, JSON.stringify(error?.response?.data), localeLanguageConverter)}`,
+                        status: true,
+                        message: responseMessageHelper.successFully(resResult.message[0], resResult.message[1], localeLanguageConverter),
+                        payload: logicResult.payload
                     }).getResponse
                 });
             }
         }
         catch (error) {
-            this.log({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: this.getErrorMessage(`Schema main controller handler: ${error.message}. Extra: ${JSON.stringify(error?.response?.data)}`),
-            });
-            return this.responseProtocolSwitch({
-                protocol: this.protocol,
-                socket: this.socket,
-                req: this.req,
-                res: this.res,
-                resStatus: 500,
-                context: ({ localeLanguageConverter }) => new ResponseSchema({
-                    status: false,
-                    message: `${responseMessageHelper.schemaUnknowErrorMain(error.message, JSON.stringify(error?.response?.data), localeLanguageConverter)}`,
-                }).getResponse
+            await this.log('error', `Schema Error: ${error.message}`);
+            return this.res.status(500).send({
+                status: false,
+                message: error.message
             });
         }
     }
 }
-export { Controller, ControllerSchema };
+export { Controller };