nexus-shared 1.1.17 → 1.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-shared",
-  "version": "1.1.17",
+  "version": "1.1.18",
   "description": "Nexus shared React components for Next.js",
   "type": "module",
   "sideEffects": [

package/src/api-services/system-service.tsx

@@ -1,6 +1,5 @@
 import { EIcons } from "../interfaces/icon-interfaces";
-import { EMenuTargets, EMenuVisibility, IClientMenu, IPanelMenu, IUtilityMenu } from "../interfaces/menu-interfaces";
-import { ENexusModules } from "../interfaces/system-interfaces";
+import { EMenuVisibility, IClientMenu, IPanelMenu, IUtilityMenu } from "../interfaces/menu-interfaces";
 
 export const GetClientMenus = async (): Promise<IClientMenu[]> => {
   return [

package/src/client.ts

@@ -21,10 +21,10 @@ export * from "./components/inputs/input";
 export * from "./components/inputs/input-box";
 export * from "./components/inputs/input-element";
 export * from "./helpers/browser-helpers";
+export * from "./services/http-client-services";
 export * from "./services/loader-service";
 export * from "./services/localstorage-service";
 export * from "./services/theme-service";
-
 // Core
 export * from "./nexus-client";
 export * from "./sso-client";

package/src/components/layouts/global-layout.tsx

@@ -39,11 +39,13 @@ export const GlobalLayout = async ({ children, globalLayout }: Readonly<{ childr
             display: "flex",
             justifyContent: "center",
             alignItems: "center",
-            backgroundColor: "rgb(40, 40, 40)",
+            backgroundColor: "rgb(60, 60, 60)",
           }}
           id={ROOT_LOADER_IDENTITY}
         >
-          <img src={FILES.LOGO.ICON} alt={"logo"} style={{ minHeight: "3rem", minWidth: "3rem", width: "3rem", height: "3rem" }} />
+          <a href={"/"} className="p5  h r bg52" style={{ marginTop: "8rem" }} title="Visit Home Page">
+            <img src={FILES.LOGO.ICON} alt={"logo"} style={{ minHeight: "3rem", minWidth: "3rem", width: "3rem", height: "3rem" }} />
+          </a>
         </div>
         {children}
         <Script type="module" src="https://cdn.jsdelivr.net/npm/ionicons@5.5.2/dist/ionicons/ionicons.esm.js" strategy="lazyOnload"></Script>

package/src/components/layouts/layout-helpers.tsx

@@ -1,23 +1,23 @@
-'use client';
-
-import { useEffect } from "react";
-import { RemoveElement } from "../../helpers/browser-helpers";
-import { IGlobalLayout, ROOT_LOADER_IDENTITY } from "../../interfaces/layout-interfaces";
-import { DEFAULT_THEME_INFORMATIONS } from "../../interfaces/theme-interfaces";
-import { O } from "../../nexus-client";
-import { InitializeStyles } from "../../services/theme-service";
-
-export const LayoutHelpers = ({ globalLayout }: Readonly<{ globalLayout: IGlobalLayout }>) => {
-  useEffect(() => {
-    globalLayout.systemThemes = DEFAULT_THEME_INFORMATIONS;
-    O.systemThemes = DEFAULT_THEME_INFORMATIONS;
-
-    const timeout = setTimeout(() => {
-      clearTimeout(timeout);
-      RemoveElement(ROOT_LOADER_IDENTITY, 500);
-      InitializeStyles();
-    }, 50);
-  }, []);
-
-  return <div className="nexus-popup-container"></div>;
-};
+"use client";
+
+import { useEffect } from "react";
+import { RemoveElement } from "../../helpers/browser-helpers";
+import { IGlobalLayout, ROOT_LOADER_IDENTITY } from "../../interfaces/layout-interfaces";
+import { DEFAULT_THEME_INFORMATIONS } from "../../interfaces/theme-interfaces";
+import { O } from "../../nexus-client";
+import { InitializeStyles } from "../../services/theme-service";
+
+export const LayoutHelpers = ({ globalLayout }: Readonly<{ globalLayout: IGlobalLayout }>) => {
+  useEffect(() => {
+    globalLayout.systemThemes = DEFAULT_THEME_INFORMATIONS;
+    O.systemThemes = DEFAULT_THEME_INFORMATIONS;
+
+    const timeout = setTimeout(() => {
+      clearTimeout(timeout);
+      RemoveElement(ROOT_LOADER_IDENTITY, 500);
+      InitializeStyles();
+    }, 50);
+  }, [globalLayout]);
+
+  return <div className="nexus-popup-container"></div>;
+};

package/src/helpers/utility-helpers.tsx

@@ -42,3 +42,4 @@ export function Debounce<T extends (...args: any[]) => void>(func: T, delay?: nu
 
   return debounced;
 }
+export const Delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

package/src/index.ts

@@ -37,5 +37,6 @@ export * from "./interfaces/type-interfaces";
 
 // Core
 export * from "./nexus.environments";
+export * from "./services/http-services";
 export * from "./sso-server";
-
+ 

package/src/interfaces/exception-interfaces.tsx

@@ -0,0 +1,99 @@
+export enum EErrorCodes {
+  Unknown = 0,
+
+  /// <summary>
+  /// Indicates that the format of the input is invalid.
+  /// </summary>
+  FormatInvalid = 1001,
+
+  /// <summary>
+  /// Indicates that the operation failed due to lack of authorization.
+  /// </summary>
+  /// <remarks>Use this value to represent scenarios where access is denied because the user or
+  /// process does not have the required permissions.</remarks>
+  Unauthorized = 2001,
+
+  /// <summary>
+  /// Indicates that the requested operation is forbidden due to insufficient permissions.
+  /// </summary>
+  Forbidden = 2002,
+
+  /// <summary>
+  /// Indicates that the authentication token has expired.
+  /// </summary>
+  /// <remarks>This value can be used to identify error conditions where a user's session or access
+  /// token is no longer valid and re-authentication is required.</remarks>
+  TokenExpired = 2003,
+
+  /// <summary>
+  /// Indicates that the requested resource could not be found.
+  /// </summary>
+  ResourceNotFound = 3001,
+
+  /// <summary>
+  /// Indicates that the specified resource already exists.
+  /// </summary>
+  AlreadyExists = 3002,
+
+  /// <summary>
+  /// Indicates that the requested operation or feature is not implemented.
+  /// </summary>
+  /// <remarks>Use this value to represent an error condition where a requested functionality is not
+  /// available or has not been provided by the system.</remarks>
+  NotImplemented = 4001,
+
+  /// <summary>
+  /// Indicates that a compile-time error has occurred.
+  /// </summary>
+  CompileTimeError = 4002,
+
+  /// <summary>
+  /// Indicates that a runtime error occurred during compilation.
+  /// </summary>
+  CompileRuntimeError = 4003,
+}
+export enum EExceptionCategories {
+  /// <summary>
+  /// Indicates that the associated value or member is related to validation operations.
+  /// </summary>
+  Validation = 1,
+
+  /// <summary>
+  /// Specifies that the item relates to security functionality or concerns.
+  /// </summary>
+  Security = 2,
+
+  /// <summary>
+  /// Represents an input/output file resource type.
+  /// </summary>
+  /// <remarks>Use this value to indicate that the resource is a file used for input or output
+  /// operations. This can be useful when distinguishing between different resource types in file handling or
+  /// resource management scenarios.</remarks>
+  IO_File = 3,
+
+  /// <summary>
+  /// Indicates that the log entry is related to database operations.
+  /// </summary>
+  Database = 4,
+
+  /// <summary>
+  /// Specifies that the log entry is associated with application-level events or messages.
+  /// </summary>
+  Application = 5,
+
+  /// <summary>
+  /// Indicates an internal service type that is not intended for external use.
+  /// </summary>
+  /// <remarks>This value is typically used to distinguish services that are only accessible within
+  /// the system or application. It may be used for internal routing, diagnostics, or other infrastructure
+  /// purposes.</remarks>
+  InternalService = 6,
+
+  /// <summary>
+  /// Indicates that the log entry is related to an external service.
+  /// </summary>
+  /// <remarks>Use this value to categorize logs that pertain to interactions with third-party or
+  /// external systems, such as APIs or external databases. This can help in filtering and analyzing logs specific
+  /// to external dependencies.</remarks>
+  ExternalService = 7,
+}

package/src/interfaces/http-interfaces.tsx

@@ -1,4 +1,7 @@
-export enum EActionMethods {
+import { EErrorCodes, EExceptionCategories } from "./exception-interfaces";
+import { IInterface, UN } from "./type-interfaces";
+
+export enum EActions {
   Get = 1,
   Post = 2,
   Put = 3,
@@ -6,10 +9,43 @@ export enum EActionMethods {
 }
 export interface IApiInformations {
   api: string;
-  method: EActionMethods;
+  method: EActions;
 }
 export interface IGetApiInformations extends IApiInformations {
   cacheCode?: string;
   /** In Minutes */
   cacheLifetime?: number;
 }
+
+export interface IRootRespose extends IInterface {
+  message: string | UN;
+  messageCode: string | UN;
+  isSuccess: boolean;
+  code: number;
+  exceptionCategory: EExceptionCategories | UN;
+  errorCode: EErrorCodes | UN;
+  inputName: string | UN;
+  result: any | UN;
+}
+
+export interface IErrorRespose extends IRootRespose {
+  exception: any | UN;
+}
+export interface ISuccessResponse extends IRootRespose {}
+export enum EBody {
+  JSON = "application/json",
+  MULTIPART_FORM_DATA = "application/x-www-form-urlencoded",
+  FORM_DATA = "multipart/form-data",
+}
+export const GetMethod = (method?: EActions) => {
+  switch (method) {
+    case EActions.Delete:
+      return "DELETE";
+    case EActions.Post:
+      return "POST";
+    case EActions.Put:
+      return "PUT";
+    default:
+      return "GET";
+  }
+};

package/src/interfaces/permission-interfaces.tsx

@@ -1,9 +1,9 @@
-import { EActionMethods } from "./http-interfaces";
-import { ENexusModules } from "./system-interfaces";
+import { EActions } from "./http-interfaces";
+import { EModules } from "./system-interfaces";
 
 export interface IAccessAction {
   controllerName: string;
   actionName: string;
-  actionMethod: EActionMethods;
-  nexusModule: ENexusModules;
+  actionMethod: EActions;
+  nexusModule: EModules;
 }

package/src/interfaces/sso-interfaces.tsx

@@ -0,0 +1,52 @@
+import { UN } from "nexus-shared";
+export interface SSOAuthResponse {
+  accessToken: string;
+  refreshToken: string;
+  expiresTokenIn: number;
+  expiresRefreshTokenIn: number;
+  returnPath?: string;
+}
+
+export interface CookieInfo {
+  ssoSession: string;
+  accessToken: string | UN;
+  refreshToken: string | UN;
+}
+
+export interface IRedirectContext {
+  redirectUri: string;
+  /** OAuth CSRF nonce sent to the client callback. */
+  state: string;
+  /** Relative path to return to after sign-in completes. */
+  returnPath: string;
+}
+
+export interface ISignInParams {
+  redirect_uri: string | UN;
+  state: string | UN;
+}
+
+export interface ISsoSessionResponse {
+  code: string;
+}
+
+export interface ILoginRequest {
+  username: string;
+  password: string;
+}
+
+export interface ILoginResponse {
+  ssoSession: string;
+  displayName: string;
+  role: string;
+  userId: number;
+}
+
+export interface IDemoUserInfo {
+  id: number;
+  username: string;
+  email: string;
+  displayName: string;
+  role: string;
+  passwordHint: string;
+}

package/src/interfaces/system-interfaces.tsx

@@ -1,9 +1,9 @@
-export enum ENexusModules {
+export enum EModules {
   None = 0,
 
   Migrations = 1 << 0, // 1    |   1
   Configuration = 1 << 1, // 2    |   2
-  Identity = 1 << 2, // 3    |   4
+  Authentication = 1 << 2, // 3    |   4
   Enterprise = 1 << 3, // 4    |   8
   Drive = 1 << 4, // 5    |   16
   Message = 1 << 5, // 6    |   32

package/src/load-env.ts

@@ -0,0 +1,2 @@
+/** Loads environment variables for nexus-shared consumers (no-op when Next.js already loaded .env). */
+export {};

package/src/nexus.environments.tsx

@@ -1,17 +1,21 @@
-import { ENexusModules } from "./interfaces/system-interfaces";
+import { EModules } from "./interfaces/system-interfaces";
 import { EBackgrounds } from "./interfaces/theme-interfaces";
 
 export const APIS = {
-  DRIVE: process.env.API_DRIVE,
-  AUTHENTICATION: process.env.API_AUTHENTICATION,
-  CONFIGURATION: process.env.API_CONFIGURATION,
-  CURRENT: process.env.API_CURRENT,
+  DRIVE: process.env.API_DRIVE as string,
+  AUTHENTICATION: process.env.API_AUTHENTICATION as string,
+  CONFIGURATION: process.env.API_CONFIGURATION as string,
+  CURRENT: process.env.API_CURRENT as string,
+  ENTERPRISE: process.env.API_ENTERPRISE as string,
+  MESSAGE: process.env.API_MESSAGE as string,
+  ACCOUNTING: process.env.API_ACCOUNTING as string,
+  REPORT: process.env.API_REPORT as string,
 };
 
 export const URLS = {
-  CURRENT: process.env.URL_CURRENT,
-  AUTHENTICATION: process.env.URL_AUTHENTICATION,
-  SIGN_IN: process.env.URL_AUTHENTICATION_SIGN_IN,
+  CURRENT: process.env.URL_CURRENT as string,
+  AUTHENTICATION: process.env.URL_AUTHENTICATION as string,
+  SIGN_IN: process.env.URL_AUTHENTICATION_SIGN_IN as string,
 };
 const FILE = (apiName: string, filePath: string, fileName: string) => `${APIS.DRIVE}/Resources/${apiName}/${encodeURIComponent(filePath)}/${encodeURIComponent(fileName)}`;
 export const FILES = {
@@ -23,15 +27,16 @@ export const FILES = {
   SCRIPT: (fileName: string, isStyles: boolean = false) => FILE("Script", isStyles ? "css" : "js", fileName),
 };
 export const NEXUS_INFO = {
-  CURRENT_MODULE: process.env.CURRENT_MODULE !== undefined ? (parseInt(process.env.CURRENT_MODULE) as ENexusModules) : undefined,
-  CURRENT_MODULE_NAME: process.env.CURRENT_MODULE_NAME,
-  CURRENT_MODULE_SHORT_NAME: process.env.CURRENT_MODULE_SHORT_NAME,
+  IS_ADMIN_MODULE: process.env.IS_ADMIN_MODULE !== "false",
+  CURRENT_MODULE: process.env.CURRENT_MODULE !== undefined ? (parseInt(process.env.CURRENT_MODULE) as EModules) : undefined,
+  CURRENT_MODULE_NAME: process.env.CURRENT_MODULE_NAME as string,
+  CURRENT_MODULE_SHORT_NAME: process.env.CURRENT_MODULE_SHORT_NAME as string,
   IS_PRODUCTION: process.env.NODE_ENV === "production",
-  SOFTWARE_COMPANY_SHORT_NAME: process.env.SOFTWARE_COMPANY_SHORT_NAME,
-  SOFTWARE_COMPANY_FULL_NAME: process.env.SOFTWARE_COMPANY_FULL_NAME,
-  SOFTWARE_VERSION: process.env.SOFTWARE_VERSION,
-  SOFTWARE_LAST_UPDATE_DATE: process.env.SOFTWARE_LAST_UPDATE_DATE,
-  SOFTWARE_COMPANY_WEBSITE: process.env.SOFTWARE_COMPANY_WEBSITE,
+  SOFTWARE_COMPANY_SHORT_NAME: process.env.SOFTWARE_COMPANY_SHORT_NAME as string,
+  SOFTWARE_COMPANY_FULL_NAME: process.env.SOFTWARE_COMPANY_FULL_NAME as string,
+  SOFTWARE_VERSION: process.env.SOFTWARE_VERSION as string,
+  SOFTWARE_LAST_UPDATE_DATE: process.env.SOFTWARE_LAST_UPDATE_DATE as string,
+  SOFTWARE_COMPANY_WEBSITE: process.env.SOFTWARE_COMPANY_WEBSITE as string,
 };
 export const NEXUS_CONFIG = {
   /** Default revalidate time for static generation (in minutes) */

package/src/services/http-client-services.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+import { EBody, IErrorRespose, ISuccessResponse } from "../interface";
+import { HttpDelete, HttpGet, HttpPost, HttpPut } from "./http-services";
+
+/** // if same url is called multiple times, it will only send one request and return the same promise
+// this is to prevent multiple requests to the same url at the same time
+// this is useful for example when user is typing in a search box and multiple requests are sent to the server
+// this will prevent multiple requests to the same url and return the same promise
+// this will also prevent multiple requests to the same url when user is navigating to different pages and the same url is called in each page
+// If country Dropdown is called multiple times, it will only send one request and return the same promise
+// this is useful for example when user is typing in a search box and multiple requests are sent to the server
+*/
+const pendingRequests: { [url: string]: Promise<any> | undefined } = {};
+export const Get = async (apiUrl: string, successMessage?: boolean, errorMessage?: boolean, revalidate?: number): Promise<ISuccessResponse | IErrorRespose> => {
+  if (pendingRequests[apiUrl] !== undefined) return pendingRequests[apiUrl]!;
+
+  pendingRequests[apiUrl] = HttpGet(apiUrl)
+    .then((response) => handleResponse(response, successMessage ?? false, errorMessage ?? true))
+    .finally(() => {
+      delete pendingRequests[apiUrl];
+    });
+  return pendingRequests[apiUrl]!;
+};
+
+export const Put = async (apiUrl: string, body?: any | null, bodyType?: EBody, successMessage?: boolean, errorMessage?: boolean, revalidate?: number) => {
+  return await handleResponse(await HttpPut(apiUrl, body, bodyType, null, revalidate, null), successMessage ?? true, errorMessage ?? true);
+};
+
+export const Post = async (apiUrl: string, body?: any | null, bodyType?: EBody, successMessage?: boolean, errorMessage?: boolean, revalidate?: number) => {
+  const isFindListing = Array.isArray(body) && apiUrl.endsWith("/FindListing");
+
+  if (!isFindListing) {
+    return await handleResponse(await HttpPost(apiUrl, body, bodyType, null, revalidate, null), successMessage ?? true, errorMessage ?? true);
+  } else {
+    const apiKey = `${apiUrl}__${(body as string[]).sort().join(",")}`;
+
+    if (pendingRequests[apiKey]) return pendingRequests[apiKey];
+
+    pendingRequests[apiKey] = HttpPost(apiUrl, body, bodyType, null, revalidate, null)
+      .then((response) => handleResponse(response, successMessage ?? true, errorMessage ?? true))
+      .finally(() => {
+        delete pendingRequests[apiKey];
+      });
+    return pendingRequests[apiKey];
+  }
+};
+
+export const Delete = async (apiUrl: string, successMessage?: boolean, errorMessage?: boolean, revalidate?: number) => {
+  return await handleResponse(await HttpDelete(apiUrl, null, revalidate, null), successMessage ?? true, errorMessage ?? true);
+};
+
+const handleResponse = async (result: ISuccessResponse | IErrorRespose, successMessage?: boolean, errorMessage?: boolean): Promise<ISuccessResponse | IErrorRespose> => {
+  if (result.isSuccess && !(result as IErrorRespose).exception) {
+    // TODO: if (successMessage) SuccessMessage("Request Success!", result.message ?? "Success");
+    return result;
+  }
+  // TODO: if (errorMessage) ErrorMessage("Request Failed!", result.message ?? "Failed");
+  return result;
+};

package/src/services/http-services.tsx

@@ -0,0 +1,143 @@
+import { Delay } from "../helpers/utility-helpers";
+import { EActions, EBody, EModules, GetMethod, IErrorRespose, ISuccessResponse } from "../interface";
+import { EErrorCodes, EExceptionCategories } from "../interfaces/exception-interfaces";
+import { APIS, NEXUS_CONFIG, NEXUS_INFO } from "../nexus.environments";
+
+const MAX_RETRIES = NEXUS_INFO.IS_PRODUCTION ? 2 : 1;
+const RETRY_DELAY_MS = NEXUS_INFO.IS_PRODUCTION ? 50 : 1;
+
+const NEXUS_HEADERS = (formdata?: any, httpMethod: EActions = EActions.Get, bodyType: EBody = EBody.JSON, token?: string | null, revalidate?: number | null, browserId?: string | null): RequestInit & { next?: { revalidate: number } } => {
+  const headers = new Headers();
+  if (token && token.length > 50) headers.append("authorization", `${token}`);
+  if (browserId) headers.append("bid", browserId);
+  if (bodyType === EBody.JSON && (httpMethod === EActions.Post || httpMethod === EActions.Put)) {
+    headers.append("Content-Type", "application/json");
+  }
+
+  const options: RequestInit & { next?: { revalidate: number } } = {
+    method: GetMethod(httpMethod),
+    headers,
+  };
+
+  if (formdata) {
+    options.body = bodyType === EBody.JSON ? JSON.stringify(formdata) : formdata;
+  }
+
+  if (!revalidate || revalidate <= 0) {
+    // No caching
+    options.cache = "no-store";
+  } else {
+    // Use Next.js ISR caching
+    options.next = { revalidate: revalidate ?? 0 };
+  }
+
+  return options;
+};
+const shouldRetry = (error: any) => error.name === "AbortError" || error.code === "ECONNREFUSED" || error.message.includes("fetch") || error.message.includes("network");
+const safeFetch = async (fetchFunc: () => Promise<Response>): Promise<ISuccessResponse | IErrorRespose> => {
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const response = await fetchFunc();
+      if (!response.ok) return await handleResponse(response);
+      return await response.json();
+    } catch (error: any) {
+      if (attempt < MAX_RETRIES - 1 && shouldRetry(error)) {
+        await Delay(RETRY_DELAY_MS * (attempt + 1));
+        continue;
+      }
+      return handleNetworkError(error);
+    }
+  }
+  return handleError({ status: 500, message: "Maximum retry attempts exceeded." });
+};
+const fetchWithTimeout = async (url: string, options?: RequestInit, timeout = NEXUS_CONFIG.DEFAULT_HTTP_REQUEST_TIMEOUT): Promise<Response> => {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    clearTimeout(id);
+    return response;
+  } catch (error) {
+    clearTimeout(id);
+    throw error;
+  }
+};
+export const HttpGet = async (apiUrl: string, token?: string | null, revalidate?: number, browserId?: string | null) => {
+  return await safeFetch(() => fetchWithTimeout(apiUrl, NEXUS_HEADERS(undefined, EActions.Get, EBody.JSON, token, revalidate, browserId)));
+};
+export const HttpPost = async (apiUrl: string, body?: any, bodyType?: EBody, token?: string | null, revalidate?: number, browserId?: string | null) => {
+  return await safeFetch(() => fetchWithTimeout(apiUrl, NEXUS_HEADERS(body, EActions.Post, bodyType, token, revalidate, browserId)));
+};
+
+export const HttpPut = async (apiUrl: string, body?: any, bodyType?: EBody, token?: string | null, revalidate?: number, browserId?: string | null) => {
+  return await safeFetch(() => fetchWithTimeout(apiUrl, NEXUS_HEADERS(body, EActions.Put, bodyType, token, revalidate, browserId)));
+};
+
+export const HttpDelete = async (apiUrl: string, token?: string | null, revalidate?: number, browserId?: string | null) => {
+  return await safeFetch(() => fetchWithTimeout(apiUrl, NEXUS_HEADERS(undefined, EActions.Delete, undefined, token, revalidate, browserId)));
+};
+export const GetRootApi = (nexusModule: EModules) => {
+  switch (nexusModule) {
+    case EModules.Authentication:
+      return APIS.AUTHENTICATION;
+    case EModules.Configuration:
+      return APIS.CONFIGURATION;
+    case EModules.Enterprise:
+      return APIS.ENTERPRISE;
+    case EModules.Drive:
+      return APIS.DRIVE;
+    case EModules.Message:
+      return APIS.MESSAGE;
+    case EModules.Accounting:
+      return APIS.ACCOUNTING;
+    case EModules.Report:
+      return APIS.REPORT;
+    default:
+      throw new Error("Invalid Nexus Module");
+  }
+};
+const handleResponse = async (response: Response): Promise<IErrorRespose> => {
+  const status = response.status;
+  try {
+    const errorData = await response.json();
+    return handleError({ ...errorData, status });
+  } catch {
+    let message = "Unexpected server error.";
+    switch (status) {
+      case 401:
+      case 403:
+        message = "You do not have permission to access this resource.";
+        break;
+      case 404:
+      case 410:
+        message = "Resource not found.";
+        break;
+      case 405:
+        message = "Method not allowed.";
+        break;
+    }
+    return handleError({ status, message });
+  }
+};
+export const handleError = (error: any): IErrorRespose => {
+  return {
+    isSuccess: false,
+    exception: error,
+    code: error?.code,
+    message: error?.message || "An unknown error occurred.",
+    messageCode: error?.key || "GENERIC_ERROR",
+    exceptionCategory: error?.exceptionCategory || EExceptionCategories.Application,
+    errorCode: error?.errorCode || EErrorCodes.Unknown,
+    inputName: error?.inputName || undefined,
+    result: null,
+  };
+};
+const handleNetworkError = (error: any): IErrorRespose => {
+  console.error("\n\nNetwork error encountered:", error);
+  return handleError({
+    status: 503,
+    message: "Unable to connect to the server. Please check your network or backend status.",
+    key: "NETWORK_ERROR",
+    exception: error,
+  });
+};