@xrystal/core 3.8.3 → 3.8.5

package/package.json

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

package/source/loader/clients/index.d.ts

@@ -0,0 +1,10 @@
+import { ApiClient } from '../../utils/index';
+import ConfigsService from '../configs';
+export default class ClientsService {
+    apiClient: ApiClient;
+    apiClientname: string;
+    load({ configs, tmp }: {
+        configs: ConfigsService;
+        tmp: any;
+    }): Promise<void>;
+}

package/source/loader/clients/index.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { ApiClient, clientRegistry } from '../../utils/index';
+export default class ClientsService {
+    apiClient;
+    apiClientname = 'base-api-client';
+    async load({ configs, tmp }) {
+        this.apiClient = new ApiClient({
+            clientName: this.apiClientname,
+            baseURL: configs.all.baseApiUri || ''
+        });
+        clientRegistry[this.apiClientname] = this.apiClient;
+        const loaderConfig = tmp?.configs?.loaders?.clients;
+        if (!loaderConfig)
+            return;
+        const { loadPath, list } = loaderConfig;
+        let serviceMap = {};
+        if (loadPath) {
+            try {
+                const resolvedPath = path.resolve(process.cwd(), loadPath);
+                serviceMap = await import(resolvedPath);
+            }
+            catch (e) {
+                //
+            }
+        }
+        if (list) {
+            for (const [instanceName, className] of Object.entries(list)) {
+                const ServiceClass = serviceMap[className];
+                if (ServiceClass) {
+                    clientRegistry[instanceName] = new ServiceClass({
+                        clientName: instanceName,
+                        baseURL: configs.all[`${instanceName}Uri`] || configs.all.baseApiUri || '',
+                        version: configs.all[`${instanceName}Version`] || 'v1',
+                        timeout: configs.all[`${instanceName}Timeout`] || 15000
+                    });
+                }
+            }
+        }
+    }
+}

package/source/loader/configs/index.js

@@ -12,6 +12,7 @@ export default class ConfigsService {
             serviceName: rawConfigs.service,
             port: process.env.PORT || rawConfigs.port || 3000,
             systemStaticFolderPath: path.resolve(rawConfigs.rootFolderPath, this.publicFolderName),
+            baseApiUri: process.env.HTTPS === 'true' ? process.env.SYSTEM_HTTPS_BASE_API_URI : process.env.SYSTEM_BASE_API_URI,
             env: process.env.NODE_ENV,
             ...rawConfigs
         };

package/source/loader/events/index.d.ts

@@ -1,6 +1,9 @@
+import LoggerService from '../logger/index';
 export default class EventsService {
     private logger;
-    load: ({}: {}) => any;
+    load: ({ logger, }: {
+        logger: LoggerService;
+    }) => any;
     private _globalLoader;
     get global(): any;
 }

package/source/loader/events/index.js

@@ -1,8 +1,7 @@
-import LoggersLoader from '../logger/index';
-import { x, LoggerLayerEnum } from '../../utils/index';
+import { LoggerLayerEnum } from '../../utils/index';
 export default class EventsService {
-    logger = x.get(LoggersLoader);
-    load = ({}) => {
+    logger;
+    load = ({ logger, }) => {
         this._globalLoader();
     };
     _globalLoader = () => {

package/source/project/index.d.ts

@@ -1,5 +1,5 @@
-export declare const coreInıt: ({ locales }: {
-    locales: Record<string, any>;
+export declare const coreInit: (params: {
+    locales?: Record<string, any>;
 }) => Promise<void>;
 declare const coreLoader: ({}: {}) => Promise<{
     _?: undefined;

package/source/project/index.js

@@ -2,10 +2,13 @@
 import path from 'path';
 import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService } from '../loader/index';
 import { packageName, tmpFileDefaultName, tmpFileDefaultExt, findFileRecursively, TmpFileLoader, x, kafkaBrokers, systemLoggerLayer, } from '../utils/index';
+import ClientsService from 'source/loader/clients';
 //
 let coreHasRun = false;
-export const coreInıt = async ({ locales }) => {
-    globalThis.__LOCAL_MESSAGES__ = locales;
+export const coreInit = async (params) => {
+    const { locales } = params;
+    if (locales)
+        globalThis.__LOCAL_MESSAGES__ = locales;
 };
 const coreLoader = async ({}) => {
     if (coreHasRun)
@@ -32,8 +35,9 @@ const coreLoader = async ({}) => {
         const logger = x.get(LoggerService);
         const events = x.get(EventsService);
         const i18n = x.get(LocalizationsService);
+        const clientsService = x.get(ClientsService);
         await system.load({
-            tmp: { _: r }
+            tmp: r
         });
         configService.load({
             tmp: r,
@@ -48,12 +52,18 @@ const coreLoader = async ({}) => {
             kafkaBrokers: kafkaBrokers ?? "",
             kafkaTopic: configs.loaders.loggers.topic
         });
-        await events.load({});
+        await events.load({
+            logger
+        });
         await i18n.load({
             loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
             fallbackLang: configs.loaders.localization.fallbackLang,
             preloadLang: configs.loaders.localization.preloadLangs
         });
+        await clientsService.load({
+            configs: configService,
+            tmp: r,
+        });
         coreHasRun = true;
         return { _: r };
     }

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

@@ -1,129 +1,63 @@
-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 {
+import { ConfigsService, LoggerService } from 'source/loader';
+export declare const clientRegistry: Record<string, any>;
+export declare abstract class Service {
+    protected configService: ConfigsService;
     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, }: {
+    constructor({ clientName, baseURL, version, timeout }: {
         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;
+    static generateRandomNumber: ({ length }: {
         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, }: {
+export declare class ApiClient extends Service {
+    constructor(config: {
         clientName: string;
         baseURL: string;
         version?: string;
-        port?: number;
-        username: string;
-        password: string;
+        timeout?: number;
     });
-    /***********
-     * 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>;
+    request(path: string, options?: RequestInit): Promise<Response>;
 }
-export declare class AxiosClient extends Service {
-    constructor({ clientName, baseURL, version }: {
+export declare abstract class AuthenticatedApiClient extends ApiClient {
+    accessToken?: string;
+    constructor(config: {
         clientName: string;
         baseURL: string;
         version?: string;
+        timeout?: number;
     });
-    /***********
-     * LOADERS *
-     ***********/
-    protected axiosLoader(): AxiosInstance;
+    request(path: string, options?: RequestInit): Promise<Response>;
+    abstract authentication(): Promise<any>;
 }
-export declare class SoapClient extends Service {
-    private client;
-    constructor({ clientName, baseURL, version }: {
+export declare class EmailClient extends Service {
+    constructor(config: {
         clientName: string;
         baseURL: string;
         version?: string;
+        timeout?: number;
     });
-    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;
-    }>;
+    nodemailerLoader(config: any): nodemailer.Transporter<import("nodemailer/lib/smtp-transport").SentMessageInfo, import("nodemailer/lib/smtp-transport").Options>;
 }
-export declare class BaseApiClient extends AxiosClient implements IAuth {
-    constructor({ clientName, baseURL, version }: {
+export declare class SoapClient extends Service {
+    constructor(config: {
         clientName: string;
         baseURL: string;
-        version: string;
+        version?: string;
+        timeout?: number;
     });
-    protected axiosLoaderAuthMiddleware(): AxiosInstance;
-    authentication: () => Promise<import("axios").AxiosResponse<any, any, {}>>;
+    call(methodName: string, args: any): Promise<any>;
 }
-export default Service;

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

@@ -1,344 +1,126 @@
-import path from 'path';
-import axios from 'axios';
-import soap from 'soap';
-// => special
+import { createHash } from 'node:crypto';
+import path from 'node:path';
 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 {
+import soap from 'soap';
+import { ConfigsService, LoggerService } from 'source/loader';
+import { TokensEnum, x } from '..';
+export const clientRegistry = {};
+export class Service {
+    configService = x.get(ConfigsService);
     logger = x.get(LoggerService);
-    //private _instance: Record<string, any> = {}
     clientName;
     baseURL;
     version = null;
-    headers; /* unknow */
-    timeout = 10000;
-    /***************
-     * CONSTRUCTOR *
-     ***************/
-    constructor({ clientName, baseURL, version, timeout, headers, }) {
+    timeout = 15000;
+    constructor({ clientName, baseURL, version, timeout }) {
         this.clientName = clientName;
         this.baseURL = baseURL;
-        version && this.version;
-        if (timeout) {
+        this.version = version || null;
+        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 cryptoHashGenerate = ({ algorithm, input, digest = 'hex' }) => {
+        return createHash(algorithm).update(input).digest(digest);
     };
-    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 = '';
+    static generateRandomNumber = ({ length = 10 }) => {
+        let result = '';
         for (let i = 0; i < length; i++) {
-            const randomDigit = Math.floor(Math.random() * 10);
-            randomNumber += randomDigit.toString();
+            result += Math.floor(Math.random() * 10).toString();
         }
-        return `${prefix && hyphen ? prefix + '-' : ''}${randomNumber}${suffix && hyphen ? '-' + suffix : ''}`;
+        return result;
     };
 }
-export class ServiceStore {
-    static _instance = null;
-    _store = {};
-    constructor() { }
-    static create() {
-        if (!ServiceStore._instance) {
-            ServiceStore._instance = new ServiceStore();
+export class ApiClient extends Service {
+    constructor(config) {
+        super(config);
+    }
+    async request(path, options = {}) {
+        const base = this.baseURL.replace(/\/$/, '');
+        const ver = this.version ? `/${this.version.replace(/^\//, '')}` : '';
+        const url = `${base}${ver}${path}`;
+        const store = LoggerService.storage.getStore();
+        const correlationId = store?.get('correlationId');
+        const headers = new Headers(options.headers || {});
+        if (!headers.has('Content-Type'))
+            headers.set('Content-Type', 'application/json');
+        if (correlationId)
+            headers.set('x-correlation-id', correlationId);
+        if (process.env.INTERNAL_SECRET)
+            headers.set('X-Internal-Secret', process.env.INTERNAL_SECRET);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, { ...options, headers, signal: controller.signal });
+            clearTimeout(timeoutId);
+            return response;
+        }
+        catch (error) {
+            this.logger.winston.error(`${this.clientName} HTTP Request Failure: ${error.message}`, { url });
+            throw error;
         }
-        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 AuthenticatedApiClient extends ApiClient {
+    accessToken;
+    constructor(config) {
+        super(config);
+    }
+    async request(path, options = {}) {
+        const injectToken = (h, t) => h.set('Cookie', `${TokensEnum.ACCESS_TOKEN}:${t}`);
+        const headers = new Headers(options.headers || {});
+        if (this.accessToken)
+            injectToken(headers, this.accessToken);
+        options.headers = headers;
+        let response = await super.request(path, options);
+        if (response.status === 401) {
+            await this.authentication();
+            if (this.accessToken) {
+                const retryHeaders = new Headers(options.headers);
+                injectToken(retryHeaders, this.accessToken);
+                return super.request(path, { ...options, headers: retryHeaders });
+            }
+        }
+        return response;
     }
 }
 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;
+    constructor(config) {
+        super(config);
     }
-    /***********
-     * LOADERS *
-     ***********/
-    nodemailerLoader({ host, port, username, password, secure = true, }) {
+    nodemailerLoader(config) {
         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,
-            },
+            host: config.host || this.baseURL,
+            port: config.port,
+            secure: config.secure ?? true,
+            auth: { user: config.username, pass: config.password }
         });
+        const staticPath = this.configService.all.systemStaticFolderPath || 'source/statics';
         transporter.use('compile', hbs({
             viewEngine: {
                 extname: '.hbs',
-                layoutsDir: path.resolve('source', 'static', 'email'),
-                defaultLayout: 'index',
-                partialsDir: path.resolve('source', 'static', 'email'),
+                layoutsDir: path.resolve(staticPath, 'email'),
+                defaultLayout: 'index'
             },
-            viewPath: path.resolve('source', 'static', 'email', 'templates'),
+            viewPath: path.resolve(staticPath, '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;
-        }
+    constructor(config) {
+        super(config);
     }
-    async createAsyncClient({ fullURL }) {
+    async call(methodName, args) {
         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;
-            }
+            const client = await soap.createClientAsync(this.baseURL);
+            const result = await client[`${methodName}Async`](args);
+            return result[0];
         }
-        else {
+        catch (error) {
+            this.logger.winston.error(`${this.clientName} SOAP Error: ${error.message}`);
             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;