@syzy/apphost 1.0.1 → 1.0.3

package/dist/App.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const componentMap: Record<string, React.ComponentType<any>>;
+declare const _default: (props: any) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/App.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// import { configureAmplify } from "./config/amplifyConfig.ts";
+import { Route, Routes } from 'react-router-dom';
+import { useCurrentUser } from './hooks/useCurrentUser';
+import { withSyzyAuth } from './hoc/withSyzyAuth';
+import React, { useEffect, useState } from 'react';
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
+import Sidebar from './components/NavBar/Sidebar';
+import { getSidebarMenu } from './services/navigationMenu';
+import ProfileForm from './components/ProfileForm/ProfileForm';
+import BranchMapping from './components/Mappings/BranchMapping/Branch';
+import MappingFormBranchUser from './components/Mappings/BranchMapping/MappingFormBranchUser';
+import ComponentRoleMapping from './components/Mappings/ComponentMapping/ComponentRoleMapping';
+import MappingFormUserRole from './components/Mappings/RoleMapping/MappingFormUserRole';
+import Home from './components/Home/Home';
+import LoadingSpinner from './components/Loader/Loader';
+// import { isHostedInContainer } from "./util/hostedinContainer.ts";
+// configureAmplify();
+export const componentMap = {
+    BranchMapping,
+    ProfileForm,
+    MappingFormBranchUser,
+    MappingFormUserRole,
+    ComponentRoleMapping,
+    Home,
+};
+const flattenRoutes = (items) => {
+    const flat = [];
+    const walk = (arr) => {
+        arr.forEach(item => {
+            if (item.path && item.requiredComponent) {
+                flat.push(item);
+            }
+            if (item.children) {
+                walk(item.children);
+            }
+        });
+    };
+    walk(items);
+    return flat;
+};
+const withAccessControl = (Component, props, requiredComponent, allowedComponents) => {
+    // Check if the user has access
+    const isAllowed = !requiredComponent || (allowedComponents?.includes(requiredComponent));
+    if (!isAllowed) {
+        return () => (_jsx("div", { className: "text-center mt-5", children: _jsx("h3", { className: "text-danger", children: "You are not allowed to see this page." }) }));
+    }
+    return () => _jsx(Component, { ...props });
+};
+function App({ isSessionReady }) {
+    const { user } = useCurrentUser();
+    const [routes, setRoutes] = useState([]);
+    const flatRoutes = flattenRoutes(routes);
+    useEffect(() => {
+        const fetchMenu = async () => {
+            const data = await getSidebarMenu();
+            setRoutes(data);
+        };
+        fetchMenu();
+    }, []);
+    // useEffect(() => {
+    //   isHostedInContainer();
+    // }, []);
+    useEffect(() => {
+        const fetchMenu = async () => {
+            const data = await getSidebarMenu();
+            setRoutes(data);
+        };
+        fetchMenu();
+    }, []);
+    // useEffect(() => {
+    //   isHostedInContainer();
+    //   configureAmplify();
+    // }, []);
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { style: { display: "flex", width: "100%" }, children: [_jsx(Sidebar, {}), _jsx("div", { style: { flex: 1, padding: "10px" }, children: !isSessionReady ? (_jsx(LoadingSpinner, {})) : (_jsx(React.Fragment, { children: _jsxs(Routes, { children: [flatRoutes.map(({ path, requiredComponent, props }) => {
+                                        const PageComponent = componentMap[requiredComponent];
+                                        if (!PageComponent)
+                                            return null;
+                                        const ProtectedComponent = withAccessControl(PageComponent, props, requiredComponent, user.allowedComponents);
+                                        return _jsx(Route, { path: path, element: _jsx(ProtectedComponent, {}) }, path);
+                                    }), _jsx(Route, { path: "*", element: _jsx("h3", { className: "text-danger", children: "Page Not Found" }) })] }) })) })] }), _jsx(ReactQueryDevtools, { initialIsOpen: false })] }));
+}
+export default withSyzyAuth(App);

package/dist/AppHostProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+interface Props {
+    children: ReactNode;
+}
+export declare const AppHostProvider: ({ children }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/AppHostProvider.js

@@ -0,0 +1,4 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export const AppHostProvider = ({ children }) => {
+    return (_jsx(_Fragment, { children: children }));
+};

package/dist/AppHostRoutes.d.ts

@@ -0,0 +1 @@
+export declare const AppHostRoutes: () => import("react/jsx-runtime").JSX.Element;

package/dist/AppHostRoutes.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Routes, Route } from "react-router-dom";
+const Dashboard = () => _jsx("div", { children: "AppHost Dashboard" });
+const Settings = () => _jsx("div", { children: "AppHost Settings" });
+export const AppHostRoutes = () => {
+    return (_jsxs(Routes, { children: [_jsx(Route, { path: "/apphost", element: _jsx(Dashboard, {}) }), _jsx(Route, { path: "/apphost/settings", element: _jsx(Settings, {}) })] }));
+};

package/dist/api/image-api.d.ts

@@ -0,0 +1,8 @@
+import { ImageDto } from "../domain/model/imageDto";
+export declare const GETIMAGEPRESIGNEDURL_QUERYKEY = "downloadimage";
+export declare const useGetImageURL: (fileName: string | undefined) => {
+    fetchedImg: string | undefined;
+    fetchedImgLoading: boolean;
+    fetchedImgError: Error | null;
+};
+export declare const useImageMutation: (imgInfo: ImageDto | undefined) => import("@tanstack/react-query").UseMutationResult<import("aws-amplify/storage").UploadDataOutput, Error, ImageDto, unknown>;

package/dist/api/image-api.js

@@ -0,0 +1,45 @@
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { LogCategoryEnum } from "../util/LogEnum";
+import { logger } from "../util/Logger";
+import { getImageUrl } from "../services/Storage-service";
+import { uploadData } from "aws-amplify/storage";
+import { toast } from "react-toastify";
+export const GETIMAGEPRESIGNEDURL_QUERYKEY = "downloadimage";
+export const useGetImageURL = (fileName) => {
+    logger.debug(LogCategoryEnum.Info, "fileName", fileName);
+    logger.debug(LogCategoryEnum.Info, "inside of get img url", fileName);
+    const { data, isLoading, error } = useQuery({
+        queryKey: [GETIMAGEPRESIGNEDURL_QUERYKEY, fileName],
+        queryFn: () => getImageUrl(fileName),
+        placeholderData: keepPreviousData,
+        staleTime: 300000,
+        enabled: fileName !== undefined
+    });
+    return { fetchedImg: data, fetchedImgLoading: isLoading, fetchedImgError: error };
+};
+export const useImageMutation = (imgInfo) => {
+    logger.debug(LogCategoryEnum.Info, "inside upload image mutation", imgInfo);
+    const uploadImage = async (image) => {
+        logger.debug(LogCategoryEnum.Info, "inside upload image function", image);
+        return uploadData({
+            key: image.imageKey,
+            data: image.file,
+            options: {
+                accessLevel: 'guest',
+                contentType: image.file.type,
+            }
+        });
+    };
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: uploadImage,
+        onSuccess: () => {
+            logger.debug(LogCategoryEnum.Info, "inside invalidate queries", imgInfo);
+            queryClient.invalidateQueries({ queryKey: [GETIMAGEPRESIGNEDURL_QUERYKEY, imgInfo?.imageKey] });
+        },
+        onError: (error) => {
+            logger.debug(LogCategoryEnum.Info, "Image Upload failed ", error);
+            toast.error("Failed in uploading Image ");
+        }
+    });
+};

package/dist/api/mapping-api.d.ts

@@ -0,0 +1,80 @@
+import { MappingDto } from "../domain/model/MappingDto";
+import { UndefinedString } from "../domain/type/Nullable";
+import { UserMappingDto } from "../domain/model/UserMappingDto";
+import { RoleMappingDto } from "../domain/model/RoleMappingDto";
+import { ComponentMappingDto, ComponentRoleMapping } from "../domain/model/ComponentMappingDto";
+import { BranchDto } from "../domain/model/BranchDto";
+import { ProfileDto } from "../domain/model/ProfileDto";
+import { Status } from "../domain/type/StatusEnum";
+export declare const MAPPING_RESOURCE: string;
+export declare const GET_MAPPING_BY_USERID_QUERYKEY: string;
+export declare const LIST_BRANCHES_RESOURCE: string;
+export declare const transformtoMappingDto: (mappingData: any) => MappingDto;
+export declare const createProfileFn: (input: Partial<ProfileDto>) => Promise<ProfileDto>;
+export declare const updateProfileFn: (input: ProfileDto) => Promise<ProfileDto>;
+export declare const getProfileFn: (pk: string) => Promise<ProfileDto>;
+export declare const listProfilesFn: () => Promise<ProfileDto[]>;
+export declare const useCreateProfileMutation: () => import("@tanstack/react-query").UseMutationResult<ProfileDto, Error, Partial<ProfileDto>, unknown>;
+export declare const useUpdateProfileMutation: () => import("@tanstack/react-query").UseMutationResult<ProfileDto, Error, ProfileDto, unknown>;
+export declare const useListProfiles: () => import("@tanstack/react-query").UseQueryResult<ProfileDto[], Error>;
+export declare const useGetProfile: (pk: string) => import("@tanstack/react-query").UseQueryResult<ProfileDto, Error>;
+export type BranchInput = {
+    pk: string;
+    sk: string;
+    branchAddress: string;
+    branchContactNumber: string;
+    createdDt: string;
+    status: string;
+};
+export declare const getBranches: () => Promise<any>;
+export declare const useListBranches: () => import("@tanstack/react-query").UseQueryResult<any, Error>;
+export declare const createBranchFn: (input: {
+    branchName: string;
+    branchAddress: string;
+    branchContactNumber: string;
+    status?: string;
+}) => Promise<BranchDto>;
+export declare const useCreateBranchMutation: () => import("@tanstack/react-query").UseMutationResult<BranchDto, any, {
+    branchName: string;
+    branchAddress: string;
+    branchContactNumber: string;
+    status?: string;
+}, unknown>;
+export declare const getUserMappingByUserIdFun: (userId: UndefinedString) => Promise<UserMappingDto>;
+export declare const useGetUserMappingByUserId: (userId: string) => {
+    userMappingByUserId: UserMappingDto | undefined;
+    userMappingByUserIdError: Error | null;
+    userMappingByUserIdLoading: boolean;
+    userMappingByUserIdFetching: boolean;
+    userMappingByUserIdSuccess: boolean;
+};
+export declare const getRolesMappingByUserIdAndEntityFun: (branchId: string, userId: string, entity: string) => Promise<RoleMappingDto[]>;
+export declare const getRoleMappingByUserIdAndRoleNameFun: (userId: UndefinedString, roleName: UndefinedString) => Promise<RoleMappingDto>;
+export declare const queryMappings: (variables: any) => Promise<any>;
+export declare const getUserComponents: (branchId: string, userId: string) => Promise<any>;
+export declare const getCompoMappingByRoleIdAndCompoIdFun: (roleId: UndefinedString, componentId: UndefinedString) => Promise<ComponentMappingDto>;
+export declare const getCompoMappingByRoleIdAndEntityFun: (branchId: string, roleId: string) => Promise<ComponentMappingDto[]>;
+export declare const getComponentsByRoleOnly: (roleId: string) => Promise<ComponentMappingDto[]>;
+export declare const useCreateMappingMutation: () => import("@tanstack/react-query").UseMutationResult<any, Error, MappingDto, unknown>;
+export declare const useUpdateMappingMutation: () => import("@tanstack/react-query").UseMutationResult<any, Error, MappingDto, unknown>;
+export declare const getBranchIdByUserId: (userId: string) => Promise<string[]>;
+export declare const getBranchNameById: (branchId: string) => Promise<string>;
+export declare const updateBranchFn: (input: BranchInput) => Promise<BranchDto>;
+export declare const useUpdateBranchMutation: () => import("@tanstack/react-query").UseMutationResult<BranchDto, Error, BranchInput, unknown>;
+export interface BranchUserMapping {
+    pk: string;
+    sk: string;
+    branchName: string;
+    userId: string;
+    userName: string;
+    status: Status;
+    createdDt: string;
+    disabledDt?: string;
+}
+export declare const fetchBranchUserMappings: (branchesMap: Record<string, string>) => Promise<BranchUserMapping[]>;
+export declare const fetchUserRoleMappings: () => Promise<any[]>;
+export declare const LIST_USER_ROLE_MAPPING_KEY = "userRoleMappings";
+export declare const useUserRoleMappings: () => import("@tanstack/react-query").UseQueryResult<any[], Error>;
+export declare const fetchComponentRoleMappings: () => Promise<ComponentRoleMapping[]>;
+export declare const LIST_COMPONENT_ROLE_MAPPING_KEY = "component-role-mapping";
+export declare const useListComponentRoleMappings: () => import("@tanstack/react-query").UseQueryResult<ComponentRoleMapping[], Error>;

package/dist/api/mapping-api.js

@@ -0,0 +1,427 @@
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { EnvConfig } from "../config/EnvConfig";
+import { Client } from "../services/Client.Service";
+import { initUserMappingDto, transformtoUserMappingDto } from "../domain/model/UserMappingDto";
+import { initRoleMappingDto, transformtoRoleMappingDto } from "../domain/model/RoleMappingDto";
+import { initComponentMappingDto, transformtoComponentMappingDto } from "../domain/model/ComponentMappingDto";
+import { v4 as uuidv4 } from "uuid";
+import { createProfile, getProfile, listProfiles, updateProfile } from "../graphql/profileQueries";
+import { getCurrentUser } from "aws-amplify/auth";
+import { logger } from "../util/Logger";
+import { createBranchMutationGQL, createMapping, updateMapping } from "../customGraphQL/customMutations";
+import { listBranchesQuery, ListBranchUserMappings, ListComponentRoleMappings, listMapping, ListUserRoleMapping, updateBranchMutationQuery } from "../customGraphQL/customQueries";
+import { Status } from "../domain/type/StatusEnum";
+export const MAPPING_RESOURCE = "mapping";
+export const GET_MAPPING_BY_USERID_QUERYKEY = "mappingbyuserid";
+export const LIST_BRANCHES_RESOURCE = "branches";
+const endpoint = EnvConfig.appHostAPi;
+export const transformtoMappingDto = (mappingData) => {
+    logger.info("transform to MappingDto:", mappingData);
+    const { __typename, createdAt, updatedAt, ...itm } = mappingData;
+    const transformedData = { ...itm };
+    logger.info("transformed mapping data:", transformedData);
+    return transformedData;
+};
+// ✅ Create Profile
+export const createProfileFn = async (input) => {
+    if (!input.name)
+        throw new Error("name is required");
+    if (!input.email)
+        throw new Error("email is required");
+    if (!input.customId)
+        throw new Error("customId (HMS ID) is required");
+    if (!input.dob)
+        throw new Error("Date of Birth is required");
+    if (!input.contactRelation)
+        throw new Error("Contact relation is required");
+    if (!input.contactPersonName)
+        throw new Error("Contact person name is required");
+    if (!input.contactPersonNumber)
+        throw new Error("Contact person number is required");
+    if (!input.aadhaarNumber)
+        throw new Error("Aadhaar number is required");
+    const user = await getCurrentUser();
+    const currentUserId = user.username || user.userId;
+    const aadhaarFileName = input.aadhaarFile ?? "";
+    const payload = {
+        pk: uuidv4(),
+        sk: input.customId,
+        name: input.name,
+        email: input.email,
+        phoneNumber: input.phoneNumber ?? "",
+        address: input.address ?? "",
+        dob: input.dob,
+        contactRelation: input.contactRelation,
+        contactPersonName: input.contactPersonName,
+        contactPersonNumber: input.contactPersonNumber,
+        aadhaarNumber: input.aadhaarNumber,
+        aadhaarFile: aadhaarFileName, // you can upload to S3 if needed
+        isAdmin: input.isAdmin ?? false,
+        status: input.status ?? Status.Active,
+        createdDt: input.createdDt ?? new Date().toISOString(),
+        createdBy: currentUserId,
+    };
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(createProfile, { input: payload });
+    return response.createProfile;
+};
+// ✅ Update Profile
+export const updateProfileFn = async (input) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(updateProfile, { input });
+    return response.updateProfile;
+};
+// ✅ Get Profile by ID
+export const getProfileFn = async (pk) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(getProfile, { pk });
+    return response.getProfile;
+};
+// ✅ List All Profiles
+export const listProfilesFn = async () => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    try {
+        const response = await client.request(listProfiles);
+        return response.listProfiles;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+// React Query Hooks
+export const useCreateProfileMutation = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: createProfileFn,
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ["profiles"] });
+        },
+    });
+};
+export const useUpdateProfileMutation = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: updateProfileFn,
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ["profiles"] });
+        },
+    });
+};
+export const useListProfiles = () => useQuery({ queryKey: ["profiles"], queryFn: listProfilesFn, });
+export const useGetProfile = (pk) => useQuery({ queryKey: ["profile", pk], queryFn: () => getProfileFn(pk), enabled: !!pk });
+export const getBranches = async () => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(listBranchesQuery);
+    return response.listBranch || [];
+};
+export const useListBranches = () => useQuery({
+    queryKey: [LIST_BRANCHES_RESOURCE],
+    queryFn: getBranches,
+    staleTime: 1000 * 60 * 5,
+});
+// ---------- API Function ----------
+export const createBranchFn = async (input) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const branchData = {
+        pk: uuidv4(),
+        sk: input.branchName,
+        branchAddress: input.branchAddress,
+        branchContactNumber: input.branchContactNumber,
+        createdDt: new Date().toISOString(),
+        status: input.status ?? "ACTIVE",
+    };
+    const response = await client.request(createBranchMutationGQL, { input: branchData });
+    return response.createBranch;
+};
+// ---------- React Query Mutation Hook ----------
+export const useCreateBranchMutation = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: createBranchFn,
+        onSuccess: (data) => {
+            logger.debug("Branch mutation success", data);
+            const qkForListBranches = [LIST_BRANCHES_RESOURCE];
+            queryClient.invalidateQueries({ queryKey: qkForListBranches });
+        },
+        onError: (err) => {
+            logger.error("Branch mutation error", err);
+        },
+    });
+};
+// to get a user from mapping table by passing userId
+export const getUserMappingByUserIdFun = async (userId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        filter: {
+            entity: { eq: "ROLE" },
+            userId: { eq: userId?.toUpperCase() },
+        },
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    return mappingData && mappingData.length > 0
+        ? transformtoUserMappingDto(mappingData[0])
+        : initUserMappingDto;
+};
+export const useGetUserMappingByUserId = (userId) => {
+    const { data, isLoading, error, isFetching, isSuccess } = useQuery({
+        queryKey: [GET_MAPPING_BY_USERID_QUERYKEY, userId],
+        queryFn: () => getUserMappingByUserIdFun(userId),
+        placeholderData: keepPreviousData,
+        staleTime: 1000 * 5 * 60,
+        enabled: userId !== "" && userId !== undefined,
+    });
+    return {
+        userMappingByUserId: data,
+        userMappingByUserIdError: error,
+        userMappingByUserIdLoading: isLoading,
+        userMappingByUserIdFetching: isFetching,
+        userMappingByUserIdSuccess: isSuccess,
+    };
+};
+// to get roles for a user from mapping table by passing userId and entity as ROLE
+export const getRolesMappingByUserIdAndEntityFun = async (branchId, userId, entity) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        pk: branchId, // ✅ branchId, not userId
+        filter: {
+            entity: { eq: entity },
+            userId: { eq: userId?.toUpperCase() },
+        }
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    return mappingData?.map((itm) => transformtoRoleMappingDto(itm)) || [];
+};
+export const getRoleMappingByUserIdAndRoleNameFun = async (userId, roleName) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        pk: userId,
+        sk: { eq: roleName }
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    logger.info("list role mapping by userId and roleName fetched successfully", mappingData);
+    return mappingData && mappingData.length > 0 ? transformtoRoleMappingDto(mappingData[0]) : initRoleMappingDto;
+};
+// 🧠 Generic query helper
+export const queryMappings = async (variables) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(listMapping, variables);
+    logger.info("Fetched mapping data", response);
+    return response.listMapping || [];
+};
+export const getUserComponents = async (branchId, userId) => {
+    const userRoles = await queryMappings({
+        pk: branchId,
+        filter: {
+            entity: { eq: "ROLE" },
+            userId: { eq: userId },
+        },
+    });
+    const roleComponentsPromises = userRoles.map((r) => queryMappings({
+        pk: branchId,
+        filter: {
+            entity: { eq: "COMPONENT" },
+            roleName: { eq: r.roleName },
+        },
+    }));
+    const roleComponentsArrays = await Promise.all(roleComponentsPromises);
+    return roleComponentsArrays.flat();
+};
+// to get a component for a role from mapping table by passing roleId and componentId
+export const getCompoMappingByRoleIdAndCompoIdFun = async (roleId, componentId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        pk: roleId,
+        sk: { eq: componentId }
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    logger.info("list component mapping by roleId and componentId fetched successfully", mappingData);
+    return mappingData && mappingData.length > 0 ? transformtoComponentMappingDto(mappingData[0]) : initComponentMappingDto;
+};
+export const getCompoMappingByRoleIdAndEntityFun = async (branchId, roleId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        pk: branchId,
+        filter: {
+            entity: { eq: "COMPONENT" }, // must match table column
+            roleId: { eq: roleId }, // must match roleId in table
+        }
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    logger.info('list component mapping by roleId and entity fetched successfully', mappingData);
+    return mappingData?.length
+        ? mappingData.map((itm) => transformtoComponentMappingDto(itm))
+        : [];
+};
+export const getComponentsByRoleOnly = async (roleId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const variables = {
+        filter: {
+            entity: { eq: "COMPONENT" },
+            roleId: { eq: roleId },
+        },
+    };
+    const response = await client.request(listMapping, variables);
+    const mappingData = response.listMapping;
+    return mappingData?.map((itm) => transformtoComponentMappingDto(itm)) || [];
+};
+//-------------------- Mapping Mutations -------------------------
+export const useCreateMappingMutation = () => {
+    async function createMappingFn(mappingData) {
+        const client = await Client.getCustomGraphqlClient(endpoint);
+        const input = {
+            ...mappingData,
+        };
+        const response = await client.request(createMapping, { input });
+        logger.info("Mapping posted successfully", response);
+        return response;
+    }
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: createMappingFn,
+        onSuccess: (_data, variables) => {
+            const queryKeyForMappingByUserId = [GET_MAPPING_BY_USERID_QUERYKEY, variables.pk];
+            queryClient.invalidateQueries({ queryKey: queryKeyForMappingByUserId });
+        },
+    });
+};
+export const useUpdateMappingMutation = () => {
+    async function updateMappingFn(mappingData) {
+        const client = await Client.getCustomGraphqlClient(endpoint);
+        const input = mappingData;
+        const response = await client.request(updateMapping, { input: input, });
+        logger.info("Mapping updated successfully", response);
+        return response;
+    }
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: updateMappingFn,
+        onSuccess: (_data, variables) => {
+            const queryKeyForMappingByUserId = [GET_MAPPING_BY_USERID_QUERYKEY, variables.pk];
+            queryClient.invalidateQueries({ queryKey: queryKeyForMappingByUserId });
+            queryClient.invalidateQueries({ queryKey: [LIST_USER_ROLE_MAPPING_KEY] });
+            queryClient.invalidateQueries({ queryKey: [LIST_COMPONENT_ROLE_MAPPING_KEY], });
+        },
+    });
+};
+export const getBranchIdByUserId = async (userId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const filter = {
+        entity: { eq: "USER" },
+        userId: { eq: userId },
+        status: { eq: "ACTIVE" },
+    };
+    try {
+        const response = await client.request(`
+      query ListMappingForUsers($pk: String, $filter: ModelMappingFilterInput) {
+        listMapping(pk: $pk, filter: $filter) {
+          pk
+          userId
+          entity
+        }
+      }
+    `, { pk: null, filter });
+        const mappingData = response.listMapping;
+        if (mappingData && mappingData.length > 0) {
+            return mappingData.map(item => item.pk);
+        }
+        return [];
+    }
+    catch (err) {
+        logger.error("Error fetching branch for user", err);
+        return [];
+    }
+};
+export const getBranchNameById = async (branchId) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    try {
+        const response = await client.request(listBranchesQuery);
+        // Remove "BRANCH#" prefix if exists
+        const cleanBranchId = branchId.replace(/^BRANCH#/, "");
+        const branch = response.listBranch.find(b => b.pk === cleanBranchId);
+        return branch?.sk || "User is not assigned to any branch. Please assign a branch.";
+    }
+    catch (err) {
+        logger.error("Error fetching branch name", err);
+        return "Unknown Branch";
+    }
+};
+// ---------- Update Branch Function ----------
+export const updateBranchFn = async (input) => {
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(updateBranchMutationQuery, { input });
+    return response.updateBranch;
+};
+// ---------- React Query Mutation Hook ----------
+export const useUpdateBranchMutation = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: updateBranchFn,
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: [LIST_BRANCHES_RESOURCE] });
+        },
+    });
+};
+export const fetchBranchUserMappings = async (branchesMap) => {
+    const endpoint = EnvConfig.appHostAPi;
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(ListBranchUserMappings);
+    return response.listMapping.map((m) => {
+        const transformed = transformtoMappingDto(m);
+        return {
+            pk: transformed.pk,
+            sk: transformed.sk,
+            branchName: branchesMap[transformed.pk.replace(/^BRANCH#/, "")] || transformed.pk,
+            userId: transformed.userId,
+            userName: transformed.userName,
+            status: transformed.status?.toUpperCase() === "INACTIVE" ? Status.Inactive : Status.Active,
+            createdDt: transformed.createdDt,
+            disabledDt: transformed.disabledDt || undefined,
+        };
+    });
+};
+export const fetchUserRoleMappings = async () => {
+    const endpoint = EnvConfig.appHostAPi;
+    const client = await Client.getCustomGraphqlClient(endpoint);
+    const response = await client.request(ListUserRoleMapping);
+    return response.listMapping.map(m => ({
+        ...m,
+        status: m.status
+    }));
+};
+export const LIST_USER_ROLE_MAPPING_KEY = "userRoleMappings";
+export const useUserRoleMappings = () => {
+    return useQuery({
+        queryKey: ["userRoleMappings"],
+        queryFn: fetchUserRoleMappings,
+        staleTime: 1000 * 60 * 5,
+    });
+};
+export const fetchComponentRoleMappings = async () => {
+    const client = await Client.getCustomGraphqlClient(EnvConfig.appHostAPi);
+    const response = await client.request(ListComponentRoleMappings);
+    return response.listMapping.map((m) => {
+        const transformed = transformtoMappingDto(m);
+        return {
+            pk: transformed.pk,
+            sk: transformed.sk,
+            roleName: transformed.roleName,
+            componentTitle: transformed.componentTitle,
+            status: transformed.status?.toUpperCase() === "INACTIVE"
+                ? Status.Inactive
+                : Status.Active,
+            createdDt: transformed.createdDt,
+            disabledDt: transformed.disabledDt || undefined,
+        };
+    });
+};
+export const LIST_COMPONENT_ROLE_MAPPING_KEY = "component-role-mapping";
+export const useListComponentRoleMappings = () => useQuery({
+    queryKey: [LIST_COMPONENT_ROLE_MAPPING_KEY],
+    queryFn: fetchComponentRoleMappings,
+    staleTime: 1000 * 60 * 5,
+});