@oxyhq/services 27.1.1 → 27.1.3

package/src/ui/components/FollowTargetButton.tsx

@@ -32,7 +32,7 @@
  */
 
 import { memo, useCallback, useMemo } from 'react';
-import type { FollowApplicationMode } from '@oxyhq/contracts';
+import type { FollowApplicationMode, FollowStatus } from '@oxyhq/contracts';
 import type { StyleProp, ViewStyle } from 'react-native';
 import { View } from 'react-native';
 import { Button } from '@oxyhq/bloom/button';
@@ -40,6 +40,7 @@ import { ChevronBottom_Stroke2_Corner0_Rounded as ChevronDown } from '@oxyhq/blo
 import { Menu, MenuContent, MenuItem, MenuItemText, MenuTrigger } from '@oxyhq/bloom/menu';
 import { toast } from '@oxyhq/bloom/toast';
 import { useFollowTarget } from '../hooks/useFollowTarget';
+import { useFollowTargetStore } from '../stores/followTargetStore';
 
 /**
  * The small vocabulary of verbs the ecosystem actually uses. An application
@@ -90,6 +91,29 @@ const DEFAULT_DURATIONS: FollowDuration[] = [
   { label: 'A week', seconds: 7 * 24 * HOUR },
 ];
 
+/**
+ * Whether an action leaves the target ACTIVE in this application.
+ *
+ * One table, read by both the primary button and the menu, because the same
+ * action reached from two controls once reported differently — and a rule
+ * living in two switch statements is a rule that drifts. `Record` rather than
+ * a function with a default, so a new action is a compile error instead of a
+ * silent `false`.
+ */
+export const FOLLOW_ACTION_LEAVES_ACTIVE: Record<
+  'follow' | 'follow-timed' | 'enable-here' | 'disable-here' | 'unfollow',
+  boolean
+> = {
+  follow: true,
+  'follow-timed': true,
+  // Re-enabling here does not change the global follow — the user already had
+  // it — but it does change whether this application acts on it, which is what
+  // a mirror is asking about.
+  'enable-here': true,
+  'disable-here': false,
+  unfollow: false,
+};
+
 /** One line in the disclosure menu. */
 export interface FollowMenuItem {
   key: string;
@@ -197,7 +221,25 @@ export interface FollowTargetButtonProps {
    * application" is not.
    */
   applicationName?: string;
-  onChange?: (following: boolean) => void;
+  /**
+   * Seed status from a list/feed payload. Incomplete rows (e.g. following without
+   * `relationshipId`) still trigger an authoritative refresh once private API is ready.
+   */
+  initialStatus?: FollowStatus;
+  /**
+   * Fires when the server accepts a change, with whether this application
+   * should act on the follow NOW — the effective state, not the global one.
+   *
+   * That is the question an application mirroring the follow is actually
+   * asking: a user who picks "Don't show in Mercaria" still follows the shop
+   * everywhere else, but the shop must leave Mercaria's own shelf, which is
+   * the entire purpose of that menu item. Reporting the global state instead
+   * would leave it there.
+   *
+   * Never fires for a refused write — the mutations resolve to whether the
+   * server accepted, and only an accepted one gets here.
+   */
+  onChange?: (activeHere: boolean) => void;
 }
 
 export const FollowTargetButton = memo(function FollowTargetButton({
@@ -210,10 +252,17 @@ export const FollowTargetButton = memo(function FollowTargetButton({
   showOptions = true,
   durations = DEFAULT_DURATIONS,
   applicationName,
+  initialStatus,
   onChange,
 }: FollowTargetButtonProps) {
   const { status, isFollowing, isUnknown, isPending, follow, unfollow, disableHere, enableHere } =
-    useFollowTarget(targetId);
+    useFollowTarget(targetId, { initialStatus });
+
+  const reportMutationFailure = useCallback(() => {
+    const message =
+      useFollowTargetStore.getState().errors[targetId] ?? 'Could not update follow status';
+    toast.error(message);
+  }, [targetId]);
 
   const text = useMemo(() => ({ ...VERB_LABELS[verb], ...labels }), [verb, labels]);
 
@@ -238,26 +287,32 @@ export const FollowTargetButton = memo(function FollowTargetButton({
   const handlePrimary = useCallback(async () => {
     switch (resolveFollowPrimaryAction({ isFollowing, applicationMode: status.applicationMode })) {
       case 'enable-here':
-        if (await enableHere()) onChange?.(true);
+        if (await enableHere()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['enable-here']);
+        else reportMutationFailure();
         return;
       case 'unfollow':
-        if (await unfollow()) onChange?.(false);
+        if (await unfollow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
+        else reportMutationFailure();
         return;
       case 'follow':
-        if (await follow()) onChange?.(true);
+        if (await follow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.follow);
+        else reportMutationFailure();
     }
-  }, [isFollowing, status.applicationMode, follow, unfollow, enableHere, onChange]);
+  }, [isFollowing, status.applicationMode, follow, unfollow, enableHere, onChange, reportMutationFailure]);
 
   const handleTimed = useCallback(
     async (seconds: number, durationLabel: string) => {
-      if (!(await follow({ expiresIn: seconds }))) return;
-      onChange?.(true);
+      if (!(await follow({ expiresIn: seconds }))) {
+        reportMutationFailure();
+        return;
+      }
+      onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['follow-timed']);
       // The confirmation is the point: a follow that ends on its own is a
       // promise, and a user who does not see it made will not believe it.
       // Which is also why it must not appear when the promise was not made.
       toast.success(`Following for ${durationLabel.toLowerCase()}`);
     },
-    [follow, onChange]
+    [follow, onChange, reportMutationFailure]
   );
 
   const menuItems = useMemo(
@@ -288,19 +343,31 @@ export const FollowTargetButton = memo(function FollowTargetButton({
         case 'follow-timed':
           void handleTimed(item.action.seconds, item.action.durationLabel);
           return;
+        // Every branch reports through `onChange`, and they must agree with
+        // the primary button: the same action reached from two controls that
+        // reported differently was a real bug — a user picking "don't show
+        // here" kept the target on the app's own shelf, which is the state the
+        // menu item exists to end.
         case 'enable-here':
-          void enableHere();
+          void enableHere().then((ok) => {
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['enable-here']);
+            else reportMutationFailure();
+          });
           return;
         case 'disable-here':
-          void disableHere();
+          void disableHere().then((ok) => {
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['disable-here']);
+            else reportMutationFailure();
+          });
           return;
         case 'unfollow':
           void unfollow().then((ok) => {
-            if (ok) onChange?.(false);
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
+            else reportMutationFailure();
           });
       }
     },
-    [handleTimed, enableHere, disableHere, unfollow, onChange]
+    [handleTimed, enableHere, disableHere, unfollow, onChange, reportMutationFailure]
   );
 
   const primary = (

package/src/ui/components/__tests__/followTargetButton.test.ts

@@ -12,8 +12,13 @@
  * to reflect.
  */
 
-import { buildFollowMenuItems, resolveFollowPrimaryAction } from '../FollowTargetButton';
 import {
+  buildFollowMenuItems,
+  FOLLOW_ACTION_LEAVES_ACTIVE,
+  resolveFollowPrimaryAction,
+} from '../FollowTargetButton';
+import {
+  isCompleteFollowStatus,
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
   withApplicationMode,
@@ -149,4 +154,66 @@ describe('withApplicationMode', () => {
     );
     expect(isFollowedGlobally(UNKNOWN_FOLLOW_STATUS)).toBe(false);
   });
+
+  it('treats a following row without relationshipId as incomplete', () => {
+    expect(
+      isCompleteFollowStatus({
+        globalState: 'active',
+        applicationMode: 'inherit',
+        effectiveState: 'following',
+      })
+    ).toBe(false);
+    expect(isCompleteFollowStatus(UNKNOWN_FOLLOW_STATUS)).toBe(true);
+  });
+});
+
+describe('what onChange reports', () => {
+  // The bug: the same action reached from the primary button and from the menu
+  // reported differently. Someone picking "Don't show in Syra" kept the artist
+  // on Syra's own shelf and kept feeding its taste signal — the exact state
+  // that menu item exists to end.
+  //
+  // Both controls now read one table, so the two cannot drift apart again.
+  // These tests pin what the table SAYS; the `Record` type is what stops a new
+  // action from being omitted.
+
+  it('reports the EFFECTIVE state — does this app act on it now', () => {
+    expect(FOLLOW_ACTION_LEAVES_ACTIVE).toEqual({
+      follow: true,
+      'follow-timed': true,
+      'enable-here': true,
+      'disable-here': false,
+      unfollow: false,
+    });
+  });
+
+  it('treats enable-here as active even though the global follow did not change', () => {
+    // The distinction that decides the whole question: a mirror is asking
+    // "should this appear in MY app", not "does the user follow it anywhere".
+    expect(FOLLOW_ACTION_LEAVES_ACTIVE['enable-here']).toBe(true);
+    expect(FOLLOW_ACTION_LEAVES_ACTIVE['disable-here']).toBe(false);
+  });
+
+  it('covers every action either control can produce', () => {
+    // A menu item whose action is missing from the table would report
+    // `undefined` — falsy, so it would silently read as "not active here".
+    const fromMenu = new Set(
+      [
+        ...buildFollowMenuItems({ ...base }),
+        ...buildFollowMenuItems({ ...base, following: true, hasRelationship: true }),
+        ...buildFollowMenuItems({
+          ...base,
+          following: true,
+          hasRelationship: true,
+          applicationMode: 'disabled',
+        }),
+      ].map((item) => item.action.type)
+    );
+    // Plus the two the primary button can produce that the menu cannot.
+    for (const action of [...fromMenu, 'follow', 'unfollow']) {
+      expect(typeof FOLLOW_ACTION_LEAVES_ACTIVE[action as keyof typeof FOLLOW_ACTION_LEAVES_ACTIVE])
+        .toBe('boolean');
+    }
+    expect(fromMenu.size).toBeGreaterThanOrEqual(3);
+  });
 });

package/src/ui/hooks/useFollow.ts

@@ -101,8 +101,8 @@ export const useFollow = (userId?: string | string[]) => {
     if (!isSingleUser || !userId) throw new Error('toggleFollow is only available for single user mode');
     if (!canUsePrivateApi) throw new Error('Authentication is required to follow users');
     const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
-    await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
-    patchCachedUserRelationship(queryClient, userId, !currentlyFollowing);
+    const accepted = await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+    if (accepted) patchCachedUserRelationship(queryClient, userId, !currentlyFollowing);
   }, [isSingleUser, userId, canUsePrivateApi, oxyServices, queryClient]);
 
   const setFollowStatus = useCallback((following: boolean) => {
@@ -157,15 +157,15 @@ export const useFollow = (userId?: string | string[]) => {
         following: state.followingCounts[singleUserId] ?? null,
       };
     },
-    enabled: !!singleUserId && followerCount === null && followingCount === null,
+    enabled: !!singleUserId && (followerCount === null || followingCount === null),
   });
 
   // Multi-user callbacks
   const toggleFollowForUser = useCallback(async (targetUserId: string) => {
     if (!canUsePrivateApi) throw new Error('Authentication is required to follow users');
     const currentState = useFollowStore.getState().followingUsers[targetUserId] ?? false;
-    await useFollowStore.getState().toggleFollowUser(targetUserId, oxyServices, currentState);
-    patchCachedUserRelationship(queryClient, targetUserId, !currentState);
+    const accepted = await useFollowStore.getState().toggleFollowUser(targetUserId, oxyServices, currentState);
+    if (accepted) patchCachedUserRelationship(queryClient, targetUserId, !currentState);
   }, [canUsePrivateApi, oxyServices, queryClient]);
 
   const setFollowStatusForUser = useCallback((targetUserId: string, following: boolean) => {
@@ -280,9 +280,9 @@ export const useFollowForButton = (userId: string, oxyServices: OxyServices, ini
     useCallback((s) => s.errors[userId] ?? null, [userId])
   );
 
-  const toggleFollow = useCallback(async () => {
+  const toggleFollow = useCallback(async (): Promise<boolean> => {
     const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
-    await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+    return useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
   }, [userId, oxyServices]);
 
   // Enqueue this id into the micro-batched resolver — every button that enqueues

package/src/ui/hooks/useFollowTarget.ts

@@ -19,6 +19,7 @@ import { useCallback, useEffect } from 'react';
 import type { FollowStatus } from '@oxyhq/contracts';
 import { useOxy } from '../context/OxyContext';
 import {
+  isCompleteFollowStatus,
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
   useFollowTargetStore,
@@ -90,15 +91,22 @@ export function useFollowTarget(
       useFollowTargetStore.getState().setStatus(targetId, next);
       useFollowTargetStore.getState().setError(targetId, undefined);
     } catch (e) {
-      useFollowTargetStore
-        .getState()
-        .setError(targetId, e instanceof Error ? e.message : 'Could not read follow status');
+      const store = useFollowTargetStore.getState();
+      const message = e instanceof Error ? e.message : 'Could not read follow status';
+      // Leave `isUnknown` false so the button stays interactive and can retry.
+      // A failed read is not the same as "never asked" — disabling forever would
+      // strand the user with no affordance when the network blips.
+      if (!store.statuses[targetId]) {
+        store.setStatus(targetId, UNKNOWN_FOLLOW_STATUS);
+      }
+      store.setError(targetId, message);
     }
   }, [targetId, canUsePrivateApi, oxyServices]);
 
   useEffect(() => {
     if (!targetId || !canUsePrivateApi) return;
-    if (useFollowTargetStore.getState().statuses[targetId]) return;
+    const existing = useFollowTargetStore.getState().statuses[targetId];
+    if (existing && isCompleteFollowStatus(existing)) return;
     void refresh();
   }, [targetId, canUsePrivateApi, refresh]);
 
@@ -110,7 +118,7 @@ export function useFollowTarget(
   const mutate = useCallback(
     async (
       optimistic: FollowStatus,
-      run: () => Promise<FollowStatus | void>,
+      run: () => Promise<FollowStatus | undefined>,
       failureMessage: string
     ): Promise<boolean> => {
       if (!targetId) return false;
@@ -175,10 +183,12 @@ export function useFollowTarget(
   const disableHere = useCallback(async () => {
     const relationshipId = current.relationshipId;
     if (!targetId || !relationshipId) return false;
+    const optimistic = withApplicationMode(current, 'disabled');
     return mutate(
-      withApplicationMode(current, 'disabled'),
+      optimistic,
       async () => {
         await oxyServices.setFollowApplicationMode(relationshipId, 'disabled');
+        return optimistic;
       },
       'Could not change this app’s setting for this follow'
     );
@@ -187,10 +197,12 @@ export function useFollowTarget(
   const enableHere = useCallback(async () => {
     const relationshipId = current.relationshipId;
     if (!targetId || !relationshipId) return false;
+    const optimistic = withApplicationMode(current, 'inherit');
     return mutate(
-      withApplicationMode(current, 'inherit'),
+      optimistic,
       async () => {
         await oxyServices.restoreFollowInheritance(relationshipId);
+        return optimistic;
       },
       'Could not change this app’s setting for this follow'
     );

package/src/ui/stores/__tests__/followStore.test.ts

@@ -116,7 +116,9 @@ describe('toggleFollowUser (optimistic)', () => {
     expect(useFollowStore.getState().loadingUsers.u1).toBe(true);
 
     resolveFollow({ message: 'ok', counts: { followers: 10, following: 3 } });
-    await pending;
+    const accepted = await pending;
+
+    expect(accepted).toBe(true);
 
     expect(useFollowStore.getState().followingUsers.u1).toBe(true);
     expect(useFollowStore.getState().loadingUsers.u1).toBe(false);
@@ -132,9 +134,9 @@ describe('toggleFollowUser (optimistic)', () => {
     const store = useFollowStore.getState();
     store.setFollowStatuses({ u1: false });
 
-    await store.toggleFollowUser('u1', services, false);
+    const accepted = await store.toggleFollowUser('u1', services, false);
 
-    // Optimistic true was rolled back to the seeded false.
+    expect(accepted).toBe(false);
     expect(useFollowStore.getState().followingUsers.u1).toBe(false);
     expect(useFollowStore.getState().loadingUsers.u1).toBe(false);
     expect(useFollowStore.getState().errors.u1).toBe('boom');
@@ -145,8 +147,9 @@ describe('toggleFollowUser (optimistic)', () => {
     mock.followUser.mockRejectedValueOnce(new Error('nope'));
 
     const store = useFollowStore.getState();
-    await store.toggleFollowUser('u1', services, false);
+    const accepted = await store.toggleFollowUser('u1', services, false);
 
+    expect(accepted).toBe(false);
     // The key is removed → back to UNKNOWN (tri-state), not a definite false.
     expect(Object.prototype.hasOwnProperty.call(useFollowStore.getState().followingUsers, 'u1')).toBe(false);
   });

package/src/ui/stores/followStore.ts

@@ -27,7 +27,7 @@ interface FollowState {
   // requested within the same tick into ONE `getFollowStatuses` call. Ids that
   // are already known/seeded or already in flight are skipped.
   resolveFollowStatuses: (userIds: string[], oxyServices: OxyServices) => void;
-  toggleFollowUser: (userId: string, oxyServices: OxyServices, isCurrentlyFollowing: boolean) => Promise<void>;
+  toggleFollowUser: (userId: string, oxyServices: OxyServices, isCurrentlyFollowing: boolean) => Promise<boolean>;
   // Bulk follow — follows MANY users in one network call; never unfollows.
   followManyUsers: (userIds: string[], oxyServices: OxyServices) => Promise<BulkFollowResult>;
   // Bulk unfollow — unfollows MANY users in one network call; idempotent, never follows.
@@ -237,6 +237,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
           return { followerCounts };
         });
       }
+      return true;
     } catch (error: unknown) {
       // Roll back to the prior value (or back to UNKNOWN if there was none).
       set((state) => {
@@ -252,6 +253,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
           errors: { ...state.errors, [userId]: (error instanceof Error ? error.message : null) || 'Failed to update follow status' },
         };
       });
+      return false;
     }
   },
   followManyUsers: async (userIds: string[], oxyServices: OxyServices): Promise<BulkFollowResult> => {

package/src/ui/stores/followTargetStore.ts

@@ -93,6 +93,17 @@ export function isFollowedGlobally(status: FollowStatus): boolean {
   return status.globalState === 'active' || status.globalState === 'requested';
 }
 
+/**
+ * Whether a cached status is safe to act on without a round trip.
+ *
+ * List payloads often carry `globalState` without `relationshipId`. Treating
+ * that as authoritative would leave disable/unfollow as no-ops forever.
+ */
+export function isCompleteFollowStatus(status: FollowStatus): boolean {
+  if (isFollowedGlobally(status)) return Boolean(status.relationshipId);
+  return true;
+}
+
 /**
  * Apply a mode change to a cached status without a round trip.
  *