@oxy.so/services 13.11.0 → 13.12.1

package/src/ui/hooks/accountQueryPersistence.ts

@@ -54,7 +54,9 @@ export interface AccountQueryMeta {
   persist: 'account';
 }
 
-function isAccountQuery(query: Query): boolean {
+type QueryIdentity = { queryKey: QueryKey; meta?: Query['meta'] };
+
+function isAccountQuery(query: Pick<QueryIdentity, 'meta'>): boolean {
   return (query.meta as Partial<AccountQueryMeta> | undefined)?.persist === 'account';
 }
 
@@ -75,22 +77,44 @@ export interface AccountQueriesConfig {
   /**
    * Roots that belong to the account too, but must not be written to disk
    * (signed URLs, AI output, search results): dropped on a switch, never persisted.
+   * `'all'` keeps every account-owned query in memory only, including marked
+   * queries unless `persistMarkedQueries` is enabled. Device-level SDK roots
+   * remain excluded unless an individual query declares account persistence.
+   */
+  memoryOnlyRoots?: readonly string[] | 'all';
+  /**
+   * When `memoryOnlyRoots` is `'all'`, persist queries explicitly marked with
+   * `meta.persist = 'account'`. SDK memory-only roots remain excluded.
+   * Defaults to false.
    */
-  memoryOnlyRoots?: readonly string[];
+  persistMarkedQueries?: boolean;
   /**
    * Mutation keys whose PAUSED (offline) instances replay after a restart for
    * the same account. Register their `mutationFn` with `setMutationDefaults`.
    */
   mutationKeys?: readonly QueryKey[];
+  /**
+   * Remove unregistered mutation records as well on every account transition.
+   * Only registered paused mutations are saved and restored; unregistered
+   * mutations are excluded from the shared persisted cache too. Removing a record
+   * does not cancel an in-flight request or its callbacks; apps must scope
+   * their mutation effects to the account that started them.
+   * Defaults to false.
+   */
+  clearUnregisteredMutations?: boolean;
 }
 
 /** Which queries and mutations an `AccountQueriesConfig` makes the account's. */
 export interface AccountQueryOwnership {
   /** Dropped from memory on a subject change. */
-  ownsQuery: (query: Query) => boolean;
+  ownsQuery: (query: QueryIdentity) => boolean;
   /** Written to the account's blob. */
-  persistsQuery: (query: Query) => boolean;
+  persistsQuery: (query: QueryIdentity) => boolean;
   ownsMutation: (mutation: Mutation) => boolean;
+  /** Eligible for the account's persisted paused mutations. */
+  persistsMutation: (mutation: Mutation) => boolean;
+  /** Whether a stored mutation key belongs to this account's offline queue. */
+  persistsMutationKey: (key: QueryKey | undefined) => boolean;
 }
 
 /** SDK roots that hold device-level data, the same whoever is signed in. */
@@ -102,14 +126,23 @@ const NO_ROOTS: AccountQueriesConfig = { roots: [] };
 export function accountQueryOwnership(
   config: AccountQueriesConfig = NO_ROOTS,
 ): AccountQueryOwnership {
-  const memoryOnly = new Set([...(config.memoryOnlyRoots ?? []), ...SDK_MEMORY_ONLY_ROOTS]);
+  const memoryOnlyAll = config.memoryOnlyRoots === 'all';
+  const memoryOnly = new Set([
+    ...(memoryOnlyAll ? [] : (config.memoryOnlyRoots ?? [])),
+    ...SDK_MEMORY_ONLY_ROOTS,
+  ]);
   const sdkRoots = new Set(PERSISTED_QUERY_PREFIXES);
   const declared = config.roots === 'all' ? null : new Set(config.roots);
   const mutationHashes = new Set((config.mutationKeys ?? []).map((key) => hashKey(key)));
+  const persistsMutationKey = (key: QueryKey | undefined): boolean =>
+    key !== undefined && mutationHashes.has(hashKey(key));
+  const isRegisteredMutation = (mutation: Mutation): boolean =>
+    persistsMutationKey(mutation.options.mutationKey);
 
-  const ownsQuery = (query: Query): boolean => {
+  const ownsQuery = (query: QueryIdentity): boolean => {
     if (isAccountQuery(query)) return true;
     const root = rootOf(query);
+    if (memoryOnlyAll && (root === null || !DEVICE_ROOTS.has(root))) return true;
     if (root !== null && memoryOnly.has(root)) return true;
     if (declared === null) return root === null || !DEVICE_ROOTS.has(root);
     return root !== null && declared.has(root);
@@ -119,16 +152,23 @@ export function accountQueryOwnership(
     persistsQuery: (query) => {
       if (!ownsQuery(query)) return false;
       const root = rootOf(query);
+      if (memoryOnlyAll) {
+        return (
+          config.persistMarkedQueries === true &&
+          isAccountQuery(query) &&
+          (root === null || !memoryOnly.has(root))
+        );
+      }
       if (root === null) return true;
       // The SDK's own roots stay with the SDK persister.
       return (
         !memoryOnly.has(root) && (isAccountQuery(query) || declared !== null || !sdkRoots.has(root))
       );
     },
-    ownsMutation: (mutation) => {
-      const key = mutation.options.mutationKey;
-      return key !== undefined && mutationHashes.has(hashKey(key));
-    },
+    ownsMutation: (mutation) =>
+      config.clearUnregisteredMutations === true || isRegisteredMutation(mutation),
+    persistsMutation: isRegisteredMutation,
+    persistsMutationKey,
   };
 }
 
@@ -160,10 +200,11 @@ export function createAccountQueryPersistence(
   queryClient: QueryClient,
   config?: AccountQueriesConfig,
 ): AccountQueryPersistence {
-  const { ownsQuery, persistsQuery, ownsMutation } = accountQueryOwnership(config);
+  const { ownsQuery, persistsQuery, ownsMutation, persistsMutation, persistsMutationKey } =
+    accountQueryOwnership(config);
   const filters: PersistFilters = {
     persistsQuery,
-    shouldDehydrateMutation: (mutation) => mutation.state.isPaused && ownsMutation(mutation),
+    shouldDehydrateMutation: (mutation) => mutation.state.isPaused && persistsMutation(mutation),
   };
   const listeners = new Set<() => void>();
 
@@ -221,7 +262,13 @@ export function createAccountQueryPersistence(
       const raw = await storage.getItem(key).catch(() => null);
       // Same tick as the hydrate: a switch in between cannot be missed.
       if (current !== generation) return;
-      if (!hydrateSnapshot(queryClient, raw, ACCOUNT_QUERY_CACHE_MAX_AGE) && raw) {
+      if (
+        !hydrateSnapshot(queryClient, raw, ACCOUNT_QUERY_CACHE_MAX_AGE, {
+          shouldRestoreQuery: persistsQuery,
+          shouldRestoreMutation: (mutation) => persistsMutationKey(mutation.mutationKey),
+        }) &&
+        raw
+      ) {
         await storage.removeItem(key).catch(() => undefined);
         if (current !== generation) return;
       }

package/src/ui/hooks/persistedQueryCache.ts

@@ -55,7 +55,7 @@ interface PersistedBlob {
   clientState: DehydratedState;
 }
 
-export function rootOf(query: Query): string | null {
+export function rootOf(query: Pick<Query, 'queryKey'>): string | null {
   const head = query.queryKey[0];
   return typeof head === 'string' ? head : null;
 }
@@ -83,6 +83,11 @@ export function hydrateSnapshot(
   queryClient: QueryClient,
   raw: string | null,
   maxAge: number,
+  options?: {
+    shouldRestoreQuery?: (query: DehydratedState['queries'][number]) => boolean;
+    shouldRestoreMutation?: (mutation: DehydratedState['mutations'][number]) => boolean;
+    restoreMutations?: boolean;
+  },
 ): boolean {
   if (!raw) return false;
   let blob: PersistedBlob;
@@ -100,8 +105,17 @@ export function hydrateSnapshot(
   }
   const sameBuild = blob.buster === getOxyBuildId();
   hydrate(queryClient, {
-    queries: sameBuild ? blob.clientState.queries : [],
-    mutations: blob.clientState.mutations ?? [],
+    queries: sameBuild
+      ? (blob.clientState.queries ?? []).filter(
+          (query) => options?.shouldRestoreQuery?.(query) ?? true,
+        )
+      : [],
+    mutations:
+      options?.restoreMutations === false
+        ? []
+        : (blob.clientState.mutations ?? []).filter(
+            (mutation) => options?.shouldRestoreMutation?.(mutation) ?? true,
+          ),
   });
   return true;
 }

package/src/ui/hooks/queryClient.ts

@@ -163,7 +163,14 @@ export const attachQueryPersistence = (
   const restored = (async () => {
     const raw = await storage.getItem(QUERY_CACHE_KEY);
     if (stopped) return;
-    if (!hydrateSnapshot(queryClient, raw, QUERY_CACHE_MAX_AGE) && raw) {
+    if (
+      !hydrateSnapshot(queryClient, raw, QUERY_CACHE_MAX_AGE, {
+        shouldRestoreQuery: (query) => !account.ownsQuery(query),
+        restoreMutations: accountQueries?.clearUnregisteredMutations !== true,
+        shouldRestoreMutation: (mutation) => !account.persistsMutationKey(mutation.mutationKey),
+      }) &&
+      raw
+    ) {
       await storage.removeItem(QUERY_CACHE_KEY);
     }
   })()

package/src/ui/hooks/useFollowTarget.ts

@@ -20,6 +20,7 @@ import type { FollowStatus } from '@oxy.so/contracts';
 import { useOxy } from '../context/oxyRuntimeContext';
 import {
   isCompleteFollowStatus,
+  getFollowTargetGeneration,
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
   useFollowTargetStore,
@@ -92,11 +93,14 @@ export function useFollowTarget(
     // that window 401s and would leave the button stuck reporting an error the
     // user cannot act on.
     if (!targetId || !canUsePrivateApi) return;
+    const generation = getFollowTargetGeneration();
     try {
       const next = await oxyServices.follows.targetStatus(targetId);
+      if (generation !== getFollowTargetGeneration()) return;
       useFollowTargetStore.getState().setStatus(targetId, next);
       useFollowTargetStore.getState().setError(targetId, undefined);
     } catch (e) {
+      if (generation !== getFollowTargetGeneration()) return;
       const store = useFollowTargetStore.getState();
       // Leave `isUnknown` false so the button stays interactive and can retry.
       // A failed read is not the same as "never asked" — disabling forever would
@@ -127,6 +131,7 @@ export function useFollowTarget(
       failure: FollowActionErrorCode,
     ): Promise<boolean> => {
       if (!targetId) return false;
+      const generation = getFollowTargetGeneration();
       const store = useFollowTargetStore.getState();
       const previous = store.statuses[targetId];
       store.setStatus(targetId, optimistic);
@@ -134,9 +139,11 @@ export function useFollowTarget(
       store.setError(targetId, undefined);
       try {
         const settled = await run();
+        if (generation !== getFollowTargetGeneration()) return false;
         if (settled) useFollowTargetStore.getState().setStatus(targetId, settled);
         return true;
       } catch (e) {
+        if (generation !== getFollowTargetGeneration()) return false;
         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.
@@ -144,7 +151,9 @@ export function useFollowTarget(
         s.setError(targetId, toFollowErrorCode(e, failure));
         return false;
       } finally {
-        useFollowTargetStore.getState().setPending(targetId, false);
+        if (generation === getFollowTargetGeneration()) {
+          useFollowTargetStore.getState().setPending(targetId, false);
+        }
       }
     },
     [targetId],

package/src/ui/hooks/useSessionManagement.ts

@@ -6,6 +6,7 @@ import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
 import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
 import type { OxyServices } from '@oxy.so/core';
 import type { QueryClient } from '@tanstack/react-query';
+import { isSessionChangedError } from '../utils/sessionChangedError';
 import { clearQueryCache } from './queryClient';
 import { isWebBrowser } from '../utils/isWebBrowser';
 import { resetSessionScopedStores } from '../stores/resetSessionScopedStores';
@@ -188,6 +189,7 @@ export const useSessionManagement = ({
           });
           activeRuntime.mergeSessions(deviceSessions, { merge: true });
         } catch (error) {
+          if (isSessionChangedError(error)) throw error;
           if (isDev()) {
             console.warn('Failed to synchronize sessions after switch:', error);
           }
@@ -195,6 +197,7 @@ export const useSessionManagement = ({
 
         return user;
       } catch (error) {
+        if (isSessionChangedError(error)) throw error;
         const invalidSession = isInvalidSessionError(error);
 
         if (invalidSession) {

package/src/ui/runtime/createOxyRuntime.ts

@@ -652,6 +652,7 @@ export function createOxyRuntime(config: OxyRuntimeConfig): OxyRuntime {
         facts.directory = null;
         facts.profiles = new Map();
         facts.pinnedAccountId = null;
+        facts.isLoading = false;
         touch();
       });
     },

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

@@ -190,3 +190,65 @@ describe('resetFollowState', () => {
     expect(useFollowStore.getState().followingUsers).toEqual({});
   });
 });
+
+describe('follow operations across account resets', () => {
+  it.each(['resolve', 'reject'] as const)(
+    'does not reconcile a previous account toggle when it %s',
+    async (outcome) => {
+      const { mock, services } = makeServices();
+      let resolve!: (result: FollowMutationResult) => void;
+      let reject!: (error: Error) => void;
+      mock.follows.follow.mockReturnValueOnce(
+        new Promise((res, rej) => {
+          resolve = res;
+          reject = rej;
+        }),
+      );
+      const pending = useFollowStore.getState().toggleFollowUser('u1', services, false);
+      useFollowStore.getState().resetFollowState();
+      useFollowStore.setState({
+        followingUsers: { u1: true },
+        loadingUsers: { u1: true },
+        errors: { u1: 'read_failed' },
+      });
+      if (outcome === 'resolve')
+        resolve({ message: 'ok', counts: { followers: 10, following: 3 } });
+      else reject(new Error('old request failed'));
+      expect(await pending).toBe(false);
+      const state = useFollowStore.getState();
+      expect(state.followingUsers.u1).toBe(true);
+      expect(state.loadingUsers.u1).toBe(true);
+      expect(state.errors.u1).toBe('read_failed');
+      expect(state.followerCounts.u1).toBeUndefined();
+    },
+  );
+
+  it.each(['followMany', 'unfollowMany'] as const)(
+    'does not reconcile a previous account %s',
+    async (method) => {
+      const { services } = makeServices();
+      let resolve!: (result: unknown) => void;
+      const response = new Promise((res) => {
+        resolve = res;
+      });
+      Object.assign(services.follows, { [method]: jest.fn(() => response) });
+      const store = useFollowStore.getState();
+      const pending =
+        method === 'followMany'
+          ? store.followManyUsers(['u1'], services)
+          : store.unfollowManyUsers(['u1'], services);
+      store.resetFollowState();
+      useFollowStore.setState({
+        followingUsers: { u1: true },
+        loadingUsers: { u1: true },
+        errors: { u1: 'read_failed' },
+      });
+      resolve({ results: [] });
+      await expect(pending).rejects.toMatchObject({ code: 'AUTH_SESSION_CHANGED' });
+      const state = useFollowStore.getState();
+      expect(state.followingUsers.u1).toBe(true);
+      expect(state.loadingUsers.u1).toBe(true);
+      expect(state.errors.u1).toBe('read_failed');
+    },
+  );
+});

package/src/ui/stores/followStore.ts

@@ -6,6 +6,7 @@ import type {
   FollowMutationResult,
 } from '@oxy.so/core';
 import { type FollowErrorCode, toFollowErrorCode } from '../utils/followErrors';
+import { createSessionChangedError } from '../utils/sessionChangedError';
 
 interface FollowState {
   // Tri-state follow map: a MISSING key means UNKNOWN (status not yet resolved),
@@ -206,6 +207,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
           });
         })
         .finally(() => {
+          if (generation !== batchGeneration) return;
           for (const id of ids) inFlightIds.delete(id);
         });
     });
@@ -215,6 +217,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     oxyServices: OxyServices,
     isCurrentlyFollowing: boolean,
   ) => {
+    const generation = batchGeneration;
     // Snapshot the prior value for rollback. `undefined` = was UNKNOWN.
     const priorState = get().followingUsers;
     const hadPrevious = hasKey(priorState, userId);
@@ -233,6 +236,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       const response: FollowMutationResult = isCurrentlyFollowing
         ? await oxyServices.follows.unfollow(userId)
         : await oxyServices.follows.follow(userId);
+      if (generation !== batchGeneration) return false;
 
       // Reconcile: confirm the optimistic value is authoritative, clear loading.
       set((state) => ({
@@ -262,6 +266,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       }
       return true;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) return false;
       // Roll back to the prior value (or back to UNKNOWN if there was none).
       set((state) => {
         const followingUsers = { ...state.followingUsers };
@@ -286,6 +291,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     userIds: string[],
     oxyServices: OxyServices,
   ): Promise<BulkFollowResult> => {
+    const generation = batchGeneration;
     // Snapshot prior values for rollback (tri-state: undefined = unknown).
     const prior = get().followingUsers;
     const previous = new Map<string, boolean | undefined>();
@@ -308,6 +314,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
 
     try {
       const result = await oxyServices.follows.followMany(userIds);
+      if (generation !== batchGeneration) throw createSessionChangedError();
       set((state) => {
         const followingUsers = { ...state.followingUsers };
         const loadingUsers = { ...state.loadingUsers };
@@ -334,6 +341,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       });
       return result;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) throw createSessionChangedError();
       const code = toFollowErrorCode(error, 'update_failed');
       // Whole batch failed — roll ALL targets back to their prior values.
       set((state) => {
@@ -359,6 +367,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     userIds: string[],
     oxyServices: OxyServices,
   ): Promise<BulkUnfollowResult> => {
+    const generation = batchGeneration;
     // Snapshot prior values for rollback (tri-state: undefined = unknown).
     const prior = get().followingUsers;
     const previous = new Map<string, boolean | undefined>();
@@ -381,6 +390,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
 
     try {
       const result = await oxyServices.follows.unfollowMany(userIds);
+      if (generation !== batchGeneration) throw createSessionChangedError();
       set((state) => {
         const followingUsers = { ...state.followingUsers };
         const loadingUsers = { ...state.loadingUsers };
@@ -407,6 +417,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       });
       return result;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) throw createSessionChangedError();
       const code = toFollowErrorCode(error, 'update_failed');
       // Whole batch failed — roll ALL targets back to their prior values.
       set((state) => {
@@ -454,11 +465,13 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     });
   },
   fetchUserCounts: async (userId: string, oxyServices: OxyServices) => {
+    const generation = batchGeneration;
     set((state) => ({
       loadingCounts: { ...state.loadingCounts, [userId]: true },
     }));
     try {
       const user = await oxyServices.users.get(userId);
+      if (generation !== batchGeneration) return;
       if (user?._count) {
         set((state) => ({
           followerCounts: {
@@ -477,6 +490,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
         }));
       }
     } catch (error: unknown) {
+      if (generation !== batchGeneration) return;
       set((state) => ({
         loadingCounts: { ...state.loadingCounts, [userId]: false },
       }));

package/src/ui/stores/followTargetStore.ts

@@ -29,6 +29,13 @@ import type { FollowErrorCode } from '../utils/followErrors';
 /** The status of one target, or `undefined` when it has never been read. */
 type StatusMap = Record<string, FollowStatus | undefined>;
 
+let followTargetGeneration = 0;
+
+/** The generation changes whenever account-scoped follow state is reset. */
+export function getFollowTargetGeneration(): number {
+  return followTargetGeneration;
+}
+
 interface FollowTargetState {
   statuses: StatusMap;
   /** In-flight writes, per target. Reads do not set this — only mutations do. */
@@ -80,7 +87,10 @@ export const useFollowTargetStore = create<FollowTargetState>((set) => ({
   // account switch the whole map is wrong, not stale — the next user's follows
   // are a different set entirely, and showing one user their previous
   // account's follow state is a privacy failure rather than a rendering one.
-  reset: () => set({ statuses: {}, pending: {}, errors: {} }),
+  reset: () => {
+    followTargetGeneration += 1;
+    set({ statuses: {}, pending: {}, errors: {} });
+  },
 }));
 
 /**

package/src/ui/utils/errorHandlers.ts

@@ -1,4 +1,5 @@
 import type { ApiError } from '@oxy.so/core';
+import { isSessionChangedError } from './sessionChangedError';
 
 type ErrorWithMessage = {
   message?: string;
@@ -52,6 +53,7 @@ const getResponseStatus = (error: unknown): number | undefined => {
  * This centralizes 401 detection across different fetch clients.
  */
 export const isInvalidSessionError = (error: unknown): boolean => {
+  if (isSessionChangedError(error)) return false;
   const status = getResponseStatus(error);
   if (status === 401) {
     return true;

package/src/ui/utils/followErrors.ts

@@ -1,3 +1,5 @@
+import { isSessionChangedError } from './sessionChangedError';
+
 /**
  * What a failed follow read or write leaves behind: a stable CODE, never text.
  *
@@ -43,6 +45,7 @@ const OFFLINE_CODES = new Set(['NETWORK_ERROR', 'CONNECTION_FAILED', 'TIMEOUT'])
  * Anything the cause does not explain falls back to the caller's `action`.
  */
 export function toFollowErrorCode(error: unknown, action: FollowActionErrorCode): FollowErrorCode {
+  if (isSessionChangedError(error)) return action;
   const { status, code } = (error && typeof error === 'object' ? error : {}) as {
     status?: unknown;
     code?: unknown;

package/src/ui/utils/sessionChangedError.ts

@@ -0,0 +1,14 @@
+/** A locally superseded request is not a server rejection of the new session. */
+export function isSessionChangedError(error: unknown): boolean {
+  return (
+    !!error && typeof error === 'object' && 'code' in error && error.code === 'AUTH_SESSION_CHANGED'
+  );
+}
+
+/** A locally superseded operation must not be mistaken for a server 401. */
+export function createSessionChangedError(): Error & { code: string; status: number } {
+  return Object.assign(new Error('The request session changed'), {
+    code: 'AUTH_SESSION_CHANGED',
+    status: 401,
+  });
+}

package/src/ui/utils/sessionHelpers.ts

@@ -1,4 +1,5 @@
 import type { ClientSession } from '@oxy.so/core';
+import { isSessionChangedError } from './sessionChangedError';
 
 interface DeviceSession {
   sessionId: string;
@@ -73,6 +74,7 @@ export const fetchSessionsWithFallback = async (
     const deviceSessions = await oxyServices.devices.sessions(sessionId);
     return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
   } catch (error) {
+    if (isSessionChangedError(error)) throw error;
     if (__DEV__ && logger) {
       logger('Failed to get device sessions, falling back to user sessions', error);
     }