@xrystal/core 3.9.3 → 3.9.4

package/package.json

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

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

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

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

@@ -17,6 +17,13 @@ export class Client {
     version = null;
     timeout = 15000;
     authConfigs;
+    breaker = {
+        failures: 0,
+        lastFailure: 0,
+        state: 'CLOSED',
+        threshold: 5,
+        cooldown: 30000
+    };
     constructor({ clientName, baseURL, version, timeout, auth }) {
         this.clientName = clientName;
         this.baseURL = baseURL;
@@ -24,9 +31,8 @@ export class Client {
         this.authConfigs = auth;
         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 +44,45 @@ 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(/^\//, '')}` : '';
@@ -60,16 +105,10 @@ export class BaseApiClient extends Client {
         }
         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, ...fetchOptions } = options;
+        const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
+        clearTimeout(timeoutId);
+        return response;
     }
 }
 export class AuthenticatedApiClient extends BaseApiClient {
@@ -78,10 +117,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 +126,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 +164,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); }