@oxyhq/services 27.1.0 → 27.1.2

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;
@@ -111,6 +134,22 @@ export interface FollowMenuItem {
  * answered — every one of them addresses a relationship that does not exist
  * yet, so offering them mid-write would mean sending a guessed id.
  */
+/**
+ * What the main button should do for the current state.
+ *
+ * Exported because the product rule is not obvious from the label alone: a
+ * follow switched off here still reads as "following" globally, so the primary
+ * press must re-enable here — not unfollow everywhere.
+ */
+export function resolveFollowPrimaryAction(input: {
+  isFollowing: boolean;
+  applicationMode: FollowApplicationMode;
+}): 'follow' | 'unfollow' | 'enable-here' {
+  if (!input.isFollowing) return 'follow';
+  if (input.applicationMode === 'disabled') return 'enable-here';
+  return 'unfollow';
+}
+
 export function buildFollowMenuItems(input: {
   following: boolean;
   applicationMode: FollowApplicationMode;
@@ -181,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({
@@ -210,22 +262,35 @@ export const FollowTargetButton = memo(function FollowTargetButton({
     return status.applicationMode === 'disabled' ? text.disabled : text.active;
   }, [isFollowing, status.globalState, status.applicationMode, text]);
 
+  // `onChange` fires ONLY when the server accepted the write.
+  //
+  // The mutations never reject — a refusal becomes error state so the button
+  // can render it — so an unconditional `onChange` after `await` reports
+  // INTENT rather than outcome. A caller mirroring the follow somewhere else
+  // (a local shelf, a ranking signal) would then mirror failures too, and the
+  // button beside it would show the server's truth while the mirror showed a
+  // press that did not happen. Same shape of trap as reading `effectiveState`
+  // as "does the user follow this".
   const handlePrimary = useCallback(async () => {
-    if (isFollowing) {
-      await unfollow();
-      onChange?.(false);
-      return;
+    switch (resolveFollowPrimaryAction({ isFollowing, applicationMode: status.applicationMode })) {
+      case 'enable-here':
+        if (await enableHere()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE['enable-here']);
+        return;
+      case 'unfollow':
+        if (await unfollow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
+        return;
+      case 'follow':
+        if (await follow()) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.follow);
     }
-    await follow();
-    onChange?.(true);
-  }, [isFollowing, follow, unfollow, onChange]);
+  }, [isFollowing, status.applicationMode, follow, unfollow, enableHere, onChange]);
 
   const handleTimed = useCallback(
     async (seconds: number, durationLabel: string) => {
-      await follow({ expiresIn: seconds });
-      onChange?.(true);
+      if (!(await follow({ expiresIn: seconds }))) 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]
@@ -259,15 +324,25 @@ 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();
-          onChange?.(false);
+          void unfollow().then((ok) => {
+            if (ok) onChange?.(FOLLOW_ACTION_LEAVES_ACTIVE.unfollow);
+          });
       }
     },
     [handleTimed, enableHere, disableHere, unfollow, onChange]

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

@@ -12,7 +12,11 @@
  * to reflect.
  */
 
-import { buildFollowMenuItems } from '../FollowTargetButton';
+import {
+  buildFollowMenuItems,
+  FOLLOW_ACTION_LEAVES_ACTIVE,
+  resolveFollowPrimaryAction,
+} from '../FollowTargetButton';
 import {
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
@@ -36,6 +40,26 @@ const base = {
 
 const keys = (items: ReturnType<typeof buildFollowMenuItems>) => items.map((i) => i.key);
 
+describe('resolveFollowPrimaryAction', () => {
+  it('follows when not following globally', () => {
+    expect(resolveFollowPrimaryAction({ isFollowing: false, applicationMode: 'inherit' })).toBe(
+      'follow'
+    );
+  });
+
+  it('unfollows when following and active here', () => {
+    expect(resolveFollowPrimaryAction({ isFollowing: true, applicationMode: 'inherit' })).toBe(
+      'unfollow'
+    );
+  });
+
+  it('re-enables here instead of unfollowing everywhere when switched off in this app', () => {
+    expect(resolveFollowPrimaryAction({ isFollowing: true, applicationMode: 'disabled' })).toBe(
+      'enable-here'
+    );
+  });
+});
+
 describe('buildFollowMenuItems', () => {
   describe('before following', () => {
     it('offers the timed follows and nothing else', () => {
@@ -108,9 +132,9 @@ describe('withApplicationMode', () => {
     expect(isFollowedGlobally(next)).toBe(true);
   });
 
-  it('restores the global state when enabled again', () => {
-    expect(withApplicationMode(withApplicationMode(active, 'disabled'), 'enabled')).toMatchObject({
-      applicationMode: 'enabled',
+  it('restores inheritance when enabled again', () => {
+    expect(withApplicationMode(withApplicationMode(active, 'disabled'), 'inherit')).toMatchObject({
+      applicationMode: 'inherit',
       effectiveState: 'following',
     });
   });
@@ -130,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

@@ -36,11 +36,20 @@ export interface UseFollowTargetResult {
   isUnknown: boolean;
   isPending: boolean;
   error: string | undefined;
-  follow: (options?: { expiresIn?: number }) => Promise<void>;
-  unfollow: () => Promise<void>;
+  /**
+   * Every mutation resolves to whether the server ACCEPTED it.
+   *
+   * They never reject — a refusal becomes `error` in the store, so the button
+   * can render it — which means a caller that only awaits them cannot tell a
+   * write that happened from one that did not. Returning the outcome is what
+   * lets a caller mirror the change somewhere else without mirroring failures
+   * too.
+   */
+  follow: (options?: { expiresIn?: number }) => Promise<boolean>;
+  unfollow: () => Promise<boolean>;
   /** Stop acting on this follow HERE, without giving it up everywhere. */
-  disableHere: () => Promise<void>;
-  enableHere: () => Promise<void>;
+  disableHere: () => Promise<boolean>;
+  enableHere: () => Promise<boolean>;
   refresh: () => Promise<void>;
 }
 
@@ -101,10 +110,10 @@ export function useFollowTarget(
   const mutate = useCallback(
     async (
       optimistic: FollowStatus,
-      run: () => Promise<FollowStatus | void>,
+      run: () => Promise<FollowStatus | undefined>,
       failureMessage: string
-    ) => {
-      if (!targetId) return;
+    ): Promise<boolean> => {
+      if (!targetId) return false;
       const store = useFollowTargetStore.getState();
       const previous = store.statuses[targetId];
       store.setStatus(targetId, optimistic);
@@ -113,12 +122,14 @@ export function useFollowTarget(
       try {
         const settled = await run();
         if (settled) useFollowTargetStore.getState().setStatus(targetId, settled);
+        return true;
       } catch (e) {
         const s = useFollowTargetStore.getState();
         // Back to what was true, not to a guess. Clearing the entry instead
         // would make the next render ask again and flash the wrong state.
         if (previous) s.setStatus(targetId, previous);
         s.setError(targetId, e instanceof Error ? e.message : failureMessage);
+        return false;
       } finally {
         useFollowTargetStore.getState().setPending(targetId, false);
       }
@@ -130,8 +141,8 @@ export function useFollowTarget(
 
   const follow = useCallback(
     async (opts?: { expiresIn?: number }) => {
-      if (!targetId) return;
-      await mutate(
+      if (!targetId) return false;
+      return mutate(
         {
           ...withApplicationMode({ ...current, globalState: 'active' }, current.applicationMode),
           ...(opts?.expiresIn
@@ -150,8 +161,8 @@ export function useFollowTarget(
 
   const unfollow = useCallback(async () => {
     const relationshipId = current.relationshipId;
-    if (!targetId || !relationshipId) return;
-    await mutate(
+    if (!targetId || !relationshipId) return false;
+    return mutate(
       { ...UNKNOWN_FOLLOW_STATUS },
       async () => {
         await oxyServices.unfollowTarget(relationshipId);
@@ -161,23 +172,33 @@ export function useFollowTarget(
     );
   }, [targetId, current.relationshipId, mutate, oxyServices]);
 
-  const setMode = useCallback(
-    async (mode: 'enabled' | 'disabled') => {
-      const relationshipId = current.relationshipId;
-      if (!targetId || !relationshipId) return;
-      await mutate(
-        withApplicationMode(current, mode),
-        async () => {
-          await oxyServices.setFollowApplicationMode(relationshipId, mode);
-        },
-        'Could not change this app’s setting for this follow'
-      );
-    },
-    [targetId, current, mutate, oxyServices]
-  );
+  const disableHere = useCallback(async () => {
+    const relationshipId = current.relationshipId;
+    if (!targetId || !relationshipId) return false;
+    const optimistic = withApplicationMode(current, 'disabled');
+    return mutate(
+      optimistic,
+      async () => {
+        await oxyServices.setFollowApplicationMode(relationshipId, 'disabled');
+        return optimistic;
+      },
+      'Could not change this app’s setting for this follow'
+    );
+  }, [targetId, current, mutate, oxyServices]);
 
-  const disableHere = useCallback(() => setMode('disabled'), [setMode]);
-  const enableHere = useCallback(() => setMode('enabled'), [setMode]);
+  const enableHere = useCallback(async () => {
+    const relationshipId = current.relationshipId;
+    if (!targetId || !relationshipId) return false;
+    const optimistic = withApplicationMode(current, 'inherit');
+    return mutate(
+      optimistic,
+      async () => {
+        await oxyServices.restoreFollowInheritance(relationshipId);
+        return optimistic;
+      },
+      'Could not change this app’s setting for this follow'
+    );
+  }, [targetId, current, mutate, oxyServices]);
 
   return {
     status: current,

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> => {