nexus-shared 1.1.18 → 1.1.19

package/src/index.ts

@@ -1,5 +1,3 @@
-import "./load-env";
-
 // API services
 export * from "./api-services/preference-service";
 export * from "./api-services/system-service";
@@ -19,24 +17,10 @@ export * from "./helpers/string-helpers";
 export * from "./helpers/utility-helpers";
 
 // Interfaces
-export * from "./interfaces/browser-interfaces";
-export * from "./interfaces/button-interfaces";
-export * from "./interfaces/datasource-interfaces";
-export * from "./interfaces/datatable-interfaces";
-export * from "./interfaces/dialogbox-interfaces";
-export * from "./interfaces/http-interfaces";
-export * from "./interfaces/icon-interfaces";
-export * from "./interfaces/input-interfaces";
-export * from "./interfaces/layout-interfaces";
-export * from "./interfaces/menu-interfaces";
-export * from "./interfaces/permission-interfaces";
-export * from "./interfaces/storage-interfaces";
-export * from "./interfaces/system-interfaces";
-export * from "./interfaces/theme-interfaces";
-export * from "./interfaces/type-interfaces";
+export * from "./interface";
 
 // Core
 export * from "./nexus.environments";
+export * from "./proxy-api-server";
 export * from "./services/http-services";
 export * from "./sso-server";
- 

package/src/interface.ts

@@ -1,15 +1,18 @@
 export * from "./interfaces/browser-interfaces";
 export * from "./interfaces/button-interfaces";
-export * from "./interfaces/datatable-interfaces";
 export * from "./interfaces/datasource-interfaces";
+export * from "./interfaces/datatable-interfaces";
 export * from "./interfaces/dialogbox-interfaces";
+export * from "./interfaces/exception-interfaces";
 export * from "./interfaces/http-interfaces";
 export * from "./interfaces/icon-interfaces";
 export * from "./interfaces/input-interfaces";
 export * from "./interfaces/layout-interfaces";
 export * from "./interfaces/menu-interfaces";
+export * from "./interfaces/message-interfaces";
 export * from "./interfaces/permission-interfaces";
 export * from "./interfaces/storage-interfaces";
 export * from "./interfaces/system-interfaces";
 export * from "./interfaces/theme-interfaces";
 export * from "./interfaces/type-interfaces";
+export * from "./interfaces/user-interfaces";

package/src/interfaces/button-interfaces.tsx

@@ -40,10 +40,10 @@ export interface IButton {
   iconSize?: ESizes | UN;
   columnSize?: number | UN;
   borderSize?: number | UN;
-  target?: ETargets | UN;
+  target?: ETargets | EButtonTypes | UN;
 }
 
-export const GetButton = (label?: string | StringCallbackHandler | string | UN, id?: string | UN, url?: string | UN, icon?: EIcons | UN, onClick?: ClickHandler | UN, data?: any | Event | UN, background?: EBackgrounds | UN, defaultClass?: string | UN, displayOrder?: number | UN, iconType?: EIconTypes | UN, iconSize?: ESizes | UN, columnSize?: number | UN, borderSize?: number | UN, target?: ETargets | UN): IButton => {
+export const GetButton = (label?: string | StringCallbackHandler | string | UN, id?: string | UN, url?: string | UN, icon?: EIcons | UN, onClick?: ClickHandler | UN, data?: any | Event | UN, background?: EBackgrounds | UN, defaultClass?: string | UN, displayOrder?: number | UN, iconType?: EIconTypes | UN, iconSize?: ESizes | UN, columnSize?: number | UN, borderSize?: number | UN, target?: ETargets | EButtonTypes | UN): IButton => {
   return {
     label: label,
     id: id,

package/src/interfaces/http-interfaces.tsx

@@ -1,6 +1,11 @@
+import { NEXUS_INFO } from "../nexus.environments";
+import { GetRootApi } from "../services/http-services";
 import { EErrorCodes, EExceptionCategories } from "./exception-interfaces";
+import { EModules } from "./system-interfaces";
 import { IInterface, UN } from "./type-interfaces";
 
+export const PROXY_PUBLIC_BASE_PATH = "/api/app";
+
 export enum EActions {
   Get = 1,
   Post = 2,
@@ -8,28 +13,32 @@ export enum EActions {
   Delete = 4,
 }
 export interface IApiInformations {
-  api: string;
+  module: EModules;
+  apiName: string;
   method: EActions;
 }
+
 export interface IGetApiInformations extends IApiInformations {
   cacheCode?: string;
   /** In Minutes */
   cacheLifetime?: number;
+  bodyType?: EBody;
+  parameters?: any;
 }
 
 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;
+  message?: string | UN;
+  messageCode?: string | UN;
+  exceptionCategory?: EExceptionCategories | UN;
+  errorCode?: EErrorCodes | UN;
+  inputName?: string | UN;
+  result?: any | UN;
 }
 
 export interface IErrorRespose extends IRootRespose {
-  exception: any | UN;
+  exception?: any | UN;
 }
 export interface ISuccessResponse extends IRootRespose {}
 export enum EBody {
@@ -49,3 +58,75 @@ export const GetMethod = (method?: EActions) => {
       return "GET";
   }
 };
+
+export const GetResponse = {
+  ERROR: (message: string = "An error occurred.", messageCode: string = "GENERIC_ERROR", exceptionCategory: EExceptionCategories = EExceptionCategories.Application, errorCode: EErrorCodes = EErrorCodes.Unknown, inputName: string | undefined = undefined, exception: any | null = null, code: number = 400): IErrorRespose => ({
+    isSuccess: false,
+    exception: exception,
+    code: code,
+    message: message,
+    messageCode: messageCode,
+    exceptionCategory: exceptionCategory,
+    errorCode: errorCode,
+    inputName: inputName,
+    result: null,
+  }),
+  SUCCESS: (result: any | UN, message: string = "Success", messageCode: string = "SUCCESS", code: number = 200): ISuccessResponse => ({
+    isSuccess: true,
+    result: result,
+    message: message,
+    messageCode: messageCode,
+    code: code,
+    exceptionCategory: EExceptionCategories.Application,
+    errorCode: EErrorCodes.Unknown,
+    inputName: undefined,
+  }),
+};
+
+const GET_API_KEYS = ["cacheCode", "cacheLifetime", "bodyType", "parameters"];
+const _isApi = (apiInformations: any | IApiInformations): boolean => {
+  if (!apiInformations || (!apiInformations.module && apiInformations.module !== EModules.None) || !apiInformations.apiName || !apiInformations.method) return false;
+  return true;
+};
+
+export const GetApiInformations = {
+  API: (module: EModules, apiName: string, method?: EActions | UN): IApiInformations => ({
+    module: module,
+    apiName: apiName,
+    method: method ?? EActions.Get,
+  }),
+  IS_API: _isApi,
+  GET_API: (module: EModules, apiName: string, method?: EActions | UN, cacheCode?: string | UN, cacheLifetime?: number | UN, bodyType?: EBody | UN, parameters?: any | UN): IGetApiInformations => {
+    return {
+      module: module,
+      apiName: apiName,
+      method: method ?? EActions.Get,
+      cacheCode: cacheCode,
+      cacheLifetime: cacheLifetime,
+      bodyType: bodyType,
+      parameters: parameters,
+    } as IGetApiInformations;
+  },
+  IS_GET_API: (apiInformations: any | IApiInformations): boolean => {
+    if (!_isApi(apiInformations)) return false;
+    const keys = Object.keys(apiInformations);
+    return GET_API_KEYS.every((key) => keys.includes(key));
+  },
+  BUILD_API: (apiInformations: IApiInformations, parameters?: any | UN) => {
+    const isProxyServer = NEXUS_INFO.IS_PROXY_SERVER;
+    if (isProxyServer) return BuildProxyApiUrl(apiInformations.module, apiInformations.apiName);
+    return `${GetRootApi(apiInformations.module)}/${apiInformations.apiName}`;
+  },
+};
+export const BuildProxyApiUrl = (module: EModules, relativePath: string, query?: string): string => {
+  const normalizedPath = relativePath.replace(/^\/+/, "");
+  if (module === EModules.None) return `/api/${normalizedPath}`;
+  const base = `${PROXY_PUBLIC_BASE_PATH}/${module}/${normalizedPath}`;
+
+  if (!query) {
+    return base;
+  }
+
+  const normalizedQuery = query.replace(/^\?+/, "");
+  return normalizedQuery ? `${base}?${normalizedQuery}` : base;
+};

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/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/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

@@ -16,8 +16,12 @@ export const URLS = {
   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"),
@@ -37,6 +41,7 @@ export const NEXUS_INFO = {
   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";