@xrystal/core 3.26.5 → 3.26.6

package/package.json

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

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

@@ -38,20 +38,4 @@ export declare class BaseApiClient extends Client {
     request(path: string, options?: CustomRequestOptions): Promise<Response>;
     private _execute;
 }
-export declare abstract class AuthenticatedApiClient extends BaseApiClient {
-    private _authPromise;
-    constructor(config: any);
-    request(path: string, options?: RequestInit & {
-        version?: string;
-        retries?: number;
-        debug?: boolean;
-    }): Promise<Response>;
-    private _synchronizedAuthentication;
-    private internalLogin;
-    authentication(): Promise<any>;
-}
-export declare class SoapClient extends Client {
-    constructor(config: any);
-    call(methodName: string, args: any): Promise<any>;
-}
 export {};

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

@@ -1,5 +1,4 @@
 import { createHash, createHmac } from 'node:crypto';
-import soap from 'soap';
 import { Configs, Logger } from '../../../loader';
 import { LoggerLayerEnum, x } from '../../index';
 export class ClientStore {
@@ -16,7 +15,7 @@ export class Client {
     baseURL;
     version = null;
     timeout = 15000;
-    debug = Number(this.configs.all.debug) >= LoggerLayerEnum.DEBUG;
+    debug;
     authConfigs;
     breaker = {
         failures: 0,
@@ -26,13 +25,13 @@ export class Client {
         cooldown: 30000
     };
     constructor({ clientName, baseURL, version, timeout, auth, debug }) {
-        this.debug = debug ?? this.debug;
         this.clientName = clientName;
         this.baseURL = baseURL;
         this.version = version || null;
         this.authConfigs = auth;
-        if (timeout)
-            this.timeout = timeout;
+        this.timeout = timeout || 15000;
+        const configDebug = Number(this.configs.all.debug) >= LoggerLayerEnum.DEBUG;
+        this.debug = debug ?? configDebug;
         if (auth?.token)
             ClientStore.set(clientName, { accessToken: auth.token });
     }
@@ -51,14 +50,14 @@ export class BaseApiClient extends Client {
                 this.breaker.state = 'HALF_OPEN';
             }
             else {
-                throw new Error(`${this.clientName} circuit is OPEN. Request blocked.`);
+                throw new Error(`[CircuitBreaker] ${this.clientName} is OPEN`);
             }
         }
         const maxRetries = options.retries ?? 3;
         let attempt = 0;
         while (attempt < maxRetries) {
             try {
-                const response = await this._execute(path, options);
+                const response = await this._execute(path, { ...options });
                 if (response.ok || response.status === 401) {
                     this.breaker.failures = 0;
                     this.breaker.state = 'CLOSED';
@@ -81,7 +80,7 @@ export class BaseApiClient extends Client {
                 await new Promise(res => setTimeout(res, backoff));
             }
         }
-        throw new Error(`${this.clientName} request failed after ${maxRetries} attempts.`);
+        throw new Error(`${this.clientName} failed after ${maxRetries} attempts`);
     }
     async _execute(path, options) {
         const base = this.baseURL.replace(/\/$/, '');
@@ -91,7 +90,11 @@ export class BaseApiClient extends Client {
         const store = Logger.storage.getStore();
         const correlationId = store?.get('correlationId');
         const headers = new Headers(options.headers || {});
-        headers.set('Content-Type', 'application/json');
+        const isUrlEncoded = options.body instanceof URLSearchParams;
+        const isFormData = options.body instanceof FormData;
+        if (!isUrlEncoded && !isFormData) {
+            headers.set('Content-Type', 'application/json');
+        }
         if (correlationId)
             headers.set('x-correlation-id', correlationId);
         const systemSecret = this.configs.all.internalSecret || process.env.INTERNAL_SECRET;
@@ -104,93 +107,36 @@ export class BaseApiClient extends Client {
             headers.set('x-internal-timestamp', timestamp);
             headers.set('x-internal-client', this.clientName);
         }
-        const isDebugMode = options.debug !== undefined ? options.debug : this.debug;
+        const isDebugMode = options.debug ?? this.debug;
         const { version, retries, debug, ...fetchOptions } = options;
-        if (fetchOptions.body && typeof fetchOptions.body === 'object' && !(fetchOptions.body instanceof FormData)) {
-            fetchOptions.body = JSON.stringify(fetchOptions.body);
+        let processedBody = fetchOptions.body;
+        if (processedBody && typeof processedBody === 'object' && !isUrlEncoded && !isFormData) {
+            processedBody = JSON.stringify(processedBody);
         }
         if (isDebugMode) {
-            const logPayload = {
-                method: options.method || 'GET',
+            const logData = {
+                method: fetchOptions.method || 'GET',
                 url,
-                headers: Object.fromEntries(headers.entries()),
-                body: options.body
+                body: processedBody && typeof processedBody === 'string' ? JSON.parse(processedBody) : processedBody
             };
-            this.logger.winston.info(`${this.clientName} Request Details: ${JSON.stringify(logPayload, null, 2)}`);
+            console.log(`[DEBUG] ${this.clientName}`, logData);
+            this.logger.winston.info(`${this.clientName} Request`, logData);
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
-        clearTimeout(timeoutId);
-        return response;
-    }
-}
-export class AuthenticatedApiClient extends BaseApiClient {
-    _authPromise = null;
-    constructor(config) { super(config); }
-    async request(path, options = {}) {
-        const headerName = this.authConfigs?.header || 'Authorization';
-        const prefix = this.authConfigs?.prefix ?? 'Bearer';
-        const injectToken = (h, t) => h.set(headerName, prefix ? `${prefix} ${t}` : t);
-        let store = ClientStore.get(this.clientName);
-        const headers = new Headers(options.headers || {});
-        if (store.accessToken)
-            injectToken(headers, store.accessToken);
-        options.headers = headers;
-        let response = await super.request(path, options);
-        if (response.status === 401) {
-            await this._synchronizedAuthentication();
-            const freshStore = ClientStore.get(this.clientName);
-            if (freshStore.accessToken) {
-                const retryHeaders = new Headers(options.headers);
-                injectToken(retryHeaders, freshStore.accessToken);
-                return super.request(path, { ...options, headers: retryHeaders });
-            }
-        }
-        return response;
-    }
-    async _synchronizedAuthentication() {
-        if (this._authPromise)
-            return this._authPromise;
-        this._authPromise = (async () => {
-            await this.authentication();
-            await this.internalLogin();
-        })().finally(() => { this._authPromise = null; });
-        return this._authPromise;
-    }
-    async internalLogin() {
-        if (!this.authConfigs || !this.authConfigs.endpoint)
-            return;
-        const { endpoint, payload, method, tokenPath } = this.authConfigs;
         try {
-            const response = await fetch(`${this.baseURL}${endpoint}`, {
-                method: method || 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(payload)
+            const response = await fetch(url, {
+                ...fetchOptions,
+                body: processedBody,
+                headers,
+                signal: controller.signal
             });
-            const data = await response.json();
-            const token = this.resolvePath(data, tokenPath || 'accessToken');
-            if (token)
-                ClientStore.set(this.clientName, { accessToken: token });
-            return data;
+            clearTimeout(timeoutId);
+            return response;
         }
         catch (error) {
+            clearTimeout(timeoutId);
             throw error;
         }
     }
-    async authentication() { return true; }
-}
-export class SoapClient extends Client {
-    constructor(config) { super(config); }
-    async call(methodName, args) {
-        try {
-            const client = await soap.createClientAsync(this.baseURL);
-            const result = await client[`${methodName}Async`](args);
-            return result[0];
-        }
-        catch (error) {
-            this.logger.winston.error(`${this.clientName} SOAP Error: ${error.message}`);
-            return null;
-        }
-    }
 }