@better-auth-ui/solid 1.6.19

package/src/lib/auth-server.ts

@@ -0,0 +1,25 @@
+import type { passkey } from "@better-auth/passkey"
+import type { Auth } from "better-auth"
+import type { magicLink, multiSession, username } from "better-auth/plugins"
+
+export type AuthServer = Pick<Auth, "api">
+
+export type MagicLinkAuthServer = Pick<
+  Auth<{ plugins: [ReturnType<typeof magicLink>] }>,
+  "api"
+>
+
+export type MultiSessionAuthServer = Pick<
+  Auth<{ plugins: [ReturnType<typeof multiSession>] }>,
+  "api"
+>
+
+export type PasskeyAuthServer = Pick<
+  Auth<{ plugins: [ReturnType<typeof passkey>] }>,
+  "api"
+>
+
+export type UsernameAuthServer = Pick<
+  Auth<{ plugins: [ReturnType<typeof username>] }>,
+  "api"
+>

package/src/lib/auth-utils.ts

@@ -0,0 +1,25 @@
+import type { AdditionalField } from "@better-auth-ui/core"
+
+export function resolveRedirectTo(fallback: string): string {
+  return (
+    (typeof window !== "undefined" &&
+      new URLSearchParams(window.location.search).get("redirectTo")?.trim()) ||
+    fallback
+  )
+}
+
+export function mergeAdditionalFields(
+  pluginFields: readonly AdditionalField[] = [],
+  userFields: readonly AdditionalField[] = []
+): AdditionalField[] {
+  const fieldsByName = new Map<string, AdditionalField>()
+
+  for (const field of pluginFields) {
+    fieldsByName.set(field.name, field)
+  }
+  for (const field of userFields) {
+    fieldsByName.set(field.name, field)
+  }
+
+  return Array.from(fieldsByName.values())
+}

package/src/lib/fetch-options-provider.tsx

@@ -0,0 +1,77 @@
+import {
+  type Accessor,
+  createContext,
+  createSignal,
+  type JSX,
+  useContext
+} from "solid-js"
+
+/** Subset of Better Auth fetch options used by auth flows. Add fields as use-cases arise. */
+export type FetchOptions = {
+  headers?: Record<string, string>
+  body?: Record<string, unknown>
+  credentials?: RequestCredentials
+  signal?: AbortSignal
+}
+
+export type FetchOptionsContextValue = {
+  /** Current fetchOptions, or `undefined` when none are set. */
+  fetchOptions: Accessor<FetchOptions | undefined>
+  /** Overrides the entire fetchOptions object. Pass `undefined` to clear. */
+  setFetchOptions: (fetchOptions: FetchOptions | undefined) => void
+  /** Clears fetchOptions and runs the registered reset callback. */
+  resetFetchOptions: () => void
+  /** Register a reset handler. Used by `captchaPlugin`. Pass `null` to clear. */
+  registerReset: (reset: (() => void) | null) => void
+}
+
+const FetchOptionsContext = createContext<FetchOptionsContextValue>()
+
+export type FetchOptionsProviderProps = {
+  children?: JSX.Element | (() => JSX.Element)
+}
+
+const resolveProviderChildren = (
+  children: FetchOptionsProviderProps["children"]
+) => (typeof children === "function" ? children() : children)
+
+export function FetchOptionsProvider(props: FetchOptionsProviderProps) {
+  const [fetchOptions, setFetchOptions] = createSignal<
+    FetchOptions | undefined
+  >()
+  let reset: (() => void) | null = null
+
+  const registerReset = (nextReset: (() => void) | null) => {
+    reset = nextReset
+  }
+
+  const resetFetchOptions = () => {
+    setFetchOptions(undefined)
+    reset?.()
+  }
+
+  return (
+    <FetchOptionsContext.Provider
+      value={{
+        fetchOptions,
+        setFetchOptions,
+        resetFetchOptions,
+        registerReset
+      }}
+    >
+      {resolveProviderChildren(props.children)}
+    </FetchOptionsContext.Provider>
+  )
+}
+
+export function useFetchOptions(): FetchOptionsContextValue {
+  const context = useContext(FetchOptionsContext)
+
+  if (!context) {
+    throw new Error(
+      "[Better Auth UI] useFetchOptions must be used within FetchOptionsProvider"
+    )
+  }
+
+  return context
+}

package/src/lib/mutation-invalidator.tsx

@@ -0,0 +1,82 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { QueryClient, QueryKey } from "@tanstack/solid-query"
+import { onCleanup } from "solid-js"
+import type { AuthMutationMeta } from "../mutations/create-auth-mutation"
+
+const keyStartsWith = (
+  queryKey: readonly unknown[],
+  prefix: readonly unknown[]
+) => prefix.every((part, index) => Object.is(queryKey[index], part))
+
+const matchesAnyPrefix = (
+  queryKey: readonly unknown[] | undefined,
+  prefixes: Array<QueryKey> | undefined
+) =>
+  Boolean(
+    queryKey &&
+      prefixes?.some((prefix) =>
+        keyStartsWith(queryKey, prefix as readonly unknown[])
+      )
+  )
+
+export async function invalidateAuthMutationMeta(
+  queryClient: QueryClient,
+  mutation: {
+    options?: { mutationKey?: QueryKey; meta?: unknown }
+    meta?: unknown
+  }
+) {
+  const mutationKey = mutation.options?.mutationKey
+
+  if (!keyStartsWith(mutationKey ?? [], authMutationKeys.all)) {
+    return
+  }
+
+  const meta = (mutation.options?.meta ??
+    mutation.meta ??
+    {}) as AuthMutationMeta
+  const { invalidates, awaits } = meta
+
+  if (invalidates?.length) {
+    queryClient.invalidateQueries({
+      predicate: (query) => matchesAnyPrefix(query.queryKey, invalidates)
+    })
+  }
+
+  if (awaits?.length) {
+    await queryClient.invalidateQueries(
+      {
+        predicate: (query) => matchesAnyPrefix(query.queryKey, awaits)
+      },
+      { cancelRefetch: false }
+    )
+  }
+}
+
+export function MutationInvalidator(props: { queryClient: QueryClient }) {
+  const mutationCache = props.queryClient.getMutationCache()
+  const previousOnSuccess = mutationCache.config.onSuccess
+
+  mutationCache.config.onSuccess = async (
+    data,
+    variables,
+    onMutateResult,
+    mutation,
+    context
+  ) => {
+    await previousOnSuccess?.(
+      data,
+      variables,
+      onMutateResult,
+      mutation,
+      context
+    )
+    await invalidateAuthMutationMeta(props.queryClient, mutation)
+  }
+
+  onCleanup(() => {
+    mutationCache.config.onSuccess = previousOnSuccess
+  })
+
+  return null
+}

package/src/lib/provider-icons.ts

@@ -0,0 +1,10 @@
+import { providerNames } from "@better-auth-ui/core"
+
+/**
+ * Stable list of provider icon keys supported by core.
+ *
+ * Solid component icons are intentionally deferred to the Zaidan registry slice;
+ * this helper lets consumers and registry tooling align on the same provider
+ * namespace without shipping React icon components from this package.
+ */
+export const providerIconNames = Object.keys(providerNames).sort()

package/src/mutations/api-key/create-api-key-mutation.ts

@@ -0,0 +1,40 @@
+import {
+  apiKeyMutationKeys,
+  apiKeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { ApiKeyAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type CreateApiKeyParams<TAuthClient extends ApiKeyAuthClient> =
+  Parameters<TAuthClient["apiKey"]["create"]>[0]
+
+export type CreateApiKeyOptions = Parameters<
+  typeof useSessionScopedMutation<
+    ApiKeyAuthClient,
+    ApiKeyAuthClient["apiKey"]["create"],
+    typeof apiKeyMutationKeys.create
+  >
+>[4]
+
+export function createApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.apiKey.create,
+    apiKeyMutationKeys.create
+  )
+}
+
+export function useCreateApiKey<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient,
+  options?: CreateApiKeyOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.apiKey.create,
+    apiKeyMutationKeys.create,
+    (userId) => ({ awaits: [apiKeyQueryKeys.lists(userId)] }),
+    options
+  )
+}

package/src/mutations/api-key/delete-api-key-mutation.ts

@@ -0,0 +1,40 @@
+import {
+  apiKeyMutationKeys,
+  apiKeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { ApiKeyAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type DeleteApiKeyParams<TAuthClient extends ApiKeyAuthClient> =
+  Parameters<TAuthClient["apiKey"]["delete"]>[0]
+
+export type DeleteApiKeyOptions = Parameters<
+  typeof useSessionScopedMutation<
+    ApiKeyAuthClient,
+    ApiKeyAuthClient["apiKey"]["delete"],
+    typeof apiKeyMutationKeys.delete
+  >
+>[4]
+
+export function deleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.apiKey.delete,
+    apiKeyMutationKeys.delete
+  )
+}
+
+export function useDeleteApiKey<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient,
+  options?: DeleteApiKeyOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.apiKey.delete,
+    apiKeyMutationKeys.delete,
+    (userId) => ({ awaits: [apiKeyQueryKeys.lists(userId)] }),
+    options
+  )
+}

package/src/mutations/auth/request-password-reset-mutation.ts

@@ -0,0 +1,15 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type RequestPasswordResetParams<TAuthClient extends AuthClient> =
+  Parameters<TAuthClient["requestPasswordReset"]>[0]
+
+export function requestPasswordResetOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.requestPasswordReset,
+    authMutationKeys.requestPasswordReset
+  )
+}

package/src/mutations/auth/reset-password-mutation.ts

@@ -0,0 +1,16 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type ResetPasswordParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["resetPassword"]
+>[0]
+
+export function resetPasswordOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.resetPassword,
+    authMutationKeys.resetPassword
+  )
+}

package/src/mutations/auth/send-verification-email-mutation.ts

@@ -0,0 +1,15 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SendVerificationEmailParams<TAuthClient extends AuthClient> =
+  Parameters<TAuthClient["sendVerificationEmail"]>[0]
+
+export function sendVerificationEmailOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.sendVerificationEmail,
+    authMutationKeys.sendVerificationEmail
+  )
+}

package/src/mutations/auth/sign-in-email-mutation.ts

@@ -0,0 +1,17 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignInEmailParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["signIn"]["email"]
+>[0]
+
+export function signInEmailOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signIn.email,
+    authMutationKeys.signIn.email,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/mutations/auth/sign-in-social-mutation.ts

@@ -0,0 +1,16 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignInSocialParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["signIn"]["social"]
+>[0]
+
+export function signInSocialOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signIn.social,
+    authMutationKeys.signIn.social
+  )
+}

package/src/mutations/auth/sign-out-mutation.ts

@@ -0,0 +1,13 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignOutParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["signOut"]
+>[0]
+
+export function signOutOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(authClient.signOut, authMutationKeys.signOut)
+}

package/src/mutations/auth/sign-up-email-mutation.ts

@@ -0,0 +1,17 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["signUp"]["email"]
+>[0]
+
+export function signUpEmailOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signUp.email,
+    authMutationKeys.signUp.email,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/mutations/auth-mutation-options.ts

@@ -0,0 +1,62 @@
+import {
+  type CreateMutationOptions,
+  type MutationKey,
+  mutationOptions
+} from "@tanstack/solid-query"
+import type { BetterFetchError, BetterFetchOption } from "better-auth/client"
+
+export type AuthMutationFn = (
+  // biome-ignore lint/suspicious/noExplicitAny: variance bridge for arbitrary Better Auth client methods
+  variables: any
+) => Promise<unknown>
+
+export type AuthMutationFnData<TFn extends AuthMutationFn> = Awaited<
+  ReturnType<TFn>
+>
+
+export type AuthMutationFnVariables<TFn extends AuthMutationFn> =
+  Parameters<TFn>[0] extends infer P
+    ? undefined extends P
+      ? // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+        NonNullable<P> | void
+      : P
+    : never
+
+export type AuthMutationOptions<
+  TFn extends AuthMutationFn,
+  TMutationKey extends MutationKey = MutationKey
+> = Omit<
+  CreateMutationOptions<
+    AuthMutationFnData<TFn>,
+    BetterFetchError,
+    AuthMutationFnVariables<TFn>
+  >,
+  "mutationKey"
+> & {
+  mutationKey: TMutationKey
+}
+
+export function authMutationOptions<
+  TFn extends AuthMutationFn,
+  const TMutationKey extends MutationKey
+>(
+  authFn: TFn,
+  mutationKey: TMutationKey
+): AuthMutationOptions<TFn, TMutationKey> {
+  const mutationFn = (variables: AuthMutationFnVariables<TFn>) => {
+    const vars = (variables ?? {}) as { fetchOptions?: BetterFetchOption }
+    return authFn({
+      ...vars,
+      fetchOptions: { ...vars.fetchOptions, throw: true }
+    }) as Promise<AuthMutationFnData<TFn>>
+  }
+
+  return mutationOptions<
+    AuthMutationFnData<TFn>,
+    BetterFetchError,
+    AuthMutationFnVariables<TFn>
+  >({
+    mutationKey,
+    mutationFn
+  }) as AuthMutationOptions<TFn, TMutationKey>
+}

package/src/mutations/create-auth-mutation.ts

@@ -0,0 +1,44 @@
+import {
+  type MutationKey,
+  mutationOptions,
+  type QueryKey
+} from "@tanstack/solid-query"
+import type { BetterFetchError, BetterFetchOption } from "better-auth/client"
+
+// biome-ignore lint/suspicious/noExplicitAny: Better Auth client methods have intentionally variable generated params.
+export type MutationMethod<TData = unknown> = (params?: any) => Promise<TData>
+
+export type MutationParams<TMethod extends MutationMethod> =
+  Parameters<TMethod>[0]
+export type MutationData<TMethod extends MutationMethod> = Awaited<
+  ReturnType<TMethod>
+>
+
+export type AuthMutationMeta = {
+  invalidates?: Array<QueryKey>
+  awaits?: Array<QueryKey>
+}
+
+export function createAuthMutationOptions<
+  TMethod extends MutationMethod,
+  const TMutationKey extends MutationKey
+>(authFn: TMethod, mutationKey: TMutationKey, meta?: AuthMutationMeta) {
+  const mutationFn = (params: MutationParams<TMethod>) => {
+    const input = (params ?? {}) as { fetchOptions?: BetterFetchOption }
+
+    return authFn({
+      ...input,
+      fetchOptions: { ...input.fetchOptions, throw: true }
+    } as MutationParams<TMethod>) as Promise<MutationData<TMethod>>
+  }
+
+  return mutationOptions<
+    MutationData<TMethod>,
+    BetterFetchError,
+    MutationParams<TMethod>
+  >({
+    mutationKey,
+    mutationFn,
+    ...(meta ? { meta } : {})
+  })
+}

package/src/mutations/magic-link/sign-in-magic-link-mutation.ts

@@ -0,0 +1,15 @@
+import { magicLinkMutationKeys } from "@better-auth-ui/core/plugins"
+import type { MagicLinkAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignInMagicLinkParams<TAuthClient extends MagicLinkAuthClient> =
+  Parameters<TAuthClient["signIn"]["magicLink"]>[0]
+
+export function signInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signIn.magicLink,
+    magicLinkMutationKeys.signIn
+  )
+}

package/src/mutations/multi-session/revoke-multi-session-mutation.ts

@@ -0,0 +1,40 @@
+import {
+  multiSessionMutationKeys,
+  multiSessionQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { MultiSessionAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type RevokeMultiSessionParams<
+  TAuthClient extends MultiSessionAuthClient
+> = Parameters<TAuthClient["multiSession"]["revoke"]>[0]
+
+export type RevokeMultiSessionOptions = Parameters<
+  typeof useSessionScopedMutation<
+    MultiSessionAuthClient,
+    MultiSessionAuthClient["multiSession"]["revoke"],
+    typeof multiSessionMutationKeys.revoke
+  >
+>[4]
+
+export function revokeMultiSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient) {
+  return createAuthMutationOptions(
+    authClient.multiSession.revoke,
+    multiSessionMutationKeys.revoke
+  )
+}
+
+export function useRevokeMultiSession<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient, options?: RevokeMultiSessionOptions) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.multiSession.revoke,
+    multiSessionMutationKeys.revoke,
+    (userId) => ({ awaits: [multiSessionQueryKeys.lists(userId)] }),
+    options
+  )
+}

package/src/mutations/multi-session/set-active-session-mutation.ts

@@ -0,0 +1,43 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  multiSessionMutationKeys,
+  multiSessionQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { MultiSessionAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> =
+  Parameters<TAuthClient["multiSession"]["setActive"]>[0]
+
+export type SetActiveSessionOptions = Parameters<
+  typeof useSessionScopedMutation<
+    MultiSessionAuthClient,
+    MultiSessionAuthClient["multiSession"]["setActive"],
+    typeof multiSessionMutationKeys.setActive
+  >
+>[4]
+
+export function setActiveSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient) {
+  return createAuthMutationOptions(
+    authClient.multiSession.setActive,
+    multiSessionMutationKeys.setActive
+  )
+}
+
+export function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(
+  authClient: TAuthClient,
+  options?: SetActiveSessionOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.multiSession.setActive,
+    multiSessionMutationKeys.setActive,
+    (userId) => ({
+      awaits: [authQueryKeys.session, multiSessionQueryKeys.lists(userId)]
+    }),
+    options
+  )
+}

package/src/mutations/organization/accept-invitation-mutation.ts

@@ -0,0 +1,38 @@
+import { organizationMutationKeys } from "@better-auth-ui/core/plugins"
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { acceptInvitationMeta } from "./metadata"
+import {
+  createOrganizationMutationOptions,
+  type OrganizationMutationOptions,
+  useOrganizationMutation
+} from "./utils"
+
+export type AcceptInvitationParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["acceptInvitation"]>[0]
+
+export type AcceptInvitationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = OrganizationMutationOptions<TAuthClient["organization"]["acceptInvitation"]>
+
+export function acceptInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  return createOrganizationMutationOptions(
+    authClient.organization.acceptInvitation,
+    organizationMutationKeys.acceptInvitation
+  )
+}
+
+export function useAcceptInvitation<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: AcceptInvitationOptions<TAuthClient>
+) {
+  return useOrganizationMutation(
+    authClient,
+    authClient.organization.acceptInvitation,
+    organizationMutationKeys.acceptInvitation,
+    acceptInvitationMeta,
+    options
+  )
+}