@terreno/rtk 0.10.0 → 0.11.1

package/src/betterAuthClient.test.ts

@@ -0,0 +1,176 @@
+import {afterAll, afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+
+type ExpoOptions = {
+  scheme?: string;
+  storagePrefix?: string;
+  storage?: {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+  };
+};
+
+const captured: {expo: ExpoOptions | null; auth: Record<string, unknown> | null} = {
+  auth: null,
+  expo: null,
+};
+
+mock.module("@better-auth/expo/client", () => ({
+  expoClient: (options: ExpoOptions) => {
+    captured.expo = options;
+    return {name: "expo-plugin"};
+  },
+}));
+
+mock.module("better-auth/react", () => ({
+  createAuthClient: (config: Record<string, unknown>) => {
+    captured.auth = config;
+    return {clientId: "mock-client", config};
+  },
+}));
+
+const secureCalls = {
+  delete: [] as string[],
+  get: [] as string[],
+  set: [] as Array<[string, string]>,
+};
+const resetSecureCalls = (): void => {
+  secureCalls.delete = [];
+  secureCalls.get = [];
+  secureCalls.set = [];
+};
+
+mock.module("expo-secure-store", () => ({
+  deleteItemAsync: async (key: string): Promise<void> => {
+    secureCalls.delete.push(key);
+  },
+  getItemAsync: async (key: string): Promise<string | null> => {
+    secureCalls.get.push(key);
+    return `secure-${key}`;
+  },
+  setItemAsync: async (key: string, value: string): Promise<void> => {
+    secureCalls.set.push([key, value]);
+  },
+}));
+
+const AsyncStorage = (await import("@react-native-async-storage/async-storage")).default;
+const {createBetterAuthClient, createStorageAdapter} = await import("./betterAuthClient");
+
+describe("createStorageAdapter (web)", () => {
+  const globalWithWindow = globalThis as {window?: unknown};
+  const originalGet = AsyncStorage.getItem;
+  const originalSet = AsyncStorage.setItem;
+  const originalRemove = AsyncStorage.removeItem;
+  const calls = {get: [] as string[], remove: [] as string[], set: [] as Array<[string, string]>};
+  let originalWindow: unknown;
+
+  beforeEach(() => {
+    originalWindow = globalWithWindow.window;
+    calls.get = [];
+    calls.remove = [];
+    calls.set = [];
+    AsyncStorage.getItem = async (key: string): Promise<string | null> => {
+      calls.get.push(key);
+      return `async-${key}`;
+    };
+    AsyncStorage.setItem = async (key: string, value: string): Promise<void> => {
+      calls.set.push([key, value]);
+    };
+    AsyncStorage.removeItem = async (key: string): Promise<void> => {
+      calls.remove.push(key);
+    };
+  });
+
+  afterEach(() => {
+    AsyncStorage.getItem = originalGet;
+    AsyncStorage.setItem = originalSet;
+    AsyncStorage.removeItem = originalRemove;
+    if (typeof originalWindow === "undefined") {
+      delete globalWithWindow.window;
+    } else {
+      globalWithWindow.window = originalWindow;
+    }
+  });
+
+  it("reads, writes, and removes via AsyncStorage when window exists", async () => {
+    globalWithWindow.window = {};
+    const adapter = createStorageAdapter(true);
+    await expect(adapter.getItem("k")).resolves.toBe("async-k");
+    await adapter.setItem("a", "b");
+    await adapter.removeItem?.("c");
+    expect(calls.get).toEqual(["k"]);
+    expect(calls.set).toEqual([["a", "b"]]);
+    expect(calls.remove).toEqual(["c"]);
+  });
+
+  it("returns null/void without touching AsyncStorage in SSR (no window)", async () => {
+    delete globalWithWindow.window;
+    const adapter = createStorageAdapter(true);
+    await expect(adapter.getItem("k")).resolves.toBeNull();
+    await expect(adapter.setItem("a", "b")).resolves.toBeUndefined();
+    await expect(adapter.removeItem?.("c")).resolves.toBeUndefined();
+    expect(calls.get).toEqual([]);
+    expect(calls.set).toEqual([]);
+    expect(calls.remove).toEqual([]);
+  });
+});
+
+describe("createStorageAdapter (native)", () => {
+  beforeEach(() => {
+    resetSecureCalls();
+  });
+
+  it("routes reads, writes, and deletes through SecureStore", async () => {
+    const adapter = createStorageAdapter(false);
+    await expect(adapter.getItem("auth")).resolves.toBe("secure-auth");
+    await adapter.setItem("auth", "token");
+    await adapter.removeItem?.("auth");
+    expect(secureCalls.get).toEqual(["auth"]);
+    expect(secureCalls.set).toEqual([["auth", "token"]]);
+    expect(secureCalls.delete).toEqual(["auth"]);
+  });
+});
+
+describe("createBetterAuthClient", () => {
+  beforeEach(() => {
+    captured.auth = null;
+    captured.expo = null;
+  });
+
+  afterAll(() => {
+    // Restore the test-preload mocks so later test files aren't polluted.
+    mock.module("@better-auth/expo/client", () => ({
+      expoClient: () => ({name: "expo-plugin"}),
+    }));
+    mock.module("better-auth/react", () => ({
+      createAuthClient: () => ({}),
+    }));
+    mock.module("expo-secure-store", () => ({
+      deleteItemAsync: async () => {},
+      getItemAsync: async () => null,
+      setItemAsync: async () => {},
+    }));
+  });
+
+  it("passes baseURL and scheme through to the Better Auth client", () => {
+    const client = createBetterAuthClient({
+      baseURL: "http://localhost:3000",
+      scheme: "terreno",
+    });
+    expect(captured.auth).not.toBeNull();
+    expect(captured.auth?.baseURL).toBe("http://localhost:3000");
+    expect(captured.expo?.scheme).toBe("terreno");
+    expect(captured.expo?.storagePrefix).toBe("terreno");
+    expect(captured.expo?.storage).toBeDefined();
+    expect(client).toBeDefined();
+  });
+
+  it("uses a custom storagePrefix when provided", () => {
+    createBetterAuthClient({
+      baseURL: "http://localhost:3000",
+      scheme: "terreno",
+      storagePrefix: "custom",
+    });
+    expect(captured.expo?.storagePrefix).toBe("custom");
+  });
+});

package/src/betterAuthClient.ts

@@ -24,7 +24,7 @@ export type {
 /**
  * Storage adapter interface matching what Better Auth expects.
  */
-interface StorageAdapter {
+export interface StorageAdapter {
   setItem: (key: string, value: string) => void | Promise<void>;
   getItem: (key: string) => string | null | Promise<string | null>;
   removeItem?: (key: string) => void | Promise<void>;
@@ -33,9 +33,12 @@ interface StorageAdapter {
 /**
  * Async storage adapter for Better Auth that works on both web and native.
  * Uses SecureStore on native platforms and AsyncStorage on web.
+ *
+ * `isWeb` is exposed as a parameter so the adapter can be unit tested
+ * without having to re-load the module for each platform.
  */
-const createStorageAdapter = (): StorageAdapter => {
-  if (IsWeb) {
+export const createStorageAdapter = (isWeb: boolean = IsWeb): StorageAdapter => {
+  if (isWeb) {
     return {
       getItem: (key: string): Promise<string | null> => {
         if (typeof window !== "undefined") {

package/src/betterAuthSlice.test.ts

@@ -6,6 +6,7 @@ import {
   selectBetterAuthError,
   selectBetterAuthIsAuthenticated,
   selectBetterAuthIsLoading,
+  selectBetterAuthState,
   selectBetterAuthUser,
   selectBetterAuthUserId,
 } from "./betterAuthSlice";
@@ -302,6 +303,66 @@ describe("generateBetterAuthSlice", () => {
     expect(mockAuthClient.signOut).toHaveBeenCalledTimes(1);
   });
 
+  it("logs and swallows signOut errors triggered by the slice logout action", async () => {
+    mockAuthClient.signOut = mock(() =>
+      Promise.reject(new Error("slice-signout-fail"))
+    ) as unknown as typeof mockAuthClient.signOut;
+    const originalError = console.error;
+    const errorCalls: unknown[][] = [];
+    console.error = (...args: unknown[]): void => {
+      errorCalls.push(args);
+    };
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+    const store = configureStore({
+      middleware: (getDefaultMiddleware) =>
+        getDefaultMiddleware().concat(...betterAuthSlice.middleware),
+      reducer: {betterAuth: betterAuthSlice.reducer},
+    });
+
+    try {
+      store.dispatch(betterAuthSlice.actions.logout());
+      await Promise.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const logged = errorCalls.find((args) =>
+        args.some((v) => typeof v === "string" && v.includes("Error signing out"))
+      );
+      expect(logged).toBeDefined();
+    } finally {
+      console.error = originalError;
+    }
+  });
+
+  it("logs and swallows signOut errors triggered by the global auth/logout action", async () => {
+    mockAuthClient.signOut = mock(() =>
+      Promise.reject(new Error("global-signout-fail"))
+    ) as unknown as typeof mockAuthClient.signOut;
+    const originalError = console.error;
+    const errorCalls: unknown[][] = [];
+    console.error = (...args: unknown[]): void => {
+      errorCalls.push(args);
+    };
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+    const store = configureStore({
+      middleware: (getDefaultMiddleware) =>
+        getDefaultMiddleware().concat(...betterAuthSlice.middleware),
+      reducer: {betterAuth: betterAuthSlice.reducer},
+    });
+
+    try {
+      store.dispatch({type: "auth/logout"});
+      await Promise.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const logged = errorCalls.find((args) =>
+        args.some((v) => typeof v === "string" && v.includes("Error signing out"))
+      );
+      expect(logged).toBeDefined();
+    } finally {
+      console.error = originalError;
+    }
+  });
+
   it("global auth/logout action signs out and clears session", async () => {
     // biome-ignore lint/suspicious/noExplicitAny: Mock client type
     const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
@@ -397,6 +458,12 @@ describe("Better Auth selectors", () => {
     expect(selectBetterAuthIsLoading(emptyState)).toBe(false);
     expect(selectBetterAuthError(emptyState)).toBeNull();
   });
+
+  it("selectBetterAuthState returns the raw betterAuth slice of state", () => {
+    expect(selectBetterAuthState(createMockState({userId: "user-zzz"}))?.userId).toBe("user-zzz");
+    // biome-ignore lint/suspicious/noExplicitAny: Test empty state
+    expect(selectBetterAuthState({} as any)).toBeUndefined();
+  });
 });
 
 describe("BetterAuthUser interface", () => {

package/src/buildNumber.test.ts

@@ -0,0 +1,120 @@
+import {afterAll, beforeEach, describe, expect, it} from "bun:test";
+
+import {coerceBuildNumber, resolveBuildNumber} from "./buildNumber";
+
+describe("coerceBuildNumber", () => {
+  it("returns undefined for undefined", () => {
+    expect(coerceBuildNumber(undefined)).toBeUndefined();
+  });
+
+  it("returns undefined for null", () => {
+    expect(coerceBuildNumber(null)).toBeUndefined();
+  });
+
+  it("returns the number for a valid positive integer", () => {
+    expect(coerceBuildNumber(42)).toBe(42);
+  });
+
+  it("returns the number for zero", () => {
+    expect(coerceBuildNumber(0)).toBe(0);
+  });
+
+  it("returns undefined for NaN", () => {
+    expect(coerceBuildNumber(Number.NaN)).toBeUndefined();
+  });
+
+  it("returns undefined for Infinity", () => {
+    expect(coerceBuildNumber(Number.POSITIVE_INFINITY)).toBeUndefined();
+  });
+
+  it("parses a valid numeric string", () => {
+    expect(coerceBuildNumber("123")).toBe(123);
+  });
+
+  it("returns undefined for a non-numeric string", () => {
+    expect(coerceBuildNumber("abc")).toBeUndefined();
+  });
+
+  it("returns the number for a negative integer", () => {
+    expect(coerceBuildNumber(-5)).toBe(-5);
+  });
+
+  it("parses a string with leading zeros", () => {
+    expect(coerceBuildNumber("007")).toBe(7);
+  });
+});
+
+describe("resolveBuildNumber", () => {
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    process.env = {...ORIGINAL_ENV};
+    delete process.env.EXPO_PUBLIC_BUILD_NUMBER;
+  });
+
+  afterAll(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  it("returns override when provided", () => {
+    expect(resolveBuildNumber({override: 99})).toBe(99);
+  });
+
+  it("returns configValue when override is not provided", () => {
+    expect(resolveBuildNumber({configValue: 50})).toBe(50);
+  });
+
+  it("returns env var when override and configValue are not provided", () => {
+    process.env.EXPO_PUBLIC_BUILD_NUMBER = "200";
+    expect(resolveBuildNumber()).toBe(200);
+  });
+
+  it("uses custom envVar name", () => {
+    process.env.CUSTOM_BUILD = "77";
+    expect(resolveBuildNumber({envVar: "CUSTOM_BUILD"})).toBe(77);
+  });
+
+  it("prefers override over configValue", () => {
+    expect(resolveBuildNumber({configValue: 10, override: 20})).toBe(20);
+  });
+
+  it("prefers configValue over env var", () => {
+    process.env.EXPO_PUBLIC_BUILD_NUMBER = "300";
+    expect(resolveBuildNumber({configValue: 15})).toBe(15);
+  });
+
+  it("falls back to git rev-list count when nothing else is set", () => {
+    const result = resolveBuildNumber();
+    // In a git repo, this should return a positive integer
+    expect(typeof result).toBe("number");
+    expect(result).toBeGreaterThan(0);
+  });
+
+  it("skips invalid env var values and falls through to git", () => {
+    process.env.EXPO_PUBLIC_BUILD_NUMBER = "not-a-number";
+    // Should fall through past the env var to git
+    const result = resolveBuildNumber();
+    expect(typeof result).toBe("number");
+    expect(result).toBeGreaterThan(0);
+  });
+
+  it("skips undefined override and uses configValue", () => {
+    expect(resolveBuildNumber({configValue: 42, override: undefined})).toBe(42);
+  });
+
+  it("skips invalid configValue and uses env var", () => {
+    process.env.EXPO_PUBLIC_BUILD_NUMBER = "88";
+    expect(resolveBuildNumber({configValue: "bad"})).toBe(88);
+  });
+
+  it("returns a number with default options", () => {
+    const result = resolveBuildNumber();
+    expect(result).toBeDefined();
+    expect(typeof result).toBe("number");
+  });
+
+  it("prefers override over env var", () => {
+    process.env.EXPO_PUBLIC_BUILD_NUMBER = "999";
+    expect(resolveBuildNumber({override: 1})).toBe(1);
+  });
+});