@xrystal/core 3.2.3

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

@@ -0,0 +1,129 @@
+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/source/utils/models/classes/class.services.js

@@ -0,0 +1,344 @@
+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/source/utils/models/classes/class.tmp-file-loader.d.ts

@@ -0,0 +1,11 @@
+import EventEmitter from "events";
+export declare class TmpFileLoader extends EventEmitter {
+    protected tmpFileJson: Record<string, any>;
+    private filePath;
+    constructor({ filePath }: {
+        filePath: string;
+    });
+    private load;
+    private watch;
+    getResolvedTmpFile(): Record<string, any>;
+}

package/source/utils/models/classes/class.tmp-file-loader.js

@@ -0,0 +1,38 @@
+import EventEmitter from "events";
+import path from "path";
+import fs from "fs";
+import yaml from 'yaml';
+import { resolveObjWithHandlebars } from "../../helpers";
+export class TmpFileLoader extends EventEmitter {
+    tmpFileJson = {};
+    filePath;
+    constructor({ filePath }) {
+        super();
+        this.filePath = path.resolve(filePath);
+        this.load();
+        this.watch();
+    }
+    load() {
+        try {
+            const bufferFile = fs.readFileSync(this.filePath);
+            const parsedYaml = yaml.parse(bufferFile.toString());
+            this.tmpFileJson = parsedYaml;
+            this.emit("reload", parsedYaml);
+        }
+        catch (err) {
+            console.error("Error:", err);
+        }
+    }
+    watch() {
+        fs.watchFile(this.filePath, () => {
+            this.load();
+        });
+    }
+    getResolvedTmpFile() {
+        if (this.tmpFileJson)
+            return resolveObjWithHandlebars(this.tmpFileJson, this.tmpFileJson);
+        this.load();
+        resolveObjWithHandlebars(this.tmpFileJson, this.tmpFileJson);
+        return this.tmpFileJson;
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare class X {
+    private _context;
+    constructor({}: {});
+    set: <T extends new (...args: any[]) => any>({ service, reference, args }: {
+        service: T;
+        reference: T;
+        args?: ConstructorParameters<T>;
+    }) => void;
+    get: <T>(service: new (...args: any) => T) => T;
+}
+declare const _default: X;
+export default _default;

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

@@ -0,0 +1,16 @@
+// => // X Service Locator
+export class X {
+    _context = new Map();
+    constructor({}) {
+    }
+    set = ({ service, reference, args }) => {
+        this._context.set(service, new reference(...(args || [])));
+    };
+    get = (service) => {
+        if (!this._context.has(service)) {
+            throw new Error(`${service} not found in context.`);
+        }
+        return this._context.get(service);
+    };
+}
+export default new X({});

package/source/utils/models/enums/index.d.ts

@@ -0,0 +1,116 @@
+export declare enum NodeEnvEnum {
+    DEV = "dev",
+    TEST = "test",
+    PROD = "prod"
+}
+export declare enum ProtocolEnum {
+    HTTP = "http",
+    HTTPS = "https",
+    WEBSOCKET = "ws",
+    SOCKETIO = "ws",
+    NONE = "none"
+}
+export declare enum PolarityTypeEnum {
+    NOTR = 0,
+    POSITIVE = 1,
+    NEGATIVE = -1
+}
+export declare enum LoggerLayerEnum {
+    CRITICAL = 0,
+    ERROR = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export declare enum CountryCodeEnum {
+    EN = "en",
+    TR = "tr"
+}
+export declare enum CurrencyCodeEnum {
+    USD = "usd",
+    EUR = "eur",
+    TRY = "try"
+}
+export declare enum HttpMethodEnum {
+    POST = "post",
+    GET = "get",
+    PUT = "put",
+    DELETE = "delete"
+}
+export declare enum ContentTypeEnum {
+    applicationJson = "application/json",
+    applicationXWwwFormUrlencoded = "application/x-www-form-urlencoded"
+}
+export declare enum DevicePlatformEnum {
+    WEB = "web",
+    NATIVE = "native",
+    OTHER = "other"
+}
+export declare enum DeviceOSEnum {
+    ANDROID = "android",
+    IOS = "ios",
+    WINDOWS = "windows",
+    MACOS = "macos",
+    MACOSX = "macosx",
+    OTHER = "other"
+}
+export declare enum PriorityEnum {
+    HIGH = 0,
+    MEDIUM = 1,
+    LOW = 2
+}
+export declare enum PrivacyEnum {
+    PRIVATE = 0,
+    PUBLIC = 1,
+    ONLY_FRIENDS = 2
+}
+export declare enum TimezoneEnum {
+    UTC = "UTC",
+    EtcUTC = "Etc/UTC",
+    EtcGMT = "Etc/GMT"
+}
+export declare enum TokensEnum {
+    CSRF_TOKEN = "csrf_token",
+    ACCESS_TOKEN = "access_token",
+    REFRESH_TOKEN = "refresh_token",
+    REFERENCE_TOKEN = "reference_token",
+    PERSONAL_ACCESS_TOKEN = "personal_access_token"
+}
+export declare enum EndpointResourceEnum {
+    EXAMPLE = "example",
+    FULL = "full",
+    SYSTEM = "system",
+    CLIENTS = "clients",
+    AUTH = "auth",
+    ACCOUNTS = "accounts",
+    USERS = "users",
+    TRANSACTIONS = "transactions",
+    NOTIFICATIONS = "notifications",
+    ADDRESSES = "addresses",
+    PAYMENTS = "payments",
+    COMMISSIONS_AND_TAXES = "commissions-and-taxes",
+    SUPPORTS = "supports",
+    INVOICES = "invoices",
+    FILES = "files",
+    TOKENS = "tokens",
+    WEBHOOKS = "webhooks",
+    OTHERS = "others"
+}
+export declare enum SupportFileExtensionsEnum {
+    'HTML' = "html",
+    'EJS' = "ejs",
+    'HBS' = "hbs",
+    "TS" = "",
+    "JS" = ".js",
+    "TSX" = "x",
+    "JSX" = ".jsx",
+    "TTF" = ".ttf",
+    "EOT" = ".eot",
+    "OTF" = ".otf",
+    "SVG" = ".svg",
+    "PNG" = ".png",
+    "WOFF" = ".woff",
+    "WOFF2" = ".woff2",
+    "CSS" = ".css",
+    "SCSS" = ".scss",
+    "SASS" = ".sass"
+}