@terreno/rtk 0.0.18 → 0.2.0

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>;
+}

package/src/constants.ts

@@ -49,9 +49,11 @@ export let baseUrl: string;
 export let baseWebsocketsUrl: string;
 export let baseTasksUrl: string;
 
-if (Constants.expoConfig?.extra?.BASE_URL) {
-  // For prod/staging
-  baseUrl = Constants.expoConfig?.extra?.BASE_URL;
+const isDev = typeof __DEV__ !== "undefined" && __DEV__;
+
+if (process.env.EXPO_PUBLIC_API_URL) {
+  // Explicit override (e.g. .env)
+  baseUrl = process.env.EXPO_PUBLIC_API_URL;
   baseWebsocketsUrl = `${baseUrl.replace("api.", "ws.")}/`;
   baseTasksUrl = `${baseUrl.replace("api.", "tasks.")}/tasks`;
 
@@ -60,9 +62,33 @@ if (Constants.expoConfig?.extra?.BASE_URL) {
       Constants.expoConfig?.extra?.APP_ENV ?? "unknown"
     }, websocket to ${baseWebsocketsUrl}, tasks to ${baseTasksUrl}`
   );
-} else if (process.env.EXPO_PUBLIC_API_URL) {
-  // For dev web
-  baseUrl = process.env.EXPO_PUBLIC_API_URL;
+} else if (isDev && Constants.expoConfig?.hostUri) {
+  // Dev simulator/device
+  baseUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}`;
+  baseWebsocketsUrl = `ws://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/`;
+  baseTasksUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/tasks`;
+  console.debug(
+    `Base URL set to hostUri ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
+    Constants.expoConfig?.hostUri
+  );
+} else if (isDev && Constants.experienceUrl) {
+  // Dev web (experienceUrl)
+  baseUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}`;
+  baseWebsocketsUrl = `ws:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/`;
+  baseTasksUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/tasks`;
+  console.debug(
+    `Base URL set to experienceUrl ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
+    Constants.expoConfig?.hostUri
+  );
+} else if (isDev) {
+  // Dev web fallback
+  baseUrl = `http://localhost:4000`;
+  baseWebsocketsUrl = `ws://localhost:4000/`;
+  baseTasksUrl = `http://localhost:4000/tasks`;
+  console.debug(`Base URL set to localhost ${baseUrl}, websocket to ${baseWebsocketsUrl}`);
+} else if (Constants.expoConfig?.extra?.BASE_URL) {
+  // Prod/staging
+  baseUrl = Constants.expoConfig?.extra?.BASE_URL;
   baseWebsocketsUrl = `${baseUrl.replace("api.", "ws.")}/`;
   baseTasksUrl = `${baseUrl.replace("api.", "tasks.")}/tasks`;
 
@@ -72,34 +98,24 @@ if (Constants.expoConfig?.extra?.BASE_URL) {
     }, websocket to ${baseWebsocketsUrl}, tasks to ${baseTasksUrl}`
   );
 } else if (Constants.expoConfig?.hostUri) {
-  // For dev simulator/device
-  baseUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":3000")}`;
-  baseWebsocketsUrl = `ws://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":3000")}/`;
-  baseTasksUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":3000")}/tasks`;
+  baseUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}`;
+  baseWebsocketsUrl = `ws://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/`;
+  baseTasksUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/tasks`;
   console.debug(
     `Base URL set to hostUri ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
     Constants.expoConfig?.hostUri
   );
 } else if (Constants.experienceUrl) {
-  // For dev web
-  baseUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":3000")}`;
-  baseWebsocketsUrl = `ws:${Constants.experienceUrl?.split(`:`)[1]?.concat(":3000")}/`;
-  baseTasksUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":3000")}/tasks`;
+  baseUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}`;
+  baseWebsocketsUrl = `ws:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/`;
+  baseTasksUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/tasks`;
   console.debug(
     `Base URL set to experienceUrl ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
     Constants.expoConfig?.hostUri
   );
-} else if (
-  !Constants.expoConfig?.extra?.BASE_URL &&
-  !Constants.expoConfig?.hostUri &&
-  !Constants.experienceUrl
-) {
-  // For dev web, which doesn't have experienceUrl for some reason?
-  baseUrl = `http://localhost:3000`;
-  baseWebsocketsUrl = `ws://localhost:3000/`;
-  baseTasksUrl = `http://localhost:3000/tasks`;
-  console.debug(`Base URL set to localhost ${baseUrl}, websocket to ${baseWebsocketsUrl}`);
 } else {
-  console.error("No base URL found", Constants.expoConfig, Constants.experienceUrl);
-  throw new Error("No base URL found");
+  baseUrl = `http://localhost:4000`;
+  baseWebsocketsUrl = `ws://localhost:4000/`;
+  baseTasksUrl = `http://localhost:4000/tasks`;
+  console.debug(`Base URL set to localhost ${baseUrl}, websocket to ${baseWebsocketsUrl}`);
 }

package/src/index.ts

@@ -1,4 +1,7 @@
 export * from "./authSlice";
+export * from "./betterAuthClient";
+export * from "./betterAuthSlice";
+export * from "./betterAuthTypes";
 export * from "./constants";
 export * from "./emptyApi";
 export * from "./mongooseSlice";

package/src/tagGenerator.ts

@@ -47,7 +47,9 @@ export const generateTags = (api: any, tagTypes: string[]): any => {
       if (!endpoint.toLowerCase().includes("byid")) {
         const tag = tagTypes.find((t: string) =>
           // remove "get" from the endpoint name and "ById" from the endpoint name
-          t.toLowerCase().includes(cleanEndpointStringToGenerateTag(endpoint))
+          t
+            .toLowerCase()
+            .includes(cleanEndpointStringToGenerateTag(endpoint))
         );
         if (tag) {
           tags[endpoint] = {providesTags: providesIdTags(tag)};