@oxyhq/services 27.1.1 → 27.1.2

package/src/ui/components/FollowButton.tsx

@@ -88,8 +88,8 @@ const FollowButtonInner = memo(function FollowButtonInner({
     if (disabled || isLoading || !isKnown) return;
 
     try {
-      await toggleFollow();
-      onFollowChange?.(!isFollowing);
+      const accepted = await toggleFollow();
+      if (accepted) onFollowChange?.(!isFollowing);
     } catch (err: unknown) {
       const error = err instanceof Error ? err : new Error(String(err));
       toast.error(error.message || 'Failed to update follow status');

package/src/ui/components/FollowTargetButton.tsx

@@ -90,6 +90,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 +220,20 @@ export interface FollowTargetButtonProps {
    * application" is not.
    */
   applicationName?: string;
-  onChange?: (following: boolean) => void;
+  /**
+   * 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({
@@ -238,20 +274,20 @@ 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']);
         return;
       case 'unfollow':
-        if (await unfollow()) onChange?.(false);
+        if (await unfollow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
         return;
       case 'follow':
-        if (await follow()) onChange?.(true);
+        if (await follow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.follow);
     }
   }, [isFollowing, status.applicationMode, follow, unfollow, enableHere, onChange]);
 
   const handleTimed = useCallback(
     async (seconds: number, durationLabel: string) => {
       if (!(await follow({ expiresIn: seconds }))) return;
-      onChange?.(true);
+      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.
@@ -288,15 +324,24 @@ 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']);
+          });
           return;
         case 'disable-here':
-          void disableHere();
+          void disableHere().then((ok) => {
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['disable-here']);
+          });
           return;
         case 'unfollow':
           void unfollow().then((ok) => {
-            if (ok) onChange?.(false);
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
           });
       }
     },

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

@@ -12,7 +12,11 @@
  * to reflect.
  */
 
-import { buildFollowMenuItems, resolveFollowPrimaryAction } from '../FollowTargetButton';
+import {
+  buildFollowMenuItems,
+  FOLLOW_ACTION_LEAVES_ACTIVE,
+  resolveFollowPrimaryAction,
+} from '../FollowTargetButton';
 import {
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
@@ -150,3 +154,54 @@ describe('withApplicationMode', () => {
     expect(isFollowedGlobally(UNKNOWN_FOLLOW_STATUS)).toBe(false);
   });
 });
+
+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

@@ -110,7 +110,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 +175,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 +189,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> => {