@xrystal/core 3.5.8 → 3.6.1

package/x/dist/utils/models/classes/class.controller.js

@@ -1,164 +0,0 @@
-import qs from 'qs';
-import { LoggerService } from '../../../loader';
-import { responseMessageHelper, ResponseSchema, x } from '../../index';
-class Controller {
-    logger = x.get(LoggerService);
-    protocol = null;
-    req = null;
-    res = null;
-    constructor({ protocol, req, res, ctx }) {
-        this.protocol = protocol;
-        if (ctx) {
-            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.user || ctx.accounts,
-                t: ctx.t
-            };
-            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);
-                }
-            };
-        }
-        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);
-                }
-            };
-        }
-    }
-    responseProtocolSwitch = async ({ protocol, req, res, resStatus = 200, context }) => {
-        const responseData = context({ localeLanguageConverter: req.t });
-        return res.status(resStatus).send(responseData);
-    };
-    parsedQuerys = (url) => {
-        const queryString = url.includes('?') ? url.split('?')[1] : '';
-        if (!queryString)
-            return {};
-        return qs.parse(queryString, { decoder: decodeURIComponent });
-    };
-    log = async (level, message) => {
-        this.logger.winston.log({ level, message });
-    };
-}
-export class ControllerSchema extends Controller {
-    async schema({ checks, logic, response, }) {
-        const payload = { req: this.req, res: this.res };
-        const convertedPayload = {
-            ...payload,
-            parsedQuerys: this.parsedQuerys(this.req.url)
-        };
-        try {
-            if (checks) {
-                const checkResult = await checks({ payload, convertedPayload });
-                let isInvalid = false;
-                if (Array.isArray(checkResult)) {
-                    isInvalid = !checkResult.every(c => c !== undefined && c !== null && c !== "");
-                }
-                else if (typeof checkResult === 'object' && checkResult.message) {
-                    return await this.responseProtocolSwitch({
-                        protocol: this.protocol,
-                        req: this.req,
-                        res: this.res,
-                        context: () => new ResponseSchema({
-                            status: checkResult.status || false,
-                            message: checkResult.message,
-                            payload: checkResult.payload,
-                            code: checkResult.code
-                        }).getResponse
-                    });
-                }
-                if (isInvalid) {
-                    return await this.responseProtocolSwitch({
-                        protocol: this.protocol,
-                        req: this.req,
-                        res: this.res,
-                        resStatus: 400,
-                        context: ({ localeLanguageConverter }) => new ResponseSchema({
-                            status: false,
-                            message: responseMessageHelper.schemaMissingDataChecks(localeLanguageConverter)
-                        }).getResponse
-                    });
-                }
-            }
-            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,
-                    req: this.req,
-                    res: this.res,
-                    resStatus: 400,
-                    context: () => new ResponseSchema({
-                        status: logicResult.status || false,
-                        message: logicResult.message,
-                        payload: logicResult.payload,
-                        code: logicResult.code
-                    }).getResponse
-                });
-            }
-            if (response) {
-                const resResult = await response({ payload, convertedPayload });
-                if (resResult.response instanceof Function) {
-                    return resResult.response(resResult);
-                }
-                return await this.responseProtocolSwitch({
-                    protocol: this.protocol,
-                    req: this.req,
-                    res: this.res,
-                    resStatus: 200,
-                    context: ({ localeLanguageConverter }) => new ResponseSchema({
-                        status: true,
-                        message: responseMessageHelper.successFully(resResult.message[0], resResult.message[1], localeLanguageConverter),
-                        payload: logicResult.payload
-                    }).getResponse
-                });
-            }
-        }
-        catch (error) {
-            await this.log('error', `Schema Error: ${error.message}`);
-            return this.res.status(500).send({
-                status: false,
-                message: error.message
-            });
-        }
-    }
-}
-export { Controller };

package/x/dist/utils/models/classes/class.response.d.ts

@@ -1,17 +0,0 @@
-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/x/dist/utils/models/classes/class.response.js

@@ -1,37 +0,0 @@
-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 };
-    }
-}

package/x/dist/utils/models/classes/class.services.d.ts

@@ -1,129 +0,0 @@
-import { AxiosInstance } from 'axios';
-import nodemailer from 'nodemailer';
-import { LoggerService } from '../../../loader/index';
-export interface IAuth {
-    authentication: (params: any) => Promise<void> | any;
-}
-declare abstract class Service {
-    protected logger: LoggerService;
-    clientName: string;
-    protected baseURL: string;
-    protected version: string | null;
-    protected headers: any;
-    protected timeout: number;
-    /***************
-     * CONSTRUCTOR *
-     ***************/
-    protected constructor({ clientName, baseURL, version, timeout, headers, }: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-        headers?: {
-            'Content-Type'?: string;
-            'Lang'?: string;
-            'Authorization'?: string;
-        };
-    });
-    /***********
-     * HELPERS *
-     ***********/
-    protected interceptorErrorComplement(error: any): void;
-    routeSlashChecker(route: string): string;
-    static cryptoHashGenerate: ({ algorithm, input, digest }: {
-        algorithm: string;
-        input: string;
-        digest?: string;
-    }) => string;
-    static cryptoHashDecrypt: ({ algorithm, input, keyEncoding, key, initializationVector, inputEncoding, outputEncoding, }: {
-        algorithm: string;
-        input: string;
-        keyEncoding?: string;
-        key: string;
-        initializationVector: string;
-        inputEncoding?: BufferEncoding;
-        outputEncoding?: BufferEncoding;
-    }) => string;
-    static objectToFormData: (object: any) => FormData;
-    static generateRandomNumber: ({ prefix, suffix, hyphen, length, totalLength }: {
-        prefix?: string;
-        suffix?: string;
-        hyphen?: boolean;
-        length?: number;
-        totalLength?: number | null;
-    }) => string;
-}
-export declare class ServiceStore {
-    private static _instance;
-    private _store;
-    private constructor();
-    static create(): ServiceStore;
-    set setStore(callback: (store: Record<any, any>) => any);
-    get instance(): Record<any, any> | null;
-    get store(): Record<any, any>;
-}
-export declare class EmailClient extends Service {
-    private _port;
-    private _username;
-    private _password;
-    constructor({ clientName, baseURL, version, port, username, password, }: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        port?: number;
-        username: string;
-        password: string;
-    });
-    /***********
-     * LOADERS *
-     ***********/
-    nodemailerLoader({ host, port, username, password, secure, }: {
-        host?: string;
-        port?: number;
-        username?: string;
-        password?: string;
-        secure?: boolean;
-    }): nodemailer.Transporter<import("nodemailer/lib/smtp-transport").SentMessageInfo, import("nodemailer/lib/smtp-transport").Options>;
-}
-export declare class AxiosClient extends Service {
-    constructor({ clientName, baseURL, version }: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-    });
-    /***********
-     * LOADERS *
-     ***********/
-    protected axiosLoader(): AxiosInstance;
-}
-export declare class SoapClient extends Service {
-    private client;
-    constructor({ clientName, baseURL, version }: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-    });
-    getAsyncBaseClient(): Promise<{
-        [key: string]: any;
-    }>;
-    createAsyncClient({ fullURL }: {
-        fullURL: string;
-    }): Promise<{
-        [key: string]: any;
-    }>;
-    getAsyncMethod(methodName: string, pathname: string, args?: {
-        [key: string | number]: any;
-    }): Promise<{
-        [key: string]: any;
-    }>;
-}
-export declare class BaseApiClient extends AxiosClient implements IAuth {
-    constructor({ clientName, baseURL, version }: {
-        clientName: string;
-        baseURL: string;
-        version: string;
-    });
-    protected axiosLoaderAuthMiddleware(): AxiosInstance;
-    authentication: () => Promise<import("axios").AxiosResponse<any, any, {}>>;
-}
-export default Service;

package/x/dist/utils/models/classes/class.services.js

@@ -1,344 +0,0 @@
-import path from 'path';
-import axios from 'axios';
-import soap from 'soap';
-// => special
-import nodemailer from 'nodemailer';
-import hbs from 'nodemailer-express-handlebars';
-//
-import { LoggerService } from '../../../loader/index';
-import { x, LoggerLayerEnum, TokensEnum } from '../../index';
-// => for cryptography
-import crypto from 'crypto';
-class Service {
-    logger = x.get(LoggerService);
-    //private _instance: Record<string, any> = {}
-    clientName;
-    baseURL;
-    version = null;
-    headers; /* unknow */
-    timeout = 10000;
-    /***************
-     * CONSTRUCTOR *
-     ***************/
-    constructor({ clientName, baseURL, version, timeout, headers, }) {
-        this.clientName = clientName;
-        this.baseURL = baseURL;
-        version && this.version;
-        if (timeout) {
-            this.timeout = timeout;
-        }
-        if (headers) {
-            this.headers = {
-                ...headers
-            };
-        }
-    }
-    /***********
-     * HELPERS *
-     ***********/
-    interceptorErrorComplement(error /* unknow */) {
-        if (error.response) {
-            this.logger.winston.info({
-                level: LoggerLayerEnum[LoggerLayerEnum.ERROR].toLowerCase(),
-                message: `${this.clientName} api service error: ${JSON.stringify(error.response)}`,
-            });
-        }
-        else {
-            this.logger.winston.info({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `${this.clientName} api service error: ${JSON.stringify(error.message)}`,
-            });
-        }
-    }
-    routeSlashChecker(route) {
-        const splash = route.split('/');
-        let withSplash;
-        if (splash[0] === '') {
-            withSplash = route.substring(1);
-        }
-        else {
-            withSplash = route;
-        }
-        return withSplash;
-    }
-    static cryptoHashGenerate = ({ algorithm, input, digest = 'string' }) => {
-        return crypto.createHash(algorithm).update(input).digest(digest);
-    };
-    static cryptoHashDecrypt = ({ algorithm, input, keyEncoding = 'hex', key, initializationVector, inputEncoding = 'base64', outputEncoding = 'utf8', }) => {
-        const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key, keyEncoding), Buffer.from(initializationVector, inputEncoding));
-        let decrypted = decipher.update(input, inputEncoding, outputEncoding);
-        decrypted += decipher.final(outputEncoding);
-        return decrypted;
-    };
-    static objectToFormData = (object) => {
-        const formData = new FormData();
-        for (const [key, value] of Object.entries(object)) {
-            let changedValue = null;
-            changedValue = value;
-            if (Array.isArray(value)) {
-                changedValue = JSON.stringify(value);
-            }
-            formData.append(key, changedValue);
-        }
-        return formData;
-    };
-    static generateRandomNumber = ({ prefix, suffix, hyphen = true, length = 10, totalLength = null }) => {
-        if (!Number.isInteger(length) || length <= 0) {
-            throw new Error(`Invalid length.`);
-        }
-        if (totalLength) {
-            const prefixLength = prefix ? Number(prefix?.length) : null;
-            const suffixLength = suffix ? Number(suffix?.length) : null;
-            if (prefixLength && !Number.isInteger(prefixLength) || length <= 0 ||
-                suffixLength && !Number.isInteger(suffixLength) || length <= 0) {
-                throw new Error(`Invalid type.`);
-            }
-            if (prefixLength) {
-                totalLength -= prefixLength + 1;
-            }
-            if (suffixLength) {
-                totalLength -= suffixLength + 1;
-            }
-            length = totalLength;
-        }
-        let randomNumber = '';
-        for (let i = 0; i < length; i++) {
-            const randomDigit = Math.floor(Math.random() * 10);
-            randomNumber += randomDigit.toString();
-        }
-        return `${prefix && hyphen ? prefix + '-' : ''}${randomNumber}${suffix && hyphen ? '-' + suffix : ''}`;
-    };
-}
-export class ServiceStore {
-    static _instance = null;
-    _store = {};
-    constructor() { }
-    static create() {
-        if (!ServiceStore._instance) {
-            ServiceStore._instance = new ServiceStore();
-        }
-        return ServiceStore._instance;
-    }
-    set setStore(callback) {
-        const returnCallback = callback(this._store);
-        this._store = {
-            ...this._store,
-            ...returnCallback
-        };
-    }
-    get instance() {
-        return ServiceStore._instance;
-    }
-    get store() {
-        return this._store;
-    }
-}
-export class EmailClient extends Service {
-    _port = null;
-    _username = null;
-    _password = null;
-    constructor({ clientName, baseURL, version, port, username, password, }) {
-        super({ clientName, baseURL, version });
-        this._username = username;
-        this._password = password;
-    }
-    /***********
-     * LOADERS *
-     ***********/
-    nodemailerLoader({ host, port, username, password, secure = true, }) {
-        const transporter = nodemailer.createTransport({
-            //@ts-ignore
-            host: host ? host : this.baseURL,
-            port: port ? port : this._port,
-            secure,
-            auth: {
-                user: username ? username : this._username,
-                pass: password ? password : this._password,
-            },
-        });
-        transporter.use('compile', hbs({
-            viewEngine: {
-                extname: '.hbs',
-                layoutsDir: path.resolve('source', 'static', 'email'),
-                defaultLayout: 'index',
-                partialsDir: path.resolve('source', 'static', 'email'),
-            },
-            viewPath: path.resolve('source', 'static', 'email', 'templates'),
-            extName: '.hbs'
-        }));
-        return transporter;
-    }
-}
-export class AxiosClient extends Service {
-    constructor({ clientName, baseURL, version }) {
-        super({ clientName, baseURL, version });
-    }
-    /***********
-     * LOADERS *
-     ***********/
-    axiosLoader() {
-        const axiosInstance = axios.create({
-            baseURL: this.baseURL,
-            timeout: this.timeout,
-            headers: {
-                ...this.headers
-            },
-        });
-        axiosInstance.interceptors.request.use((config /* unknow */) => {
-            return config;
-        }, (error) => {
-            this.logger.winston.info({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `${this.clientName} api service error: ${JSON.stringify(error)}`,
-            });
-            return Promise.reject(error);
-        });
-        return axiosInstance;
-    }
-}
-export class SoapClient extends Service {
-    client;
-    constructor({ clientName, baseURL, version }) {
-        super({ clientName, baseURL, version });
-    }
-    async getAsyncBaseClient() {
-        try {
-            this.client = await soap.createClientAsync(this.baseURL);
-            return this.client;
-        }
-        catch (exception) {
-            this.logger.winston.error({
-                level: LoggerLayerEnum[LoggerLayerEnum.ERROR].toLowerCase(),
-                message: `${this.clientName} - soap client error: ${exception}`,
-            });
-            return null;
-        }
-    }
-    async createAsyncClient({ fullURL }) {
-        try {
-            this.client = await soap.createClientAsync(fullURL);
-            //console.log(this.client)
-            return this.client;
-        }
-        catch (exception) {
-            this.logger.winston.error({
-                level: LoggerLayerEnum[LoggerLayerEnum.ERROR].toLowerCase(),
-                message: `${this.clientName} - soap client error: ${exception}`,
-            });
-            return null;
-        }
-    }
-    async getAsyncMethod(methodName, pathname, args) {
-        let client = null;
-        let result = null;
-        if (pathname) {
-            client = await this.createAsyncClient({ fullURL: `${this.baseURL}${pathname}` });
-        }
-        else {
-            client = await this.getAsyncBaseClient();
-        }
-        //console.log('client: ', client)
-        if (client) {
-            try {
-                let data = await client[`${methodName}Async`](args);
-                result = data[0];
-            }
-            catch (exception) {
-                this.logger.winston.error({
-                    level: LoggerLayerEnum[LoggerLayerEnum.ERROR].toLowerCase(),
-                    message: `${this.clientName} - soap client method error: ${exception}`,
-                });
-                return null;
-            }
-        }
-        else {
-            return null;
-        }
-        return result;
-    }
-}
-export class BaseApiClient extends AxiosClient {
-    constructor({ clientName, baseURL, version }) {
-        super({
-            clientName,
-            baseURL,
-            version
-        });
-    }
-    axiosLoaderAuthMiddleware() {
-        const axiosInstance = this.axiosLoader();
-        let _retry = false;
-        axiosInstance.interceptors.request.use((config) => {
-            const accessToken = (ServiceStore.create()).store?.[this.clientName]?.accessToken;
-            if (accessToken) {
-                config.headers['Cookie'] = `${TokensEnum.ACCESS_TOKEN}:${accessToken}`;
-            }
-            return config;
-        }, (error) => {
-            return Promise.reject(error);
-        });
-        axiosInstance.interceptors.response.use(async (response) => {
-            const originalRequest = response.config;
-            if (!_retry && response.data?.success === false && response.data?.status_code === 101) {
-                this.logger.winston.info({
-                    level: LoggerLayerEnum[LoggerLayerEnum.INFO].toLowerCase(),
-                    message: `${this.clientName} client - token refreshed!`,
-                });
-                try {
-                    await this.authentication();
-                    _retry = true;
-                    originalRequest.headers['Cookie'] = `${TokensEnum.ACCESS_TOKEN}:${(ServiceStore.create()).store?.[this.clientName]?.accessToken}`;
-                    //console.log(originalConfig)
-                    return axiosInstance(originalRequest);
-                }
-                catch (error) {
-                    this.logger.winston.info({
-                        level: LoggerLayerEnum[LoggerLayerEnum.INFO].toLowerCase(),
-                        message: `${this.clientName} client - token refresh request not initial!`,
-                    });
-                    return Promise.reject(error);
-                }
-            }
-            return response;
-        }, async (error) => {
-            const originalConfig = error.config;
-            if (error.response.status === 401 && !originalConfig._retry) {
-                this.logger.winston.info({
-                    level: LoggerLayerEnum[LoggerLayerEnum.INFO].toLowerCase(),
-                    message: `${this.clientName} client - token refreshed!`,
-                });
-                originalConfig._retry = true;
-                try {
-                    await this.authentication();
-                    const accessToken = (ServiceStore.create()).store?.[this.clientName]?.accessToken;
-                    originalConfig.headers['Cookie'] = `${TokensEnum.ACCESS_TOKEN}:${accessToken}`;
-                    //console.log(originalConfig)
-                    return axiosInstance(originalConfig);
-                }
-                catch (error) {
-                    this.logger.winston.info({
-                        level: LoggerLayerEnum[LoggerLayerEnum.INFO].toLowerCase(),
-                        message: `${this.clientName} client - token refresh request not initial!`,
-                    });
-                    return Promise.reject(error);
-                }
-            }
-            return Promise.reject(error);
-        });
-        return axiosInstance;
-    }
-    authentication = async () => {
-        const response = await this.axiosLoader().post(`/${this.version}/auth/sign-in`, {});
-        if (response.data.success !== true) {
-            throw new Error('Authorization not implemented');
-        }
-        const servicesStore = ServiceStore.create();
-        servicesStore.setStore = ((prevState => ({
-            [this.clientName]: {
-                accessToken: response.data?.payload?.data?.token
-            }
-        })));
-        return response;
-    };
-}
-export default Service;

package/x/dist/utils/models/classes/class.tmp-file-loader.d.ts

@@ -1,8 +0,0 @@
-import { EventEmitter } from "node:events";
-export declare class TmpFileLoader extends EventEmitter {
-    #private;
-    constructor({ filePath }: {
-        filePath: string;
-    });
-    getResolvedTmpFile(): any;
-}