@xrystal/core 3.2.3

package/source/utils/models/classes/class.controller.d.ts

@@ -0,0 +1,121 @@
+import { NextFunction, Response } from 'express';
+import { ParsedQs } from 'qs';
+import { ProtocolEnum, ResponseSchema } from '../../index';
+export interface CustomRequest extends Request {
+    accounts?: any;
+    query: {
+        sort?: string;
+        ['start-date']?: string;
+        date?: string;
+        ['end-date']?: string;
+        offset?: string;
+        limit?: string;
+    } & ParsedQs;
+}
+export interface CustomResponse extends Response {
+    locals: {
+        ID?: any;
+        user?: any;
+    };
+}
+export interface ReturnChecksCallbackFuncInterface {
+    status?: boolean;
+    message?: string;
+    payload?: any;
+    code?: number;
+    response?: Function;
+    invalid?: boolean;
+}
+export interface ReturnLogicCallbackFuncInterface {
+    status?: boolean;
+    message?: string;
+    payload?: any;
+    code?: number;
+    response?: Response | NextFunction | Function;
+}
+export interface ReturnResponseCallbackFuncInterface {
+    message: Array<string>;
+    response?: Response;
+}
+export type Sort = {
+    key: string;
+    value: number;
+};
+declare abstract class Controller {
+    private logger;
+    protected protocol: ProtocolEnum | null;
+    protected socket: any | null;
+    protected req: CustomRequest | null | undefined;
+    protected res: Response | null | undefined;
+    protected accounts: any;
+    protected startDate: string | null;
+    protected date: string | null;
+    protected dateStart: string | null;
+    protected endDate: string | null;
+    protected sort: Sort | null;
+    protected offset: string | null;
+    protected limit: string | null;
+    defaultLimitSize: number;
+    maxLimitSize: number;
+    constructor({ protocol, socket, req, res }: {
+        protocol: ProtocolEnum;
+        socket?: any;
+        req?: CustomRequest;
+        res?: Response;
+    });
+    protected payloadProtocolSwitch: ({ protocol, socket, req, res }: {
+        protocol: ProtocolEnum;
+        socket?: any;
+        req?: any;
+        res?: Response;
+    }) => Promise<any>;
+    protected convertedPayloadProtocolSwitch: ({ protocol, socket, req, res, }: {
+        protocol: ProtocolEnum;
+        socket?: any;
+        req?: any;
+        res?: Response;
+    }) => Promise<any>;
+    protected responseProtocolSwitch: ({ protocol, socket, req, res, resStatus, context }: {
+        protocol: ProtocolEnum;
+        socket?: any;
+        req?: any;
+        res?: Response;
+        resStatus?: number;
+        context: ({ localeLanguageConverter }: {
+            localeLanguageConverter?: Function;
+        }) => ResponseSchema;
+    }) => Promise<Response | ResponseSchema>;
+    protected parsedQuerys: (url: string) => Record<any, any>;
+    protected parsedQuerysWithTrueType: (url: string) => Record<string, any>;
+    protected dateNativeUTCToUTCConverter: (date: string) => string;
+    protected sortParser: (sort: string) => Sort | null;
+    protected aprotator(value: any): boolean;
+    protected log: ({ level, message }: {
+        level: string;
+        message: string;
+    }) => Promise<void>;
+    protected getErrorMessage(error: unknown): string;
+}
+declare class ControllerSchema extends Controller {
+    constructor({ protocol, socket, req, res }: {
+        protocol: ProtocolEnum;
+        socket?: any;
+        req?: CustomRequest;
+        res?: Response;
+    });
+    schema({ checks, logic, response, }: {
+        checks?: ({ payload, convertedPayload }: {
+            payload?: any;
+            convertedPayload?: any;
+        }) => Promise<ReturnChecksCallbackFuncInterface | Array<any>>;
+        logic: ({ payload, convertedPayload }: {
+            payload?: any;
+            convertedPayload?: any;
+        }) => Promise<ReturnLogicCallbackFuncInterface>;
+        response?: ({ payload, convertedPayload }: {
+            payload?: any;
+            convertedPayload?: any;
+        }) => Promise<ReturnResponseCallbackFuncInterface>;
+    }): Promise<Response | ResponseSchema>;
+}
+export { Controller, ControllerSchema };

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

@@ -0,0 +1,421 @@
+import qs from 'qs';
+import { LoggerService } from '../../../loader';
+import { LoggerLayerEnum, ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../index';
+class Controller {
+    logger = x.get(LoggerService);
+    //private static logger: LogCallback | null = null
+    // => it wants properties for proccessing
+    protocol = null;
+    socket = null;
+    req = null;
+    res = null;
+    //
+    // => special properties
+    accounts = null;
+    // => special querys
+    startDate = null;
+    date = null;
+    dateStart = null;
+    endDate = null;
+    sort = null;
+    offset = null;
+    limit = null;
+    //
+    // => options
+    defaultLimitSize = 20;
+    maxLimitSize = 100;
+    //
+    constructor({ protocol, socket, req, res }) {
+        this.protocol = protocol;
+        this.socket = socket;
+        this.req = req;
+        this.res = res;
+    }
+    // => to switch
+    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');
+                }
+                this.req = req;
+                this.res = res;
+                const parsedQuerys = this.parsedQuerys(req?.originalUrl ? req?.originalUrl : '');
+                payload = {
+                    //socket: this.socket,
+                    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?.originalUrl ? req.originalUrl : '');
+                const parsedQuerysWithTrueType = this.parsedQuerysWithTrueType(req?.originalUrl ? req.originalUrl : '');
+                convertedPayload = {
+                    //socket: this.socket,
+                    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`);
+                }
+                return res.status(resStatus).send(context({
+                    localeLanguageConverter: req.t
+                }));
+            case ProtocolEnum.WEBSOCKET:
+                return context({});
+            case ProtocolEnum.SOCKETIO:
+                return context({});
+            case ProtocolEnum.NONE:
+                return context({});
+            default:
+                throw new Error('Protocol not match.');
+        }
+    };
+    //
+    // => helper
+    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;
+    };
+    dateNativeUTCToUTCConverter = (date) => {
+        const convertedDate = (new Date(date)).toISOString();
+        return convertedDate;
+    };
+    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 }) {
+        super({
+            protocol,
+            socket,
+            req,
+            res
+        });
+    }
+    async schema({ checks, logic, response, }) {
+        const { res, req } = this;
+        try {
+            let logicCallbackFunc;
+            // controlling all properties start
+            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 checked = 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
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.log({
+                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                    message: this.getErrorMessage(`Schema check controller handler: ${error.message}. Extra explanation: ${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
+                });
+            }
+            //end
+            // logic response start
+            try { // => (message and response) first rendering. If there is no message or data, it goes to the response scope.
+                logicCallbackFunc = await logic({
+                    payload: this.payloadProtocolSwitch,
+                    convertedPayload: await this.convertedPayloadProtocolSwitch({
+                        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');
+                    }
+                }
+                if (logicCallbackFunc?.message) {
+                    return 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
+                        }).getResponse
+                    });
+                }
+            }
+            catch (error /* unknow */) {
+                this.log({
+                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                    message: this.getErrorMessage(`Schema logic controller handler: ${error.message}. Extra explanation: ${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.schemaUnknowErrorLogic(error.message, JSON.stringify(error?.response?.data), localeLanguageConverter)}`,
+                    }).getResponse
+                });
+            }
+            //end
+            // return response start
+            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.");
+                    }
+                }
+                else {
+                    throw new Error('Please use response scope.');
+                }
+            }
+            catch (error /* unknow */) {
+                this.log({
+                    level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                    message: this.getErrorMessage(`Schema response controller handler: ${error.message}. Extra explanation: ${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.schemaUnknowErrorResponse(error.message, JSON.stringify(error?.response?.data), localeLanguageConverter)}`, // logic içersinde db dışında hata fırlatan data da olabilir düzenleme gerekecek
+                    }).getResponse
+                });
+            }
+            // end
+        }
+        catch (error /* unknow */) {
+            this.log({
+                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                message: this.getErrorMessage(`Schema main controller handler: ${error.message}. Extra explanation: ${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
+            });
+        }
+    }
+}
+export { Controller, ControllerSchema };

package/source/utils/models/classes/class.response.d.ts

@@ -0,0 +1,17 @@
+export interface PayloadSchemaInterface {
+    status: boolean;
+    message: string;
+    payload?: any;
+    [key: string]: any;
+    code?: number;
+}
+export declare class ResponseSchema {
+    constructor({ status, message, payload, code }: PayloadSchemaInterface);
+    status: boolean;
+    message: string;
+    payload: any;
+    code: number;
+    validData(): any;
+    statusCodeGenerator(): number;
+    get getResponse(): ResponseSchema;
+}

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

@@ -0,0 +1,37 @@
+export class ResponseSchema {
+    constructor({ status = false, message = '', payload = null, code = 0 }) {
+        this.status = status;
+        this.message = message;
+        this.payload = payload;
+        this.code = code;
+    }
+    status;
+    message;
+    payload;
+    code;
+    validData() {
+        return this.payload; // => ileride burada değiştirmeler olabilir.
+    }
+    statusCodeGenerator() {
+        if (this.status === false && this.code === 401 || this.code === 403) {
+            return Number(this.code);
+        }
+        else if (this.status === true) {
+            return this.code = 0;
+        }
+        else {
+            return this.code = 1;
+        }
+    }
+    get getResponse() {
+        let response = {
+            status: this.status,
+            message: this.message,
+        };
+        if (this.payload !== null) {
+            response.payload = this.validData();
+        }
+        response.code = this.statusCodeGenerator();
+        return { ...response };
+    }
+}