better-auth-ui 3.2.5

package/src/lib/triplit/model-names.ts

@@ -0,0 +1,24 @@
+const namespaces = [
+    "user",
+    "session",
+    "account",
+    "passkey",
+    "twoFactor"
+] as const
+type Namespace = (typeof namespaces)[number]
+
+export type ModelNames = {
+    [key in Namespace]: string
+}
+
+export const getModelName = ({
+    namespace,
+    modelNames,
+    usePlural = false
+}: {
+    namespace: Namespace
+    modelNames?: Partial<ModelNames>
+    usePlural?: boolean
+}) => {
+    return modelNames?.[namespace] || `${namespace}${usePlural ? "s" : ""}`
+}

package/src/lib/triplit/use-conditional-query.ts

@@ -0,0 +1,82 @@
+import type {
+    FetchResult,
+    Models,
+    SchemaQuery,
+    SubscriptionOptions,
+    SubscriptionSignalPayload,
+    TriplitClient
+} from "@triplit/client"
+import type { WorkerClient } from "@triplit/client/worker-client"
+import { createStateSubscription } from "@triplit/react"
+import { useCallback, useMemo, useState, useSyncExternalStore } from "react"
+
+export function useConditionalQuery<
+    M extends Models<M>,
+    Q extends SchemaQuery<M>
+>(
+    client: TriplitClient<M> | WorkerClient<M>,
+    query?: Q | false | null | "" | 0,
+    options?: Partial<SubscriptionOptions> & { disabled?: boolean }
+) {
+    const stringifiedQuery =
+        !options?.disabled && query && JSON.stringify(query)
+    const localOnly = !!options?.localOnly
+    const [remoteFulfilled, setRemoteFulfilled] = useState(false)
+
+    const defaultValue: SubscriptionSignalPayload<M, Q> = {
+        results: undefined,
+        fetching: true,
+        fetchingLocal: false,
+        fetchingRemote: false,
+        error: undefined
+    }
+
+    // biome-ignore lint/correctness/useExhaustiveDependencies: prevent infinite re-renders
+    const [subscribe, snapshot] = useMemo(
+        () =>
+            stringifiedQuery
+                ? createStateSubscription(client, query, {
+                      ...options,
+                      onRemoteFulfilled: () => setRemoteFulfilled(true)
+                  })
+                : [() => () => {}, () => defaultValue],
+        [stringifiedQuery, localOnly]
+    )
+
+    const getServerSnapshot = useCallback(() => snapshot(), [snapshot])
+    const { fetching, ...rest } = useSyncExternalStore(
+        subscribe,
+        snapshot,
+        getServerSnapshot
+    )
+    return { fetching: fetching && !remoteFulfilled, ...rest }
+}
+
+type useConditionalQueryOnePayload<
+    M extends Models<M>,
+    Q extends SchemaQuery<M>
+> = Omit<SubscriptionSignalPayload<M, Q>, "results"> & {
+    result: FetchResult<M, Q, "one">
+}
+
+export function useConditionalQueryOne<
+    M extends Models<M>,
+    Q extends SchemaQuery<M>
+>(
+    client: TriplitClient<M> | WorkerClient<M>,
+    query?: Q | false | null | "" | 0,
+    options?: Partial<SubscriptionOptions> & { disabled?: boolean }
+): useConditionalQueryOnePayload<M, Q> {
+    const { fetching, fetchingLocal, fetchingRemote, results, error } =
+        useConditionalQuery(
+            client,
+            query ? ({ ...query, limit: 1 } as Q) : query,
+            options
+        )
+
+    const result = useMemo(() => {
+        return results?.[0] ?? null
+    }, [results])
+
+    return { fetching, fetchingLocal, fetchingRemote, result, error }
+}

package/src/lib/triplit/use-list-accounts.ts

@@ -0,0 +1,31 @@
+import type { AuthHooks } from "../../types/auth-hooks"
+import { getModelName } from "./model-names"
+import { useConditionalQuery } from "./use-conditional-query"
+import type { UseTriplitOptionsProps } from "./use-triplit-hooks"
+import { useTriplitToken } from "./use-triplit-token"
+
+export function useListAccounts({
+    triplit,
+    modelNames,
+    usePlural,
+    isPending
+}: UseTriplitOptionsProps): ReturnType<AuthHooks["useListAccounts"]> {
+    const modelName = getModelName({
+        namespace: "account",
+        modelNames,
+        usePlural
+    })
+
+    const { payload } = useTriplitToken(triplit)
+
+    const { results, error, fetching } = useConditionalQuery(
+        triplit,
+        payload?.sub && triplit.query(modelName)
+    )
+
+    return {
+        data: results,
+        isPending: isPending || fetching,
+        error
+    }
+}

package/src/lib/triplit/use-list-sessions.ts

@@ -0,0 +1,33 @@
+import type { Session } from "better-auth"
+import type { AuthHooks } from "../../types/auth-hooks"
+import { getModelName } from "./model-names"
+import { useConditionalQuery } from "./use-conditional-query"
+import type { UseTriplitOptionsProps } from "./use-triplit-hooks"
+import { useTriplitToken } from "./use-triplit-token"
+
+export function useListSessions({
+    triplit,
+    modelNames,
+    usePlural,
+    isPending
+}: UseTriplitOptionsProps): ReturnType<AuthHooks["useListSessions"]> {
+    const modelName = getModelName({
+        namespace: "session",
+        modelNames,
+        usePlural
+    })
+
+    const { payload } = useTriplitToken(triplit)
+
+    const {
+        results: sessions,
+        error,
+        fetching
+    } = useConditionalQuery(triplit, payload?.sub && triplit.query(modelName))
+
+    return {
+        data: sessions as Session[] | undefined,
+        isPending: isPending || fetching,
+        error
+    }
+}

package/src/lib/triplit/use-session.ts

@@ -0,0 +1,42 @@
+import type { User } from "../../types/auth-client"
+import type { AuthHooks } from "../../types/auth-hooks"
+import { getModelName } from "./model-names"
+import { useConditionalQueryOne } from "./use-conditional-query"
+import type { UseTriplitOptionsProps } from "./use-triplit-hooks"
+import { useTriplitToken } from "./use-triplit-token"
+
+export function useSession({
+    triplit,
+    sessionData,
+    isPending,
+    refetch,
+    usePlural,
+    modelNames
+}: UseTriplitOptionsProps): ReturnType<AuthHooks["useSession"]> {
+    const modelName = getModelName({
+        namespace: "user",
+        modelNames,
+        usePlural
+    })
+
+    const { payload } = useTriplitToken(triplit)
+
+    const { result: user, error } = useConditionalQueryOne(
+        triplit,
+        payload?.sub && triplit.query(modelName)
+    )
+
+    return {
+        data: sessionData
+            ? {
+                  session: sessionData.session,
+                  user: (sessionData?.user.id === user?.id
+                      ? user
+                      : sessionData.user) as User
+              }
+            : null,
+        error,
+        isPending: isPending,
+        refetch: refetch || (() => {})
+    }
+}

package/src/lib/triplit/use-triplit-hooks.ts

@@ -0,0 +1,68 @@
+import type { TriplitClient } from "@triplit/client"
+import type { User } from "better-auth"
+import { useMemo } from "react"
+
+import type { Session } from "../../types/auth-client"
+import type { AuthHooks } from "../../types/auth-hooks"
+import type { Refetch } from "../../types/refetch"
+import { useListAccounts } from "./use-list-accounts"
+import { useListSessions } from "./use-list-sessions"
+import { useSession } from "./use-session"
+
+const namespaces = ["user", "session", "account", "passkey"] as const
+type Namespace = (typeof namespaces)[number]
+
+type ModelNames = {
+    [key in Namespace]: string
+}
+
+export interface UseTriplitOptionsProps {
+    // biome-ignore lint/suspicious/noExplicitAny: ignore
+    triplit: TriplitClient<any>
+    modelNames?: Partial<ModelNames>
+    usePlural?: boolean
+    sessionData?: { user: User; session: Session } | null
+    refetch?: Refetch
+    isPending: boolean
+}
+
+export function useTriplitHooks({
+    triplit,
+    usePlural = true,
+    modelNames,
+    sessionData,
+    isPending
+}: UseTriplitOptionsProps) {
+    const hooks = useMemo(() => {
+        return {
+            useSession: () =>
+                useSession({
+                    triplit,
+                    modelNames,
+                    usePlural,
+                    sessionData,
+                    isPending
+                }),
+            useListAccounts: () =>
+                useListAccounts({
+                    triplit,
+                    modelNames,
+                    usePlural,
+                    sessionData,
+                    isPending
+                }),
+            useListSessions: () =>
+                useListSessions({
+                    triplit,
+                    modelNames,
+                    usePlural,
+                    sessionData,
+                    isPending
+                })
+        } as AuthHooks
+    }, [triplit, modelNames, usePlural, sessionData, isPending])
+
+    return {
+        hooks
+    }
+}

package/src/lib/triplit/use-triplit-token.ts

@@ -0,0 +1,44 @@
+import type { TriplitClient } from "@triplit/client"
+import { useConnectionStatus } from "@triplit/react"
+import { useMemo } from "react"
+
+export function useTriplitToken(triplit: TriplitClient) {
+    const connectionStatus = useConnectionStatus(triplit)
+
+    // biome-ignore lint/correctness/useExhaustiveDependencies: update when connection status changes
+    const payload = useMemo(
+        () =>
+            triplit.token
+                ? (decodeJWT(triplit.token) as Record<string, unknown> & {
+                      exp: number
+                      iat: number
+                      sub?: string
+                      email?: string
+                      name?: string
+                  })
+                : undefined,
+        [connectionStatus]
+    )
+
+    return { token: payload && triplit.token, payload }
+}
+
+function decodeJWT(token: string) {
+    try {
+        const base64Url = token.split(".")[1]
+        const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/")
+        const jsonPayload = decodeURIComponent(
+            atob(base64)
+                .split("")
+                .map((char) => {
+                    return `%${(`00${char.charCodeAt(0).toString(16)}`).slice(-2)}`
+                })
+                .join("")
+        )
+
+        return JSON.parse(jsonPayload)
+    } catch (error) {
+        console.error("Failed to decode JWT:", error)
+        return null
+    }
+}

package/src/lib/utils.ts

@@ -0,0 +1,105 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+import * as z from "zod"
+import type { AuthLocalization } from "../localization/auth-localization"
+import type { PasswordValidation } from "../types/password-validation"
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs))
+}
+
+export function isValidEmail(email: string) {
+    const emailRegex: RegExp = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    return emailRegex.test(email)
+}
+
+/**
+ * Converts error codes from SNAKE_CASE to camelCase
+ * Example: INVALID_TWO_FACTOR_COOKIE -> invalidTwoFactorCookie
+ */
+export function errorCodeToCamelCase(errorCode: string): string {
+    return errorCode
+        .toLowerCase()
+        .replace(/_([a-z])/g, (_, char) => char.toUpperCase())
+}
+
+/**
+ * Gets a localized error message from an error object
+ */
+export function getLocalizedError({
+    error,
+    localization
+}: {
+    // biome-ignore lint/suspicious/noExplicitAny: ignore
+    error: any
+    localization?: Partial<AuthLocalization>
+}) {
+    if (typeof error === "string") {
+        if (localization?.[error as keyof AuthLocalization])
+            return localization[error as keyof AuthLocalization]
+    }
+
+    if (error?.error) {
+        if (error.error.code) {
+            const errorCode = error.error.code as keyof AuthLocalization
+            if (localization?.[errorCode]) return localization[errorCode]
+        }
+
+        return (
+            error.error.message ||
+            error.error.code ||
+            error.error.statusText ||
+            localization?.REQUEST_FAILED
+        )
+    }
+
+    return error?.message || localization?.REQUEST_FAILED || "Request failed"
+}
+
+export function getSearchParam(paramName: string) {
+    return typeof window !== "undefined"
+        ? new URLSearchParams(window.location.search).get(paramName)
+        : null
+}
+
+export function getViewByPath<T extends object>(viewPaths: T, path?: string) {
+    for (const key in viewPaths) {
+        if (viewPaths[key] === path) {
+            return key
+        }
+    }
+}
+
+export function getKeyByValue<T extends Record<string, unknown>>(
+    object: T,
+    value?: T[keyof T]
+): keyof T | undefined {
+    return (Object.keys(object) as Array<keyof T>).find(
+        (key) => object[key] === value
+    )
+}
+
+export function getPasswordSchema(
+    passwordValidation?: PasswordValidation,
+    localization?: AuthLocalization
+) {
+    let schema = z.string().min(1, {
+        message: localization?.PASSWORD_REQUIRED
+    })
+    if (passwordValidation?.minLength) {
+        schema = schema.min(passwordValidation.minLength, {
+            message: localization?.PASSWORD_TOO_SHORT
+        })
+    }
+    if (passwordValidation?.maxLength) {
+        schema = schema.max(passwordValidation.maxLength, {
+            message: localization?.PASSWORD_TOO_LONG
+        })
+    }
+    if (passwordValidation?.regex) {
+        schema = schema.regex(passwordValidation.regex, {
+            message: localization?.INVALID_PASSWORD
+        })
+    }
+    return schema
+}

package/src/lib/view-paths.ts

@@ -0,0 +1,55 @@
+export const authViewPaths = {
+    /** @default "callback" */
+    CALLBACK: "callback",
+    /** @default "email-otp" */
+    EMAIL_OTP: "email-otp",
+    /** @default "forgot-password" */
+    FORGOT_PASSWORD: "forgot-password",
+    /** @default "magic-link" */
+    MAGIC_LINK: "magic-link",
+    /** @default "recover-account" */
+    RECOVER_ACCOUNT: "recover-account",
+    /** @default "reset-password" */
+    RESET_PASSWORD: "reset-password",
+    /** @default "sign-in" */
+    SIGN_IN: "sign-in",
+    /** @default "sign-out" */
+    SIGN_OUT: "sign-out",
+    /** @default "sign-up" */
+    SIGN_UP: "sign-up",
+    /** @default "two-factor" */
+    TWO_FACTOR: "two-factor",
+    /** @default "accept-invitation" */
+    ACCEPT_INVITATION: "accept-invitation"
+}
+
+export type AuthViewPaths = typeof authViewPaths
+
+// Account-scoped views (signed-in user)
+export const accountViewPaths = {
+    /** @default "settings" */
+    SETTINGS: "settings",
+    /** @default "security" */
+    SECURITY: "security",
+    /** @default "api-keys" */
+    API_KEYS: "api-keys",
+    /** @default "organizations" */
+    ORGANIZATIONS: "organizations"
+}
+
+export type AccountViewPaths = typeof accountViewPaths
+
+// Organization-scoped views
+export const organizationViewPaths = {
+    /** @default "settings" */
+    SETTINGS: "settings",
+    /** @default "members" */
+    MEMBERS: "members",
+    /** @default "api-keys" */
+    API_KEYS: "api-keys"
+}
+
+export type OrganizationViewPaths = typeof organizationViewPaths
+export type AuthViewPath = keyof AuthViewPaths
+export type AccountViewPath = keyof AccountViewPaths
+export type OrganizationViewPath = keyof OrganizationViewPaths

package/src/localization/admin-error-codes.ts

@@ -0,0 +1,20 @@
+export const ADMIN_ERROR_CODES = {
+    FAILED_TO_CREATE_USER: "Failed to create user",
+    USER_ALREADY_EXISTS: "User already exists",
+    YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself",
+    YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE:
+        "You are not allowed to change users role",
+    YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users",
+    YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users",
+    YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS:
+        "You are not allowed to list users sessions",
+    YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users",
+    YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS:
+        "You are not allowed to impersonate users",
+    YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS:
+        "You are not allowed to revoke users sessions",
+    YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users",
+    YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD:
+        "You are not allowed to set users password",
+    BANNED_USER: "You have been banned from this application"
+}

package/src/localization/anonymous-error-codes.ts

@@ -0,0 +1,6 @@
+export const ANONYMOUS_ERROR_CODES = {
+    FAILED_TO_CREATE_USER: "Failed to create user",
+    COULD_NOT_CREATE_SESSION: "Could not create session",
+    ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY:
+        "Anonymous users cannot sign in again anonymously"
+}

package/src/localization/api-key-error-codes.ts

@@ -0,0 +1,32 @@
+export const API_KEY_ERROR_CODES = {
+    INVALID_METADATA_TYPE: "metadata must be an object or undefined",
+    REFILL_AMOUNT_AND_INTERVAL_REQUIRED:
+        "refillAmount is required when refillInterval is provided",
+    REFILL_INTERVAL_AND_AMOUNT_REQUIRED:
+        "refillInterval is required when refillAmount is provided",
+    USER_BANNED: "User is banned",
+    UNAUTHORIZED_SESSION: "Unauthorized or invalid session",
+    KEY_NOT_FOUND: "API Key not found",
+    KEY_DISABLED: "API Key is disabled",
+    KEY_EXPIRED: "API Key has expired",
+    USAGE_EXCEEDED: "API Key has reached its usage limit",
+    KEY_NOT_RECOVERABLE: "API Key is not recoverable",
+    EXPIRES_IN_IS_TOO_SMALL:
+        "The expiresIn is smaller than the predefined minimum value.",
+    EXPIRES_IN_IS_TOO_LARGE:
+        "The expiresIn is larger than the predefined maximum value.",
+    INVALID_REMAINING: "The remaining count is either too large or too small.",
+    INVALID_PREFIX_LENGTH:
+        "The prefix length is either too large or too small.",
+    INVALID_NAME_LENGTH: "The name length is either too large or too small.",
+    METADATA_DISABLED: "Metadata is disabled.",
+    RATE_LIMIT_EXCEEDED: "Rate limit exceeded.",
+    NO_VALUES_TO_UPDATE: "No values to update.",
+    KEY_DISABLED_EXPIRATION: "Custom key expiration values are disabled.",
+    INVALID_API_KEY: "Invalid API key.",
+    INVALID_USER_ID_FROM_API_KEY: "The user id from the API key is invalid.",
+    INVALID_API_KEY_GETTER_RETURN_TYPE:
+        "API Key getter returned an invalid key type. Expected string.",
+    SERVER_ONLY_PROPERTY:
+        "The property you're trying to set can only be set from the server auth instance only."
+}