@terreno/rtk 0.26.0 → 0.27.0

package/src/authSliceNative.test.ts

@@ -1,5 +1,4 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
-import {afterAll, afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
 
 // Keep this mock a superset of the preload's react-native mock so that other
 // test files (e.g. useUpgradeCheck.test.ts) can still find AppState and Linking
@@ -17,7 +16,8 @@ mock.module("react-native", () => ({
 
 // Force IsWeb=false regardless of whether ./platform was already imported
 // elsewhere in the test run. `mock.module` is hoisted in bun, so this takes
-// effect before the dynamic imports below.
+// effect before the dynamic imports below. Web-path test files must set their
+// own top-of-file `IsWeb: true` guard; do not rely on afterAll restore here.
 mock.module("./platform", () => ({IsWeb: false}));
 
 const secureCalls = {
@@ -69,7 +69,7 @@ const api = createApi({
 });
 
 const createTestStore = () => {
-  const {authReducer, middleware, authSlice} = auth.generateAuthSlice(api as any);
+  const {authReducer, middleware, authSlice} = auth.generateAuthSlice(api);
   const store = configureStore({
     middleware: (getDefault) =>
       getDefault({serializableCheck: false}).concat(api.middleware, ...middleware),
@@ -111,20 +111,6 @@ describe("native listener middleware side effects", () => {
     console.error = originalError;
   });
 
-  afterAll(() => {
-    // Restore mocks to the values the rest of the suite expects.
-    mock.module("react-native", () => ({
-      Platform: {OS: "web"},
-      StyleSheet: {create: (s: unknown) => s},
-    }));
-    mock.module("./platform", () => ({IsWeb: true}));
-    mock.module("expo-secure-store", () => ({
-      deleteItemAsync: async () => {},
-      getItemAsync: async () => null,
-      setItemAsync: async () => {},
-    }));
-  });
-
   it("stores tokens in SecureStore on native login", async () => {
     const {store} = createTestStore();
     store.dispatch({

package/src/betterAuthClient.ts

@@ -96,8 +96,7 @@ export const createBetterAuthClient = (config: BetterAuthClientConfig) => {
     plugins: [
       expoClient({
         scheme: config.scheme,
-        // biome-ignore lint/suspicious/noExplicitAny: Better Auth storage type is flexible
-        storage: storage as any,
+        storage: storage as NonNullable<Parameters<typeof expoClient>[0]>["storage"],
         storagePrefix: config.storagePrefix ?? "terreno",
       }),
     ],

package/src/betterAuthSlice.test.ts

@@ -1,3 +1,4 @@
+// noExplicitAny: test mock typing
 // biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it, mock} from "bun:test";
 import {configureStore} from "@reduxjs/toolkit";

package/src/emptyApi.ts

@@ -207,8 +207,7 @@ export const getBaseQuery = (
         return result;
       }
     },
-    // biome-ignore lint/suspicious/noExplicitAny: Weird typing from rtk query
-  })(args, api, extraOptions as any);
+  })(args, api, extraOptions as Parameters<ReturnType<typeof fetchBaseQuery>>[2]);
 };
 
 export const staggeredBaseQuery = retry(
@@ -355,8 +354,10 @@ export const emptySplitApi = createApi({
         url: "/version-check",
       }),
     }),
-    // biome-ignore lint/suspicious/noExplicitAny: Generic
-    ...generateProfileEndpoints(builder as any, "users"), // using 'users' here since it is highly intertwined with Users
+    ...generateProfileEndpoints(
+      builder as unknown as Parameters<typeof generateProfileEndpoints>[0],
+      "users"
+    ), // using 'users' here since it is highly intertwined with Users
   }),
   reducerPath: "terreno-rtk",
 });

package/src/isolated/constants.isolated.ts

@@ -0,0 +1,118 @@
+/**
+ * In-process isolated coverage for constants.ts module-load debug paths.
+ *
+ * The base test suite loads constants.ts once with debug flags disabled, so the
+ * enable-time branches (AUTH_DEBUG / WEBSOCKETS_DEBUG log lines and the Expo
+ * tunnel warning) never execute under coverage. Here we re-mock expo-constants
+ * with every flag enabled and re-import the module through a cache-busting query
+ * so its top-level runs again while coverage instrumentation is active.
+ */
+import {beforeEach, describe, it, mock} from "bun:test";
+import {assert} from "chai";
+
+interface ConstantsModule {
+  AUTH_DEBUG: boolean;
+  logAuth: (...args: string[]) => void;
+  logSocket: (
+    user?: {featureFlags?: {debugWebsockets?: {enabled?: boolean}}} | boolean,
+    ...args: string[]
+  ) => void;
+  isWebsocketsDebugEnabled: () => boolean;
+}
+
+const loadWithEnabledFlags = async (): Promise<{
+  module: ConstantsModule;
+  debugCalls: unknown[][];
+  errorCalls: unknown[][];
+  infoCalls: unknown[][];
+}> => {
+  mock.module("expo-constants", () => ({
+    default: {
+      expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}},
+      expoGoConfig: {debuggerHost: "abc.exp.direct"},
+    },
+  }));
+
+  const debugCalls: unknown[][] = [];
+  const errorCalls: unknown[][] = [];
+  const infoCalls: unknown[][] = [];
+  const originalDebug = console.debug;
+  const originalError = console.error;
+  const originalInfo = console.info;
+  console.debug = (...args: unknown[]): void => {
+    debugCalls.push(args);
+  };
+  console.error = (...args: unknown[]): void => {
+    errorCalls.push(args);
+  };
+  console.info = (...args: unknown[]): void => {
+    infoCalls.push(args);
+  };
+
+  try {
+    const constantsUrl = new URL("../constants.ts", import.meta.url).href;
+    const module = (await import(`${constantsUrl}?enabledFlags`)) as ConstantsModule;
+    return {debugCalls, errorCalls, infoCalls, module};
+  } finally {
+    console.debug = originalDebug;
+    console.error = originalError;
+    console.info = originalInfo;
+  }
+};
+
+describe("constants module-load debug paths", () => {
+  beforeEach(() => {
+    mock.restore();
+  });
+
+  it("logs debug lines and the tunnel warning when every flag is enabled", async () => {
+    const {module, debugCalls, errorCalls} = await loadWithEnabledFlags();
+
+    assert.isTrue(module.AUTH_DEBUG);
+    assert.isTrue(module.isWebsocketsDebugEnabled());
+    assert.isTrue(
+      debugCalls.some((args) =>
+        args.some((value) => String(value).includes("AUTH_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      debugCalls.some((args) =>
+        args.some((value) => String(value).includes("WEBSOCKETS_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      errorCalls.some((args) =>
+        args.some((value) => String(value).includes("Expo Tunnel is not currently"))
+      )
+    );
+  });
+
+  it("routes logAuth and logSocket through console when flags are enabled", async () => {
+    const {module} = await loadWithEnabledFlags();
+
+    const debugCalls: unknown[][] = [];
+    const infoCalls: unknown[][] = [];
+    const originalDebug = console.debug;
+    const originalInfo = console.info;
+    console.debug = (...args: unknown[]): void => {
+      debugCalls.push(args);
+    };
+    console.info = (...args: unknown[]): void => {
+      infoCalls.push(args);
+    };
+    try {
+      module.logAuth("auth message");
+      module.logSocket(undefined, "socket message");
+    } finally {
+      console.debug = originalDebug;
+      console.info = originalInfo;
+    }
+
+    assert.isTrue(
+      debugCalls.some((args) => args.some((value) => String(value).includes("auth message")))
+    );
+    assert.isTrue(
+      infoCalls.some((args) => args[0] === "[websocket]" && args[1] === "socket message")
+    );
+  });
+});

package/src/isolated/offlineMiddleware.isolated.ts

@@ -89,8 +89,7 @@ const api = createApi({
 
 const createTestStore = (endpoints = ["postTodos", "patchTodosById", "deleteTodosById"]) => {
   const offline = createOfflineMiddleware({
-    // biome-ignore lint/suspicious/noExplicitAny: Generic API type is intentionally broad.
-    api: api as any,
+    api: api as unknown as Parameters<typeof createOfflineMiddleware>[0]["api"],
     endpoints,
   });
 

package/src/isolated/offlineMiddleware.native.isolated.ts

@@ -45,8 +45,7 @@ const api = createApi({
 
 const createNativeStore = () => {
   const offline = createOfflineMiddleware({
-    // biome-ignore lint/suspicious/noExplicitAny: Generic API type is intentionally broad.
-    api: api as any,
+    api: api as unknown as Parameters<typeof createOfflineMiddleware>[0]["api"],
     endpoints: ["patchTodosById"],
   });
 

package/src/isolated/useUpgradeCheck.mobile.isolated.ts

@@ -195,6 +195,66 @@ describe("useUpgradeCheck (mobile)", () => {
     });
   });
 
+  describe("recheckOnForeground", () => {
+    it("re-checks when the app returns to the foreground", async () => {
+      const {result} = renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      expect(result.current).toBeDefined();
+      expect(appStateListeners.length).toBeGreaterThan(0);
+      const initialCalls = mockTrigger.mock.calls.length;
+
+      await act(async () => {
+        // First go to the background, then return to the foreground: the
+        // background transition primes appState.current so the subsequent
+        // active transition satisfies the wasBackground && isNowActive guard.
+        for (const listener of appStateListeners) {
+          listener("background");
+        }
+        for (const listener of appStateListeners) {
+          listener("active");
+        }
+        await flushPromises();
+      });
+
+      expect(mockTrigger.mock.calls.length).toBeGreaterThan(initialCalls);
+    });
+
+    it("does not re-check when the app stays inactive", async () => {
+      renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      const initialCalls = mockTrigger.mock.calls.length;
+
+      await act(async () => {
+        for (const listener of appStateListeners) {
+          listener("inactive");
+        }
+        await flushPromises();
+      });
+
+      expect(mockTrigger.mock.calls.length).toBe(initialCalls);
+    });
+
+    it("removes the AppState subscription on unmount", async () => {
+      const {unmount} = renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      mockRemove.mockClear();
+      unmount();
+      expect(mockRemove).toHaveBeenCalled();
+    });
+  });
+
   describe("canUpdate", () => {
     it("is false on mobile when updateUrl is not set", () => {
       const {result} = renderHook(() => useUpgradeCheck());

package/src/offlineGate.ts

@@ -13,8 +13,7 @@ export const configureOfflineMutationEndpoints = (endpoints: string[]): void =>
  */
 export const shouldDeferOfflineMutation = (
   endpointName: string,
-  // biome-ignore lint/suspicious/noExplicitAny: Redux getState is app-specific
-  getState: () => any
+  getState: () => unknown
 ): boolean => {
   if (!offlineMutationEndpoints.has(endpointName)) {
     return false;

package/src/offlineMiddleware.test.ts

@@ -1,4 +1,4 @@
-import {describe, expect, it} from "bun:test";
+import {describe, expect, it, mock} from "bun:test";
 import {configureStore, type UnknownAction} from "@reduxjs/toolkit";
 import type {Api} from "@reduxjs/toolkit/query/react";
 
@@ -10,6 +10,9 @@ import {
 } from "./offlineMiddleware";
 import {type OfflineState, type QueuedMutation, selectOfflineQueue} from "./offlineSlice";
 
+// Force IsWeb=true regardless of load order with the native test files.
+mock.module("./platform", () => ({IsWeb: true}));
+
 interface QueryEntry {
   data?: {data: Record<string, unknown>[]};
   originalArgs: unknown;
@@ -47,6 +50,7 @@ const initialTestApiState: TestApiState = {
 
 const testApiReducer = (state: TestApiState = initialTestApiState): TestApiState => state;
 
+// noExplicitAny: Test double covers only fields used by offline middleware.
 // biome-ignore lint/suspicious/noExplicitAny: Test double covers only fields used by offline middleware.
 const createTestApi = (): Api<any, any, any, any> => {
   return {
@@ -66,6 +70,7 @@ const createTestApi = (): Api<any, any, any, any> => {
       invalidateTags: () => ({type: "testApi/invalidateTags"}),
       updateQueryData: () => ({type: "testApi/updateQueryData"}),
     },
+    // noExplicitAny: Test double covers only fields used by offline middleware.
     // biome-ignore lint/suspicious/noExplicitAny: Test double covers only fields used by offline middleware.
   } as unknown as Api<any, any, any, any>;
 };

package/src/offlineMiddleware.ts

@@ -28,6 +28,7 @@ export interface OfflineMiddlewareConfig {
   /** RTK Query mutation endpoint names to queue when offline */
   endpoints: string[];
   /** The RTK Query API instance */
+  // noExplicitAny: Generic API type
   // biome-ignore lint/suspicious/noExplicitAny: Generic API type
   api: Api<any, any, any, any>;
 }
@@ -54,6 +55,7 @@ const inferMutationType = (endpointName: string): "create" | "update" | "delete"
  * not an auth or application-level FETCH_ERROR from emptyApi.
  */
 export const isNetworkFetchError = (
+  // noExplicitAny: RTK Query error shapes vary by source
   // biome-ignore lint/suspicious/noExplicitAny: RTK Query error shapes vary by source
   source: any
 ): boolean => {
@@ -141,8 +143,10 @@ const inferGetByIdEndpointName = (endpointName: string): string => {
 const extractBaseUpdatedAt = (
   endpointName: string,
   originalArgs: unknown,
+  // noExplicitAny: Generic getState
   // biome-ignore lint/suspicious/noExplicitAny: Generic getState
   getState: () => any,
+  // noExplicitAny: Generic API type
   // biome-ignore lint/suspicious/noExplicitAny: Generic API type
   api: Api<any, any, any, any>
 ): string | undefined => {
@@ -162,6 +166,7 @@ const extractBaseUpdatedAt = (
 
   const getByIdEndpoint = inferGetByIdEndpointName(endpointName);
   const state = getState();
+  // noExplicitAny: RTK Query internal state shape
   // biome-ignore lint/suspicious/noExplicitAny: RTK Query internal state shape
   const queries: Record<string, any> = state[api.reducerPath]?.queries ?? {};
   for (const key of Object.keys(queries)) {
@@ -188,13 +193,16 @@ const extractBaseUpdatedAt = (
  * args the consumer passed to the query hook, e.g. `{}` vs `undefined`).
  */
 const getCachedQueryArgs = (
+  // noExplicitAny: Generic API state shape
   // biome-ignore lint/suspicious/noExplicitAny: Generic API state shape
   getState: () => any,
+  // noExplicitAny: Generic API type
   // biome-ignore lint/suspicious/noExplicitAny: Generic API type
   api: Api<any, any, any, any>,
   listEndpointName: string
 ): unknown[] => {
   const state = getState();
+  // noExplicitAny: RTK Query internal state shape
   // biome-ignore lint/suspicious/noExplicitAny: RTK Query internal state shape
   const queries: Record<string, any> = state[api.reducerPath]?.queries ?? {};
   const cachedArgs: unknown[] = [];
@@ -213,10 +221,13 @@ const getCachedQueryArgs = (
  * Apply an optimistic update to the RTK Query cache for a queued mutation.
  */
 const applyOptimisticUpdate = (
+  // noExplicitAny: Generic API type
   // biome-ignore lint/suspicious/noExplicitAny: Generic API type
   api: Api<any, any, any, any>,
+  // noExplicitAny: Generic dispatch
   // biome-ignore lint/suspicious/noExplicitAny: Generic dispatch
   dispatch: any,
+  // noExplicitAny: Generic getState
   // biome-ignore lint/suspicious/noExplicitAny: Generic getState
   getState: () => any,
   mutation: QueuedMutation
@@ -225,10 +236,12 @@ const applyOptimisticUpdate = (
   const listEndpointName = `get${tagType.charAt(0).toUpperCase() + tagType.slice(1)}`;
   const cachedArgs = getCachedQueryArgs(getState, api, listEndpointName);
 
+  // noExplicitAny: RTK Query cache shape varies by endpoint
   // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
   const updateAllCacheEntries = (updater: (draft: any) => void): void => {
     for (const queryArg of cachedArgs) {
       dispatch(
+        // noExplicitAny: RTK Query cache shape varies by endpoint
         // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
         api.util.updateQueryData(listEndpointName as any, queryArg, updater)
       );
@@ -238,6 +251,7 @@ const applyOptimisticUpdate = (
   if (mutation.type === "create") {
     const args = mutation.args as {body?: Record<string, unknown>};
     const tempItem = buildOptimisticCreateItem(mutation, args?.body);
+    // noExplicitAny: RTK Query cache shape varies by endpoint
     // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
     updateAllCacheEntries((draft: any) => {
       if (draft?.data && Array.isArray(draft.data)) {
@@ -247,6 +261,7 @@ const applyOptimisticUpdate = (
   } else if (mutation.type === "update") {
     const args = mutation.args as {id?: string; body?: Record<string, unknown>};
     if (args?.id && args?.body) {
+      // noExplicitAny: RTK Query cache shape varies by endpoint
       // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
       updateAllCacheEntries((draft: any) => {
         if (draft?.data && Array.isArray(draft.data)) {
@@ -262,6 +277,7 @@ const applyOptimisticUpdate = (
   } else if (mutation.type === "delete") {
     const args = mutation.args as {id?: string};
     if (args?.id) {
+      // noExplicitAny: RTK Query cache shape varies by endpoint
       // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
       updateAllCacheEntries((draft: any) => {
         if (draft?.data && Array.isArray(draft.data)) {
@@ -278,10 +294,13 @@ const applyOptimisticUpdate = (
  * Remove optimistic temp items from the cache after they've been replayed.
  */
 const removeTempItems = (
+  // noExplicitAny: Generic API type
   // biome-ignore lint/suspicious/noExplicitAny: Generic API type
   api: Api<any, any, any, any>,
+  // noExplicitAny: Generic dispatch
   // biome-ignore lint/suspicious/noExplicitAny: Generic dispatch
   dispatch: any,
+  // noExplicitAny: Generic getState
   // biome-ignore lint/suspicious/noExplicitAny: Generic getState
   getState: () => any,
   mutations: QueuedMutation[]
@@ -295,6 +314,7 @@ const removeTempItems = (
 
     for (const queryArg of cachedArgs) {
       dispatch(
+        // noExplicitAny: RTK Query cache shape varies by endpoint
         // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies by endpoint
         api.util.updateQueryData(listEndpointName as any, queryArg, (draft: any) => {
           if (draft?.data && Array.isArray(draft.data)) {
@@ -369,6 +389,7 @@ const replayMutation = async (
  * Web apps should use `useServerStatus` for server-level health checking.
  */
 const setupNativeNetworkMonitoring = (
+  // noExplicitAny: Generic dispatch
   // biome-ignore lint/suspicious/noExplicitAny: Generic dispatch
   dispatch: any
 ): (() => void) => {
@@ -438,6 +459,7 @@ export const createOfflineMiddleware = (
   // RTK Query dispatches actions with type "terreno-rtk/executeMutation/rejected"
   // when a mutation fails. Queue the mutation and apply an optimistic cache update.
   listenerMiddleware.startListening({
+    // noExplicitAny: RTK Query action types are complex
     // biome-ignore lint/suspicious/noExplicitAny: RTK Query action types are complex
     effect: async (action: any, listenerApi) => {
       const state = listenerApi.getState() as {offline: OfflineState};
@@ -464,11 +486,13 @@ export const createOfflineMiddleware = (
           const listEndpointName = `get${tagType.charAt(0).toUpperCase() + tagType.slice(1)}`;
           const cachedArgs = getCachedQueryArgs(listenerApi.getState, api, listEndpointName);
           for (const queryArg of cachedArgs) {
+            // noExplicitAny: RTK Query cache shape and endpoint types vary
             // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape and endpoint types vary
             const endpoint = (api.endpoints as any)[listEndpointName];
             if (!endpoint?.select) {
               continue;
             }
+            // noExplicitAny: RTK Query cache shape varies
             // biome-ignore lint/suspicious/noExplicitAny: RTK Query cache shape varies
             const cacheEntry = endpoint.select(queryArg)(listenerApi.getState() as any) as any;
             const items = cacheEntry?.data?.data;
@@ -513,6 +537,7 @@ export const createOfflineMiddleware = (
         listenerApi.dispatch(setOnlineStatus(false));
       }
     },
+    // noExplicitAny: RTK Query internal action shape
     // biome-ignore lint/suspicious/noExplicitAny: RTK Query internal action shape
     predicate: (action: any) => {
       if (typeof action?.type !== "string") {
@@ -535,6 +560,7 @@ export const createOfflineMiddleware = (
         listenerApi.dispatch(setOnlineStatus(false));
       }
     },
+    // noExplicitAny: RTK Query internal action shape
     // biome-ignore lint/suspicious/noExplicitAny: RTK Query internal action shape
     predicate: (action: any) => {
       if (typeof action?.type !== "string") {
@@ -557,6 +583,7 @@ export const createOfflineMiddleware = (
         listenerApi.dispatch(setOnlineStatus(true));
       }
     },
+    // noExplicitAny: RTK Query internal action shape
     // biome-ignore lint/suspicious/noExplicitAny: RTK Query internal action shape
     predicate: (action: any) => {
       if (typeof action?.type !== "string") {

package/src/realtime.test.ts

@@ -1,3 +1,4 @@
+// noExplicitAny: realtime RTK tests mock Socket.io and RTK Query runtime shapes
 // biome-ignore-all lint/suspicious/noExplicitAny: realtime RTK tests mock Socket.io and RTK Query runtime shapes
 import {afterEach, describe, expect, it} from "bun:test";
 import type {Socket} from "socket.io-client";

package/src/sessionApi.test.ts

@@ -0,0 +1,115 @@
+import {afterEach, describe, expect, it, mock} from "bun:test";
+import {configureStore} from "@reduxjs/toolkit";
+
+import {createSessionApi} from "./sessionApi";
+
+type FetchArgs = Parameters<typeof fetch>;
+
+interface RecordedFetch {
+  urls: string[];
+  handler: (input: FetchArgs[0], init: FetchArgs[1]) => Response;
+}
+
+const jsonResponse = (body: unknown, status = 200): Response =>
+  new Response(JSON.stringify(body), {
+    headers: {"Content-Type": "application/json"},
+    status,
+  });
+
+const originalFetch = global.fetch;
+let recorded: RecordedFetch;
+
+const setFetch = (handler: RecordedFetch["handler"]): void => {
+  recorded = {handler, urls: []};
+  global.fetch = mock((input: FetchArgs[0], init: FetchArgs[1]) => {
+    const url =
+      typeof input === "string" ? input : input instanceof Request ? input.url : String(input);
+    recorded.urls.push(url);
+    return Promise.resolve(handler(input, init));
+  }) as unknown as typeof fetch;
+};
+
+const buildStore = () => {
+  const api = createSessionApi({baseUrl: "http://localhost:9999"});
+  const withEndpoints = api.injectEndpoints({
+    endpoints: (build) => ({
+      getThing: build.query<unknown, void>({query: () => "/thing"}),
+      getWithParams: build.query<unknown, void>({
+        query: () => ({params: {ids: {$in: [1, 2]}, status: "active"}, url: "/things"}),
+      }),
+    }),
+    overrideExisting: true,
+  });
+  const store = configureStore({
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(api.middleware),
+    reducer: {[api.reducerPath]: api.reducer},
+  });
+  return {api, store, withEndpoints};
+};
+
+describe("createSessionApi", () => {
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it("defaults reducerPath to terreno-session", () => {
+    const api = createSessionApi();
+    expect(api.reducerPath).toBe("terreno-session");
+  });
+
+  it("uses a custom reducerPath when provided", () => {
+    const api = createSessionApi({reducerPath: "admin-session"});
+    expect(api.reducerPath).toBe("admin-session");
+  });
+
+  describe("responseHandler", () => {
+    it("returns null for a 204 No Content response", async () => {
+      setFetch(() => new Response(null, {status: 204}));
+      const {store, withEndpoints} = buildStore();
+
+      const result = await store.dispatch(withEndpoints.endpoints.getThing.initiate());
+
+      expect(result.error).toBeUndefined();
+      expect(result.data).toBeNull();
+    });
+
+    it("returns the whole payload for list responses containing `more`", async () => {
+      const payload = {data: [{id: "1"}], more: false, page: 1};
+      setFetch(() => jsonResponse(payload));
+      const {store, withEndpoints} = buildStore();
+
+      const result = await store.dispatch(withEndpoints.endpoints.getThing.initiate());
+
+      expect(result.data).toEqual(payload);
+    });
+
+    it("unwraps the `data` envelope for single-resource responses", async () => {
+      setFetch(() => jsonResponse({data: {id: "42", name: "answer"}}));
+      const {store, withEndpoints} = buildStore();
+
+      const result = await store.dispatch(withEndpoints.endpoints.getThing.initiate());
+
+      expect(result.data).toEqual({id: "42", name: "answer"});
+    });
+
+    it("returns the raw result when there is no `data` envelope or `more` field", async () => {
+      setFetch(() => jsonResponse({id: "7", name: "raw"}));
+      const {store, withEndpoints} = buildStore();
+
+      const result = await store.dispatch(withEndpoints.endpoints.getThing.initiate());
+
+      expect(result.data).toEqual({id: "7", name: "raw"});
+    });
+  });
+
+  it("serializes nested query params with qs", async () => {
+    setFetch(() => jsonResponse({id: "1"}));
+    const {store, withEndpoints} = buildStore();
+
+    await store.dispatch(withEndpoints.endpoints.getWithParams.initiate());
+
+    const requestedUrl = recorded.urls[0];
+    expect(requestedUrl).toContain("ids%5B%24in%5D%5B0%5D=1");
+    expect(requestedUrl).toContain("status=active");
+  });
+});

package/src/sync.test.ts

@@ -87,8 +87,7 @@ const createApi = (queries: Record<string, QueryEntry> | null) => {
 
 const renderSync = (
   socket: FakeSocket | null,
-  // biome-ignore lint/suspicious/noExplicitAny: test-only structural RTK Query api stub
-  api: any,
+  api: ReturnType<typeof createApi>["api"],
   store: ReturnType<typeof configureStore>,
   options: {tagTypes?: string[]; debug?: boolean} = {}
 ) => {

package/src/sync.ts

@@ -40,7 +40,8 @@ interface UseSyncConnectionOptions {
   /** Socket.io client instance (from useSocketConnection) */
   socket: Socket | null;
   /** RTK Query API instance (the enhanced API with tag types) */
-  // biome-ignore lint/suspicious/noExplicitAny: noExplicitAny: RTK Query Api generic requires four app-specific type parameters
+  // noExplicitAny: RTK Query Api generic requires four app-specific type parameters
+  // biome-ignore lint/suspicious/noExplicitAny: RTK Query Api generic requires four app-specific type parameters
   api: any;
   /** Tag types to listen for (e.g. ["todos", "users"]) — these should match the collection field in events */
   tagTypes: string[];

package/src/testPreload.test.ts

@@ -23,6 +23,13 @@ describe("test-preload default mocks", () => {
     expect(state.isConnected).toBe(true);
   });
 
+  it("expo-network mock exposes addNetworkStateListener", async () => {
+    const network = await import("expo-network");
+    const subscription = network.addNetworkStateListener(() => {});
+    expect(subscription.remove).toBeTypeOf("function");
+    subscription.remove();
+  });
+
   it("expo-constants mock exposes an empty config", async () => {
     const Constants = (await import("expo-constants")).default;
     expect(Constants.expoConfig?.extra).toBeDefined();