RG-T117 chat feature flag

Author: ucswift

src/api/feature-flags/feature-flags.ts

@@ -0,0 +1,37 @@
+import { api } from '../common/client';
+
+const FEATURE_TOGGLES = '/FeatureToggles';
+
+// ---------------------------------------------------------------------------
+// Feature toggle evaluation (department-scoped, any authenticated user).
+// Backed by the v4 FeatureToggles API; keys live in Resgrid.Model.FeatureFlagKeys.
+// ---------------------------------------------------------------------------
+
+export interface FeatureToggleData {
+  Key: string;
+  Enabled: boolean;
+  Value?: string | null;
+  ValueType?: string | null;
+  Source?: string | null;
+}
+
+export interface FeatureTogglesResult {
+  Data?: FeatureToggleData[];
+  StateHash?: string;
+}
+
+export interface FeatureToggleResult {
+  Data?: FeatureToggleData;
+}
+
+/** Evaluates every active flag for the caller's department. */
+export const getAllFeatureFlags = async (signal?: AbortSignal) => {
+  const response = await api.get<FeatureTogglesResult>(`${FEATURE_TOGGLES}/GetAll`, { signal });
+  return response.data;
+};
+
+/** Lightweight enabled-only check for a single flag. */
+export const getFeatureFlagState = async (key: string, signal?: AbortSignal) => {
+  const response = await api.get<FeatureToggleResult>(`${FEATURE_TOGGLES}/GetState`, { params: { key }, signal });
+  return response.data;
+};

src/app/(app)/_layout.tsx

@@ -30,6 +30,7 @@ import { type GetConfigResultData } from '@/models/v4/configs/getConfigResultDat
 import { usePushNotifications } from '@/services/push-notification';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useCallsStore } from '@/stores/calls/store';
+import { FeatureFlagKeys, featureFlagsStore } from '@/stores/feature-flags/store';
 import useLockscreenStore from '@/stores/lockscreen/store';
 import { useRolesStore } from '@/stores/roles/store';
 import { securityStore } from '@/stores/security/store';
@@ -150,7 +151,14 @@ export default function TabLayout() {
         await securityStore.getState().getRights();
 
         logger.info({
-          message: 'Security rights retrieved, connecting SignalR',
+          message: 'Security rights retrieved, fetching feature flags',
+          context: { platform: Platform.OS },
+        });
+
+        await featureFlagsStore.getState().fetchFlags();
+
+        logger.info({
+          message: 'Feature flags fetched, connecting SignalR',
           context: { platform: Platform.OS },
         });
 
@@ -169,18 +177,26 @@ export default function TabLayout() {
           // Don't fail initialization if SignalR connection fails
         }
 
-        // Connect the realtime chat hub (best-effort; chat may be disabled per department)
-        try {
-          await useSignalRStore.getState().connectChatHub();
+        // Connect the realtime chat hub only when the Chat.System feature flag is on for
+        // this department; when it is off every chat surface stays hidden.
+        if (featureFlagsStore.getState().isEnabled(FeatureFlagKeys.ChatSystem)) {
+          try {
+            await useSignalRStore.getState().connectChatHub();
+            logger.info({
+              message: 'SignalR chat hub connected successfully',
+              context: { platform: Platform.OS },
+            });
+          } catch (error) {
+            logger.error({
+              message: 'Failed to connect SignalR chat hub during initialization',
+              context: { error, platform: Platform.OS },
+            });
+          }
+        } else {
           logger.info({
-            message: 'SignalR chat hub connected successfully',
+            message: 'Chat disabled by feature flag; skipping chat hub connection',
             context: { platform: Platform.OS },
           });
-        } catch (error) {
-          logger.error({
-            message: 'Failed to connect SignalR chat hub during initialization',
-            context: { error, platform: Platform.OS },
-          });
         }
 
         // Initialize weather alerts

src/app/(app)/chat.tsx

@@ -1,4 +1,4 @@
-import { type Href, Stack, useFocusEffect, useRouter } from 'expo-router';
+import { type Href, Redirect, Stack, useFocusEffect, useRouter } from 'expo-router';
 import { Bot, MessageCircle, MessagesSquare, Network, Plus, Sparkles, Users } from 'lucide-react-native';
 import React, { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -19,6 +19,7 @@ import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
 import { type ChatChannelResultData, ChatChannelType } from '@/models/v4/chat';
 import { useChatStore } from '@/stores/chat/store';
+import { useIsChatEnabled } from '@/stores/feature-flags/store';
 
 function ChannelRow({ channel, onPress }: { channel: ChatChannelResultData; onPress: () => void }) {
   const { t } = useTranslation();
@@ -81,6 +82,7 @@ function Section({ title, channels, onOpen }: { title: string; channels: ChatCha
 export default function ChatScreen() {
   const { t } = useTranslation();
   const router = useRouter();
+  const isChatEnabled = useIsChatEnabled();
   const channels = useChatStore((s) => s.channels);
   const isLoading = useChatStore((s) => s.isLoadingChannels);
   const pendingAcks = useChatStore((s) => s.pendingAcks);
@@ -89,9 +91,10 @@ export default function ChatScreen() {
 
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       useChatStore.getState().fetchChannels();
       useChatStore.getState().fetchPendingAcks();
-    }, [])
+    }, [isChatEnabled])
   );
 
   const grouped = groupChannels(channels);
@@ -103,6 +106,11 @@ export default function ChatScreen() {
     [router]
   );
 
+  // Chat.System feature flag off: no chat for this department.
+  if (!isChatEnabled) {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   return (
     <Box className="size-full flex-1 bg-background-0">
       <Stack.Screen options={{ headerShown: false }} />

src/app/(app)/chatbot.tsx

@@ -1,4 +1,4 @@
-import { Stack, useFocusEffect } from 'expo-router';
+import { type Href, Redirect, Stack, useFocusEffect } from 'expo-router';
 import { RefreshCw, Send, Sparkles } from 'lucide-react-native';
 import React, { useCallback, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -19,9 +19,11 @@ import { VStack } from '@/components/ui/vstack';
 import { type ChatMessageResultData } from '@/models/v4/chat';
 import useAuthStore from '@/stores/auth/store';
 import { useChatStore } from '@/stores/chat/store';
+import { useIsChatEnabled } from '@/stores/feature-flags/store';
 
 export default function ChatbotScreen() {
   const { t } = useTranslation();
+  const isChatEnabled = useIsChatEnabled();
   const currentUserId = useAuthStore((s) => s.userId);
   const chatbotChannelId = useChatStore((s) => s.chatbotChannelId);
   const chatbotTyping = useChatStore((s) => s.chatbotTyping);
@@ -30,19 +32,21 @@ export default function ChatbotScreen() {
 
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       const store = useChatStore.getState();
       void store.initChatbot();
       return () => {
         useChatStore.getState().setActiveChannel(null);
       };
-    }, [])
+    }, [isChatEnabled])
   );
 
   // Keep the assistant channel active while viewing so incoming messages don't inflate unread.
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       if (chatbotChannelId) useChatStore.getState().setActiveChannel(chatbotChannelId);
-    }, [chatbotChannelId])
+    }, [chatbotChannelId, isChatEnabled])
   );
 
   const inverted = useMemo(() => (messages ? messages.slice().reverse() : []), [messages]);
@@ -61,6 +65,11 @@ export default function ChatbotScreen() {
     [currentUserId]
   );
 
+  // Chat.System feature flag off: no chat for this department.
+  if (!isChatEnabled) {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   return (
     <Box className="size-full flex-1 bg-background-0">
       <Stack.Screen options={{ headerShown: false }} />

src/app/chat/[channelId].tsx

@@ -1,5 +1,5 @@
 import { Image } from 'expo-image';
-import { type Href, Stack, useFocusEffect, useLocalSearchParams, useRouter } from 'expo-router';
+import { type Href, Redirect, Stack, useFocusEffect, useLocalSearchParams, useRouter } from 'expo-router';
 import { Circle } from 'lucide-react-native';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -27,6 +27,7 @@ import { VStack } from '@/components/ui/vstack';
 import { ChatChannelType, ChatMessagePriority, type ChatMessageResultData, ChatMessageType, type GifResultData } from '@/models/v4/chat';
 import useAuthStore from '@/stores/auth/store';
 import { useChatStore } from '@/stores/chat/store';
+import { useIsChatEnabled } from '@/stores/feature-flags/store';
 import { securityStore } from '@/stores/security/store';
 import { useToastStore } from '@/stores/toast/store';
 
@@ -38,6 +39,7 @@ export default function ChannelConversationScreen() {
 
   const currentUserId = useAuthStore((s) => s.userId);
   const isModerator = !!securityStore((s) => s.rights)?.IsAdmin;
+  const isChatEnabled = useIsChatEnabled();
 
   const channel = useChatStore((s) => s.channels.find((c) => c.ChatChannelId === channelId));
   const messages = useChatStore((s) => (channelId ? s.messagesByChannel[channelId] : undefined));
@@ -64,7 +66,7 @@ export default function ChannelConversationScreen() {
   // Mount: activate channel, join hub, load history and members.
   useFocusEffect(
     useCallback(() => {
-      if (!channelId) return;
+      if (!channelId || !isChatEnabled) return;
       const store = useChatStore.getState();
       store.setActiveChannel(channelId);
       void store.joinChannel(channelId);
@@ -73,7 +75,7 @@ export default function ChannelConversationScreen() {
       return () => {
         useChatStore.getState().setActiveChannel(null);
       };
-    }, [channelId])
+    }, [channelId, isChatEnabled])
   );
 
   // Fetch presence for the channel members (for the header online dot).
@@ -234,6 +236,11 @@ export default function ChannelConversationScreen() {
     if (channelId) void useChatStore.getState().loadOlderMessages(channelId);
   }, [channelId]);
 
+  // Chat.System feature flag off: no chat for this department.
+  if (!isChatEnabled) {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   const title = channel ? getChannelDisplayName(channel, t) : t('chat.title');
 
   return (

src/app/chat/thread/[messageId].tsx

@@ -1,4 +1,4 @@
-import { Stack, useLocalSearchParams } from 'expo-router';
+import { type Href, Redirect, Stack, useLocalSearchParams } from 'expo-router';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Platform } from 'react-native';
@@ -16,25 +16,27 @@ import { logger } from '@/lib/logging';
 import { ChatMessagePriority, type ChatMessageResultData, ChatMessageType } from '@/models/v4/chat';
 import useAuthStore from '@/stores/auth/store';
 import { useChatStore } from '@/stores/chat/store';
+import { useIsChatEnabled } from '@/stores/feature-flags/store';
 
 export default function ThreadScreen() {
   const { t } = useTranslation();
   const params = useLocalSearchParams<{ messageId: string; channelId: string }>();
   const messageId = Array.isArray(params.messageId) ? params.messageId[0] : params.messageId;
   const channelId = Array.isArray(params.channelId) ? params.channelId[0] : params.channelId;
 
+  const isChatEnabled = useIsChatEnabled();
   const currentUserId = useAuthStore((s) => s.userId);
   const channelMessages = useChatStore((s) => (channelId ? s.messagesByChannel[channelId] : undefined));
   const [fetchedReplies, setFetchedReplies] = useState<ChatMessageResultData[]>([]);
 
   const root = useMemo(() => (channelMessages ?? []).find((m) => m.ChatMessageId === messageId), [channelMessages, messageId]);
 
   useEffect(() => {
-    if (!messageId) return;
+    if (!messageId || !isChatEnabled) return;
     getThread(messageId, undefined, 50)
       .then((response) => setFetchedReplies(response.Data ?? []))
       .catch((error) => logger.error({ message: 'chat: failed to load thread', context: { error, messageId } }));
-  }, [messageId]);
+  }, [messageId, isChatEnabled]);
 
   // Merge fetched replies with any realtime/optimistic replies already in the channel cache.
   const replies = useMemo(() => {
@@ -96,6 +98,11 @@ export default function ThreadScreen() {
     [currentUserId, channelId]
   );
 
+  // Chat.System feature flag off: no chat for this department.
+  if (!isChatEnabled) {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   return (
     <Box className="size-full flex-1 bg-background-0">
       <Stack.Screen options={{ title: t('chat.thread'), headerShown: true, headerBackTitle: '' }} />

src/components/sidebar/side-menu.tsx

@@ -23,6 +23,8 @@ import React, { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
 
+import { useIsChatEnabled } from '@/stores/feature-flags/store';
+
 interface SideMenuProps {
   onNavigate?: () => void;
   colorScheme?: 'light' | 'dark';
@@ -93,7 +95,9 @@ function SideMenu({ onNavigate, colorScheme: propColorScheme }: SideMenuProps):
   const router = useRouter();
   const { t } = useTranslation();
   const [expandedItems, setExpandedItems] = useState<Set<string>>(new Set());
-  const menuItems = getMenuItems(t);
+  const isChatEnabled = useIsChatEnabled();
+  // Chat and the assistant are gated by the Chat.System feature flag.
+  const menuItems = getMenuItems(t).filter((item) => (item.id === 'chat' || item.id === 'assistant' ? isChatEnabled : true));
 
   // Use prop if provided, otherwise default to light on web
   const isDark = propColorScheme === 'dark';

src/stores/feature-flags/store.ts

@@ -0,0 +1,66 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+import { getAllFeatureFlags } from '@/api/feature-flags/feature-flags';
+import { logger } from '@/lib/logging';
+import { zustandStorage } from '@/lib/storage';
+
+// Well-known feature flag keys. Keep values in sync with Resgrid.Model.FeatureFlagKeys.
+export const FeatureFlagKeys = {
+  ChatSystem: 'Chat.System',
+} as const;
+
+export type FeatureFlagKey = (typeof FeatureFlagKeys)[keyof typeof FeatureFlagKeys];
+
+interface FeatureFlagEntry {
+  enabled: boolean;
+  value?: string | null;
+}
+
+export interface FeatureFlagsState {
+  flags: Record<string, FeatureFlagEntry>;
+  isLoaded: boolean;
+  error: string | null;
+  fetchFlags: () => Promise<void>;
+  isEnabled: (key: string, defaultValue?: boolean) => boolean;
+}
+
+export const featureFlagsStore = create<FeatureFlagsState>()(
+  persist(
+    (set, get) => ({
+      flags: {},
+      isLoaded: false,
+      error: null,
+      fetchFlags: async () => {
+        try {
+          const response = await getAllFeatureFlags();
+          const flags: Record<string, FeatureFlagEntry> = {};
+          for (const flag of response?.Data ?? []) {
+            if (flag?.Key) {
+              flags[flag.Key] = { enabled: !!flag.Enabled, value: flag.Value ?? null };
+            }
+          }
+          set({ flags, isLoaded: true, error: null });
+        } catch (error) {
+          // Keep any persisted flags on failure so gating stays stable while offline.
+          logger.error({
+            message: 'Failed to fetch feature flags',
+            context: { error },
+          });
+          set({ error: error instanceof Error ? error.message : 'Failed to fetch feature flags' });
+        }
+      },
+      isEnabled: (key: string, defaultValue = false) => get().flags[key]?.enabled ?? defaultValue,
+    }),
+    {
+      name: 'feature-flags-storage',
+      storage: createJSONStorage(() => zustandStorage),
+    }
+  )
+);
+
+// Reactive hook; components re-render when the flag changes. Unknown flags default to disabled
+// so gated features stay hidden until the server confirms them.
+export const useFeatureFlag = (key: string, defaultValue = false) => featureFlagsStore((state) => state.flags[key]?.enabled ?? defaultValue);
+
+export const useIsChatEnabled = () => useFeatureFlag(FeatureFlagKeys.ChatSystem);