@terreno/rtk 0.1.0 → 0.3.0

package/src/betterAuthSlice.test.ts

@@ -0,0 +1,329 @@
+import {beforeEach, describe, expect, it, mock} from "bun:test";
+import {
+  type BetterAuthState,
+  generateBetterAuthSlice,
+  selectBetterAuthError,
+  selectBetterAuthIsAuthenticated,
+  selectBetterAuthIsLoading,
+  selectBetterAuthUser,
+  selectBetterAuthUserId,
+} from "./betterAuthSlice";
+import type {BetterAuthClientConfig, BetterAuthUser} from "./betterAuthTypes";
+
+// Mock Better Auth client
+const createMockAuthClient = () => ({
+  getSession: mock(() =>
+    Promise.resolve({
+      data: {
+        session: {
+          createdAt: new Date(),
+          expiresAt: new Date(Date.now() + 3600000),
+          id: "session-456",
+          ipAddress: null,
+          updatedAt: new Date(),
+          userAgent: null,
+          userId: "user-123",
+        },
+        user: {
+          createdAt: new Date(),
+          email: "test@example.com",
+          emailVerified: true,
+          id: "user-123",
+          image: null,
+          name: "Test User",
+          updatedAt: new Date(),
+        },
+      },
+    })
+  ),
+  signIn: {
+    email: mock(() => Promise.resolve({data: {user: {id: "user-123"}}})),
+    social: mock(() => Promise.resolve({data: {user: {id: "user-123"}}})),
+  },
+  signOut: mock(() => Promise.resolve()),
+  signUp: {
+    email: mock(() => Promise.resolve({data: {user: {id: "user-123"}}})),
+  },
+});
+
+describe("BetterAuthClientConfig", () => {
+  it("defines config interface correctly", () => {
+    const config: BetterAuthClientConfig = {
+      baseURL: "http://localhost:3000",
+      scheme: "terreno",
+      storagePrefix: "myapp",
+    };
+
+    expect(config.baseURL).toBe("http://localhost:3000");
+    expect(config.scheme).toBe("terreno");
+    expect(config.storagePrefix).toBe("myapp");
+  });
+
+  it("allows minimal config without storagePrefix", () => {
+    const config: BetterAuthClientConfig = {
+      baseURL: "http://localhost:3000",
+      scheme: "terreno",
+    };
+
+    expect(config.storagePrefix).toBeUndefined();
+  });
+});
+
+describe("generateBetterAuthSlice", () => {
+  let mockAuthClient: ReturnType<typeof createMockAuthClient>;
+
+  beforeEach(() => {
+    mockAuthClient = createMockAuthClient();
+  });
+
+  it("creates a slice with initial state", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    const initialState = betterAuthSlice.reducer(undefined, {type: "@@INIT"});
+
+    expect(initialState.isAuthenticated).toBe(false);
+    expect(initialState.userId).toBeNull();
+    expect(initialState.user).toBeNull();
+    expect(initialState.isLoading).toBe(true);
+    expect(initialState.error).toBeNull();
+  });
+
+  it("setSession action updates state correctly", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    const user: BetterAuthUser = {
+      createdAt: new Date(),
+      email: "test@example.com",
+      emailVerified: true,
+      id: "user-123",
+      image: null,
+      name: "Test User",
+      updatedAt: new Date(),
+    };
+
+    const state = betterAuthSlice.reducer(
+      undefined,
+      betterAuthSlice.actions.setSession({user, userId: "user-123"})
+    );
+
+    expect(state.isAuthenticated).toBe(true);
+    expect(state.userId).toBe("user-123");
+    expect(state.user?.email).toBe("test@example.com");
+    expect(state.isLoading).toBe(false);
+    expect(state.error).toBeNull();
+  });
+
+  it("clearSession action resets state", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    // First set a session
+    let state = betterAuthSlice.reducer(
+      undefined,
+      betterAuthSlice.actions.setSession({
+        user: {
+          createdAt: new Date(),
+          email: "test@example.com",
+          emailVerified: true,
+          id: "user-123",
+          image: null,
+          name: "Test",
+          updatedAt: new Date(),
+        },
+        userId: "user-123",
+      })
+    );
+
+    // Then clear it
+    state = betterAuthSlice.reducer(state, betterAuthSlice.actions.clearSession());
+
+    expect(state.isAuthenticated).toBe(false);
+    expect(state.userId).toBeNull();
+    expect(state.user).toBeNull();
+  });
+
+  it("setLoading action updates loading state", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    let state = betterAuthSlice.reducer(undefined, betterAuthSlice.actions.setLoading(true));
+    expect(state.isLoading).toBe(true);
+
+    state = betterAuthSlice.reducer(state, betterAuthSlice.actions.setLoading(false));
+    expect(state.isLoading).toBe(false);
+  });
+
+  it("setError action updates error state", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    const state = betterAuthSlice.reducer(
+      undefined,
+      betterAuthSlice.actions.setError("Something went wrong")
+    );
+
+    expect(state.error).toBe("Something went wrong");
+    expect(state.isLoading).toBe(false);
+  });
+
+  it("logout action clears session state", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    // First set a session
+    let state = betterAuthSlice.reducer(
+      undefined,
+      betterAuthSlice.actions.setSession({
+        user: {
+          createdAt: new Date(),
+          email: "test@example.com",
+          emailVerified: true,
+          id: "user-123",
+          image: null,
+          name: "Test",
+          updatedAt: new Date(),
+        },
+        userId: "user-123",
+      })
+    );
+
+    // Then logout
+    state = betterAuthSlice.reducer(state, betterAuthSlice.actions.logout());
+
+    expect(state.isAuthenticated).toBe(false);
+    expect(state.userId).toBeNull();
+    expect(state.user).toBeNull();
+  });
+
+  it("returns middleware array", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    expect(Array.isArray(betterAuthSlice.middleware)).toBe(true);
+    expect(betterAuthSlice.middleware.length).toBeGreaterThan(0);
+  });
+
+  it("returns authClient reference", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type comparison
+    expect(betterAuthSlice.authClient).toBe(mockAuthClient as any);
+  });
+
+  it("syncSession function updates state from auth client", async () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mock client type
+    const betterAuthSlice = generateBetterAuthSlice({authClient: mockAuthClient as any});
+
+    // biome-ignore lint/suspicious/noExplicitAny: Test mock for dispatched actions
+    const dispatchedActions: any[] = [];
+    // biome-ignore lint/suspicious/noExplicitAny: Test mock dispatch function
+    const mockDispatch = (action: any) => {
+      dispatchedActions.push(action);
+    };
+
+    await betterAuthSlice.syncSession(mockDispatch);
+
+    // Should dispatch setLoading(true) then setSession
+    expect(dispatchedActions.length).toBeGreaterThanOrEqual(2);
+    expect(dispatchedActions[0].type).toBe("betterAuth/setLoading");
+  });
+});
+
+describe("Better Auth selectors", () => {
+  // biome-ignore lint/suspicious/noExplicitAny: Test mock state factory
+  const createMockState = (betterAuth: Partial<BetterAuthState> = {}): any => ({
+    betterAuth: {
+      error: null,
+      isAuthenticated: false,
+      isLoading: false,
+      lastSyncTimestamp: null,
+      user: null,
+      userId: null,
+      ...betterAuth,
+    },
+  });
+
+  it("selectBetterAuthIsAuthenticated returns correct value", () => {
+    expect(selectBetterAuthIsAuthenticated(createMockState({isAuthenticated: true}))).toBe(true);
+    expect(selectBetterAuthIsAuthenticated(createMockState({isAuthenticated: false}))).toBe(false);
+  });
+
+  it("selectBetterAuthUserId returns correct value", () => {
+    expect(selectBetterAuthUserId(createMockState({userId: "user-123"}))).toBe("user-123");
+    expect(selectBetterAuthUserId(createMockState({userId: null}))).toBeNull();
+  });
+
+  it("selectBetterAuthUser returns correct value", () => {
+    const user: BetterAuthUser = {
+      createdAt: new Date(),
+      email: "test@example.com",
+      emailVerified: true,
+      id: "user-123",
+      image: null,
+      name: "Test",
+      updatedAt: new Date(),
+    };
+
+    expect(selectBetterAuthUser(createMockState({user}))?.email).toBe("test@example.com");
+    expect(selectBetterAuthUser(createMockState({user: null}))).toBeNull();
+  });
+
+  it("selectBetterAuthIsLoading returns correct value", () => {
+    expect(selectBetterAuthIsLoading(createMockState({isLoading: true}))).toBe(true);
+    expect(selectBetterAuthIsLoading(createMockState({isLoading: false}))).toBe(false);
+  });
+
+  it("selectBetterAuthError returns correct value", () => {
+    expect(selectBetterAuthError(createMockState({error: "Error message"}))).toBe("Error message");
+    expect(selectBetterAuthError(createMockState({error: null}))).toBeNull();
+  });
+
+  it("selectors handle missing betterAuth state gracefully", () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Test empty state for selector edge case
+    const emptyState = {} as any;
+
+    expect(selectBetterAuthIsAuthenticated(emptyState)).toBe(false);
+    expect(selectBetterAuthUserId(emptyState)).toBeNull();
+    expect(selectBetterAuthUser(emptyState)).toBeNull();
+    expect(selectBetterAuthIsLoading(emptyState)).toBe(false);
+    expect(selectBetterAuthError(emptyState)).toBeNull();
+  });
+});
+
+describe("BetterAuthUser interface", () => {
+  it("defines user data structure correctly", () => {
+    const user: BetterAuthUser = {
+      createdAt: new Date("2024-01-01"),
+      email: "test@example.com",
+      emailVerified: true,
+      id: "user-123",
+      image: "https://example.com/avatar.jpg",
+      name: "Test User",
+      updatedAt: new Date("2024-01-02"),
+    };
+
+    expect(user.id).toBe("user-123");
+    expect(user.email).toBe("test@example.com");
+    expect(user.name).toBe("Test User");
+    expect(user.image).toBe("https://example.com/avatar.jpg");
+    expect(user.emailVerified).toBe(true);
+  });
+
+  it("allows null values for optional fields", () => {
+    const user: BetterAuthUser = {
+      createdAt: new Date(),
+      email: "test@example.com",
+      emailVerified: false,
+      id: "user-123",
+      image: null,
+      name: null,
+      updatedAt: new Date(),
+    };
+
+    expect(user.name).toBeNull();
+    expect(user.image).toBeNull();
+  });
+});

package/src/betterAuthSlice.ts

@@ -0,0 +1,307 @@
+/**
+ * Better Auth Redux slice for session state management.
+ *
+ * Provides Redux integration for Better Auth, including session synchronization,
+ * login/logout actions, and selectors for auth state.
+ */
+
+import {createListenerMiddleware, createSlice, type PayloadAction} from "@reduxjs/toolkit";
+
+import type {BetterAuthClientInterface, BetterAuthUser} from "./betterAuthTypes";
+
+/**
+ * Global logout action type for compatibility with other auth systems.
+ */
+const LOGOUT_ACTION_TYPE = "auth/logout";
+
+/**
+ * Root state type - loosely typed to avoid circular dependencies.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed to work with any Redux store configuration.
+type RootState = any;
+
+/**
+ * Better Auth Redux state interface.
+ */
+export interface BetterAuthState {
+  /**
+   * Whether the user is authenticated.
+   */
+  isAuthenticated: boolean;
+
+  /**
+   * The authenticated user's ID, or null if not authenticated.
+   */
+  userId: string | null;
+
+  /**
+   * The authenticated user data, or null if not authenticated.
+   */
+  user: BetterAuthUser | null;
+
+  /**
+   * Whether the auth state is currently loading.
+   */
+  isLoading: boolean;
+
+  /**
+   * Last error message, if any.
+   */
+  error: string | null;
+
+  /**
+   * Timestamp of the last session sync.
+   */
+  lastSyncTimestamp: number | null;
+}
+
+const initialState: BetterAuthState = {
+  error: null,
+  isAuthenticated: false,
+  isLoading: true,
+  lastSyncTimestamp: null,
+  user: null,
+  userId: null,
+};
+
+/**
+ * Configuration for generating the Better Auth slice.
+ */
+export interface GenerateBetterAuthSliceConfig {
+  /**
+   * The Better Auth client instance.
+   */
+  authClient: BetterAuthClientInterface;
+
+  /**
+   * How often to sync the session state (in milliseconds).
+   * @default 60000 (1 minute)
+   */
+  syncInterval?: number;
+}
+
+/**
+ * Generates a Better Auth Redux slice with session management.
+ *
+ * @example
+ * ```typescript
+ * const authClient = createBetterAuthClient({
+ *   baseURL: "http://localhost:3000",
+ *   scheme: "terreno",
+ * });
+ *
+ * const betterAuthSlice = generateBetterAuthSlice({ authClient });
+ *
+ * // Add to your store
+ * const store = configureStore({
+ *   reducer: {
+ *     betterAuth: betterAuthSlice.reducer,
+ *   },
+ *   middleware: (getDefaultMiddleware) =>
+ *     getDefaultMiddleware().concat(betterAuthSlice.middleware),
+ * });
+ *
+ * // Use in components
+ * const isAuthenticated = useSelector(selectBetterAuthIsAuthenticated);
+ * const user = useSelector(selectBetterAuthUser);
+ *
+ * // Trigger logout
+ * dispatch(betterAuthSlice.actions.logout());
+ * ```
+ */
+export const generateBetterAuthSlice = (config: GenerateBetterAuthSliceConfig) => {
+  const {authClient} = config;
+
+  const betterAuthSlice = createSlice({
+    initialState,
+    name: "betterAuth",
+    reducers: {
+      /**
+       * Clear the session data on logout.
+       */
+      clearSession: (state) => {
+        state.isAuthenticated = false;
+        state.userId = null;
+        state.user = null;
+        state.isLoading = false;
+        state.error = null;
+        state.lastSyncTimestamp = Date.now();
+      },
+
+      /**
+       * Trigger logout action.
+       */
+      logout: (state) => {
+        state.isAuthenticated = false;
+        state.userId = null;
+        state.user = null;
+        state.isLoading = false;
+        state.error = null;
+      },
+
+      /**
+       * Set error state.
+       */
+      setError: (state, action: PayloadAction<string | null>) => {
+        state.error = action.payload;
+        state.isLoading = false;
+      },
+
+      /**
+       * Set loading state.
+       */
+      setLoading: (state, action: PayloadAction<boolean>) => {
+        state.isLoading = action.payload;
+      },
+      /**
+       * Set the session data after successful authentication or session refresh.
+       */
+      setSession: (state, action: PayloadAction<{user: BetterAuthUser; userId: string}>) => {
+        state.isAuthenticated = true;
+        state.userId = action.payload.userId;
+        state.user = action.payload.user;
+        state.isLoading = false;
+        state.error = null;
+        state.lastSyncTimestamp = Date.now();
+      },
+    },
+  });
+
+  // Listener middleware for handling logout side effects
+  const logoutListenerMiddleware = createListenerMiddleware();
+
+  // Handle logout action - sign out from Better Auth
+  logoutListenerMiddleware.startListening({
+    actionCreator: betterAuthSlice.actions.logout,
+    effect: async (_action, _listenerApi) => {
+      try {
+        await authClient.signOut();
+        console.debug("Better Auth: Signed out successfully");
+      } catch (error) {
+        console.error("Better Auth: Error signing out:", error);
+      }
+    },
+  });
+
+  // Also listen for the global logout action type for compatibility
+  logoutListenerMiddleware.startListening({
+    effect: async (_action, listenerApi) => {
+      try {
+        await authClient.signOut();
+        listenerApi.dispatch(betterAuthSlice.actions.clearSession());
+        console.debug("Better Auth: Signed out via global logout action");
+      } catch (error) {
+        console.error("Better Auth: Error signing out:", error);
+      }
+    },
+    type: LOGOUT_ACTION_TYPE,
+  });
+
+  /**
+   * Syncs the session state from Better Auth to Redux.
+   * Call this on app startup and periodically to keep state in sync.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: Redux dispatch type varies by store configuration
+  const syncSession = async (dispatch: any): Promise<void> => {
+    dispatch(betterAuthSlice.actions.setLoading(true));
+
+    try {
+      const sessionData = await authClient.getSession();
+
+      if (sessionData?.data?.user && sessionData?.data?.session) {
+        dispatch(
+          betterAuthSlice.actions.setSession({
+            user: sessionData.data.user as BetterAuthUser,
+            userId: sessionData.data.user.id,
+          })
+        );
+      } else {
+        dispatch(betterAuthSlice.actions.clearSession());
+      }
+    } catch (error) {
+      console.error("Better Auth: Error syncing session:", error);
+      dispatch(betterAuthSlice.actions.setError("Failed to sync session"));
+      dispatch(betterAuthSlice.actions.clearSession());
+    }
+  };
+
+  return {
+    /**
+     * Actions for the Better Auth slice.
+     */
+    actions: betterAuthSlice.actions,
+
+    /**
+     * The Better Auth client instance.
+     */
+    authClient,
+
+    /**
+     * Middleware for handling Better Auth side effects.
+     */
+    middleware: [logoutListenerMiddleware.middleware],
+
+    /**
+     * The reducer for the Better Auth slice.
+     */
+    reducer: betterAuthSlice.reducer,
+    /**
+     * The Better Auth Redux slice.
+     */
+    slice: betterAuthSlice,
+
+    /**
+     * Function to sync session state from Better Auth to Redux.
+     */
+    syncSession,
+  };
+};
+
+/**
+ * Type for the return value of generateBetterAuthSlice.
+ */
+export type BetterAuthSlice = ReturnType<typeof generateBetterAuthSlice>;
+
+// Selectors
+
+/**
+ * Selects the entire Better Auth state.
+ */
+export const selectBetterAuthState = (state: RootState): BetterAuthState | undefined =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth;
+
+/**
+ * Selects whether the user is authenticated.
+ */
+export const selectBetterAuthIsAuthenticated = (state: RootState): boolean =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth?.isAuthenticated ?? false;
+
+/**
+ * Selects the current user ID.
+ */
+export const selectBetterAuthUserId = (state: RootState): string | null =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth?.userId ?? null;
+
+/**
+ * Selects the current user data.
+ */
+export const selectBetterAuthUser = (state: RootState): BetterAuthUser | null =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth?.user ?? null;
+
+/**
+ * Selects whether the auth state is loading.
+ */
+export const selectBetterAuthIsLoading = (state: RootState): boolean =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth?.isLoading ?? false;
+
+/**
+ * Selects the last error message.
+ */
+export const selectBetterAuthError = (state: RootState): string | null =>
+  // biome-ignore lint/suspicious/noExplicitAny: RootState is loosely typed
+  (state as any).betterAuth?.error ?? null;

package/src/betterAuthTypes.ts

@@ -0,0 +1,81 @@
+/**
+ * Better Auth types for use in Redux slices and components.
+ *
+ * This file contains only type definitions to avoid importing React Native
+ * dependencies in environments that don't support them (e.g., tests).
+ */
+
+/**
+ * Configuration options for the Better Auth client.
+ */
+export interface BetterAuthClientConfig {
+  /**
+   * Base URL of the auth server (e.g., "http://localhost:3000").
+   */
+  baseURL: string;
+
+  /**
+   * App URL scheme for deep linking (e.g., "terreno").
+   */
+  scheme: string;
+
+  /**
+   * Storage key prefix for auth tokens.
+   * @default "terreno"
+   */
+  storagePrefix?: string;
+}
+
+/**
+ * User data from Better Auth session.
+ */
+export interface BetterAuthUser {
+  id: string;
+  email: string;
+  name: string | null;
+  image: string | null;
+  emailVerified: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Session data from Better Auth.
+ */
+export interface BetterAuthSession {
+  id: string;
+  userId: string;
+  expiresAt: Date;
+  ipAddress: string | null;
+  userAgent: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Combined session and user data from Better Auth.
+ */
+export interface BetterAuthSessionData {
+  session: BetterAuthSession;
+  user: BetterAuthUser;
+}
+
+/**
+ * OAuth provider types supported by Better Auth.
+ */
+export type BetterAuthOAuthProvider = "google" | "github" | "apple";
+
+/**
+ * Minimal interface for the Better Auth client used by the Redux slice.
+ * This interface defines only the methods needed by the slice, allowing
+ * tests to use mock clients without importing React Native.
+ */
+export interface BetterAuthClientInterface {
+  getSession: () => Promise<{
+    data?: {
+      user?: BetterAuthUser;
+      session?: BetterAuthSession;
+    };
+  }>;
+  signOut: () => Promise<void>;
+}