nexus-shared 1.1.17 → 1.1.19

package/src/interfaces/input-interfaces.tsx

@@ -1,6 +1,7 @@
 import { EButtonTypes, ETargets } from "./button-interfaces";
 import { DatasourceTypes } from "./datasource-interfaces";
 import { IColumn } from "./datatable-interfaces";
+import { EActions, IApiInformations, IErrorRespose, ISuccessResponse } from "./http-interfaces";
 import { EIcons, EIconTypes } from "./icon-interfaces";
 import { EFlexPositions, EOpacity, ESizes } from "./layout-interfaces";
 import { EBackgrounds } from "./theme-interfaces";
@@ -11,11 +12,16 @@ export type OnElementLoad = (inputBox: HTMLElement | null, inputWrapper: HTMLEle
 export type AutoCompletes = "on" | "off";
 export type ForceChangeDefaultValue<T> = (defaultValue: T, type?: EValueChangeTypes, invokeOnChanged?: boolean | UN) => boolean;
 export type OnFormChangeHandler = (currentValue: any, isInitilizing: boolean, isForcedChanged: boolean, isDisposed: boolean, currentKey: string, index: number, type?: EValueChangeTypes, dataSource?: any | any[]) => void;
+export type OnFormSubmitHandler = (currentValue: any, isValidForm: boolean, event: Event, form: IFormCreateResults, defaultValue: any | UN) => void;
+export type OnApiFormSubmitHandler = (currentValue: any, apiResponse: ISuccessResponse | IErrorRespose, formResults: ISubmitFormCreateResults, defaultValue: any | UN) => void;
+export type OverrideValidation = (currentValue: any, isValidForm: boolean, formReference: IFormCreateResults | null, action?: EActions | UN) => boolean;
+export type RegexTypes = ERegexs | string[] | UN;
 
 export const DEFAULT_INPUT_BACKGROUND = EBackgrounds.Background1;
 export const MAX_INPUT_TYPE = 1900;
 export const DEFAULT_INPUT_BORDER_SIZE = 1;
 export const DEFAULT_TEXTAREA_ROWS = 3;
+export const DEFAULT_ROW_GAP = 3;
 
 export const REQUIRED_TEXT1 = "✲";
 
@@ -28,18 +34,20 @@ export enum EValueChangeTypes {
 }
 export enum ERegexs {
   Fullname = "^[A-Za-z]+(?: [A-Za-z]+)*[0-9]?$",
-  Username = "^[A-Za-z0-9]{7,30}$",
-  ContactNumber = "^[0-9]{10}$",
-  /** Allow Null */
-  ContactNumber_NULL = "^$|^[0-9]{10}$",
   Email = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
   /** Allow Null */
   Email_NULL = "^$|^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$",
   EmailUsername = "^(?=.*[a-zA-Z0-9])[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z]{2,}$|[a-zA-Z0-9]{8,100}$",
   Password = "^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*()_+{}|:,.<>?/~]).{8,30}$",
-  EmailUsernameContact = "^(?:[A-Za-z]+[A-Za-z0-9]{2,30}|[0-9]{10}|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})$",
   Hexadecimal = "^[0-9A-Fa-f]{8}$",
   ContactEmail = "^(?:[0-9]{10}|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})$",
+
+  /** Allow Null */
+  ContactNumber_NULL = "^$|^[0-9]{10}$",
+
+  ContactNumber = "^[0-9]{10}$",
+  Username = "^(?!.*[._-]{2})[a-zA-Z0-9]+(?:[._-][a-zA-Z0-9]+)*$",
+  EmailUsernameMobile = "^(?:[0-9]{10}|(?!.*[._-]{2})[a-zA-Z0-9]+(?:[._-][a-zA-Z0-9]+)*|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[A-Za-z]{2,})$",
 }
 export enum EInputTypes {
   Textbox = 1,
@@ -119,7 +127,7 @@ export interface ISubmitbutton extends IElement {
 }
 export interface ITextbox extends IInputParameters<string | null> {
   isPassword?: boolean | UN;
-  regexKey?: ERegexs | UN;
+  regexKey?: RegexTypes | UN;
 }
 export interface ISlider extends IInputParameters<number | null> {
   step?: number | UN;
@@ -133,7 +141,7 @@ export interface IRadiobox extends ICheckbox {}
 export interface ITextarea extends IInputParameters<string | null> {
   isShowPreview?: boolean | UN;
   rows?: number | UN;
-  regexKey?: ERegexs | UN;
+  regexKey?: RegexTypes | UN;
 }
 export interface INumber extends IInputParameters<number | null> {
   floatingPoint?: number | UN;
@@ -176,18 +184,60 @@ export interface IForm {
   onChanged: OnFormChangeHandler;
   index: number;
   isTabularForm: boolean;
-  parentIdentifier: HTMLElement | UN | string;
   defaultValue?: any | UN;
 }
+export interface ISubmitForm {
+  inputs: IInputRootParameters<any>[];
+  onChanged: OnFormChangeHandler | UN;
+  defaultValue?: DatasourceTypes | UN;
+  onSubmit: OnFormSubmitHandler;
+  onCancelClick?: ClickHandler | UN;
+  overrideValidation?: OverrideValidation | UN;
+}
+
+export interface IApiForm {
+  inputs: IInputRootParameters<any>[];
+  api: IApiInformations;
+  onApiSubmit: OnApiFormSubmitHandler;
+  onChanged: OnFormChangeHandler | UN;
+  onSubmit: OnFormSubmitHandler | UN;
+  defaultValue?: DatasourceTypes | UN;
+  onCancelClick?: ClickHandler | UN;
+  overrideValidation?: OverrideValidation | UN;
+}
+
 export interface IFormCreateResults {
   inputResults: IInputCreateResults[];
   formElement: HTMLElement;
   dispose: (invokeOnChanged?: boolean) => void;
   forceChangeDefaultValue: ForceChangeDefaultValue<any> | null;
 }
+export interface ISubmitFormCreateResults {
+  formElement: HTMLElement;
+  dispose: () => void;
+  formObject: IFormCreateResults;
+}
 
 export const GetForms = {
-  FORM: (inputs: IInputRootParameters<any>[], parentIdentifier: HTMLElement | string | UN, onChanged: OnFormChangeHandler, defaultValue?: any, index?: number, isTabularForm?: boolean): IForm => ({ inputs, onChanged, index: index ?? 0, isTabularForm: isTabularForm ?? false, parentIdentifier, defaultValue }),
+  FORM: (inputs: IInputRootParameters<any>[], onChanged: OnFormChangeHandler, defaultValue?: any | UN, index?: number | UN, isTabularForm?: boolean | UN): IForm => ({ inputs, onChanged, index: index ?? 0, isTabularForm: isTabularForm ?? false, defaultValue }),
+  SUBMITFORM: (inputs: IInputRootParameters<any>[], onSubmit: OnFormSubmitHandler, defaultValue?: DatasourceTypes | UN, overrideValidation?: OverrideValidation | UN, onChanged?: OnFormChangeHandler | UN, onCancelClick?: ClickHandler | UN): ISubmitForm => ({
+    inputs,
+    onChanged,
+    defaultValue,
+    onSubmit,
+    onCancelClick,
+    overrideValidation,
+  }),
+  APIFORM: (inputs: IInputRootParameters<any>[], api: IApiInformations, onApiSubmit: OnApiFormSubmitHandler, defaultValue?: DatasourceTypes | UN, onSubmit?: OnFormSubmitHandler | UN, overrideValidation?: OverrideValidation | UN, onCancelClick?: ClickHandler | UN, onChanged?: OnFormChangeHandler | UN): IApiForm => ({
+    inputs,
+    api,
+    onApiSubmit,
+    onChanged,
+    defaultValue,
+    onSubmit,
+    onCancelClick,
+    overrideValidation,
+  }),
 };
 export const GetInputs = {
   ICON: (icon: EIcons, iconSize?: ESizes | UN, boxSize?: ESizes | UN, opacity?: EOpacity | UN, type?: EIconTypes | UN, background?: EBackgrounds | UN, onClicked?: ClickHandler | UN, onMouseEnter?: ClickHandler | UN): IInputIcon => ({
@@ -200,7 +250,7 @@ export const GetInputs = {
     onClicked: onClicked,
     onMouseEnter: onMouseEnter,
   }),
-  TEXTBOX: (id: string, columnSize: number, displayOrder: number, label?: string | UN, placeholder?: string | UN, validatorKey?: string | UN, minLength?: number | UN, maxLength?: number | UN, regexKey?: ERegexs | UN, isPassword?: boolean | UN, isReadonly?: boolean | UN, isAutoComplete?: boolean | UN, defaultValue?: string | UN, background?: EBackgrounds | UN, borderSize?: number | UN, inputSize?: ESizes | UN, icon?: IInputIcon | UN, defaultClass?: string | UN, onChanged?: OnInputChangeHandler<string | null> | UN): ITextbox => ({
+  TEXTBOX: (id: string, columnSize: number, displayOrder: number, label?: string | UN, placeholder?: string | UN, validatorKey?: string | UN, minLength?: number | UN, maxLength?: number | UN, regexKey?: RegexTypes | UN, isPassword?: boolean | UN, isReadonly?: boolean | UN, isAutoComplete?: boolean | UN, defaultValue?: string | UN, background?: EBackgrounds | UN, borderSize?: number | UN, inputSize?: ESizes | UN, icon?: IInputIcon | UN, defaultClass?: string | UN, onChanged?: OnInputChangeHandler<string | null> | UN): ITextbox => ({
     id: id,
     columnSize: columnSize,
     displayOrder: displayOrder,
@@ -223,7 +273,7 @@ export const GetInputs = {
     inputType: EInputTypes.Textbox,
     autoComplete: isAutoComplete !== false ? undefined : "off",
   }),
-  TEXTAREA: (id: string, columnSize: number, displayOrder: number, label?: string | UN, placeholder?: string | UN, validatorKey?: string | UN, minLength?: number | UN, maxLength?: number | UN, rows?: number | UN, isShowPreview?: boolean | UN, defaultValue?: string | UN, regexKey?: ERegexs | UN, isReadonly?: boolean | UN, isAutoComplete?: boolean | UN, background?: EBackgrounds | UN, borderSize?: number | UN, inputSize?: ESizes | UN, icon?: IInputIcon | UN, defaultClass?: string | UN, onChanged?: OnInputChangeHandler<string | null> | UN): ITextarea => ({
+  TEXTAREA: (id: string, columnSize: number, displayOrder: number, label?: string | UN, placeholder?: string | UN, validatorKey?: string | UN, minLength?: number | UN, maxLength?: number | UN, rows?: number | UN, isShowPreview?: boolean | UN, defaultValue?: string | UN, regexKey?: RegexTypes | UN, isReadonly?: boolean | UN, isAutoComplete?: boolean | UN, background?: EBackgrounds | UN, borderSize?: number | UN, inputSize?: ESizes | UN, icon?: IInputIcon | UN, defaultClass?: string | UN, onChanged?: OnInputChangeHandler<string | null> | UN): ITextarea => ({
     id: id,
     columnSize: columnSize,
     displayOrder: displayOrder,

package/src/interfaces/message-interfaces.tsx

@@ -0,0 +1,32 @@
+import { EIcons } from "./icon-interfaces";
+import { EBackgrounds } from "./theme-interfaces";
+
+export enum EMessageTypes {
+  Information = EBackgrounds.InfoColor,
+  Success = EBackgrounds.SuccessColor,
+  Warning = EBackgrounds.WarningColor,
+  Error = EBackgrounds.ErrorColor,
+}
+export enum EMessageIcons {
+  Information = EIcons.INFORMATION,
+  Success = EIcons.CHECKMARK_DOUBLE,
+  Warning = EIcons.WARNING,
+  Error = EIcons.CLOSE,
+  Question = EIcons.HELP,
+  Delete = EIcons.TRASH,
+  Bin = EIcons.TRASH_BIN,
+}
+export enum EMessageResult {
+  OK = "OK",
+  Yes = "Yes",
+  No = "No",
+  Cancel = "Cancel",
+  Undefined = "Undefined",
+}
+
+export enum EMessageBoxButtons {
+  OK = "OK",
+  YES_NO = "Yes_No",
+  YES_CANCEL = "Yes_Cancel",
+  YES_NO_CANCEL = "Yes_No_Cancel",
+}

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/storage-interfaces.tsx

@@ -1,3 +1,4 @@
 export const LOCAL_STORAGE_KEYS = {
   ACTIVE_THEME: "nexus-themes",
+  FORM_BUTTON_POSITION: "nexus-form-button-position",
 };

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/interfaces/type-interfaces.tsx

@@ -15,8 +15,14 @@ export type ObjectCallbackHandler<T> = CallbackHandler<T, T>;
 export type ObjectNullCallbackHandler<T> = CallbackHandler<T | UN, T | UN>;
 export type ArrayCallbackHandler<T> = CallbackHandler<T[], T[]>;
 export type ArrayNullCallbackHandler<T> = CallbackHandler<T[] | UN, T[] | UN>;
-export type VoidCallbackHandler = CallbackHandler<void, void>;
-
+export type VoidCallbackHandler = CallbackHandler<void | any | any[] | UN, void>;
+export type PopupMessageCallback = (type: ECallbackTypes) => void;
 export interface IInterface {
   // Blank Interface
 }
+
+export enum ECallbackTypes {
+  Initialize = 0,
+  Destroy = 1,
+  ForceChangeValue = 2,
+}

package/src/interfaces/user-interfaces.tsx

@@ -0,0 +1,17 @@
+import { EModules } from "./system-interfaces";
+
+export enum EUserRoles {
+  Guest = 0,
+  User = 1,
+  Admin = 2,
+  SuperAdmin = 3,
+}
+
+export interface IUserValidationResponse {
+  isValidUser: boolean;
+  isValidCompany: boolean;
+  isValidBranch: boolean;
+  isValidFiscalYear: boolean;
+  userRole: EUserRoles;
+  assignedModules: EModules;
+}

package/src/nexus.environments.tsx

@@ -1,19 +1,27 @@
-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,
+  ALLOWED_ORIGINS: (process.env.ALLOWED_ORIGINS ?? "")
+    .split(",")
+    .map((origin) => origin.trim())
+    .filter(Boolean),
 };
-const FILE = (apiName: string, filePath: string, fileName: string) => `${APIS.DRIVE}/Resources/${apiName}/${encodeURIComponent(filePath)}/${encodeURIComponent(fileName)}`;
+const FILE = (apiName: string, filePath: string, fileName: string) => `${process.env.API_RESOURCES_BASE_PATH ?? `/api/app/${EModules.Drive}/Resources`}/${apiName}/${encodeURIComponent(filePath)}/${encodeURIComponent(fileName)}`;
 export const FILES = {
   LOGO: {
     ICON: FILE("Image", "logos", "icon-logo"),
@@ -23,15 +31,17 @@ 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,
+  IS_PROXY_SERVER: process.env.IS_PROXY_SERVER !== "false",
 };
 export const NEXUS_CONFIG = {
   /** Default revalidate time for static generation (in minutes) */

package/src/proxy-api/proxy-backend.tsx

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+import { EErrorCodes } from "../interfaces/exception-interfaces";
+import { GetRootApi } from "../services/http-services";
+import { DecryptCookieValue } from "../sso-config/cookie-encryption";
+import { ALLOWED_MODULES, PROXY_ALLOWED_METHODS } from "./proxy-constants";
+import { BuildBackendUrl, BuildForwardHeaders, ProxyErrorResponse, ReadRequestBody, SanitizeResponseHeaders } from "./proxy-helpers";
+
+const GENERIC_PROXY_ERROR = "Unable to reach the backend service.";
+const MODULE_NOT_ALLOWED_ERROR = "This module is not allowed for proxy requests.";
+
+const ACCESS_TOKEN_COOKIE = "access_token";
+
+export async function ProxyToBackend(req: NextRequest, moduleParam: string, pathSegments: string[]): Promise<NextResponse> {
+  const method = req.method.toUpperCase();
+
+  if (!PROXY_ALLOWED_METHODS.has(method)) {
+    return ProxyErrorResponse(`Method ${method} is not supported.`, 405, "METHOD_NOT_SUPPORTED", EErrorCodes.Forbidden);
+  }
+
+  const module = ALLOWED_MODULES.includes(moduleParam) ? parseInt(moduleParam) : null;
+  if (!module) return ProxyErrorResponse(MODULE_NOT_ALLOWED_ERROR, 400, "INVALID_MODULE");
+  const backendBase = GetRootApi(module);
+  const backendUrl = BuildBackendUrl(backendBase, pathSegments, req.nextUrl.searchParams);
+
+  return ProxyToBackendRequest(backendUrl, backendBase, module, method, req);
+}
+
+export async function ProxyToBackendRequest(backendFullUrl: string, backendUrlBase: string, module: number, method: string, req: NextRequest): Promise<NextResponse> {
+  // BuildForwardHeaders already strips the Cookie header (see PROXY_REQUEST_HEADERS_TO_SKIP).
+  const headers = BuildForwardHeaders(req);
+
+  // Decrypt the access token from the httpOnly cookie and inject it as a Bearer token.
+  // The raw encrypted blob is never forwarded — only the plaintext token reaches the backend.
+  const encryptedToken = req.cookies.get(ACCESS_TOKEN_COOKIE)?.value;
+  if (encryptedToken) {
+    const token = DecryptCookieValue(encryptedToken);
+    if (token) headers.set("Authorization", `Bearer ${token}`);
+  }
+
+  const body = await ReadRequestBody(req, method);
+
+  let backendResponse: Response;
+  try {
+    backendResponse = await fetch(backendFullUrl, {
+      method,
+      headers,
+      body,
+      redirect: "manual",
+    });
+  } catch {
+    return ProxyErrorResponse(GENERIC_PROXY_ERROR, 502, "BACKEND_UNREACHABLE");
+  }
+  const responseHeaders = SanitizeResponseHeaders(backendResponse.headers, backendUrlBase, module);
+  const responseBody = await backendResponse.arrayBuffer();
+
+  return new NextResponse(responseBody, {
+    status: backendResponse.status,
+    headers: responseHeaders,
+  });
+}

package/src/proxy-api/proxy-constants.tsx

@@ -0,0 +1,28 @@
+import { EModules } from "../interfaces/system-interfaces";
+
+
+/** HTTP methods supported by the backend proxy. */
+export const PROXY_ALLOWED_METHODS = new Set(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+
+/** Request headers that must not be forwarded to the backend. */
+export const PROXY_REQUEST_HEADERS_TO_SKIP = new Set(["host", "connection", "content-length", "transfer-encoding", "keep-alive", "upgrade", "cookie"]);
+
+/** Response headers that must not be forwarded to the browser. */
+export const PROXY_RESPONSE_HEADERS_TO_SKIP = new Set(["connection", "transfer-encoding", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "upgrade"]);
+
+/** Public path prefix the browser uses to reach the proxy. */
+
+/** Allowed modules for proxy requests. */
+
+export const ALLOWED_MODULES = [
+    EModules.Authentication.toString(),
+    EModules.Configuration.toString(),
+    EModules.Enterprise.toString(),
+    EModules.Drive.toString(),
+    EModules.Message.toString(),
+    EModules.Accounting.toString(),
+    EModules.Report.toString(),
+    EModules.Portfolio.toString(),
+    EModules.Subscription.toString(),
+    EModules.Reservation.toString(),
+]

package/src/proxy-api/proxy-helpers.tsx

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from "next/server";
+import { EErrorCodes, EExceptionCategories } from "../interfaces/exception-interfaces";
+import { GetResponse, PROXY_PUBLIC_BASE_PATH } from "../interfaces/http-interfaces";
+import { EModules } from "../interfaces/system-interfaces";
+import { PROXY_REQUEST_HEADERS_TO_SKIP, PROXY_RESPONSE_HEADERS_TO_SKIP } from "./proxy-constants";
+
+const BACKEND_NOT_CONFIGURED_ERROR = "Backend API is not configured.";
+
+export function BuildBackendUrl(backendBase: string, pathSegments: string[], searchParams: URLSearchParams): string {
+  if (pathSegments.some((segment) => segment === ".." || segment === "." || segment.includes("\\"))) throw new Error("Invalid path.");
+  else if (!backendBase) throw new Error(BACKEND_NOT_CONFIGURED_ERROR);
+
+  const path = pathSegments.map(encodeURIComponent).join("/");
+  const query = searchParams.toString();
+
+  return query ? `${backendBase}/${path}?${query}` : `${backendBase}/${path}`;
+}
+
+export function BuildForwardHeaders(req: NextRequest): Headers {
+  const headers = new Headers();
+
+  req.headers.forEach((value, key) => {
+    if (PROXY_REQUEST_HEADERS_TO_SKIP.has(key.toLowerCase())) {
+      return;
+    }
+
+    headers.set(key, value);
+  });
+
+  return headers;
+}
+
+export async function ReadRequestBody(req: NextRequest, method: string): Promise<BodyInit | undefined> {
+  if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
+    return undefined;
+  }
+
+  return await req.arrayBuffer();
+}
+
+export function ProxyErrorResponse(message: string, status: number, messageCode = "PROXY_ERROR", errorCode: EErrorCodes = EErrorCodes.Unknown): NextResponse {
+  return NextResponse.json(GetResponse.ERROR(message, messageCode, EExceptionCategories.Application, errorCode, undefined, null, status), { status });
+}
+function stripBackendBasePath(pathname: string, backendBaseUrl: string): string {
+  try {
+    const basePath = new URL(backendBaseUrl).pathname.replace(/\/+$/, "");
+    if (pathname.startsWith(basePath)) {
+      return pathname.slice(basePath.length).replace(/^\/+/, "");
+    }
+  } catch {
+    // Fall through to pathname cleanup below.
+  }
+
+  return pathname.replace(/^\/+/, "");
+}
+export function SanitizeResponseHeaders(headers: Headers, backendBaseUrl: string, module: EModules): Headers {
+  const sanitized = new Headers();
+  let backendHost: string | undefined;
+
+  try {
+    backendHost = new URL(backendBaseUrl).host;
+  } catch {
+    backendHost = undefined;
+  }
+
+  headers.forEach((value, key) => {
+    const lowerKey = key.toLowerCase();
+
+    if (PROXY_RESPONSE_HEADERS_TO_SKIP.has(lowerKey)) {
+      return;
+    }
+
+    if (lowerKey === "location" && backendHost) {
+      try {
+        const location = new URL(value, backendBaseUrl);
+        if (location.host === backendHost) {
+          const relativePath = stripBackendBasePath(location.pathname, backendBaseUrl);
+          const proxyPath = `${PROXY_PUBLIC_BASE_PATH}/${module}/${relativePath}${location.search}`;
+          sanitized.set(key, proxyPath);
+          return;
+        }
+      } catch {
+        // Relative locations are forwarded as-is.
+      }
+    }
+
+    sanitized.set(key, value);
+  });
+
+  return sanitized;
+}

package/src/proxy-api-client.tsx

@@ -0,0 +1 @@
+export * from "./proxy-api/proxy-constants";

package/src/proxy-api-server.tsx

@@ -0,0 +1,2 @@
+export * from "./proxy-api/proxy-backend";
+export * from "./proxy-api/proxy-constants";

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

@@ -0,0 +1,75 @@
+"use client";
+
+/**
+ * Client-side HTTP utilities for `"use client"` pages and components.
+ * Adds UI-level response handling (loader/toast hooks). For Route Handlers and
+ * Server Components use `http-services` (`HttpPost`, `HttpGet`, …) from `nexus-shared` instead.
+ */
+import { DatasourceTypes, EBody, GetApiInformations, GetResponse, IApiInformations, IErrorRespose, IInterface, ISuccessResponse, UN } from "../interface";
+import { HttpDelete, HttpGet, HttpPost, HttpPut } from "./http-services";
+import { ErrorMessage, SuccessMessage } from "./message-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 | UN, errorMessage?: boolean | UN): 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 | UN, bodyType?: EBody | UN, successMessage?: boolean | UN, errorMessage?: boolean | UN) => {
+  return await handleResponse(await HttpPut(apiUrl, body, bodyType, null, 0, null), successMessage ?? true, errorMessage ?? true);
+};
+
+export const Post = async (apiUrl: string, body?: any | UN, bodyType?: EBody | UN, successMessage?: boolean | UN, errorMessage?: boolean | UN) => {
+  const isFindListing = Array.isArray(body) && apiUrl.endsWith("/FindListing");
+
+  if (!isFindListing) {
+    return await handleResponse(await HttpPost(apiUrl, body, bodyType, null, 0, 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, 0, null)
+      .then((response) => handleResponse(response, successMessage ?? true, errorMessage ?? true))
+      .finally(() => {
+        delete pendingRequests[apiKey];
+      });
+    return pendingRequests[apiKey];
+  }
+};
+
+export const Delete = async (apiUrl: string, successMessage?: boolean | UN, errorMessage?: boolean | UN) => {
+  return await handleResponse(await HttpDelete(apiUrl, null, 0, null), successMessage ?? true, errorMessage ?? true);
+};
+export const SubmitApi = async (api: DatasourceTypes | UN, parameters: IInterface | IInterface[] | UN, successMessage?: boolean | UN, errorMessage?: boolean | UN): Promise<IErrorRespose | ISuccessResponse> => {
+  if (!api || Array.isArray(api) || !GetApiInformations.IS_API(api)) return Promise.resolve(GetResponse.SUCCESS(api));
+  const apiInfo = api as IApiInformations;
+
+  const url = GetApiInformations.BUILD_API(apiInfo, parameters);
+
+  // TODO:
+  return Post(url, parameters, null, successMessage, errorMessage);
+};
+
+const handleResponse = async (result: ISuccessResponse | IErrorRespose, successMessage?: boolean, errorMessage?: boolean): Promise<ISuccessResponse | IErrorRespose> => {
+  if (result.isSuccess && !(result as IErrorRespose).exception) {
+    if (successMessage) SuccessMessage("Request Success!", result.message ?? "Success");
+    return result;
+  }
+  if (errorMessage) ErrorMessage("Request Failed!", result.message ?? "Failed");
+  return result;
+};