@xrystal/core 3.9.3 → 3.9.6

package/package.json

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

package/source/loader/configs/index.js

@@ -7,6 +7,7 @@ export default class ConfigsService {
         this._systemService = systemService;
         const rawConfigs = tmp?.configs || tmp?.configs || {};
         this.config = {
+            debug: process.env.SYSTEM_LOGGER_LAYER,
             rootFolderPath: rawConfigs.rootFolderPath || 'x',
             projectName: tmp.project.name,
             serviceName: rawConfigs.service,

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

@@ -1,13 +1,13 @@
 import { ProtocolEnum } from '../../index';
 export interface CustomRequest {
     accounts?: any;
-    query: Record<string, any>;
     url: string;
     method: string;
-    headers: Record<string, string>;
+    headers: Record<string, any>;
     body?: any;
-    params?: Record<string, string>;
-    t?: Function;
+    params: Record<string, any>;
+    query: Record<string, any>;
+    t?: any;
 }
 export interface CustomResponse {
     status: (code: number) => CustomResponse;
@@ -15,45 +15,11 @@ export interface CustomResponse {
     json: (data: any) => any;
     locals: Record<string, 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?: Function;
-}
-export interface ReturnResponseCallbackFuncInterface {
-    message: Array<string>;
-    response?: Function;
-}
-export type Sort = {
-    key: string;
-    value: number;
-};
 declare abstract class Controller {
     private logger;
     protected protocol: ProtocolEnum | null;
     protected req: CustomRequest | null;
     protected res: CustomResponse | null;
-    protected locals: Record<string, any>;
-    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, req, res, ctx }: {
         protocol: ProtocolEnum;
         req?: any;
@@ -62,7 +28,6 @@ declare abstract class Controller {
     });
     protected responseProtocolSwitch: ({ res, resStatus, context, req }: any) => Promise<any>;
     protected parsedQuerys: (url: string) => Record<string, any>;
-    protected log: (level: string, message: string) => Promise<void>;
 }
 export declare class ControllerSchema extends Controller {
     schema({ checks, logic, response, }: {

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

@@ -6,78 +6,64 @@ class Controller {
     protocol = null;
     req = null;
     res = null;
-    locals = {};
-    accounts = null;
-    startDate = null;
-    date = null;
-    dateStart = null;
-    endDate = null;
-    sort = null;
-    offset = null;
-    limit = null;
-    defaultLimitSize = 20;
-    maxLimitSize = 100;
     constructor({ protocol, req, res, ctx }) {
         this.protocol = protocol;
         if (ctx) {
             this.req = {
                 url: ctx.request?.url || '',
                 method: ctx.request?.method || '',
-                headers: ctx.headers || (ctx.request?.headers ? Object.fromEntries(ctx.request.headers) : {}),
+                headers: ctx.headers || {},
                 body: ctx.body,
-                params: ctx.params,
+                params: ctx.params || {},
                 query: ctx.query || {},
                 accounts: ctx.user || ctx.accounts,
                 t: ctx.t
             };
             this.res = {
-                locals: this.locals,
-                status: (code) => {
+                locals: {},
+                status(code) {
                     this.locals._code = code;
-                    return this.res;
+                    return this;
                 },
-                send: (data) => {
-                    if (this.protocol === ProtocolEnum.WEBSOCKET) {
+                send(data) {
+                    if (protocol === ProtocolEnum.WEBSOCKET)
                         return data;
-                    }
                     return new Response(JSON.stringify(data), {
                         status: this.locals._code || 200,
                         headers: { 'content-type': 'application/json' }
                     });
                 },
-                json: (data) => this.res.send(data)
+                json(data) {
+                    return this.send(data);
+                }
             };
         }
         else {
             this.req = {
-                url: req?.originalUrl || req?.url,
-                method: req?.method,
+                url: req?.originalUrl || req?.url || '',
+                method: req?.method || 'GET',
                 headers: req?.headers || {},
                 body: req?.body,
-                params: req?.params,
+                params: req?.params || {},
                 query: req?.query || {},
                 accounts: req?.accounts,
                 t: req?.t
             };
-            this.locals = res?.locals || {};
             this.res = {
-                locals: this.locals,
-                status: (code) => {
-                    if (res && typeof res.status === 'function') {
+                locals: res?.locals || {},
+                status(code) {
+                    if (res?.status)
                         res.status(code);
-                    }
-                    return this.res;
+                    return this;
                 },
-                send: (data) => {
-                    if (res && typeof res.send === 'function') {
+                send(data) {
+                    if (res?.send)
                         return res.send(data);
-                    }
                     return data;
                 },
-                json: (data) => {
-                    if (res && typeof res.json === 'function') {
+                json(data) {
+                    if (res?.json)
                         return res.json(data);
-                    }
                     return data;
                 }
             };
@@ -91,12 +77,11 @@ class Controller {
         const queryString = url.includes('?') ? url.split('?')[1] : '';
         return queryString ? 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, }) {
+        if (!this.req || !this.res)
+            return;
         const payload = { req: this.req, res: this.res };
         const convertedPayload = {
             ...payload,
@@ -168,7 +153,6 @@ export class ControllerSchema extends Controller {
             }
         }
         catch (error) {
-            await this.log('error', `Schema Error: ${error.message}`);
             return this.res.status(500).send({ status: false, message: error.message });
         }
     }

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

@@ -11,8 +11,16 @@ export declare abstract class Client {
     protected baseURL: string;
     protected version: string | null;
     protected timeout: number;
+    protected debug: boolean;
     protected authConfigs: any;
-    constructor({ clientName, baseURL, version, timeout, auth }: any);
+    protected breaker: {
+        failures: number;
+        lastFailure: number;
+        state: "CLOSED" | "OPEN" | "HALF_OPEN";
+        threshold: number;
+        cooldown: number;
+    };
+    constructor({ clientName, baseURL, version, timeout, auth, debug }: any);
     protected resolvePath(obj: any, path: string): any;
     static cryptoHashGenerate: ({ algorithm, input, digest }: {
         algorithm: string;
@@ -24,13 +32,18 @@ export declare class BaseApiClient extends Client {
     constructor(config: any);
     request(path: string, options?: RequestInit & {
         version?: string;
+        retries?: number;
+        debug?: boolean;
     }): 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;

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

@@ -1,7 +1,7 @@
 import { createHash, createHmac } from 'node:crypto';
 import soap from 'soap';
 import { ConfigsService, LoggerService } from '../../../loader';
-import { x } from '../../index';
+import { LoggerLayerEnum, x } from '../../index';
 export class ClientStore {
     static _store = {};
     static get(clientName) { return this._store[clientName] || {}; }
@@ -16,17 +16,25 @@ export class Client {
     baseURL;
     version = null;
     timeout = 15000;
+    debug = Number(this.configService.all.debug) >= LoggerLayerEnum.DEBUG;
     authConfigs;
-    constructor({ clientName, baseURL, version, timeout, auth }) {
+    breaker = {
+        failures: 0,
+        lastFailure: 0,
+        state: 'CLOSED',
+        threshold: 5,
+        cooldown: 30000
+    };
+    constructor({ clientName, baseURL, version, timeout, auth, debug }) {
         this.clientName = clientName;
         this.baseURL = baseURL;
         this.version = version || null;
         this.authConfigs = auth;
+        this.debug = debug ?? this.debug;
         if (timeout)
             this.timeout = timeout;
-        if (auth?.token) {
+        if (auth?.token)
             ClientStore.set(clientName, { accessToken: auth.token });
-        }
     }
     resolvePath(obj, path) {
         return path.split('.').reduce((prev, curr) => prev ? prev[curr] : undefined, obj);
@@ -38,6 +46,44 @@ export class Client {
 export class BaseApiClient extends Client {
     constructor(config) { super(config); }
     async request(path, options = {}) {
+        if (this.breaker.state === 'OPEN') {
+            if (Date.now() - this.breaker.lastFailure > this.breaker.cooldown) {
+                this.breaker.state = 'HALF_OPEN';
+            }
+            else {
+                throw new Error(`${this.clientName} circuit is OPEN. Request blocked.`);
+            }
+        }
+        const maxRetries = options.retries ?? 3;
+        let attempt = 0;
+        while (attempt < maxRetries) {
+            try {
+                const response = await this._execute(path, options);
+                if (response.ok || response.status === 401) {
+                    this.breaker.failures = 0;
+                    this.breaker.state = 'CLOSED';
+                    return response;
+                }
+                if ([502, 503, 504].includes(response.status)) {
+                    throw new Error(`Server Error: ${response.status}`);
+                }
+                return response;
+            }
+            catch (error) {
+                attempt++;
+                this.breaker.failures++;
+                this.breaker.lastFailure = Date.now();
+                if (this.breaker.failures >= this.breaker.threshold)
+                    this.breaker.state = 'OPEN';
+                if (attempt >= maxRetries)
+                    throw error;
+                const backoff = Math.pow(2, attempt) * 500;
+                await new Promise(res => setTimeout(res, backoff));
+            }
+        }
+        throw new Error(`${this.clientName} request failed after ${maxRetries} attempts.`);
+    }
+    async _execute(path, options) {
         const base = this.baseURL.replace(/\/$/, '');
         const activeVersion = options.version !== undefined ? options.version : this.version;
         const ver = activeVersion ? `/${activeVersion.replace(/^\//, '')}` : '';
@@ -58,18 +104,21 @@ 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;
+        if (isDebugMode) {
+            this.logger.winston.info(`${this.clientName} Request Details`, {
+                method: options.method || 'GET',
+                url,
+                headers: Object.fromEntries(headers.entries()),
+                body: options.body ? (typeof options.body === 'string' ? JSON.parse(options.body) : 'Data') : null
+            });
+        }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const { version, ...fetchOptions } = options;
-            const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
-            clearTimeout(timeoutId);
-            return response;
-        }
-        catch (error) {
-            this.logger.winston.error(`${this.clientName} HTTP Request Failure: ${error.message}`, { url });
-            throw error;
-        }
+        const { version, retries, debug, ...fetchOptions } = options;
+        const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
+        clearTimeout(timeoutId);
+        return response;
     }
 }
 export class AuthenticatedApiClient extends BaseApiClient {
@@ -78,10 +127,7 @@ export class AuthenticatedApiClient extends BaseApiClient {
     async request(path, options = {}) {
         const headerName = this.authConfigs?.header || 'Authorization';
         const prefix = this.authConfigs?.prefix ?? 'Bearer';
-        const injectToken = (h, t) => {
-            const value = prefix ? `${prefix} ${t}` : t;
-            h.set(headerName, value);
-        };
+        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)
@@ -90,10 +136,10 @@ export class AuthenticatedApiClient extends BaseApiClient {
         let response = await super.request(path, options);
         if (response.status === 401) {
             await this._synchronizedAuthentication();
-            store = ClientStore.get(this.clientName);
-            if (store.accessToken) {
+            const freshStore = ClientStore.get(this.clientName);
+            if (freshStore.accessToken) {
                 const retryHeaders = new Headers(options.headers);
-                injectToken(retryHeaders, store.accessToken);
+                injectToken(retryHeaders, freshStore.accessToken);
                 return super.request(path, { ...options, headers: retryHeaders });
             }
         }
@@ -128,9 +174,7 @@ export class AuthenticatedApiClient extends BaseApiClient {
             throw error;
         }
     }
-    async authentication() {
-        return true;
-    }
+    async authentication() { return true; }
 }
 export class SoapClient extends Client {
     constructor(config) { super(config); }