Merge pull request #1328 from Pallavikumarimdb/enhancement-#906/dashboard-enhancements

Enhancement #906/Resources Dashboard: Targets Column, Customizable Columns & Status Indicators

messages/en-US.json

@@ -2081,5 +2081,19 @@
     "supportSend": "Send",
     "supportMessageSent": "Message Sent!",
     "supportWillContact": "We'll be in touch shortly!",
-    "selectLogRetention": "Select log retention"
+    "selectLogRetention": "Select log retention",
+    "showColumns": "Show Columns",
+    "hideColumns": "Hide Columns",
+    "columnVisibility": "Column Visibility",
+    "toggleColumn": "Toggle {columnName} column",
+    "allColumns": "All Columns",
+    "defaultColumns": "Default Columns",
+    "customizeView": "Customize View",
+    "viewOptions": "View Options",
+    "selectAll": "Select All",
+    "selectNone": "Select None",
+    "selectedResources": "Selected Resources",
+    "enableSelected": "Enable Selected",
+    "disableSelected": "Disable Selected",
+    "checkSelectedStatus": "Check Status of Selected"
 }

server/routers/resource/listResources.ts

@@ -6,7 +6,9 @@ import {
     userResources,
     roleResources,
     resourcePassword,
-    resourcePincode
+    resourcePincode,
+    targets,
+    targetHealthCheck,
 } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -40,6 +42,59 @@ const listResourcesSchema = z.object({
         .pipe(z.number().int().nonnegative())
 });
 
+// (resource fields + a single joined target)
+type JoinedRow = {
+    resourceId: number;
+    niceId: string;
+    name: string;
+    ssl: boolean;
+    fullDomain: string | null;
+    passwordId: number | null;
+    sso: boolean;
+    pincodeId: number | null;
+    whitelist: boolean;
+    http: boolean;
+    protocol: string;
+    proxyPort: number | null;
+    enabled: boolean;
+    domainId: string | null;
+    headerAuthId: number | null;
+
+    targetId: number | null;
+    targetIp: string | null;
+    targetPort: number | null;
+    targetEnabled: boolean | null;
+
+    hcHealth: string | null;
+    hcEnabled: boolean | null;
+};
+
+// grouped by resource with targets[]) 
+export type ResourceWithTargets = {
+    resourceId: number;
+    name: string;
+    ssl: boolean;
+    fullDomain: string | null;
+    passwordId: number | null;
+    sso: boolean;
+    pincodeId: number | null;
+    whitelist: boolean;
+    http: boolean;
+    protocol: string;
+    proxyPort: number | null;
+    enabled: boolean;
+    domainId: string | null;
+    niceId: string;
+    headerAuthId: number | null;
+    targets: Array<{
+        targetId: number;
+        ip: string;
+        port: number;
+        enabled: boolean;
+        healthStatus?: 'healthy' | 'unhealthy' | 'unknown';
+    }>;
+};
+
 function queryResources(accessibleResourceIds: number[], orgId: string) {
     return db
         .select({
@@ -57,7 +112,15 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
             enabled: resources.enabled,
             domainId: resources.domainId,
             niceId: resources.niceId,
-            headerAuthId: resourceHeaderAuth.headerAuthId
+            headerAuthId: resourceHeaderAuth.headerAuthId,
+
+            targetId: targets.targetId,
+            targetIp: targets.ip,
+            targetPort: targets.port,
+            targetEnabled: targets.enabled,
+
+            hcHealth: targetHealthCheck.hcHealth,
+            hcEnabled: targetHealthCheck.hcEnabled,
         })
         .from(resources)
         .leftJoin(
@@ -72,6 +135,11 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
             resourceHeaderAuth,
             eq(resourceHeaderAuth.resourceId, resources.resourceId)
         )
+        .leftJoin(targets, eq(targets.resourceId, resources.resourceId))
+        .leftJoin(
+            targetHealthCheck,
+            eq(targetHealthCheck.targetId, targets.targetId)
+        )
         .where(
             and(
                 inArray(resources.resourceId, accessibleResourceIds),
@@ -81,7 +149,7 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
 }
 
 export type ListResourcesResponse = {
-    resources: NonNullable<Awaited<ReturnType<typeof queryResources>>>;
+    resources: ResourceWithTargets[];
     pagination: { total: number; limit: number; offset: number };
 };
 
@@ -146,7 +214,7 @@ export async function listResources(
             );
         }
 
-        let accessibleResources;
+        let accessibleResources: Array<{ resourceId: number }>;
         if (req.user) {
             accessibleResources = await db
                 .select({
@@ -183,9 +251,56 @@ export async function listResources(
 
         const baseQuery = queryResources(accessibleResourceIds, orgId);
 
-        const resourcesList = await baseQuery!.limit(limit).offset(offset);
+        const rows: JoinedRow[] = await baseQuery.limit(limit).offset(offset);
+
+        // avoids TS issues with reduce/never[]
+        const map = new Map<number, ResourceWithTargets>();
+
+        for (const row of rows) {
+            let entry = map.get(row.resourceId);
+            if (!entry) {
+                entry = {
+                    resourceId: row.resourceId,
+                    niceId: row.niceId,
+                    name: row.name,
+                    ssl: row.ssl,
+                    fullDomain: row.fullDomain,
+                    passwordId: row.passwordId,
+                    sso: row.sso,
+                    pincodeId: row.pincodeId,
+                    whitelist: row.whitelist,
+                    http: row.http,
+                    protocol: row.protocol,
+                    proxyPort: row.proxyPort,
+                    enabled: row.enabled,
+                    domainId: row.domainId,
+                    headerAuthId: row.headerAuthId,
+                    targets: [],
+                };
+                map.set(row.resourceId, entry);
+            }
+
+            if (row.targetId != null && row.targetIp && row.targetPort != null && row.targetEnabled != null) {
+                let healthStatus: 'healthy' | 'unhealthy' | 'unknown' = 'unknown';
+
+                if (row.hcEnabled && row.hcHealth) {
+                    healthStatus = row.hcHealth as 'healthy' | 'unhealthy' | 'unknown';
+                }
+
+                entry.targets.push({
+                    targetId: row.targetId,
+                    ip: row.targetIp,
+                    port: row.targetPort,
+                    enabled: row.targetEnabled,
+                    healthStatus: healthStatus,
+                });
+            }
+        }
+
+        const resourcesList: ResourceWithTargets[] = Array.from(map.values());
+
         const totalCountResult = await countQuery;
-        const totalCount = totalCountResult[0].count;
+        const totalCount = totalCountResult[0]?.count ?? 0;
 
         return response<ListResourcesResponse>(res, {
             data: {

src/app/[orgId]/settings/resources/page.tsx

@@ -1,8 +1,8 @@
 import { internal } from "@app/lib/api";
 import { authCookieHeader } from "@app/lib/api/cookies";
 import ResourcesTable, {
-    ResourceRow,
-    InternalResourceRow
+  ResourceRow,
+  InternalResourceRow
 } from "../../../../components/ResourcesTable";
 import { AxiosResponse } from "axios";
 import { ListResourcesResponse } from "@server/routers/resource";
@@ -17,123 +17,130 @@ import { pullEnv } from "@app/lib/pullEnv";
 import { toUnicode } from "punycode";
 
 type ResourcesPageProps = {
-    params: Promise<{ orgId: string }>;
-    searchParams: Promise<{ view?: string }>;
+  params: Promise<{ orgId: string }>;
+  searchParams: Promise<{ view?: string }>;
 };
 
 export const dynamic = "force-dynamic";
 
 export default async function ResourcesPage(props: ResourcesPageProps) {
-    const params = await props.params;
-    const searchParams = await props.searchParams;
-    const t = await getTranslations();
+  const params = await props.params;
+  const searchParams = await props.searchParams;
+  const t = await getTranslations();
 
-    const env = pullEnv();
+  const env = pullEnv();
 
-    // Default to 'proxy' view, or use the query param if provided
-    let defaultView: "proxy" | "internal" = "proxy";
-    if (env.flags.enableClients) {
-        defaultView = searchParams.view === "internal" ? "internal" : "proxy";
-    }
+  // Default to 'proxy' view, or use the query param if provided
+  let defaultView: "proxy" | "internal" = "proxy";
+  if (env.flags.enableClients) {
+    defaultView = searchParams.view === "internal" ? "internal" : "proxy";
+  }
 
-    let resources: ListResourcesResponse["resources"] = [];
-    try {
-        const res = await internal.get<AxiosResponse<ListResourcesResponse>>(
-            `/org/${params.orgId}/resources`,
-            await authCookieHeader()
-        );
-        resources = res.data.data.resources;
-    } catch (e) { }
-
-    let siteResources: ListAllSiteResourcesByOrgResponse["siteResources"] = [];
-    try {
-        const res = await internal.get<
-            AxiosResponse<ListAllSiteResourcesByOrgResponse>
-        >(`/org/${params.orgId}/site-resources`, await authCookieHeader());
-        siteResources = res.data.data.siteResources;
-    } catch (e) { }
-
-    let org = null;
-    try {
-        const getOrg = cache(async () =>
-            internal.get<AxiosResponse<GetOrgResponse>>(
-                `/org/${params.orgId}`,
-                await authCookieHeader()
-            )
-        );
-        const res = await getOrg();
-        org = res.data.data;
-    } catch {
-        redirect(`/${params.orgId}/settings/resources`);
-    }
-
-    if (!org) {
-        redirect(`/${params.orgId}/settings/resources`);
-    }
-
-    const resourceRows: ResourceRow[] = resources.map((resource) => {
-        return {
-            id: resource.resourceId,
-            name: resource.name,
-            orgId: params.orgId,
-            nice: resource.niceId,
-            domain: `${resource.ssl ? "https://" : "http://"}${toUnicode(resource.fullDomain || "")}`,
-            protocol: resource.protocol,
-            proxyPort: resource.proxyPort,
-            http: resource.http,
-            authState: !resource.http
-                ? "none"
-                : resource.sso ||
-                    resource.pincodeId !== null ||
-                    resource.passwordId !== null ||
-                    resource.whitelist ||
-                    resource.headerAuthId
-                    ? "protected"
-                    : "not_protected",
-            enabled: resource.enabled,
-            domainId: resource.domainId || undefined,
-            ssl: resource.ssl
-        };
-    });
-
-    const internalResourceRows: InternalResourceRow[] = siteResources.map(
-        (siteResource) => {
-            return {
-                id: siteResource.siteResourceId,
-                name: siteResource.name,
-                orgId: params.orgId,
-                siteName: siteResource.siteName,
-                protocol: siteResource.protocol,
-                proxyPort: siteResource.proxyPort,
-                siteId: siteResource.siteId,
-                destinationIp: siteResource.destinationIp,
-                destinationPort: siteResource.destinationPort,
-                siteNiceId: siteResource.siteNiceId
-            };
-        }
+  let resources: ListResourcesResponse["resources"] = [];
+  try {
+    const res = await internal.get<AxiosResponse<ListResourcesResponse>>(
+      `/org/${params.orgId}/resources`,
+      await authCookieHeader()
     );
+    resources = res.data.data.resources;
+  } catch (e) { }
 
-    return (
-        <>
-            <SettingsSectionTitle
-                title={t("resourceTitle")}
-                description={t("resourceDescription")}
-            />
+  let siteResources: ListAllSiteResourcesByOrgResponse["siteResources"] = [];
+  try {
+    const res = await internal.get<
+      AxiosResponse<ListAllSiteResourcesByOrgResponse>
+    >(`/org/${params.orgId}/site-resources`, await authCookieHeader());
+    siteResources = res.data.data.siteResources;
+  } catch (e) { }
 
-            <OrgProvider org={org}>
-                <ResourcesTable
-                    resources={resourceRows}
-                    internalResources={internalResourceRows}
-                    orgId={params.orgId}
-                    defaultView={
-                        env.flags.enableClients ? defaultView : "proxy"
-                    }
-                    defaultSort={{
-                        id: "name",
-                        desc: false
-                    }}
-                />
-            </OrgProvider>
-        </>
+  let org = null;
+  try {
+    const getOrg = cache(async () =>
+      internal.get<AxiosResponse<GetOrgResponse>>(
+        `/org/${params.orgId}`,
+        await authCookieHeader()
+      )
     );
-}
+    const res = await getOrg();
+    org = res.data.data;
+  } catch {
+    redirect(`/${params.orgId}/settings/resources`);
+  }
+
+  if (!org) {
+    redirect(`/${params.orgId}/settings/resources`);
+  }
+
+  const resourceRows: ResourceRow[] = resources.map((resource) => {
+    return {
+      id: resource.resourceId,
+      name: resource.name,
+      orgId: params.orgId,
+      nice: resource.niceId,
+      domain: `${resource.ssl ? "https://" : "http://"}${toUnicode(resource.fullDomain || "")}`,
+      protocol: resource.protocol,
+      proxyPort: resource.proxyPort,
+      http: resource.http,
+      authState: !resource.http
+        ? "none"
+        : resource.sso ||
+          resource.pincodeId !== null ||
+          resource.passwordId !== null ||
+          resource.whitelist ||
+          resource.headerAuthId
+          ? "protected"
+          : "not_protected",
+      enabled: resource.enabled,
+      domainId: resource.domainId || undefined,
+      ssl: resource.ssl,
+      targets: resource.targets?.map(target => ({
+        targetId: target.targetId,
+        ip: target.ip,
+        port: target.port,
+        enabled: target.enabled,
+        healthStatus: target.healthStatus
+      }))
+    };
+  });
+
+  const internalResourceRows: InternalResourceRow[] = siteResources.map(
+    (siteResource) => {
+      return {
+        id: siteResource.siteResourceId,
+        name: siteResource.name,
+        orgId: params.orgId,
+        siteName: siteResource.siteName,
+        protocol: siteResource.protocol,
+        proxyPort: siteResource.proxyPort,
+        siteId: siteResource.siteId,
+        destinationIp: siteResource.destinationIp,
+        destinationPort: siteResource.destinationPort,
+        siteNiceId: siteResource.siteNiceId
+      };
+    }
+  );
+
+  return (
+    <>
+      <SettingsSectionTitle
+        title={t("resourceTitle")}
+        description={t("resourceDescription")}
+      />
+
+      <OrgProvider org={org}>
+        <ResourcesTable
+          resources={resourceRows}
+          internalResources={internalResourceRows}
+          orgId={params.orgId}
+          defaultView={
+            env.flags.enableClients ? defaultView : "proxy"
+          }
+          defaultSort={{
+            id: "name",
+            desc: false
+          }}
+        />
+      </OrgProvider>
+    </>
+  );
+}

src/components/ResourcesTable.tsx

@@ -9,13 +9,15 @@ import {
     SortingState,
     getSortedRowModel,
     ColumnFiltersState,
-    getFilteredRowModel
+    getFilteredRowModel,
+    VisibilityState
 } from "@tanstack/react-table";
 import {
     DropdownMenu,
     DropdownMenuContent,
     DropdownMenuItem,
-    DropdownMenuTrigger
+    DropdownMenuTrigger,
+    DropdownMenuCheckboxItem,
 } from "@app/components/ui/dropdown-menu";
 import { Button } from "@app/components/ui/button";
 import {
@@ -25,7 +27,16 @@ import {
     ArrowUpRight,
     ShieldOff,
     ShieldCheck,
-    RefreshCw
+    RefreshCw,
+    Settings2,
+    Plus,
+    Search,
+    ChevronDown,
+    Clock,
+    Wifi,
+    WifiOff,
+    CheckCircle2,
+    XCircle,
 } from "lucide-react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
@@ -44,7 +55,6 @@ import { useTranslations } from "next-intl";
 import { InfoPopup } from "@app/components/ui/info-popup";
 import { Input } from "@app/components/ui/input";
 import { DataTablePagination } from "@app/components/DataTablePagination";
-import { Plus, Search } from "lucide-react";
 import { Card, CardContent, CardHeader } from "@app/components/ui/card";
 import {
     Table,
@@ -65,6 +75,15 @@ import EditInternalResourceDialog from "@app/components/EditInternalResourceDial
 import CreateInternalResourceDialog from "@app/components/CreateInternalResourceDialog";
 import { Alert, AlertDescription } from "@app/components/ui/alert";
 
+
+export type TargetHealth = {
+    targetId: number;
+    ip: string;
+    port: number;
+    enabled: boolean;
+    healthStatus?: 'healthy' | 'unhealthy' | 'unknown';
+};
+
 export type ResourceRow = {
     id: number;
     nice: string | null;
@@ -78,8 +97,54 @@ export type ResourceRow = {
     enabled: boolean;
     domainId?: string;
     ssl: boolean;
+    targetHost?: string;
+    targetPort?: number;
+    targets?: TargetHealth[];
 };
 
+
+function getOverallHealthStatus(targets?: TargetHealth[]): 'online' | 'degraded' | 'offline' | 'unknown' {
+    if (!targets || targets.length === 0) {
+        return 'unknown';
+    }
+
+    const monitoredTargets = targets.filter(t => t.enabled && t.healthStatus && t.healthStatus !== 'unknown');
+
+    if (monitoredTargets.length === 0) {
+        return 'unknown';
+    }
+
+    const healthyCount = monitoredTargets.filter(t => t.healthStatus === 'healthy').length;
+    const unhealthyCount = monitoredTargets.filter(t => t.healthStatus === 'unhealthy').length;
+
+    if (healthyCount === monitoredTargets.length) {
+        return 'online';
+    } else if (unhealthyCount === monitoredTargets.length) {
+        return 'offline';
+    } else {
+        return 'degraded';
+    }
+}
+
+function StatusIcon({ status, className = "" }: {
+    status: 'online' | 'degraded' | 'offline' | 'unknown';
+    className?: string;
+}) {
+    const iconClass = `h-4 w-4 ${className}`;
+
+    switch (status) {
+        case 'online':
+            return <CheckCircle2 className={`${iconClass} text-green-500`} />;
+        case 'degraded':
+            return <CheckCircle2 className={`${iconClass} text-yellow-500`} />;
+        case 'offline':
+            return <XCircle className={`${iconClass} text-destructive`} />;
+        case 'unknown':
+            return <Clock className={`${iconClass} text-gray-400`} />;
+        default:
+            return null;
+    }
+}
 export type InternalResourceRow = {
     id: number;
     name: string;
@@ -143,6 +208,7 @@ const setStoredPageSize = (pageSize: number, tableId?: string): void => {
 };
 
 
+
 export default function ResourcesTable({
     resources,
     internalResources,
@@ -158,6 +224,7 @@ export default function ResourcesTable({
 
     const api = createApiClient({ env });
 
+
     const [proxyPageSize, setProxyPageSize] = useState<number>(() =>
         getStoredPageSize('proxy-resources', 20)
     );
@@ -179,6 +246,10 @@ export default function ResourcesTable({
     const [proxySorting, setProxySorting] = useState<SortingState>(
         defaultSort ? [defaultSort] : []
     );
+
+    const [proxyColumnVisibility, setProxyColumnVisibility] = useState<VisibilityState>({});
+    const [internalColumnVisibility, setInternalColumnVisibility] = useState<VisibilityState>({});
+
     const [proxyColumnFilters, setProxyColumnFilters] =
         useState<ColumnFiltersState>([]);
     const [proxyGlobalFilter, setProxyGlobalFilter] = useState<any>([]);
@@ -349,6 +420,76 @@ export default function ResourcesTable({
             });
     }
 
+    function TargetStatusCell({ targets }: { targets?: TargetHealth[] }) {
+        const overallStatus = getOverallHealthStatus(targets);
+
+        if (!targets || targets.length === 0) {
+            return (
+                <div className="flex items-center gap-2">
+                    <StatusIcon status="unknown" />
+                    <span className="text-sm text-muted-foreground">No targets</span>
+                </div>
+            );
+        }
+
+        const monitoredTargets = targets.filter(t => t.enabled && t.healthStatus && t.healthStatus !== 'unknown');
+        const unknownTargets = targets.filter(t => !t.enabled || !t.healthStatus || t.healthStatus === 'unknown');
+
+        return (
+            <DropdownMenu>
+                <DropdownMenuTrigger asChild>
+                    <Button variant="ghost" size="sm" className="flex items-center gap-2 h-8">
+                        <StatusIcon status={overallStatus} />
+                        <span className="text-sm">
+                            {overallStatus === 'online' && 'Healthy'}
+                            {overallStatus === 'degraded' && 'Degraded'}
+                            {overallStatus === 'offline' && 'Offline'}
+                            {overallStatus === 'unknown' && 'Unknown'}
+                        </span>
+                        <ChevronDown className="h-3 w-3" />
+                    </Button>
+                </DropdownMenuTrigger>
+                <DropdownMenuContent align="start" className="min-w-[280px]">
+                    {monitoredTargets.length > 0 && (
+                        <>
+                            {monitoredTargets.map((target) => (
+                                <DropdownMenuItem key={target.targetId} className="flex items-center justify-between gap-4">
+                                    <div className="flex items-center gap-2">
+                                        <StatusIcon
+                                            status={target.healthStatus === 'healthy' ? 'online' : 'offline'}
+                                            className="h-3 w-3"
+                                        />
+                                        {`${target.ip}:${target.port}`}
+                                    </div>
+                                    <span className={`capitalize ${target.healthStatus === 'healthy' ? 'text-green-500' : 'text-destructive'
+                                        }`}>
+                                        {target.healthStatus}
+                                    </span>
+                                </DropdownMenuItem>
+                            ))}
+                        </>
+                    )}
+                    {unknownTargets.length > 0 && (
+                        <>
+                            {unknownTargets.map((target) => (
+                                <DropdownMenuItem key={target.targetId} className="flex items-center justify-between gap-4">
+                                    <div className="flex items-center gap-2">
+                                        <StatusIcon status="unknown" className="h-3 w-3" />
+                                        {`${target.ip}:${target.port}`}
+                                    </div>
+                                    <span className="text-muted-foreground">
+                                        {!target.enabled ? 'Disabled' : 'Not monitored'}
+                                    </span>
+                                </DropdownMenuItem>
+                            ))}
+                        </>
+                    )}
+                </DropdownMenuContent>
+            </DropdownMenu>
+        );
+    }
+
+    
     const proxyColumns: ColumnDef<ResourceRow>[] = [
         {
             accessorKey: "name",
@@ -390,6 +531,33 @@ export default function ResourcesTable({
                 return <span>{resourceRow.http ? (resourceRow.ssl ? "HTTPS" : "HTTP") : resourceRow.protocol.toUpperCase()}</span>;
             }
         },
+        {
+            id: "status",
+            accessorKey: "status",
+            header: ({ column }) => {
+                return (
+                    <Button
+                        variant="ghost"
+                        onClick={() =>
+                            column.toggleSorting(column.getIsSorted() === "asc")
+                        }
+                    >
+                        {t("status")}
+                        <ArrowUpDown className="ml-2 h-4 w-4" />
+                    </Button>
+                );
+            },
+            cell: ({ row }) => {
+                const resourceRow = row.original;
+                return <TargetStatusCell targets={resourceRow.targets} />;
+            },
+            sortingFn: (rowA, rowB) => {
+                const statusA = getOverallHealthStatus(rowA.original.targets);
+                const statusB = getOverallHealthStatus(rowB.original.targets);
+                const statusOrder = { online: 3, degraded: 2, offline: 1, unknown: 0 };
+                return statusOrder[statusA] - statusOrder[statusB];
+            }
+        },
         {
             accessorKey: "domain",
             header: t("access"),
@@ -647,6 +815,7 @@ export default function ResourcesTable({
         onColumnFiltersChange: setProxyColumnFilters,
         getFilteredRowModel: getFilteredRowModel(),
         onGlobalFilterChange: setProxyGlobalFilter,
+        onColumnVisibilityChange: setProxyColumnVisibility,
         initialState: {
             pagination: {
                 pageSize: proxyPageSize,
@@ -656,7 +825,8 @@ export default function ResourcesTable({
         state: {
             sorting: proxySorting,
             columnFilters: proxyColumnFilters,
-            globalFilter: proxyGlobalFilter
+            globalFilter: proxyGlobalFilter,
+            columnVisibility: proxyColumnVisibility
         }
     });
 
@@ -670,6 +840,7 @@ export default function ResourcesTable({
         onColumnFiltersChange: setInternalColumnFilters,
         getFilteredRowModel: getFilteredRowModel(),
         onGlobalFilterChange: setInternalGlobalFilter,
+        onColumnVisibilityChange: setInternalColumnVisibility,
         initialState: {
             pagination: {
                 pageSize: internalPageSize,
@@ -679,7 +850,8 @@ export default function ResourcesTable({
         state: {
             sorting: internalSorting,
             columnFilters: internalColumnFilters,
-            globalFilter: internalGlobalFilter
+            globalFilter: internalGlobalFilter,
+            columnVisibility: internalColumnVisibility
         }
     });
 
@@ -868,6 +1040,34 @@ export default function ResourcesTable({
                                     <DataTablePagination
                                         table={proxyTable}
                                         onPageSizeChange={handleProxyPageSizeChange}
+                                        renderAdditionalControls={() => (
+                                            <DropdownMenu>
+                                                <DropdownMenuTrigger asChild>
+                                                    <Button variant="outline">
+                                                        <Settings2 className="mr-2 h-4 w-4" />
+                                                        {t("columns")}
+                                                    </Button>
+                                                </DropdownMenuTrigger>
+                                                <DropdownMenuContent align="end" className="w-48">
+                                                    {proxyTable.getAllColumns()
+                                                        .filter(column => column.getCanHide())
+                                                        .map(column => (
+                                                            <DropdownMenuCheckboxItem
+                                                                key={column.id}
+                                                                className="capitalize"
+                                                                checked={column.getIsVisible()}
+                                                                onCheckedChange={(value) => column.toggleVisibility(!!value)}
+                                                            >
+                                                                {column.id === "target" ? t("target") :
+                                                                    column.id === "authState" ? t("authentication") :
+                                                                        column.id === "enabled" ? t("enabled") :
+                                                                            column.id === "status" ? t("status") :
+                                                                                column.id}
+                                                            </DropdownMenuCheckboxItem>
+                                                        ))}
+                                                </DropdownMenuContent>
+                                            </DropdownMenu>
+                                        )}
                                     />
                                 </div>
                             </TabsContent>
@@ -969,6 +1169,34 @@ export default function ResourcesTable({
                                     <DataTablePagination
                                         table={internalTable}
                                         onPageSizeChange={handleInternalPageSizeChange}
+                                        renderAdditionalControls={() => (
+                                            <DropdownMenu>
+                                                <DropdownMenuTrigger asChild>
+                                                    <Button variant="outline">
+                                                        <Settings2 className="mr-2 h-4 w-4" />
+                                                        {t("columns")}
+                                                    </Button>
+                                                </DropdownMenuTrigger>
+                                                <DropdownMenuContent align="end" className="w-48">
+                                                    {internalTable.getAllColumns()
+                                                        .filter(column => column.getCanHide())
+                                                        .map(column => (
+                                                            <DropdownMenuCheckboxItem
+                                                                key={column.id}
+                                                                className="capitalize"
+                                                                checked={column.getIsVisible()}
+                                                                onCheckedChange={(value) => column.toggleVisibility(!!value)}
+                                                            >
+                                                                {column.id === "target" ? t("target") :
+                                                                    column.id === "authState" ? t("authentication") :
+                                                                        column.id === "enabled" ? t("enabled") :
+                                                                            column.id === "status" ? t("status") :
+                                                                                column.id}
+                                                            </DropdownMenuCheckboxItem>
+                                                        ))}
+                                                </DropdownMenuContent>
+                                            </DropdownMenu>
+                                        )}
                                     />
                                 </div>
                             </TabsContent>