stream-chat-react-native-core 9.3.1 → 9.4.0-beta.1

package/src/hooks/actions/__tests__/useChannelMemberActionItems.test.tsx

@@ -0,0 +1,372 @@
+import React, { PropsWithChildren } from 'react';
+import { Alert } from 'react-native';
+
+import { renderHook } from '@testing-library/react-native';
+import type { Channel, ChannelMemberResponse, Mute } from 'stream-chat';
+
+import * as useMutedUsersModule from '../../../components/ChannelList/hooks/useMutedUsers';
+import { ChatProvider } from '../../../contexts/chatContext/ChatContext';
+import type { TranslationContextValue } from '../../../contexts/translationContext/TranslationContext';
+import * as TranslationContext from '../../../contexts/translationContext/TranslationContext';
+import * as useChannelOwnCapabilitiesModule from '../../useChannelOwnCapabilities';
+import * as useChannelActionsModule from '../useChannelActions';
+import {
+  buildDefaultChannelMemberActionItems,
+  getChannelMemberActionItems,
+  GetChannelMemberActionItems,
+  useChannelMemberActionItems,
+} from '../useChannelMemberActionItems';
+import * as useUserActionsModule from '../useUserActions';
+
+const createUserActions = (): useUserActionsModule.UserActions => ({
+  blockUser: jest.fn(),
+  muteUser: jest.fn(),
+  unblockUser: jest.fn(),
+  unmuteUser: jest.fn(),
+});
+
+const removeMembers = jest.fn();
+const channelActions = { removeMembers } as unknown as useChannelActionsModule.ChannelActions;
+
+const createMemberMock = (userId = 'target-user-id'): ChannelMemberResponse =>
+  ({
+    user: { id: userId, name: 'Target Name' },
+    user_id: userId,
+  }) as ChannelMemberResponse;
+
+const createChannelMock = (params?: { blockedUserIds?: string[]; userID?: string }): Channel => {
+  const { blockedUserIds = [], userID = 'current-user-id' } = params ?? {};
+  return {
+    getClient: () => ({
+      blockedUsers: {
+        getLatestValue: () => ({ userIds: blockedUserIds }),
+        subscribeWithSelector: () => () => {},
+      },
+      userID,
+    }),
+  } as unknown as Channel;
+};
+
+describe('useChannelMemberActionItems', () => {
+  const channel = createChannelMock();
+  const member = createMemberMock();
+  const userActions = createUserActions();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest
+      .spyOn(TranslationContext, 'useTranslationContext')
+      .mockImplementation(
+        () => ({ t: (value: string) => value }) as unknown as TranslationContextValue,
+      );
+    jest.spyOn(useMutedUsersModule, 'useMutedUsers').mockReturnValue([] as Mute[]);
+    jest.spyOn(useUserActionsModule, 'useUserActions').mockReturnValue(userActions);
+    jest.spyOn(useChannelActionsModule, 'useChannelActions').mockReturnValue(channelActions);
+    jest.spyOn(useChannelOwnCapabilitiesModule, 'useChannelOwnCapabilities').mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns default member action items', () => {
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+
+    expect(result.current).toHaveLength(2);
+    expect(result.current.map((item) => item.id)).toEqual(['muteUser', 'block']);
+    expect(result.current.map((item) => item.action)).toEqual([
+      userActions.muteUser,
+      userActions.blockUser,
+    ]);
+    expect(result.current.map((item) => item.type)).toEqual(['standard', 'destructive']);
+    expect(result.current.map((item) => item.label)).toEqual(['Mute User', 'Block User']);
+  });
+
+  it('returns no action items when the member is the current user', () => {
+    const currentUserChannel = createChannelMock({ userID: 'target-user-id' });
+
+    const { result } = renderHook(() =>
+      useChannelMemberActionItems({ channel: currentUserChannel, member }),
+    );
+
+    expect(result.current).toEqual([]);
+  });
+
+  it('toggles muteUser to unmuteUser when the member is already muted', () => {
+    jest
+      .spyOn(useMutedUsersModule, 'useMutedUsers')
+      .mockReturnValue([
+        { target: { id: 'target-user-id' }, user: { id: 'current-user-id' } },
+      ] as Mute[]);
+
+    const wrapper = ({ children }: PropsWithChildren) => (
+      <ChatProvider value={{ client: { userID: 'current-user-id' } } as never}>
+        {children}
+      </ChatProvider>
+    );
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }), {
+      wrapper,
+    });
+
+    const muteItem = result.current.find((item) => item.id === 'muteUser');
+    expect(muteItem?.action).toBe(userActions.unmuteUser);
+    expect(muteItem?.label).toBe('Unmute User');
+  });
+
+  it('toggles block to unblockUser when the member is already blocked', () => {
+    const blockedChannel = createChannelMock({ blockedUserIds: ['target-user-id'] });
+
+    const { result } = renderHook(() =>
+      useChannelMemberActionItems({ channel: blockedChannel, member }),
+    );
+
+    const blockItem = result.current.find((item) => item.id === 'block');
+    expect(blockItem?.action).toBe(userActions.unblockUser);
+    expect(blockItem?.label).toBe('Unblock User');
+  });
+
+  it('forwards options from item.action to the underlying user action', async () => {
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+
+    const muteItem = result.current.find((item) => item.id === 'muteUser');
+    const onSuccess = jest.fn();
+    await muteItem?.action({ onSuccess });
+
+    expect(userActions.muteUser).toHaveBeenCalledWith({ onSuccess });
+  });
+
+  it('marks block as destructive when user is not blocked', () => {
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+
+    const blockItem = result.current.find((item) => item.id === 'block');
+    expect(blockItem?.type).toBe('destructive');
+  });
+
+  it('adds a destructive removeMember item when the user can update channel members', () => {
+    jest
+      .spyOn(useChannelOwnCapabilitiesModule, 'useChannelOwnCapabilities')
+      .mockReturnValue(['update-channel-members']);
+
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+
+    const removeItem = result.current.find((item) => item.id === 'removeMember');
+    expect(result.current.map((item) => item.id)).toEqual(['muteUser', 'block', 'removeMember']);
+    expect(removeItem?.label).toBe('Remove User');
+    expect(removeItem?.type).toBe('destructive');
+  });
+
+  it('does not add removeMember without the update-channel-members capability', () => {
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+
+    expect(result.current.find((item) => item.id === 'removeMember')).toBeUndefined();
+  });
+
+  it('does not add removeMember for the current user even with the capability', () => {
+    jest
+      .spyOn(useChannelOwnCapabilitiesModule, 'useChannelOwnCapabilities')
+      .mockReturnValue(['update-channel-members']);
+    const currentUserChannel = createChannelMock({ userID: 'target-user-id' });
+
+    const { result } = renderHook(() =>
+      useChannelMemberActionItems({ channel: currentUserChannel, member }),
+    );
+
+    expect(result.current).toEqual([]);
+  });
+
+  it('confirms via Alert before removing the member', () => {
+    jest
+      .spyOn(useChannelOwnCapabilitiesModule, 'useChannelOwnCapabilities')
+      .mockReturnValue(['update-channel-members']);
+    const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {});
+
+    const { result } = renderHook(() => useChannelMemberActionItems({ channel, member }));
+    const removeItem = result.current.find((item) => item.id === 'removeMember');
+    removeItem?.action();
+
+    expect(alertSpy).toHaveBeenCalledTimes(1);
+    expect(removeMembers).not.toHaveBeenCalled();
+
+    // Invoke the destructive button's onPress to confirm removal.
+    const buttons = alertSpy.mock.calls[0][2] as { onPress?: () => void; style?: string }[];
+    const confirmButton = buttons.find((button) => button.style === 'destructive');
+    confirmButton?.onPress?.();
+
+    expect(removeMembers).toHaveBeenCalledWith(['target-user-id']);
+
+    alertSpy.mockRestore();
+  });
+
+  it('keeps block standard when user is already blocked', () => {
+    const blockedChannel = createChannelMock({ blockedUserIds: ['target-user-id'] });
+
+    const { result } = renderHook(() =>
+      useChannelMemberActionItems({ channel: blockedChannel, member }),
+    );
+
+    const blockItem = result.current.find((item) => item.id === 'block');
+    expect(blockItem?.type).toBe('standard');
+  });
+
+  it('uses custom getChannelMemberActionItems with context and defaultItems when provided', () => {
+    const customGetItems = jest.fn(({ defaultItems }: Parameters<GetChannelMemberActionItems>[0]) =>
+      defaultItems.slice(0, 1),
+    );
+
+    const { result } = renderHook(() =>
+      useChannelMemberActionItems({
+        channel,
+        getChannelMemberActionItems: customGetItems,
+        member,
+      }),
+    );
+
+    expect(customGetItems).toHaveBeenCalledWith({
+      context: {
+        channel,
+        channelActions,
+        isBlocked: false,
+        isCurrentUser: false,
+        member,
+        ownCapabilities: [],
+        t: expect.any(Function),
+        userActions,
+        userMuteActive: false,
+      },
+      defaultItems: expect.any(Array),
+    });
+    expect(result.current).toHaveLength(1);
+    expect(result.current[0].id).toBe('muteUser');
+  });
+});
+
+describe('buildDefaultChannelMemberActionItems', () => {
+  const channel = createChannelMock();
+  const member = createMemberMock();
+
+  it('creates default mute and block items', () => {
+    const actions = createUserActions();
+    const items = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: false,
+      isCurrentUser: false,
+      member,
+      ownCapabilities: undefined,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: false,
+    });
+
+    expect(items.map((item) => item.id)).toEqual(['muteUser', 'block']);
+    expect(items.map((item) => item.action)).toEqual([actions.muteUser, actions.blockUser]);
+    expect(items.map((item) => item.label)).toEqual(['Mute User', 'Block User']);
+    expect(items.map((item) => item.type)).toEqual(['standard', 'destructive']);
+  });
+
+  it('returns no items when the member is the current user', () => {
+    const actions = createUserActions();
+    const items = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: false,
+      isCurrentUser: true,
+      member,
+      ownCapabilities: undefined,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: false,
+    });
+
+    expect(items).toEqual([]);
+  });
+
+  it('appends a destructive removeMember item when own capabilities allow updating members', () => {
+    const actions = createUserActions();
+    const items = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: false,
+      isCurrentUser: false,
+      member,
+      ownCapabilities: ['update-channel-members'],
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: false,
+    });
+
+    expect(items.map((item) => item.id)).toEqual(['muteUser', 'block', 'removeMember']);
+    const removeItem = items.find((item) => item.id === 'removeMember');
+    expect(removeItem?.label).toBe('Remove User');
+    expect(removeItem?.type).toBe('destructive');
+  });
+
+  it('returns unmute/unblock variants when toggles are active', () => {
+    const actions = createUserActions();
+    const items = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: true,
+      isCurrentUser: false,
+      member,
+      ownCapabilities: undefined,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: true,
+    });
+
+    expect(items.map((item) => item.action)).toEqual([actions.unmuteUser, actions.unblockUser]);
+    expect(items.map((item) => item.label)).toEqual(['Unmute User', 'Unblock User']);
+    expect(items.map((item) => item.type)).toEqual(['standard', 'standard']);
+  });
+
+  it('mute and block reflect their respective active states independently', () => {
+    const actions = createUserActions();
+    const items = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: false,
+      isCurrentUser: false,
+      member,
+      ownCapabilities: undefined,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: true,
+    });
+
+    expect(items.find((item) => item.id === 'muteUser')?.action).toBe(actions.unmuteUser);
+    expect(items.find((item) => item.id === 'block')?.action).toBe(actions.blockUser);
+  });
+
+  it('default getChannelMemberActionItems returns defaultItems unchanged', () => {
+    const actions = createUserActions();
+    const defaultItems = buildDefaultChannelMemberActionItems({
+      channel,
+      channelActions,
+      isBlocked: false,
+      isCurrentUser: false,
+      member,
+      ownCapabilities: undefined,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userActions: actions,
+      userMuteActive: false,
+    });
+
+    const items = getChannelMemberActionItems({
+      context: {
+        channel,
+        channelActions,
+        isBlocked: false,
+        isCurrentUser: false,
+        member,
+        ownCapabilities: undefined,
+        t: ((value: string) => value) as TranslationContextValue['t'],
+        userActions: actions,
+        userMuteActive: false,
+      },
+      defaultItems,
+    });
+
+    expect(items).toBe(defaultItems);
+  });
+});

package/src/hooks/actions/__tests__/useUserActions.test.tsx

@@ -0,0 +1,251 @@
+import { renderHook, waitFor } from '@testing-library/react-native';
+import type { UserResponse } from 'stream-chat';
+
+import * as useNotificationApiModule from '../../../components/Notifications/hooks/useNotificationApi';
+import * as ChatContext from '../../../contexts/chatContext/ChatContext';
+import type { TranslationContextValue } from '../../../contexts/translationContext/TranslationContext';
+import * as TranslationContext from '../../../contexts/translationContext/TranslationContext';
+import { useUserActions } from '../useUserActions';
+
+const createUser = (overrides?: Partial<UserResponse>): UserResponse =>
+  ({
+    id: 'target-user-id',
+    name: 'Target Name',
+    ...overrides,
+  }) as UserResponse;
+
+describe('useUserActions', () => {
+  const muteUser = jest.fn();
+  const unmuteUser = jest.fn();
+  const blockUser = jest.fn();
+  const unBlockUser = jest.fn();
+  const addNotification = jest.fn();
+
+  const setUpMocks = () => {
+    muteUser.mockResolvedValue(undefined);
+    unmuteUser.mockResolvedValue(undefined);
+    blockUser.mockResolvedValue(undefined);
+    unBlockUser.mockResolvedValue(undefined);
+
+    jest.spyOn(ChatContext, 'useChatContext').mockImplementation(
+      () =>
+        ({
+          client: {
+            blockUser,
+            muteUser,
+            unBlockUser,
+            unmuteUser,
+          },
+        }) as unknown as ChatContext.ChatContextValue,
+    );
+    jest
+      .spyOn(useNotificationApiModule, 'useNotificationApi')
+      .mockReturnValue({ addNotification } as unknown as useNotificationApiModule.NotificationApi);
+    jest
+      .spyOn(TranslationContext, 'useTranslationContext')
+      .mockImplementation(
+        () => ({ t: (value: string) => value }) as unknown as TranslationContextValue,
+      );
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    setUpMocks();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns stable references across re-renders', () => {
+    const user = createUser();
+    const { result, rerender } = renderHook(() => useUserActions(user));
+
+    const firstResult = result.current;
+    rerender({});
+    expect(result.current).toBe(firstResult);
+  });
+
+  describe('muteUser', () => {
+    it('calls client.muteUser with the user id and runs onSuccess', async () => {
+      const user = createUser();
+      const onSuccess = jest.fn();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.muteUser({ onSuccess });
+
+      expect(muteUser).toHaveBeenCalledWith('target-user-id');
+      expect(onSuccess).toHaveBeenCalledTimes(1);
+      expect(addNotification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: '{{ user }} has been muted',
+          options: expect.objectContaining({
+            severity: 'success',
+            type: 'api:user:mute:success',
+          }),
+        }),
+      );
+    });
+
+    it('emits an error notification when the client rejects', async () => {
+      muteUser.mockRejectedValueOnce(new Error('boom'));
+      const user = createUser();
+      const onSuccess = jest.fn();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.muteUser({ onSuccess });
+
+      expect(onSuccess).not.toHaveBeenCalled();
+      await waitFor(() =>
+        expect(addNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            message: 'Error muting a user ...',
+            options: expect.objectContaining({
+              severity: 'error',
+              type: 'api:user:mute:failed',
+            }),
+          }),
+        ),
+      );
+    });
+  });
+
+  describe('unmuteUser', () => {
+    it('calls client.unmuteUser with the user id and runs onSuccess', async () => {
+      const user = createUser();
+      const onSuccess = jest.fn();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.unmuteUser({ onSuccess });
+
+      expect(unmuteUser).toHaveBeenCalledWith('target-user-id');
+      expect(onSuccess).toHaveBeenCalledTimes(1);
+      expect(addNotification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          options: expect.objectContaining({
+            severity: 'success',
+            type: 'api:user:unmute:success',
+          }),
+        }),
+      );
+    });
+
+    it('emits an error notification when the client rejects', async () => {
+      unmuteUser.mockRejectedValueOnce(new Error('boom'));
+      const user = createUser();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.unmuteUser();
+
+      await waitFor(() =>
+        expect(addNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            options: expect.objectContaining({
+              severity: 'error',
+              type: 'api:user:unmute:failed',
+            }),
+          }),
+        ),
+      );
+    });
+  });
+
+  describe('blockUser', () => {
+    it('calls client.blockUser with the user id and runs onSuccess', async () => {
+      const user = createUser();
+      const onSuccess = jest.fn();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.blockUser({ onSuccess });
+
+      expect(blockUser).toHaveBeenCalledWith('target-user-id');
+      expect(onSuccess).toHaveBeenCalledTimes(1);
+      expect(addNotification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'User blocked',
+          options: expect.objectContaining({
+            severity: 'success',
+            type: 'api:user:block:success',
+          }),
+        }),
+      );
+    });
+
+    it('emits an error notification when the client rejects', async () => {
+      blockUser.mockRejectedValueOnce(new Error('boom'));
+      const user = createUser();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.blockUser();
+
+      await waitFor(() =>
+        expect(addNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            options: expect.objectContaining({
+              severity: 'error',
+              type: 'api:user:block:failed',
+            }),
+          }),
+        ),
+      );
+    });
+  });
+
+  describe('unblockUser', () => {
+    it('calls client.unBlockUser with the user id and runs onSuccess', async () => {
+      const user = createUser();
+      const onSuccess = jest.fn();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.unblockUser({ onSuccess });
+
+      expect(unBlockUser).toHaveBeenCalledWith('target-user-id');
+      expect(onSuccess).toHaveBeenCalledTimes(1);
+      expect(addNotification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'User unblocked',
+          options: expect.objectContaining({
+            severity: 'success',
+            type: 'api:user:unblock:success',
+          }),
+        }),
+      );
+    });
+
+    it('emits an error notification when the client rejects', async () => {
+      unBlockUser.mockRejectedValueOnce(new Error('boom'));
+      const user = createUser();
+      const { result } = renderHook(() => useUserActions(user));
+
+      await result.current.unblockUser();
+
+      await waitFor(() =>
+        expect(addNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            options: expect.objectContaining({
+              severity: 'error',
+              type: 'api:user:block:failed',
+            }),
+          }),
+        ),
+      );
+    });
+  });
+
+  describe('when the user is undefined', () => {
+    it('does not call the client or add notifications for any handler', async () => {
+      const { result } = renderHook(() => useUserActions(undefined));
+
+      await result.current.muteUser();
+      await result.current.unmuteUser();
+      await result.current.blockUser();
+      await result.current.unblockUser();
+
+      expect(muteUser).not.toHaveBeenCalled();
+      expect(unmuteUser).not.toHaveBeenCalled();
+      expect(blockUser).not.toHaveBeenCalled();
+      expect(unBlockUser).not.toHaveBeenCalled();
+      expect(addNotification).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/hooks/actions/index.ts

@@ -0,0 +1,5 @@
+export * from './useChannelActions';
+export * from './useChannelActionItems';
+export * from './useChannelActionItemsById';
+export * from './useChannelMemberActionItems';
+export * from './useUserActions';

package/src/hooks/actions/types.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+
+import type { IconProps } from '../../icons';
+
+export type ActionOptions = {
+  onSuccess?: () => void;
+  onFailure?: (error: unknown) => void;
+};
+
+export type ActionHandler = (options?: ActionOptions) => Promise<void>;
+
+export type ActionItemHandler = (options?: ActionOptions) => Promise<void> | void;
+
+export type ActionItem<TId extends string = string> = {
+  action: ActionItemHandler;
+  Icon: React.ComponentType<IconProps>;
+  id: TId;
+  label: string;
+  type: 'destructive' | 'standard';
+};