This is page 41 of 49. Use http://codebase.md/better-auth/better-auth?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .github
│ ├── CODEOWNERS
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.yml
│ │ └── feature_request.yml
│ ├── renovate.json5
│ └── workflows
│ ├── ci.yml
│ ├── e2e.yml
│ ├── preview.yml
│ └── release.yml
├── .gitignore
├── .npmrc
├── .nvmrc
├── .vscode
│ └── settings.json
├── banner-dark.png
├── banner.png
├── biome.json
├── bump.config.ts
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── demo
│ ├── expo-example
│ │ ├── .env.example
│ │ ├── .gitignore
│ │ ├── app.config.ts
│ │ ├── assets
│ │ │ ├── bg-image.jpeg
│ │ │ ├── fonts
│ │ │ │ └── SpaceMono-Regular.ttf
│ │ │ ├── icon.png
│ │ │ └── images
│ │ │ ├── adaptive-icon.png
│ │ │ ├── favicon.png
│ │ │ ├── logo.png
│ │ │ ├── partial-react-logo.png
│ │ │ ├── react-logo.png
│ │ │ ├── [email protected]
│ │ │ ├── [email protected]
│ │ │ └── splash.png
│ │ ├── babel.config.js
│ │ ├── components.json
│ │ ├── expo-env.d.ts
│ │ ├── index.ts
│ │ ├── metro.config.js
│ │ ├── nativewind-env.d.ts
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── app
│ │ │ │ ├── _layout.tsx
│ │ │ │ ├── api
│ │ │ │ │ └── auth
│ │ │ │ │ └── [...route]+api.ts
│ │ │ │ ├── dashboard.tsx
│ │ │ │ ├── forget-password.tsx
│ │ │ │ ├── index.tsx
│ │ │ │ └── sign-up.tsx
│ │ │ ├── components
│ │ │ │ ├── icons
│ │ │ │ │ └── google.tsx
│ │ │ │ └── ui
│ │ │ │ ├── avatar.tsx
│ │ │ │ ├── button.tsx
│ │ │ │ ├── card.tsx
│ │ │ │ ├── dialog.tsx
│ │ │ │ ├── input.tsx
│ │ │ │ ├── separator.tsx
│ │ │ │ └── text.tsx
│ │ │ ├── global.css
│ │ │ └── lib
│ │ │ ├── auth-client.ts
│ │ │ ├── auth.ts
│ │ │ ├── icons
│ │ │ │ ├── iconWithClassName.ts
│ │ │ │ └── X.tsx
│ │ │ └── utils.ts
│ │ ├── tailwind.config.js
│ │ └── tsconfig.json
│ └── nextjs
│ ├── .env.example
│ ├── .gitignore
│ ├── app
│ │ ├── (auth)
│ │ │ ├── forget-password
│ │ │ │ └── page.tsx
│ │ │ ├── reset-password
│ │ │ │ └── page.tsx
│ │ │ ├── sign-in
│ │ │ │ ├── loading.tsx
│ │ │ │ └── page.tsx
│ │ │ └── two-factor
│ │ │ ├── otp
│ │ │ │ └── page.tsx
│ │ │ └── page.tsx
│ │ ├── accept-invitation
│ │ │ └── [id]
│ │ │ ├── invitation-error.tsx
│ │ │ └── page.tsx
│ │ ├── admin
│ │ │ └── page.tsx
│ │ ├── api
│ │ │ └── auth
│ │ │ └── [...all]
│ │ │ └── route.ts
│ │ ├── apps
│ │ │ └── register
│ │ │ └── page.tsx
│ │ ├── client-test
│ │ │ └── page.tsx
│ │ ├── dashboard
│ │ │ ├── change-plan.tsx
│ │ │ ├── client.tsx
│ │ │ ├── organization-card.tsx
│ │ │ ├── page.tsx
│ │ │ ├── upgrade-button.tsx
│ │ │ └── user-card.tsx
│ │ ├── device
│ │ │ ├── approve
│ │ │ │ └── page.tsx
│ │ │ ├── denied
│ │ │ │ └── page.tsx
│ │ │ ├── layout.tsx
│ │ │ ├── page.tsx
│ │ │ └── success
│ │ │ └── page.tsx
│ │ ├── favicon.ico
│ │ ├── features.tsx
│ │ ├── fonts
│ │ │ ├── GeistMonoVF.woff
│ │ │ └── GeistVF.woff
│ │ ├── globals.css
│ │ ├── layout.tsx
│ │ ├── oauth
│ │ │ └── authorize
│ │ │ ├── concet-buttons.tsx
│ │ │ └── page.tsx
│ │ ├── page.tsx
│ │ └── pricing
│ │ └── page.tsx
│ ├── components
│ │ ├── account-switch.tsx
│ │ ├── blocks
│ │ │ └── pricing.tsx
│ │ ├── logo.tsx
│ │ ├── one-tap.tsx
│ │ ├── sign-in-btn.tsx
│ │ ├── sign-in.tsx
│ │ ├── sign-up.tsx
│ │ ├── theme-provider.tsx
│ │ ├── theme-toggle.tsx
│ │ ├── tier-labels.tsx
│ │ ├── ui
│ │ │ ├── accordion.tsx
│ │ │ ├── alert-dialog.tsx
│ │ │ ├── alert.tsx
│ │ │ ├── aspect-ratio.tsx
│ │ │ ├── avatar.tsx
│ │ │ ├── badge.tsx
│ │ │ ├── breadcrumb.tsx
│ │ │ ├── button.tsx
│ │ │ ├── calendar.tsx
│ │ │ ├── card.tsx
│ │ │ ├── carousel.tsx
│ │ │ ├── chart.tsx
│ │ │ ├── checkbox.tsx
│ │ │ ├── collapsible.tsx
│ │ │ ├── command.tsx
│ │ │ ├── context-menu.tsx
│ │ │ ├── copy-button.tsx
│ │ │ ├── dialog.tsx
│ │ │ ├── drawer.tsx
│ │ │ ├── dropdown-menu.tsx
│ │ │ ├── form.tsx
│ │ │ ├── hover-card.tsx
│ │ │ ├── input-otp.tsx
│ │ │ ├── input.tsx
│ │ │ ├── label.tsx
│ │ │ ├── menubar.tsx
│ │ │ ├── navigation-menu.tsx
│ │ │ ├── pagination.tsx
│ │ │ ├── password-input.tsx
│ │ │ ├── popover.tsx
│ │ │ ├── progress.tsx
│ │ │ ├── radio-group.tsx
│ │ │ ├── resizable.tsx
│ │ │ ├── scroll-area.tsx
│ │ │ ├── select.tsx
│ │ │ ├── separator.tsx
│ │ │ ├── sheet.tsx
│ │ │ ├── skeleton.tsx
│ │ │ ├── slider.tsx
│ │ │ ├── sonner.tsx
│ │ │ ├── switch.tsx
│ │ │ ├── table.tsx
│ │ │ ├── tabs.tsx
│ │ │ ├── tabs2.tsx
│ │ │ ├── textarea.tsx
│ │ │ ├── toast.tsx
│ │ │ ├── toaster.tsx
│ │ │ ├── toggle-group.tsx
│ │ │ ├── toggle.tsx
│ │ │ └── tooltip.tsx
│ │ └── wrapper.tsx
│ ├── components.json
│ ├── hooks
│ │ └── use-toast.ts
│ ├── lib
│ │ ├── auth-client.ts
│ │ ├── auth-types.ts
│ │ ├── auth.ts
│ │ ├── email
│ │ │ ├── invitation.tsx
│ │ │ ├── resend.ts
│ │ │ └── reset-password.tsx
│ │ ├── metadata.ts
│ │ ├── shared.ts
│ │ └── utils.ts
│ ├── next.config.ts
│ ├── package.json
│ ├── postcss.config.mjs
│ ├── proxy.ts
│ ├── public
│ │ ├── __og.png
│ │ ├── _og.png
│ │ ├── favicon
│ │ │ ├── android-chrome-192x192.png
│ │ │ ├── android-chrome-512x512.png
│ │ │ ├── apple-touch-icon.png
│ │ │ ├── favicon-16x16.png
│ │ │ ├── favicon-32x32.png
│ │ │ ├── favicon.ico
│ │ │ ├── light
│ │ │ │ ├── android-chrome-192x192.png
│ │ │ │ ├── android-chrome-512x512.png
│ │ │ │ ├── apple-touch-icon.png
│ │ │ │ ├── favicon-16x16.png
│ │ │ │ ├── favicon-32x32.png
│ │ │ │ ├── favicon.ico
│ │ │ │ └── site.webmanifest
│ │ │ └── site.webmanifest
│ │ ├── logo.svg
│ │ └── og.png
│ ├── README.md
│ ├── tailwind.config.ts
│ ├── tsconfig.json
│ └── turbo.json
├── docker-compose.yml
├── docs
│ ├── .env.example
│ ├── .gitignore
│ ├── app
│ │ ├── api
│ │ │ ├── ai-chat
│ │ │ │ └── route.ts
│ │ │ ├── analytics
│ │ │ │ ├── conversation
│ │ │ │ │ └── route.ts
│ │ │ │ ├── event
│ │ │ │ │ └── route.ts
│ │ │ │ └── feedback
│ │ │ │ └── route.ts
│ │ │ ├── chat
│ │ │ │ └── route.ts
│ │ │ ├── og
│ │ │ │ └── route.tsx
│ │ │ ├── og-release
│ │ │ │ └── route.tsx
│ │ │ ├── search
│ │ │ │ └── route.ts
│ │ │ └── support
│ │ │ └── route.ts
│ │ ├── blog
│ │ │ ├── _components
│ │ │ │ ├── _layout.tsx
│ │ │ │ ├── blog-list.tsx
│ │ │ │ ├── changelog-layout.tsx
│ │ │ │ ├── default-changelog.tsx
│ │ │ │ ├── fmt-dates.tsx
│ │ │ │ ├── icons.tsx
│ │ │ │ ├── stat-field.tsx
│ │ │ │ └── support.tsx
│ │ │ ├── [[...slug]]
│ │ │ │ └── page.tsx
│ │ │ └── layout.tsx
│ │ ├── changelogs
│ │ │ ├── _components
│ │ │ │ ├── _layout.tsx
│ │ │ │ ├── changelog-layout.tsx
│ │ │ │ ├── default-changelog.tsx
│ │ │ │ ├── fmt-dates.tsx
│ │ │ │ ├── grid-pattern.tsx
│ │ │ │ ├── icons.tsx
│ │ │ │ └── stat-field.tsx
│ │ │ ├── [[...slug]]
│ │ │ │ └── page.tsx
│ │ │ └── layout.tsx
│ │ ├── community
│ │ │ ├── _components
│ │ │ │ ├── header.tsx
│ │ │ │ └── stats.tsx
│ │ │ └── page.tsx
│ │ ├── docs
│ │ │ ├── [[...slug]]
│ │ │ │ ├── page.client.tsx
│ │ │ │ └── page.tsx
│ │ │ ├── layout.tsx
│ │ │ └── lib
│ │ │ └── get-llm-text.ts
│ │ ├── global.css
│ │ ├── layout.config.tsx
│ │ ├── layout.tsx
│ │ ├── llms.txt
│ │ │ ├── [...slug]
│ │ │ │ └── route.ts
│ │ │ └── route.ts
│ │ ├── not-found.tsx
│ │ ├── page.tsx
│ │ ├── reference
│ │ │ └── route.ts
│ │ ├── sitemap.xml
│ │ ├── static.json
│ │ │ └── route.ts
│ │ └── v1
│ │ ├── _components
│ │ │ └── v1-text.tsx
│ │ ├── bg-line.tsx
│ │ └── page.tsx
│ ├── assets
│ │ ├── Geist.ttf
│ │ └── GeistMono.ttf
│ ├── components
│ │ ├── ai-chat-modal.tsx
│ │ ├── anchor-scroll-fix.tsx
│ │ ├── api-method-tabs.tsx
│ │ ├── api-method.tsx
│ │ ├── banner.tsx
│ │ ├── blocks
│ │ │ └── features.tsx
│ │ ├── builder
│ │ │ ├── beam.tsx
│ │ │ ├── code-tabs
│ │ │ │ ├── code-editor.tsx
│ │ │ │ ├── code-tabs.tsx
│ │ │ │ ├── index.tsx
│ │ │ │ ├── tab-bar.tsx
│ │ │ │ └── theme.ts
│ │ │ ├── index.tsx
│ │ │ ├── sign-in.tsx
│ │ │ ├── sign-up.tsx
│ │ │ ├── social-provider.tsx
│ │ │ ├── store.ts
│ │ │ └── tabs.tsx
│ │ ├── display-techstack.tsx
│ │ ├── divider-text.tsx
│ │ ├── docs
│ │ │ ├── docs.client.tsx
│ │ │ ├── docs.tsx
│ │ │ ├── layout
│ │ │ │ ├── nav.tsx
│ │ │ │ ├── theme-toggle.tsx
│ │ │ │ ├── toc-thumb.tsx
│ │ │ │ └── toc.tsx
│ │ │ ├── page.client.tsx
│ │ │ ├── page.tsx
│ │ │ ├── shared.tsx
│ │ │ └── ui
│ │ │ ├── button.tsx
│ │ │ ├── collapsible.tsx
│ │ │ ├── popover.tsx
│ │ │ └── scroll-area.tsx
│ │ ├── endpoint.tsx
│ │ ├── features.tsx
│ │ ├── floating-ai-search.tsx
│ │ ├── fork-button.tsx
│ │ ├── generate-apple-jwt.tsx
│ │ ├── generate-secret.tsx
│ │ ├── github-stat.tsx
│ │ ├── icons.tsx
│ │ ├── landing
│ │ │ ├── gradient-bg.tsx
│ │ │ ├── grid-pattern.tsx
│ │ │ ├── hero.tsx
│ │ │ ├── section-svg.tsx
│ │ │ ├── section.tsx
│ │ │ ├── spotlight.tsx
│ │ │ └── testimonials.tsx
│ │ ├── logo-context-menu.tsx
│ │ ├── logo.tsx
│ │ ├── markdown-renderer.tsx
│ │ ├── markdown.tsx
│ │ ├── mdx
│ │ │ ├── add-to-cursor.tsx
│ │ │ └── database-tables.tsx
│ │ ├── message-feedback.tsx
│ │ ├── mobile-search-icon.tsx
│ │ ├── nav-bar.tsx
│ │ ├── nav-link.tsx
│ │ ├── nav-mobile.tsx
│ │ ├── promo-card.tsx
│ │ ├── resource-card.tsx
│ │ ├── resource-grid.tsx
│ │ ├── resource-section.tsx
│ │ ├── ripple.tsx
│ │ ├── search-dialog.tsx
│ │ ├── side-bar.tsx
│ │ ├── sidebar-content.tsx
│ │ ├── techstack-icons.tsx
│ │ ├── theme-provider.tsx
│ │ ├── theme-toggler.tsx
│ │ └── ui
│ │ ├── accordion.tsx
│ │ ├── alert-dialog.tsx
│ │ ├── alert.tsx
│ │ ├── aside-link.tsx
│ │ ├── aspect-ratio.tsx
│ │ ├── avatar.tsx
│ │ ├── background-beams.tsx
│ │ ├── background-boxes.tsx
│ │ ├── badge.tsx
│ │ ├── breadcrumb.tsx
│ │ ├── button.tsx
│ │ ├── calendar.tsx
│ │ ├── callout.tsx
│ │ ├── card.tsx
│ │ ├── carousel.tsx
│ │ ├── chart.tsx
│ │ ├── checkbox.tsx
│ │ ├── code-block.tsx
│ │ ├── collapsible.tsx
│ │ ├── command.tsx
│ │ ├── context-menu.tsx
│ │ ├── dialog.tsx
│ │ ├── drawer.tsx
│ │ ├── dropdown-menu.tsx
│ │ ├── dynamic-code-block.tsx
│ │ ├── fade-in.tsx
│ │ ├── form.tsx
│ │ ├── hover-card.tsx
│ │ ├── input-otp.tsx
│ │ ├── input.tsx
│ │ ├── label.tsx
│ │ ├── menubar.tsx
│ │ ├── navigation-menu.tsx
│ │ ├── pagination.tsx
│ │ ├── popover.tsx
│ │ ├── progress.tsx
│ │ ├── radio-group.tsx
│ │ ├── resizable.tsx
│ │ ├── scroll-area.tsx
│ │ ├── select.tsx
│ │ ├── separator.tsx
│ │ ├── sheet.tsx
│ │ ├── sidebar.tsx
│ │ ├── skeleton.tsx
│ │ ├── slider.tsx
│ │ ├── sonner.tsx
│ │ ├── sparkles.tsx
│ │ ├── switch.tsx
│ │ ├── table.tsx
│ │ ├── tabs.tsx
│ │ ├── textarea.tsx
│ │ ├── toggle-group.tsx
│ │ ├── toggle.tsx
│ │ ├── tooltip-docs.tsx
│ │ ├── tooltip.tsx
│ │ └── use-copy-button.tsx
│ ├── components.json
│ ├── content
│ │ ├── blogs
│ │ │ ├── 0-supabase-auth-to-planetscale-migration.mdx
│ │ │ ├── 1-3.mdx
│ │ │ ├── authjs-joins-better-auth.mdx
│ │ │ └── seed-round.mdx
│ │ ├── changelogs
│ │ │ ├── 1-2.mdx
│ │ │ └── 1.0.mdx
│ │ └── docs
│ │ ├── adapters
│ │ │ ├── community-adapters.mdx
│ │ │ ├── drizzle.mdx
│ │ │ ├── mongo.mdx
│ │ │ ├── mssql.mdx
│ │ │ ├── mysql.mdx
│ │ │ ├── other-relational-databases.mdx
│ │ │ ├── postgresql.mdx
│ │ │ ├── prisma.mdx
│ │ │ └── sqlite.mdx
│ │ ├── authentication
│ │ │ ├── apple.mdx
│ │ │ ├── atlassian.mdx
│ │ │ ├── cognito.mdx
│ │ │ ├── discord.mdx
│ │ │ ├── dropbox.mdx
│ │ │ ├── email-password.mdx
│ │ │ ├── facebook.mdx
│ │ │ ├── figma.mdx
│ │ │ ├── github.mdx
│ │ │ ├── gitlab.mdx
│ │ │ ├── google.mdx
│ │ │ ├── huggingface.mdx
│ │ │ ├── kakao.mdx
│ │ │ ├── kick.mdx
│ │ │ ├── line.mdx
│ │ │ ├── linear.mdx
│ │ │ ├── linkedin.mdx
│ │ │ ├── microsoft.mdx
│ │ │ ├── naver.mdx
│ │ │ ├── notion.mdx
│ │ │ ├── other-social-providers.mdx
│ │ │ ├── paypal.mdx
│ │ │ ├── reddit.mdx
│ │ │ ├── roblox.mdx
│ │ │ ├── salesforce.mdx
│ │ │ ├── slack.mdx
│ │ │ ├── spotify.mdx
│ │ │ ├── tiktok.mdx
│ │ │ ├── twitch.mdx
│ │ │ ├── twitter.mdx
│ │ │ ├── vk.mdx
│ │ │ └── zoom.mdx
│ │ ├── basic-usage.mdx
│ │ ├── comparison.mdx
│ │ ├── concepts
│ │ │ ├── api.mdx
│ │ │ ├── cli.mdx
│ │ │ ├── client.mdx
│ │ │ ├── cookies.mdx
│ │ │ ├── database.mdx
│ │ │ ├── email.mdx
│ │ │ ├── hooks.mdx
│ │ │ ├── oauth.mdx
│ │ │ ├── plugins.mdx
│ │ │ ├── rate-limit.mdx
│ │ │ ├── session-management.mdx
│ │ │ ├── typescript.mdx
│ │ │ └── users-accounts.mdx
│ │ ├── examples
│ │ │ ├── astro.mdx
│ │ │ ├── next-js.mdx
│ │ │ ├── nuxt.mdx
│ │ │ ├── remix.mdx
│ │ │ └── svelte-kit.mdx
│ │ ├── guides
│ │ │ ├── auth0-migration-guide.mdx
│ │ │ ├── browser-extension-guide.mdx
│ │ │ ├── clerk-migration-guide.mdx
│ │ │ ├── create-a-db-adapter.mdx
│ │ │ ├── next-auth-migration-guide.mdx
│ │ │ ├── optimizing-for-performance.mdx
│ │ │ ├── saml-sso-with-okta.mdx
│ │ │ ├── supabase-migration-guide.mdx
│ │ │ └── your-first-plugin.mdx
│ │ ├── installation.mdx
│ │ ├── integrations
│ │ │ ├── astro.mdx
│ │ │ ├── convex.mdx
│ │ │ ├── elysia.mdx
│ │ │ ├── expo.mdx
│ │ │ ├── express.mdx
│ │ │ ├── fastify.mdx
│ │ │ ├── hono.mdx
│ │ │ ├── lynx.mdx
│ │ │ ├── nestjs.mdx
│ │ │ ├── next.mdx
│ │ │ ├── nitro.mdx
│ │ │ ├── nuxt.mdx
│ │ │ ├── remix.mdx
│ │ │ ├── solid-start.mdx
│ │ │ ├── svelte-kit.mdx
│ │ │ ├── tanstack.mdx
│ │ │ └── waku.mdx
│ │ ├── introduction.mdx
│ │ ├── meta.json
│ │ ├── plugins
│ │ │ ├── 2fa.mdx
│ │ │ ├── admin.mdx
│ │ │ ├── anonymous.mdx
│ │ │ ├── api-key.mdx
│ │ │ ├── autumn.mdx
│ │ │ ├── bearer.mdx
│ │ │ ├── captcha.mdx
│ │ │ ├── community-plugins.mdx
│ │ │ ├── device-authorization.mdx
│ │ │ ├── dodopayments.mdx
│ │ │ ├── dub.mdx
│ │ │ ├── email-otp.mdx
│ │ │ ├── generic-oauth.mdx
│ │ │ ├── have-i-been-pwned.mdx
│ │ │ ├── jwt.mdx
│ │ │ ├── last-login-method.mdx
│ │ │ ├── magic-link.mdx
│ │ │ ├── mcp.mdx
│ │ │ ├── multi-session.mdx
│ │ │ ├── oauth-proxy.mdx
│ │ │ ├── oidc-provider.mdx
│ │ │ ├── one-tap.mdx
│ │ │ ├── one-time-token.mdx
│ │ │ ├── open-api.mdx
│ │ │ ├── organization.mdx
│ │ │ ├── passkey.mdx
│ │ │ ├── phone-number.mdx
│ │ │ ├── polar.mdx
│ │ │ ├── siwe.mdx
│ │ │ ├── sso.mdx
│ │ │ ├── stripe.mdx
│ │ │ └── username.mdx
│ │ └── reference
│ │ ├── contributing.mdx
│ │ ├── faq.mdx
│ │ ├── options.mdx
│ │ ├── resources.mdx
│ │ ├── security.mdx
│ │ └── telemetry.mdx
│ ├── hooks
│ │ └── use-mobile.ts
│ ├── ignore-build.sh
│ ├── lib
│ │ ├── blog.ts
│ │ ├── chat
│ │ │ └── inkeep-qa-schema.ts
│ │ ├── constants.ts
│ │ ├── export-search-indexes.ts
│ │ ├── inkeep-analytics.ts
│ │ ├── is-active.ts
│ │ ├── metadata.ts
│ │ ├── source.ts
│ │ └── utils.ts
│ ├── next.config.js
│ ├── package.json
│ ├── postcss.config.js
│ ├── proxy.ts
│ ├── public
│ │ ├── avatars
│ │ │ └── beka.jpg
│ │ ├── blogs
│ │ │ ├── authjs-joins.png
│ │ │ ├── seed-round.png
│ │ │ └── supabase-ps.png
│ │ ├── branding
│ │ │ ├── better-auth-brand-assets.zip
│ │ │ ├── better-auth-logo-dark.png
│ │ │ ├── better-auth-logo-dark.svg
│ │ │ ├── better-auth-logo-light.png
│ │ │ ├── better-auth-logo-light.svg
│ │ │ ├── better-auth-logo-wordmark-dark.png
│ │ │ ├── better-auth-logo-wordmark-dark.svg
│ │ │ ├── better-auth-logo-wordmark-light.png
│ │ │ └── better-auth-logo-wordmark-light.svg
│ │ ├── extension-id.png
│ │ ├── favicon
│ │ │ ├── android-chrome-192x192.png
│ │ │ ├── android-chrome-512x512.png
│ │ │ ├── apple-touch-icon.png
│ │ │ ├── favicon-16x16.png
│ │ │ ├── favicon-32x32.png
│ │ │ ├── favicon.ico
│ │ │ ├── light
│ │ │ │ ├── android-chrome-192x192.png
│ │ │ │ ├── android-chrome-512x512.png
│ │ │ │ ├── apple-touch-icon.png
│ │ │ │ ├── favicon-16x16.png
│ │ │ │ ├── favicon-32x32.png
│ │ │ │ ├── favicon.ico
│ │ │ │ └── site.webmanifest
│ │ │ └── site.webmanifest
│ │ ├── images
│ │ │ └── blogs
│ │ │ └── better auth (1).png
│ │ ├── logo.png
│ │ ├── logo.svg
│ │ ├── LogoDark.webp
│ │ ├── LogoLight.webp
│ │ ├── og.png
│ │ ├── open-api-reference.png
│ │ ├── people-say
│ │ │ ├── code-with-antonio.jpg
│ │ │ ├── dagmawi-babi.png
│ │ │ ├── dax.png
│ │ │ ├── dev-ed.png
│ │ │ ├── egoist.png
│ │ │ ├── guillermo-rauch.png
│ │ │ ├── jonathan-wilke.png
│ │ │ ├── josh-tried-coding.jpg
│ │ │ ├── kitze.jpg
│ │ │ ├── lazar-nikolov.png
│ │ │ ├── nizzy.png
│ │ │ ├── omar-mcadam.png
│ │ │ ├── ryan-vogel.jpg
│ │ │ ├── saltyatom.jpg
│ │ │ ├── sebastien-chopin.png
│ │ │ ├── shreyas-mididoddi.png
│ │ │ ├── tech-nerd.png
│ │ │ ├── theo.png
│ │ │ ├── vybhav-bhargav.png
│ │ │ └── xavier-pladevall.jpg
│ │ ├── plus.svg
│ │ ├── release-og
│ │ │ ├── 1-2.png
│ │ │ ├── 1-3.png
│ │ │ └── changelog-og.png
│ │ └── v1-og.png
│ ├── README.md
│ ├── scripts
│ │ ├── endpoint-to-doc
│ │ │ ├── index.ts
│ │ │ ├── input.ts
│ │ │ ├── output.mdx
│ │ │ └── readme.md
│ │ └── sync-orama.ts
│ ├── source.config.ts
│ ├── tailwind.config.js
│ ├── tsconfig.json
│ └── turbo.json
├── e2e
│ ├── integration
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ ├── solid-vinxi
│ │ │ ├── .gitignore
│ │ │ ├── app.config.ts
│ │ │ ├── e2e
│ │ │ │ ├── test.spec.ts
│ │ │ │ └── utils.ts
│ │ │ ├── package.json
│ │ │ ├── public
│ │ │ │ └── favicon.ico
│ │ │ ├── src
│ │ │ │ ├── app.tsx
│ │ │ │ ├── entry-client.tsx
│ │ │ │ ├── entry-server.tsx
│ │ │ │ ├── global.d.ts
│ │ │ │ ├── lib
│ │ │ │ │ ├── auth-client.ts
│ │ │ │ │ └── auth.ts
│ │ │ │ └── routes
│ │ │ │ ├── [...404].tsx
│ │ │ │ ├── api
│ │ │ │ │ └── auth
│ │ │ │ │ └── [...all].ts
│ │ │ │ └── index.tsx
│ │ │ └── tsconfig.json
│ │ ├── test-utils
│ │ │ ├── package.json
│ │ │ └── src
│ │ │ └── playwright.ts
│ │ └── vanilla-node
│ │ ├── e2e
│ │ │ ├── app.ts
│ │ │ ├── domain.spec.ts
│ │ │ ├── postgres-js.spec.ts
│ │ │ ├── test.spec.ts
│ │ │ └── utils.ts
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── main.ts
│ │ │ └── vite-env.d.ts
│ │ ├── tsconfig.json
│ │ └── vite.config.ts
│ └── smoke
│ ├── package.json
│ ├── test
│ │ ├── bun.spec.ts
│ │ ├── cloudflare.spec.ts
│ │ ├── deno.spec.ts
│ │ ├── fixtures
│ │ │ ├── bun-simple.ts
│ │ │ ├── cloudflare
│ │ │ │ ├── .gitignore
│ │ │ │ ├── drizzle
│ │ │ │ │ ├── 0000_clean_vector.sql
│ │ │ │ │ └── meta
│ │ │ │ │ ├── _journal.json
│ │ │ │ │ └── 0000_snapshot.json
│ │ │ │ ├── drizzle.config.ts
│ │ │ │ ├── package.json
│ │ │ │ ├── src
│ │ │ │ │ ├── auth-schema.ts
│ │ │ │ │ ├── db.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── test
│ │ │ │ │ ├── apply-migrations.ts
│ │ │ │ │ ├── env.d.ts
│ │ │ │ │ └── index.test.ts
│ │ │ │ ├── tsconfig.json
│ │ │ │ ├── vitest.config.ts
│ │ │ │ ├── worker-configuration.d.ts
│ │ │ │ └── wrangler.json
│ │ │ ├── deno-simple.ts
│ │ │ ├── tsconfig-decelration
│ │ │ │ ├── package.json
│ │ │ │ ├── src
│ │ │ │ │ └── index.ts
│ │ │ │ └── tsconfig.json
│ │ │ ├── tsconfig-exact-optional-property-types
│ │ │ │ ├── package.json
│ │ │ │ ├── src
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── organization.ts
│ │ │ │ │ ├── user-additional-fields.ts
│ │ │ │ │ └── username.ts
│ │ │ │ └── tsconfig.json
│ │ │ ├── tsconfig-verbatim-module-syntax-node10
│ │ │ │ ├── package.json
│ │ │ │ ├── src
│ │ │ │ │ └── index.ts
│ │ │ │ └── tsconfig.json
│ │ │ └── vite
│ │ │ ├── package.json
│ │ │ ├── src
│ │ │ │ ├── client.ts
│ │ │ │ └── server.ts
│ │ │ ├── tsconfig.json
│ │ │ └── vite.config.ts
│ │ ├── ssr.ts
│ │ ├── typecheck.spec.ts
│ │ └── vite.spec.ts
│ └── tsconfig.json
├── LICENSE.md
├── package.json
├── packages
│ ├── better-auth
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── __snapshots__
│ │ │ │ └── init.test.ts.snap
│ │ │ ├── adapters
│ │ │ │ ├── adapter-factory
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── test
│ │ │ │ │ │ ├── __snapshots__
│ │ │ │ │ │ │ └── adapter-factory.test.ts.snap
│ │ │ │ │ │ └── adapter-factory.test.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── create-test-suite.ts
│ │ │ │ ├── drizzle-adapter
│ │ │ │ │ ├── drizzle-adapter.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── test
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── adapter.drizzle.mysql.test.ts
│ │ │ │ │ ├── adapter.drizzle.pg.test.ts
│ │ │ │ │ ├── adapter.drizzle.sqlite.test.ts
│ │ │ │ │ └── generate-schema.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── kysely-adapter
│ │ │ │ │ ├── bun-sqlite-dialect.ts
│ │ │ │ │ ├── dialect.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── kysely-adapter.ts
│ │ │ │ │ ├── node-sqlite-dialect.ts
│ │ │ │ │ ├── test
│ │ │ │ │ │ ├── adapter.kysely.mssql.test.ts
│ │ │ │ │ │ ├── adapter.kysely.mysql.test.ts
│ │ │ │ │ │ ├── adapter.kysely.pg.test.ts
│ │ │ │ │ │ ├── adapter.kysely.sqlite.test.ts
│ │ │ │ │ │ └── node-sqlite-dialect.test.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── memory-adapter
│ │ │ │ │ ├── adapter.memory.test.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── memory-adapter.ts
│ │ │ │ ├── mongodb-adapter
│ │ │ │ │ ├── adapter.mongo-db.test.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── mongodb-adapter.ts
│ │ │ │ ├── prisma-adapter
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── prisma-adapter.ts
│ │ │ │ │ └── test
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── base.prisma
│ │ │ │ │ ├── generate-auth-config.ts
│ │ │ │ │ ├── generate-prisma-schema.ts
│ │ │ │ │ ├── get-prisma-client.ts
│ │ │ │ │ ├── prisma.mysql.test.ts
│ │ │ │ │ ├── prisma.pg.test.ts
│ │ │ │ │ ├── prisma.sqlite.test.ts
│ │ │ │ │ └── push-prisma-schema.ts
│ │ │ │ ├── test-adapter.ts
│ │ │ │ ├── test.ts
│ │ │ │ ├── tests
│ │ │ │ │ ├── auth-flow.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── normal.ts
│ │ │ │ │ ├── number-id.ts
│ │ │ │ │ ├── performance.ts
│ │ │ │ │ └── transactions.ts
│ │ │ │ └── utils.ts
│ │ │ ├── api
│ │ │ │ ├── check-endpoint-conflicts.test.ts
│ │ │ │ ├── index.test.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── middlewares
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── origin-check.test.ts
│ │ │ │ │ └── origin-check.ts
│ │ │ │ ├── rate-limiter
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── rate-limiter.test.ts
│ │ │ │ ├── routes
│ │ │ │ │ ├── account.test.ts
│ │ │ │ │ ├── account.ts
│ │ │ │ │ ├── callback.ts
│ │ │ │ │ ├── email-verification.test.ts
│ │ │ │ │ ├── email-verification.ts
│ │ │ │ │ ├── error.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── ok.ts
│ │ │ │ │ ├── reset-password.test.ts
│ │ │ │ │ ├── reset-password.ts
│ │ │ │ │ ├── session-api.test.ts
│ │ │ │ │ ├── session.ts
│ │ │ │ │ ├── sign-in.test.ts
│ │ │ │ │ ├── sign-in.ts
│ │ │ │ │ ├── sign-out.test.ts
│ │ │ │ │ ├── sign-out.ts
│ │ │ │ │ ├── sign-up.test.ts
│ │ │ │ │ ├── sign-up.ts
│ │ │ │ │ ├── update-user.test.ts
│ │ │ │ │ └── update-user.ts
│ │ │ │ ├── to-auth-endpoints.test.ts
│ │ │ │ └── to-auth-endpoints.ts
│ │ │ ├── auth.test.ts
│ │ │ ├── auth.ts
│ │ │ ├── call.test.ts
│ │ │ ├── client
│ │ │ │ ├── client-ssr.test.ts
│ │ │ │ ├── client.test.ts
│ │ │ │ ├── config.ts
│ │ │ │ ├── fetch-plugins.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── lynx
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── lynx-store.ts
│ │ │ │ ├── parser.ts
│ │ │ │ ├── path-to-object.ts
│ │ │ │ ├── plugins
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── infer-plugin.ts
│ │ │ │ ├── proxy.ts
│ │ │ │ ├── query.ts
│ │ │ │ ├── react
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── react-store.ts
│ │ │ │ ├── session-atom.ts
│ │ │ │ ├── solid
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── solid-store.ts
│ │ │ │ ├── svelte
│ │ │ │ │ └── index.ts
│ │ │ │ ├── test-plugin.ts
│ │ │ │ ├── types.ts
│ │ │ │ ├── url.test.ts
│ │ │ │ ├── vanilla.ts
│ │ │ │ └── vue
│ │ │ │ ├── index.ts
│ │ │ │ └── vue-store.ts
│ │ │ ├── cookies
│ │ │ │ ├── check-cookies.ts
│ │ │ │ ├── cookie-utils.ts
│ │ │ │ ├── cookies.test.ts
│ │ │ │ └── index.ts
│ │ │ ├── crypto
│ │ │ │ ├── buffer.ts
│ │ │ │ ├── hash.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── jwt.ts
│ │ │ │ ├── password.test.ts
│ │ │ │ ├── password.ts
│ │ │ │ └── random.ts
│ │ │ ├── db
│ │ │ │ ├── db.test.ts
│ │ │ │ ├── field.ts
│ │ │ │ ├── get-migration.ts
│ │ │ │ ├── get-schema.ts
│ │ │ │ ├── get-tables.test.ts
│ │ │ │ ├── get-tables.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── internal-adapter.test.ts
│ │ │ │ ├── internal-adapter.ts
│ │ │ │ ├── schema.ts
│ │ │ │ ├── secondary-storage.test.ts
│ │ │ │ ├── to-zod.ts
│ │ │ │ ├── utils.ts
│ │ │ │ └── with-hooks.ts
│ │ │ ├── index.ts
│ │ │ ├── init.test.ts
│ │ │ ├── init.ts
│ │ │ ├── integrations
│ │ │ │ ├── next-js.ts
│ │ │ │ ├── node.ts
│ │ │ │ ├── react-start.ts
│ │ │ │ ├── solid-start.ts
│ │ │ │ └── svelte-kit.ts
│ │ │ ├── oauth2
│ │ │ │ ├── index.ts
│ │ │ │ ├── link-account.test.ts
│ │ │ │ ├── link-account.ts
│ │ │ │ ├── state.ts
│ │ │ │ └── utils.ts
│ │ │ ├── plugins
│ │ │ │ ├── access
│ │ │ │ │ ├── access.test.ts
│ │ │ │ │ ├── access.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── additional-fields
│ │ │ │ │ ├── additional-fields.test.ts
│ │ │ │ │ └── client.ts
│ │ │ │ ├── admin
│ │ │ │ │ ├── access
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ └── statement.ts
│ │ │ │ │ ├── admin.test.ts
│ │ │ │ │ ├── admin.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── error-codes.ts
│ │ │ │ │ ├── has-permission.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── anonymous
│ │ │ │ │ ├── anon.test.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── api-key
│ │ │ │ │ ├── api-key.test.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── rate-limit.ts
│ │ │ │ │ ├── routes
│ │ │ │ │ │ ├── create-api-key.ts
│ │ │ │ │ │ ├── delete-all-expired-api-keys.ts
│ │ │ │ │ │ ├── delete-api-key.ts
│ │ │ │ │ │ ├── get-api-key.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── list-api-keys.ts
│ │ │ │ │ │ ├── update-api-key.ts
│ │ │ │ │ │ └── verify-api-key.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── bearer
│ │ │ │ │ ├── bearer.test.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── captcha
│ │ │ │ │ ├── captcha.test.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── error-codes.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── types.ts
│ │ │ │ │ ├── utils.ts
│ │ │ │ │ └── verify-handlers
│ │ │ │ │ ├── captchafox.ts
│ │ │ │ │ ├── cloudflare-turnstile.ts
│ │ │ │ │ ├── google-recaptcha.ts
│ │ │ │ │ ├── h-captcha.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── custom-session
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── custom-session.test.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── device-authorization
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── device-authorization.test.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── schema.ts
│ │ │ │ ├── email-otp
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── email-otp.test.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── generic-oauth
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── generic-oauth.test.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── haveibeenpwned
│ │ │ │ │ ├── haveibeenpwned.test.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── jwt
│ │ │ │ │ ├── adapter.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── jwt.test.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── sign.ts
│ │ │ │ │ ├── types.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── last-login-method
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── custom-prefix.test.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── last-login-method.test.ts
│ │ │ │ ├── magic-link
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── magic-link.test.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── mcp
│ │ │ │ │ ├── authorize.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── mcp.test.ts
│ │ │ │ ├── multi-session
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── multi-session.test.ts
│ │ │ │ ├── oauth-proxy
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── oauth-proxy.test.ts
│ │ │ │ ├── oidc-provider
│ │ │ │ │ ├── authorize.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── oidc.test.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── types.ts
│ │ │ │ │ ├── ui.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── one-tap
│ │ │ │ │ ├── client.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── one-time-token
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── one-time-token.test.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── open-api
│ │ │ │ │ ├── generator.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── logo.ts
│ │ │ │ │ └── open-api.test.ts
│ │ │ │ ├── organization
│ │ │ │ │ ├── access
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ └── statement.ts
│ │ │ │ │ ├── adapter.ts
│ │ │ │ │ ├── call.ts
│ │ │ │ │ ├── client.test.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── error-codes.ts
│ │ │ │ │ ├── has-permission.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── organization-hook.test.ts
│ │ │ │ │ ├── organization.test.ts
│ │ │ │ │ ├── organization.ts
│ │ │ │ │ ├── permission.ts
│ │ │ │ │ ├── routes
│ │ │ │ │ │ ├── crud-access-control.test.ts
│ │ │ │ │ │ ├── crud-access-control.ts
│ │ │ │ │ │ ├── crud-invites.ts
│ │ │ │ │ │ ├── crud-members.test.ts
│ │ │ │ │ │ ├── crud-members.ts
│ │ │ │ │ │ ├── crud-org.test.ts
│ │ │ │ │ │ ├── crud-org.ts
│ │ │ │ │ │ └── crud-team.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── team.test.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── passkey
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── passkey.test.ts
│ │ │ │ ├── phone-number
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── phone-number-error.ts
│ │ │ │ │ └── phone-number.test.ts
│ │ │ │ ├── siwe
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── siwe.test.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── two-factor
│ │ │ │ │ ├── backup-codes
│ │ │ │ │ │ └── index.ts
│ │ │ │ │ ├── client.ts
│ │ │ │ │ ├── constant.ts
│ │ │ │ │ ├── error-code.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── otp
│ │ │ │ │ │ └── index.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── totp
│ │ │ │ │ │ └── index.ts
│ │ │ │ │ ├── two-factor.test.ts
│ │ │ │ │ ├── types.ts
│ │ │ │ │ ├── utils.ts
│ │ │ │ │ └── verify-two-factor.ts
│ │ │ │ └── username
│ │ │ │ ├── client.ts
│ │ │ │ ├── error-codes.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── schema.ts
│ │ │ │ └── username.test.ts
│ │ │ ├── social-providers
│ │ │ │ └── index.ts
│ │ │ ├── social.test.ts
│ │ │ ├── test-utils
│ │ │ │ ├── headers.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── state.ts
│ │ │ │ └── test-instance.ts
│ │ │ ├── types
│ │ │ │ ├── adapter.ts
│ │ │ │ ├── api.ts
│ │ │ │ ├── helper.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── models.ts
│ │ │ │ ├── plugins.ts
│ │ │ │ └── types.test.ts
│ │ │ └── utils
│ │ │ ├── await-object.ts
│ │ │ ├── boolean.ts
│ │ │ ├── clone.ts
│ │ │ ├── constants.ts
│ │ │ ├── date.ts
│ │ │ ├── ensure-utc.ts
│ │ │ ├── get-request-ip.ts
│ │ │ ├── hashing.ts
│ │ │ ├── hide-metadata.ts
│ │ │ ├── id.ts
│ │ │ ├── import-util.ts
│ │ │ ├── index.ts
│ │ │ ├── is-atom.ts
│ │ │ ├── is-promise.ts
│ │ │ ├── json.ts
│ │ │ ├── merger.ts
│ │ │ ├── middleware-response.ts
│ │ │ ├── misc.ts
│ │ │ ├── password.ts
│ │ │ ├── plugin-helper.ts
│ │ │ ├── shim.ts
│ │ │ ├── time.ts
│ │ │ ├── url.ts
│ │ │ └── wildcard.ts
│ │ ├── tsconfig.json
│ │ ├── tsdown.config.ts
│ │ └── vitest.config.ts
│ ├── cli
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── commands
│ │ │ │ ├── generate.ts
│ │ │ │ ├── info.ts
│ │ │ │ ├── init.ts
│ │ │ │ ├── login.ts
│ │ │ │ ├── mcp.ts
│ │ │ │ ├── migrate.ts
│ │ │ │ └── secret.ts
│ │ │ ├── generators
│ │ │ │ ├── auth-config.ts
│ │ │ │ ├── drizzle.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── kysely.ts
│ │ │ │ ├── prisma.ts
│ │ │ │ └── types.ts
│ │ │ ├── index.ts
│ │ │ └── utils
│ │ │ ├── add-svelte-kit-env-modules.ts
│ │ │ ├── check-package-managers.ts
│ │ │ ├── format-ms.ts
│ │ │ ├── get-config.ts
│ │ │ ├── get-package-info.ts
│ │ │ ├── get-tsconfig-info.ts
│ │ │ └── install-dependencies.ts
│ │ ├── test
│ │ │ ├── __snapshots__
│ │ │ │ ├── auth-schema-mysql-enum.txt
│ │ │ │ ├── auth-schema-mysql-number-id.txt
│ │ │ │ ├── auth-schema-mysql-passkey-number-id.txt
│ │ │ │ ├── auth-schema-mysql-passkey.txt
│ │ │ │ ├── auth-schema-mysql.txt
│ │ │ │ ├── auth-schema-number-id.txt
│ │ │ │ ├── auth-schema-pg-enum.txt
│ │ │ │ ├── auth-schema-pg-passkey.txt
│ │ │ │ ├── auth-schema-sqlite-enum.txt
│ │ │ │ ├── auth-schema-sqlite-number-id.txt
│ │ │ │ ├── auth-schema-sqlite-passkey-number-id.txt
│ │ │ │ ├── auth-schema-sqlite-passkey.txt
│ │ │ │ ├── auth-schema-sqlite.txt
│ │ │ │ ├── auth-schema.txt
│ │ │ │ ├── migrations.sql
│ │ │ │ ├── schema-mongodb.prisma
│ │ │ │ ├── schema-mysql-custom.prisma
│ │ │ │ ├── schema-mysql.prisma
│ │ │ │ ├── schema-numberid.prisma
│ │ │ │ └── schema.prisma
│ │ │ ├── generate-all-db.test.ts
│ │ │ ├── generate.test.ts
│ │ │ ├── get-config.test.ts
│ │ │ ├── info.test.ts
│ │ │ └── migrate.test.ts
│ │ ├── tsconfig.json
│ │ ├── tsconfig.test.json
│ │ └── tsdown.config.ts
│ ├── core
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── api
│ │ │ │ └── index.ts
│ │ │ ├── async_hooks
│ │ │ │ └── index.ts
│ │ │ ├── context
│ │ │ │ ├── endpoint-context.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── transaction.ts
│ │ │ ├── db
│ │ │ │ ├── adapter
│ │ │ │ │ └── index.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── plugin.ts
│ │ │ │ ├── schema
│ │ │ │ │ ├── account.ts
│ │ │ │ │ ├── rate-limit.ts
│ │ │ │ │ ├── session.ts
│ │ │ │ │ ├── shared.ts
│ │ │ │ │ ├── user.ts
│ │ │ │ │ └── verification.ts
│ │ │ │ └── type.ts
│ │ │ ├── env
│ │ │ │ ├── color-depth.ts
│ │ │ │ ├── env-impl.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── logger.test.ts
│ │ │ │ └── logger.ts
│ │ │ ├── error
│ │ │ │ ├── codes.ts
│ │ │ │ └── index.ts
│ │ │ ├── index.ts
│ │ │ ├── oauth2
│ │ │ │ ├── client-credentials-token.ts
│ │ │ │ ├── create-authorization-url.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── oauth-provider.ts
│ │ │ │ ├── refresh-access-token.ts
│ │ │ │ ├── utils.ts
│ │ │ │ └── validate-authorization-code.ts
│ │ │ ├── social-providers
│ │ │ │ ├── apple.ts
│ │ │ │ ├── atlassian.ts
│ │ │ │ ├── cognito.ts
│ │ │ │ ├── discord.ts
│ │ │ │ ├── dropbox.ts
│ │ │ │ ├── facebook.ts
│ │ │ │ ├── figma.ts
│ │ │ │ ├── github.ts
│ │ │ │ ├── gitlab.ts
│ │ │ │ ├── google.ts
│ │ │ │ ├── huggingface.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── kakao.ts
│ │ │ │ ├── kick.ts
│ │ │ │ ├── line.ts
│ │ │ │ ├── linear.ts
│ │ │ │ ├── linkedin.ts
│ │ │ │ ├── microsoft-entra-id.ts
│ │ │ │ ├── naver.ts
│ │ │ │ ├── notion.ts
│ │ │ │ ├── paypal.ts
│ │ │ │ ├── reddit.ts
│ │ │ │ ├── roblox.ts
│ │ │ │ ├── salesforce.ts
│ │ │ │ ├── slack.ts
│ │ │ │ ├── spotify.ts
│ │ │ │ ├── tiktok.ts
│ │ │ │ ├── twitch.ts
│ │ │ │ ├── twitter.ts
│ │ │ │ ├── vk.ts
│ │ │ │ └── zoom.ts
│ │ │ ├── types
│ │ │ │ ├── context.ts
│ │ │ │ ├── cookie.ts
│ │ │ │ ├── helper.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── init-options.ts
│ │ │ │ ├── plugin-client.ts
│ │ │ │ └── plugin.ts
│ │ │ └── utils
│ │ │ ├── error-codes.ts
│ │ │ └── index.ts
│ │ ├── tsconfig.json
│ │ └── tsdown.config.ts
│ ├── expo
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── client.ts
│ │ │ ├── expo.test.ts
│ │ │ └── index.ts
│ │ ├── tsconfig.json
│ │ └── tsdown.config.ts
│ ├── sso
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── client.ts
│ │ │ ├── index.ts
│ │ │ ├── oidc.test.ts
│ │ │ └── saml.test.ts
│ │ ├── tsconfig.json
│ │ └── tsdown.config.ts
│ ├── stripe
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── client.ts
│ │ │ ├── hooks.ts
│ │ │ ├── index.ts
│ │ │ ├── schema.ts
│ │ │ ├── stripe.test.ts
│ │ │ ├── types.ts
│ │ │ └── utils.ts
│ │ ├── tsconfig.json
│ │ ├── tsdown.config.ts
│ │ └── vitest.config.ts
│ └── telemetry
│ ├── package.json
│ ├── src
│ │ ├── detectors
│ │ │ ├── detect-auth-config.ts
│ │ │ ├── detect-database.ts
│ │ │ ├── detect-framework.ts
│ │ │ ├── detect-project-info.ts
│ │ │ ├── detect-runtime.ts
│ │ │ └── detect-system-info.ts
│ │ ├── index.ts
│ │ ├── project-id.ts
│ │ ├── telemetry.test.ts
│ │ ├── types.ts
│ │ └── utils
│ │ ├── hash.ts
│ │ ├── id.ts
│ │ ├── import-util.ts
│ │ └── package-json.ts
│ ├── tsconfig.json
│ └── tsdown.config.ts
├── pnpm-lock.yaml
├── pnpm-workspace.yaml
├── README.md
├── SECURITY.md
├── tsconfig.json
└── turbo.json
```
# Files
--------------------------------------------------------------------------------
/packages/better-auth/src/adapters/tests/normal.ts:
--------------------------------------------------------------------------------
```typescript
import { expect } from "vitest";
import { createTestSuite } from "../create-test-suite";
import type { User } from "../../types";
import type { BetterAuthPlugin } from "@better-auth/core";
/**
* This test suite tests the basic CRUD operations of the adapter.
*/
export const normalTestSuite = createTestSuite("normal", {}, (helpers) => {
const tests = getNormalTestSuiteTests(helpers);
return {
"init - tests": async () => {
const opts = helpers.getBetterAuthOptions();
expect(opts.advanced?.database?.useNumberId).toBe(undefined);
},
...tests,
};
});
export const getNormalTestSuiteTests = ({
adapter,
generate,
insertRandom,
modifyBetterAuthOptions,
sortModels,
customIdGenerator,
getBetterAuthOptions,
}: Parameters<Parameters<typeof createTestSuite>[2]>[0]) => {
return {
"create - should create a model": async () => {
const user = await generate("user");
const result = await adapter.create<User>({
model: "user",
data: user,
forceAllowId: true,
});
const options = getBetterAuthOptions();
if (options.advanced?.database?.useNumberId) {
expect(typeof result.id).toEqual("string");
user.id = result.id;
} else {
expect(typeof result.id).toEqual("string");
}
expect(result).toEqual(user);
},
"create - should always return an id": async () => {
const { id: _, ...user } = await generate("user");
const res = await adapter.create<User>({
model: "user",
data: user,
});
expect(res).toHaveProperty("id");
expect(typeof res.id).toEqual("string");
},
"create - should use generateId if provided": async () => {
const ID = (await customIdGenerator?.()) || "MOCK-ID";
await modifyBetterAuthOptions(
{
advanced: {
database: {
generateId: () => ID,
},
},
},
false,
);
const { id: _, ...user } = await generate("user");
const res = await adapter.create<User>({
model: "user",
data: user,
});
expect(res.id).toEqual(ID);
const findResult = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: res.id }],
});
expect(findResult).toEqual(res);
},
"create - should return null for nullable foreign keys": async () => {
await modifyBetterAuthOptions(
{
plugins: [
{
id: "nullable-test",
schema: {
testModel: {
fields: {
nullableReference: {
type: "string",
references: { field: "id", model: "user" },
required: false,
},
},
},
},
} satisfies BetterAuthPlugin,
],
},
true,
);
const { nullableReference } = await adapter.create<{
nullableReference: string | null;
}>({
model: "testModel",
data: { nullableReference: null },
forceAllowId: true,
});
expect(nullableReference).toBeNull();
},
"findOne - should find a model": async () => {
const [user] = await insertRandom("user");
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
expect(result).toEqual(user);
},
"findOne - should find a model using a reference field": async () => {
const [user, session] = await insertRandom("session");
const result = await adapter.findOne<User>({
model: "session",
where: [{ field: "userId", value: user.id }],
});
expect(result).toEqual(session);
},
"findOne - should not throw on record not found": async () => {
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: "100000" }],
});
expect(result).toBeNull();
},
"findOne - should find a model without id": async () => {
const [user] = await insertRandom("user");
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "email", value: user.email }],
});
expect(result).toEqual(user);
},
"findOne - should find a model with modified field name": async () => {
await modifyBetterAuthOptions(
{
user: {
fields: {
email: "email_address",
},
},
},
true,
);
const [user] = await insertRandom("user");
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "email", value: user.email }],
});
expect(result).toEqual(user);
expect(result?.email).toEqual(user.email);
expect(true).toEqual(true);
},
"findOne - should find a model with modified model name": async () => {
await modifyBetterAuthOptions(
{
user: {
modelName: "user_custom",
},
},
true,
);
const [user] = await insertRandom("user");
expect(user).toBeDefined();
expect(user).toHaveProperty("id");
expect(user).toHaveProperty("name");
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "email", value: user.email }],
});
expect(result).toEqual(user);
expect(result?.email).toEqual(user.email);
expect(true).toEqual(true);
},
"findOne - should find a model with additional fields": async () => {
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
customField: {
type: "string",
input: false,
required: true,
defaultValue: "default-value",
},
},
},
},
true,
);
const [user_] = await insertRandom("user");
const user = user_ as User & { customField: string };
expect(user).toHaveProperty("customField");
expect(user.customField).toBe("default-value");
const result = await adapter.findOne<User & { customField: string }>({
model: "user",
where: [{ field: "customField", value: user.customField }],
});
expect(result).toEqual(user);
expect(result?.customField).toEqual("default-value");
},
"findOne - should select fields": async () => {
const [user] = await insertRandom("user");
const result = await adapter.findOne<Pick<User, "email" | "name">>({
model: "user",
where: [{ field: "id", value: user.id }],
select: ["email", "name"],
});
expect(result).toEqual({ email: user.email, name: user.name });
},
"findOne - should find model with date field": async () => {
const [user] = await insertRandom("user");
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "createdAt", value: user.createdAt, operator: "eq" }],
});
expect(result).toEqual(user);
expect(result?.createdAt).toBeInstanceOf(Date);
expect(result?.createdAt).toEqual(user.createdAt);
},
"findMany - should find many models with date fields": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const youngestUser = users.sort(
(a, b) => b.createdAt.getTime() - a.createdAt.getTime(),
)[0]!;
const result = await adapter.findMany<User>({
model: "user",
where: [
{ field: "createdAt", value: youngestUser.createdAt, operator: "lt" },
],
});
expect(sortModels(result)).toEqual(
sortModels(
users.filter((user) => user.createdAt < youngestUser.createdAt),
),
);
},
"findMany - should find many models": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
});
expect(sortModels(result)).toEqual(sortModels(users));
},
"findMany - should return an empty array when no models are found":
async () => {
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "id", value: "100000" }],
});
expect(result).toEqual([]);
},
"findMany - should find many models with starts_with operator":
async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "name", value: "user", operator: "starts_with" }],
});
expect(sortModels(result)).toEqual(sortModels(users));
},
"findMany - starts_with should not interpret regex patterns": async () => {
// Create a user whose name literally starts with the regex-like prefix
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: ".*danger",
},
forceAllowId: true,
});
// Also create some normal users that do NOT start with ".*"
await insertRandom("user", 3);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "name", value: ".*", operator: "starts_with" }],
});
// Should only match the literal ".*" prefix, not treat it as a regex matching everything
expect(result.length).toBe(1);
expect(result[0]!.id).toBe(literalRegexUser.id);
expect(result[0]!.name.startsWith(".*")).toBe(true);
},
"findMany - ends_with should not interpret regex patterns": async () => {
// Create a user whose name literally ends with the regex-like suffix
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: "danger.*",
},
forceAllowId: true,
});
// Also create some normal users that do NOT end with ".*"
await insertRandom("user", 3);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "name", value: ".*", operator: "ends_with" }],
});
// Should only match the literal ".*" suffix, not treat it as a regex matching everything
expect(result.length).toBe(1);
expect(result[0]!.id).toBe(literalRegexUser.id);
expect(result[0]!.name.endsWith(".*")).toBe(true);
},
"findMany - contains should not interpret regex patterns": async () => {
// Create a user whose name literally contains the regex-like pattern
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: "prefix-.*-suffix",
},
forceAllowId: true,
});
// Also create some normal users that do NOT contain ".*"
await insertRandom("user", 3);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "name", value: ".*", operator: "contains" }],
});
// Should only match the literal substring ".*", not treat it as a regex matching everything
expect(result.length).toBe(1);
expect(result[0]!.id).toBe(literalRegexUser.id);
expect(result[0]!.name.includes(".*")).toBe(true);
},
"findMany - should find many models with ends_with operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
for (const user of users) {
const res = await adapter.update<User>({
model: "user",
where: [{ field: "id", value: user.id }],
update: { name: user.name.toLowerCase() }, // make name lowercase
});
if (!res) throw new Error("No result");
let u = users.find((u) => u.id === user.id)!;
u.name = res.name;
u.updatedAt = res.updatedAt;
}
const ends_with = users[0]!.name.slice(-1);
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "name",
value: ends_with,
operator: "ends_with",
},
],
});
const expectedResult = sortModels(
users.filter((user) => user.name.endsWith(ends_with)),
);
if (result.length !== expectedResult.length) {
console.log(`Result length: ${result.length}`);
console.log(sortModels(result));
console.log("--------------------------------");
console.log(
`Expected result length: ${expectedResult.length} - key: ${JSON.stringify(ends_with)}`,
);
console.log(expectedResult);
}
expect(sortModels(result)).toEqual(expectedResult);
},
"findMany - should find many models with contains operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
// if this check fails, the test will fail.
// insertRandom needs to generate emails that contain `@email.com`
expect(users[0]!.email).toContain("@email.com");
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "email",
value: "mail", // all emails contains `@email.com` from `insertRandom`
operator: "contains",
},
],
});
expect(sortModels(result)).toEqual(sortModels(users));
},
"findMany - should handle multiple where conditions with different operators":
async () => {
const testData = [
{ name: "john doe", email: "[email protected]" },
{ name: "jane smith", email: "[email protected]" },
];
const createdUsers: User[] = [];
for (const data of testData) {
const user = await adapter.create({
model: "user",
data: {
...generate("user"),
...data,
},
forceAllowId: true,
});
createdUsers.push(user as User);
}
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "email",
value: "[email protected]",
operator: "eq",
connector: "AND",
},
{
field: "name",
value: "john",
operator: "contains",
connector: "AND",
},
],
});
expect(result.length).toBe(1);
expect(result[0]!.email).toBe("[email protected]");
expect(result[0]!.name).toBe("john doe");
const result2 = await adapter.findMany<User>({
model: "user",
where: [
{
field: "email",
value: "gmail",
operator: "contains",
connector: "AND",
},
{
field: "name",
value: "jane",
operator: "contains",
connector: "AND",
},
],
});
expect(result2.length).toBe(1);
expect(result2[0]!.email).toBe("[email protected]");
expect(result2[0]!.name).toBe("jane smith");
const result3 = await adapter.findMany<User>({
model: "user",
where: [
{
field: "email",
value: "john",
operator: "starts_with",
connector: "AND",
},
{
field: "name",
value: "john",
operator: "contains",
connector: "AND",
},
],
});
expect(result3.length).toBe(1);
expect(result3[0]!.email).toBe("[email protected]");
expect(result3[0]!.name).toBe("john doe");
},
"findMany - should find many models with contains operator (using symbol)":
async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "email", value: "@", operator: "contains" }],
});
expect(sortModels(result)).toEqual(sortModels(users));
},
"findMany - should find many models with eq operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "email", value: users[0]!.email, operator: "eq" }],
});
expect(sortModels(result)).toEqual(sortModels([users[0]!]));
},
"findMany - should find many models with ne operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [{ field: "email", value: users[0]!.email, operator: "ne" }],
});
expect(sortModels(result)).toEqual(sortModels(users.slice(1)));
},
"findMany - should find many models with gt operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const oldestUser = users.sort(
(a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
)[0]!;
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "createdAt",
value: oldestUser.createdAt,
operator: "gt",
},
],
});
const expectedResult = sortModels(
users.filter((user) => user.createdAt > oldestUser.createdAt),
);
expect(result.length).not.toBe(0);
expect(sortModels(result)).toEqual(expectedResult);
},
"findMany - should find many models with gte operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const oldestUser = users.sort(
(a, b) => b.createdAt.getTime() - a.createdAt.getTime(),
)[0]!;
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "createdAt",
value: oldestUser.createdAt,
operator: "gte",
},
],
});
const expectedResult = users.filter(
(user) => user.createdAt >= oldestUser.createdAt,
);
expect(result.length).not.toBe(0);
expect(sortModels(result)).toEqual(sortModels(expectedResult));
},
"findMany - should find many models with lte operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [
{ field: "createdAt", value: users[0]!.createdAt, operator: "lte" },
],
});
const expectedResult = users.filter(
(user) => user.createdAt <= users[0]!.createdAt,
);
expect(sortModels(result)).toEqual(sortModels(expectedResult));
},
"findMany - should find many models with lt operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [
{ field: "createdAt", value: users[0]!.createdAt, operator: "lt" },
],
});
const expectedResult = users.filter(
(user) => user.createdAt < users[0]!.createdAt,
);
expect(sortModels(result)).toEqual(sortModels(expectedResult));
},
"findMany - should find many models with in operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "id",
value: [users[0]!.id, users[1]!.id],
operator: "in",
},
],
});
const expectedResult = users.filter(
(user) => user.id === users[0]!.id || user.id === users[1]!.id,
);
expect(sortModels(result)).toEqual(sortModels(expectedResult));
},
"findMany - should find many models with not_in operator": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
where: [
{
field: "id",
value: [users[0]!.id, users[1]!.id],
operator: "not_in",
},
],
});
expect(sortModels(result)).toEqual([users[2]]);
},
"findMany - should find many models with sortBy": async () => {
let n = -1;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return n++;
},
},
},
},
},
true,
);
const users = (await insertRandom("user", 5)).map(
(x) => x[0],
) as (User & { numericField: number })[];
const result = await adapter.findMany<User & { numericField: number }>({
model: "user",
sortBy: { field: "numericField", direction: "asc" },
});
const expectedResult = users
.map((x) => x.numericField)
.sort((a, b) => a - b);
try {
expect(result.map((x) => x.numericField)).toEqual(expectedResult);
} catch (error) {
console.log(`--------------------------------`);
console.log(`result:`);
console.log(result.map((x) => x.id));
console.log(`expected result:`);
console.log(expectedResult);
console.log(`--------------------------------`);
throw error;
}
const options = getBetterAuthOptions();
if (options.advanced?.database?.useNumberId) {
expect(Number(users[0]!.id)).not.toBeNaN();
}
},
"findMany - should find many models with limit": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
const result = await adapter.findMany<User>({
model: "user",
limit: 1,
});
expect(result.length).toEqual(1);
expect(users.find((x) => x.id === result[0]!.id)).not.toBeNull();
},
"findMany - should find many models with offset": async () => {
// Note: The returned rows are ordered in no particular order
// This is because databases return rows in whatever order is fastest for the query.
const count = 10;
await insertRandom("user", count);
const result = await adapter.findMany<User>({
model: "user",
offset: 2,
});
expect(result.length).toEqual(count - 2);
},
"findMany - should find many models with limit and offset": async () => {
// Note: The returned rows are ordered in no particular order
// This is because databases return rows in whatever order is fastest for the query.
const count = 5;
await insertRandom("user", count);
const result = await adapter.findMany<User>({
model: "user",
limit: 2,
offset: 2,
});
expect(result.length).toEqual(2);
expect(result).toBeInstanceOf(Array);
result.forEach((user) => {
expect(user).toHaveProperty("id");
expect(user).toHaveProperty("name");
expect(user).toHaveProperty("email");
});
},
"findMany - should find many models with sortBy and offset": async () => {
let n = -1;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return n++;
},
},
},
},
},
true,
);
const users = (await insertRandom("user", 5)).map(
(x) => x[0],
) as (User & { numericField: number })[];
const result = await adapter.findMany<User>({
model: "user",
sortBy: { field: "numericField", direction: "asc" },
offset: 2,
});
expect(result).toHaveLength(3);
expect(result).toEqual(
users.sort((a, b) => a.numericField - b.numericField).slice(2),
);
},
"findMany - should find many models with sortBy and limit": async () => {
let n = -1;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return n++;
},
},
},
},
},
true,
);
const users = (await insertRandom("user", 5)).map(
(x) => x[0],
) as (User & { numericField: number })[];
const result = await adapter.findMany<User>({
model: "user",
sortBy: { field: "numericField", direction: "asc" },
limit: 2,
});
expect(result).toEqual(
users.sort((a, b) => a.numericField - b.numericField).slice(0, 2),
);
},
"findMany - should find many models with sortBy and limit and offset":
async () => {
let n = -1;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return n++;
},
},
},
},
},
true,
);
const users = (await insertRandom("user", 5)).map(
(x) => x[0],
) as (User & { numericField: number })[];
const result = await adapter.findMany<User>({
model: "user",
sortBy: { field: "numericField", direction: "asc" },
limit: 2,
offset: 2,
});
expect(result.length).toBe(2);
expect(result).toEqual(
users.sort((a, b) => a.numericField - b.numericField).slice(2, 4),
);
},
"findMany - should find many models with sortBy and limit and offset and where":
async () => {
let n = -1;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return n++;
},
},
},
},
},
true,
);
let users = (await insertRandom("user", 10)).map(
(x) => x[0],
) as (User & { numericField: number })[];
// update the last three users to end with "last"
let i = -1;
for (const user of users) {
i++;
if (i < 5) continue;
const result = await adapter.update<User>({
model: "user",
where: [{ field: "id", value: user.id }],
update: { name: user.name + "-last" },
});
if (!result) throw new Error("No result");
users[i]!.name = result.name;
users[i]!.updatedAt = result.updatedAt;
}
const result = await adapter.findMany<User & { numericField: number }>({
model: "user",
sortBy: { field: "numericField", direction: "asc" },
limit: 2,
offset: 2,
where: [{ field: "name", value: "last", operator: "ends_with" }],
});
// Order of operation for most DBs:
// FROM → WHERE → SORT BY → OFFSET → LIMIT
let expectedResult: any[] = [];
expectedResult = users
.filter((user) => user.name.endsWith("last"))
.sort((a, b) => a.numericField - b.numericField)
.slice(2, 4);
try {
expect(result.length).toBe(2);
expect(result).toEqual(expectedResult);
} catch (error) {
console.log(`--------------------------------`);
console.log(`results:`);
console.log(result.map((x) => x.id));
console.log(`expected results, sorted:`);
console.log(
users
.filter((x) => x.name.toString().endsWith("last"))
.map((x) => x.numericField)
.sort((a, b) => a - b),
);
console.log(`expected results, sorted + offset:`);
console.log(
users
.filter((x) => x.name.toString().endsWith("last"))
.map((x) => x.numericField)
.sort((a, b) => a - b)
.slice(2, 4),
);
console.log(`--------------------------------`);
console.log("FAIL", error);
console.log(`--------------------------------`);
throw error;
}
},
"update - should update a model": async () => {
const [user] = await insertRandom("user");
const result = await adapter.update<User>({
model: "user",
where: [{ field: "id", value: user.id }],
update: { name: "test-name" },
});
const expectedResult = {
...user,
name: "test-name",
};
// because of `onUpdate` hook, the updatedAt field will be different
result!.updatedAt = user.updatedAt;
expect(result).toEqual(expectedResult);
const findResult = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
// because of `onUpdate` hook, the updatedAt field will be different
findResult!.updatedAt = user.updatedAt;
expect(findResult).toEqual(expectedResult);
},
"updateMany - should update all models when where is empty": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.updateMany({
model: "user",
where: [],
update: { name: "test-name" },
});
const result = await adapter.findMany<User>({
model: "user",
});
expect(sortModels(result)).toEqual(
sortModels(users).map((user, i) => ({
...user,
name: "test-name",
updatedAt: sortModels(result)[i]!.updatedAt,
})),
);
},
"updateMany - should update many models with a specific where":
async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.updateMany({
model: "user",
where: [{ field: "id", value: users[0]!.id }],
update: { name: "test-name" },
});
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: users[0]!.id }],
});
expect(result).toEqual({
...users[0],
name: "test-name",
updatedAt: result!.updatedAt,
});
},
"updateMany - should update many models with a multiple where":
async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.updateMany({
model: "user",
where: [
{ field: "id", value: users[0]!.id, connector: "OR" },
{ field: "id", value: users[1]!.id, connector: "OR" },
],
update: { name: "test-name" },
});
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: users[0]!.id }],
});
expect(result).toEqual({
...users[0],
name: "test-name",
updatedAt: result!.updatedAt,
});
},
"delete - should delete a model": async () => {
const [user] = await insertRandom("user");
await adapter.delete({
model: "user",
where: [{ field: "id", value: user.id }],
});
const result = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
expect(result).toBeNull();
},
"delete - should not throw on record not found": async () => {
await expect(
adapter.delete({
model: "user",
where: [{ field: "id", value: "100000" }],
}),
).resolves.not.toThrow();
},
"deleteMany - should delete many models": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.deleteMany({
model: "user",
where: [
{ field: "id", value: users[0]!.id, connector: "OR" },
{ field: "id", value: users[1]!.id, connector: "OR" },
],
});
const result = await adapter.findMany<User>({
model: "user",
});
expect(sortModels(result)).toEqual(sortModels(users.slice(2)));
},
"deleteMany - starts_with should not interpret regex patterns":
async () => {
// Create a user whose name literally starts with the regex-like prefix
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: ".*danger",
},
forceAllowId: true,
});
// Also create some normal users that do NOT start with ".*"
const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.deleteMany({
model: "user",
where: [{ field: "name", value: ".*", operator: "starts_with" }],
});
// The literal ".*danger" user should be deleted
const deleted = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: literalRegexUser.id }],
});
expect(deleted).toBeNull();
// Normal users should remain
for (const user of normalUsers) {
const stillThere = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
expect(stillThere).not.toBeNull();
}
},
"deleteMany - ends_with should not interpret regex patterns": async () => {
// Create a user whose name literally ends with the regex-like suffix
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: "danger.*",
},
forceAllowId: true,
});
const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.deleteMany({
model: "user",
where: [{ field: "name", value: ".*", operator: "ends_with" }],
});
const deleted = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: literalRegexUser.id }],
});
expect(deleted).toBeNull();
for (const user of normalUsers) {
const stillThere = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
expect(stillThere).not.toBeNull();
}
},
"deleteMany - contains should not interpret regex patterns": async () => {
// Create a user whose name literally contains the regex-like pattern
const userTemplate = await generate("user");
const literalRegexUser = await adapter.create<User>({
model: "user",
data: {
...userTemplate,
name: "prefix-.*-suffix",
},
forceAllowId: true,
});
const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
await adapter.deleteMany({
model: "user",
where: [{ field: "name", value: ".*", operator: "contains" }],
});
const deleted = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: literalRegexUser.id }],
});
expect(deleted).toBeNull();
for (const user of normalUsers) {
const stillThere = await adapter.findOne<User>({
model: "user",
where: [{ field: "id", value: user.id }],
});
expect(stillThere).not.toBeNull();
}
},
"deleteMany - should delete many models with numeric values": async () => {
let i = 0;
await modifyBetterAuthOptions(
{
user: {
additionalFields: {
numericField: {
type: "number",
defaultValue() {
return i++;
},
},
},
},
},
true,
);
const users = (await insertRandom("user", 3)).map(
(x) => x[0],
) as (User & { numericField: number })[];
if (!users[0] || !users[1] || !users[2]) {
expect(false).toBe(true);
throw new Error("Users not found");
}
expect(users[0].numericField).toEqual(0);
expect(users[1].numericField).toEqual(1);
expect(users[2].numericField).toEqual(2);
await adapter.deleteMany({
model: "user",
where: [
{
field: "numericField",
value: users[0].numericField,
operator: "gt",
},
],
});
const result = await adapter.findMany<User>({
model: "user",
});
expect(result).toEqual([users[0]]);
},
"deleteMany - should delete many models with boolean values": async () => {
const users = (await insertRandom("user", 3)).map((x) => x[0]);
// in this test, we have 3 users, two of which have emailVerified set to true and one to false
// delete all that has emailVerified set to true, and expect users[1] to be the only one left
if (!users[0] || !users[1] || !users[2]) {
expect(false).toBe(true);
throw new Error("Users not found");
}
await adapter.updateMany({
model: "user",
where: [],
update: { emailVerified: true },
});
await adapter.update({
model: "user",
where: [{ field: "id", value: users[1].id }],
update: { emailVerified: false },
});
await adapter.deleteMany({
model: "user",
where: [{ field: "emailVerified", value: true }],
});
const result = await adapter.findMany<User>({
model: "user",
});
expect(result).toHaveLength(1);
expect(result.find((user) => user.id === users[0]?.id)).toBeUndefined();
expect(result.find((user) => user.id === users[1]?.id)).toBeDefined();
expect(result.find((user) => user.id === users[2]?.id)).toBeUndefined();
},
"count - should count many models": async () => {
const users = await insertRandom("user", 15);
const result = await adapter.count({
model: "user",
});
expect(result).toEqual(users.length);
},
"count - should return 0 with no rows to count": async () => {
const result = await adapter.count({
model: "user",
});
expect(result).toEqual(0);
},
"count - should count with where clause": async () => {
const users = (await insertRandom("user", 15)).map((x) => x[0]);
const result = await adapter.count({
model: "user",
where: [
{ field: "id", value: users[2]!.id, connector: "OR" },
{ field: "id", value: users[3]!.id, connector: "OR" },
],
});
expect(result).toEqual(2);
},
"update - should correctly return record when updating a field used in where clause":
async () => {
// This tests the fix for MySQL where updating a field that's in the where clause
// would previously fail to find the record using the old value
const [user] = await insertRandom("user");
const originalEmail = user.email;
// Update the email, using the old email in the where clause
const result = await adapter.update<User>({
model: "user",
where: [{ field: "email", value: originalEmail }],
update: { email: "[email protected]" },
});
// Should return the updated record with the new email
expect(result).toBeDefined();
expect(result!.email).toBe("[email protected]");
expect(result!.id).toBe(user.id);
// Verify the update persisted by finding with new email
const foundUser = await adapter.findOne<User>({
model: "user",
where: [{ field: "email", value: "[email protected]" }],
});
expect(foundUser).toBeDefined();
expect(foundUser!.id).toBe(user.id);
// Old email should not exist
const oldUser = await adapter.findOne<User>({
model: "user",
where: [{ field: "email", value: originalEmail }],
});
expect(oldUser).toBeNull();
},
"update - should handle updating multiple fields including where clause field":
async () => {
const [user] = await insertRandom("user");
const originalEmail = user.email;
const result = await adapter.update<User>({
model: "user",
where: [{ field: "email", value: originalEmail }],
update: {
email: "[email protected]",
name: "Updated Name",
emailVerified: true,
},
});
expect(result!.email).toBe("[email protected]");
expect(result!.name).toBe("Updated Name");
expect(result!.emailVerified).toBe(true);
expect(result!.id).toBe(user.id);
},
"update - should work when updated field is not in where clause":
async () => {
// Regression test: ensure normal updates still work
const [user] = await insertRandom("user");
const result = await adapter.update<User>({
model: "user",
where: [{ field: "email", value: user.email }],
update: { name: "Updated Name Only" },
});
expect(result!.name).toBe("Updated Name Only");
expect(result!.email).toBe(user.email); // Should remain unchanged
expect(result!.id).toBe(user.id);
},
};
};
```
--------------------------------------------------------------------------------
/packages/stripe/src/index.ts:
--------------------------------------------------------------------------------
```typescript
import {
type GenericEndpointContext,
type BetterAuthPlugin,
logger,
} from "better-auth";
import { createAuthEndpoint, createAuthMiddleware } from "better-auth/plugins";
import Stripe from "stripe";
import { type Stripe as StripeType } from "stripe";
import * as z from "zod/v4";
import {
sessionMiddleware,
APIError,
originCheck,
getSessionFromCtx,
} from "better-auth/api";
import {
onCheckoutSessionCompleted,
onSubscriptionDeleted,
onSubscriptionUpdated,
} from "./hooks";
import type {
InputSubscription,
StripeOptions,
StripePlan,
Subscription,
} from "./types";
import { getPlanByName, getPlanByPriceInfo, getPlans } from "./utils";
import { getSchema } from "./schema";
import { defu } from "defu";
import { defineErrorCodes } from "@better-auth/core/utils";
const STRIPE_ERROR_CODES = defineErrorCodes({
SUBSCRIPTION_NOT_FOUND: "Subscription not found",
SUBSCRIPTION_PLAN_NOT_FOUND: "Subscription plan not found",
ALREADY_SUBSCRIBED_PLAN: "You're already subscribed to this plan",
UNABLE_TO_CREATE_CUSTOMER: "Unable to create customer",
FAILED_TO_FETCH_PLANS: "Failed to fetch plans",
EMAIL_VERIFICATION_REQUIRED:
"Email verification is required before you can subscribe to a plan",
SUBSCRIPTION_NOT_ACTIVE: "Subscription is not active",
SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION:
"Subscription is not scheduled for cancellation",
});
const getUrl = (ctx: GenericEndpointContext, url: string) => {
if (url.startsWith("http")) {
return url;
}
return `${ctx.context.options.baseURL}${
url.startsWith("/") ? url : `/${url}`
}`;
};
async function resolvePriceIdFromLookupKey(
stripeClient: Stripe,
lookupKey: string,
): Promise<string | undefined> {
if (!lookupKey) return undefined;
const prices = await stripeClient.prices.list({
lookup_keys: [lookupKey],
active: true,
limit: 1,
});
return prices.data[0]?.id;
}
export const stripe = <O extends StripeOptions>(options: O) => {
const client = options.stripeClient;
const referenceMiddleware = (
action:
| "upgrade-subscription"
| "list-subscription"
| "cancel-subscription"
| "restore-subscription"
| "billing-portal",
) =>
createAuthMiddleware(async (ctx) => {
const session = ctx.context.session;
if (!session) {
throw new APIError("UNAUTHORIZED");
}
const referenceId =
ctx.body?.referenceId || ctx.query?.referenceId || session.user.id;
if (ctx.body?.referenceId && !options.subscription?.authorizeReference) {
logger.error(
`Passing referenceId into a subscription action isn't allowed if subscription.authorizeReference isn't defined in your stripe plugin config.`,
);
throw new APIError("BAD_REQUEST", {
message:
"Reference id is not allowed. Read server logs for more details.",
});
}
const isAuthorized = ctx.body?.referenceId
? await options.subscription?.authorizeReference?.(
{
user: session.user,
session: session.session,
referenceId,
action,
},
ctx,
)
: true;
if (!isAuthorized) {
throw new APIError("UNAUTHORIZED", {
message: "Unauthorized",
});
}
});
const subscriptionEndpoints = {
/**
* ### Endpoint
*
* POST `/subscription/upgrade`
*
* ### API Methods
*
* **server:**
* `auth.api.upgradeSubscription`
*
* **client:**
* `authClient.subscription.upgrade`
*
* @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/stripe#api-method-subscription-upgrade)
*/
upgradeSubscription: createAuthEndpoint(
"/subscription/upgrade",
{
method: "POST",
body: z.object({
/**
* The name of the plan to subscribe
*/
plan: z.string().meta({
description: 'The name of the plan to upgrade to. Eg: "pro"',
}),
/**
* If annual plan should be applied.
*/
annual: z
.boolean()
.meta({
description: "Whether to upgrade to an annual plan. Eg: true",
})
.optional(),
/**
* Reference id of the subscription to upgrade
* This is used to identify the subscription to upgrade
* If not provided, the user's id will be used
*/
referenceId: z
.string()
.meta({
description:
'Reference id of the subscription to upgrade. Eg: "123"',
})
.optional(),
/**
* This is to allow a specific subscription to be upgrade.
* If subscription id is provided, and subscription isn't found,
* it'll throw an error.
*/
subscriptionId: z
.string()
.meta({
description:
'The id of the subscription to upgrade. Eg: "sub_123"',
})
.optional(),
/**
* Any additional data you want to store in your database
* subscriptions
*/
metadata: z.record(z.string(), z.any()).optional(),
/**
* If a subscription
*/
seats: z
.number()
.meta({
description:
"Number of seats to upgrade to (if applicable). Eg: 1",
})
.optional(),
/**
* Success URL to redirect back after successful subscription
*/
successUrl: z
.string()
.meta({
description:
'Callback URL to redirect back after successful subscription. Eg: "https://example.com/success"',
})
.default("/"),
/**
* Cancel URL
*/
cancelUrl: z
.string()
.meta({
description:
'If set, checkout shows a back button and customers will be directed here if they cancel payment. Eg: "https://example.com/pricing"',
})
.default("/"),
/**
* Return URL
*/
returnUrl: z
.string()
.meta({
description:
'URL to take customers to when they click on the billing portal’s link to return to your website. Eg: "https://example.com/dashboard"',
})
.optional(),
/**
* Disable Redirect
*/
disableRedirect: z
.boolean()
.meta({
description:
"Disable redirect after successful subscription. Eg: true",
})
.default(false),
}),
use: [
sessionMiddleware,
originCheck((c) => {
return [c.body.successURL as string, c.body.cancelURL as string];
}),
referenceMiddleware("upgrade-subscription"),
],
},
async (ctx) => {
const { user, session } = ctx.context.session;
if (
!user.emailVerified &&
options.subscription?.requireEmailVerification
) {
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.EMAIL_VERIFICATION_REQUIRED,
});
}
const referenceId = ctx.body.referenceId || user.id;
const plan = await getPlanByName(options, ctx.body.plan);
if (!plan) {
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_PLAN_NOT_FOUND,
});
}
const subscriptionToUpdate = ctx.body.subscriptionId
? await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: ctx.body.subscriptionId,
connector: "OR",
},
{
field: "stripeSubscriptionId",
value: ctx.body.subscriptionId,
connector: "OR",
},
],
})
: referenceId
? await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [{ field: "referenceId", value: referenceId }],
})
: null;
if (ctx.body.subscriptionId && !subscriptionToUpdate) {
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
let customerId =
subscriptionToUpdate?.stripeCustomerId || user.stripeCustomerId;
if (!customerId) {
try {
// Try to find existing Stripe customer by email
const existingCustomers = await client.customers.list({
email: user.email,
limit: 1,
});
let stripeCustomer = existingCustomers.data[0];
if (!stripeCustomer) {
stripeCustomer = await client.customers.create({
email: user.email,
name: user.name,
metadata: {
...ctx.body.metadata,
userId: user.id,
},
});
}
// Update local DB with Stripe customer ID
await ctx.context.adapter.update({
model: "user",
update: {
stripeCustomerId: stripeCustomer.id,
},
where: [
{
field: "id",
value: user.id,
},
],
});
customerId = stripeCustomer.id;
} catch (e: any) {
ctx.context.logger.error(e);
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER,
});
}
}
const subscriptions = subscriptionToUpdate
? [subscriptionToUpdate]
: await ctx.context.adapter.findMany<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: ctx.body.referenceId || user.id,
},
],
});
const activeOrTrialingSubscription = subscriptions.find(
(sub) => sub.status === "active" || sub.status === "trialing",
);
const activeSubscriptions = await client.subscriptions
.list({
customer: customerId,
})
.then((res) =>
res.data.filter(
(sub) => sub.status === "active" || sub.status === "trialing",
),
);
const activeSubscription = activeSubscriptions.find((sub) => {
// If we have a specific subscription to update, match by ID
if (
subscriptionToUpdate?.stripeSubscriptionId ||
ctx.body.subscriptionId
) {
return (
sub.id === subscriptionToUpdate?.stripeSubscriptionId ||
sub.id === ctx.body.subscriptionId
);
}
// Only find subscription for the same referenceId to avoid mixing personal and org subscriptions
if (activeOrTrialingSubscription?.stripeSubscriptionId) {
return sub.id === activeOrTrialingSubscription.stripeSubscriptionId;
}
return false;
});
// Also find any incomplete subscription that we can reuse
const incompleteSubscription = subscriptions.find(
(sub) => sub.status === "incomplete",
);
if (
activeOrTrialingSubscription &&
activeOrTrialingSubscription.status === "active" &&
activeOrTrialingSubscription.plan === ctx.body.plan &&
activeOrTrialingSubscription.seats === (ctx.body.seats || 1)
) {
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.ALREADY_SUBSCRIBED_PLAN,
});
}
if (activeSubscription && customerId) {
// Find the corresponding database subscription for this Stripe subscription
let dbSubscription = await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "stripeSubscriptionId",
value: activeSubscription.id,
},
],
});
// If no database record exists for this Stripe subscription, update the existing one
if (!dbSubscription && activeOrTrialingSubscription) {
await ctx.context.adapter.update<InputSubscription>({
model: "subscription",
update: {
stripeSubscriptionId: activeSubscription.id,
updatedAt: new Date(),
},
where: [
{
field: "id",
value: activeOrTrialingSubscription.id,
},
],
});
dbSubscription = activeOrTrialingSubscription;
}
// Resolve price ID if using lookup keys
let priceIdToUse: string | undefined = undefined;
if (ctx.body.annual) {
priceIdToUse = plan.annualDiscountPriceId;
if (!priceIdToUse && plan.annualDiscountLookupKey) {
priceIdToUse = await resolvePriceIdFromLookupKey(
client,
plan.annualDiscountLookupKey,
);
}
} else {
priceIdToUse = plan.priceId;
if (!priceIdToUse && plan.lookupKey) {
priceIdToUse = await resolvePriceIdFromLookupKey(
client,
plan.lookupKey,
);
}
}
if (!priceIdToUse) {
throw ctx.error("BAD_REQUEST", {
message: "Price ID not found for the selected plan",
});
}
const { url } = await client.billingPortal.sessions
.create({
customer: customerId,
return_url: getUrl(ctx, ctx.body.returnUrl || "/"),
flow_data: {
type: "subscription_update_confirm",
after_completion: {
type: "redirect",
redirect: {
return_url: getUrl(ctx, ctx.body.returnUrl || "/"),
},
},
subscription_update_confirm: {
subscription: activeSubscription.id,
items: [
{
id: activeSubscription.items.data[0]?.id as string,
quantity: ctx.body.seats || 1,
price: priceIdToUse,
},
],
},
},
})
.catch(async (e) => {
throw ctx.error("BAD_REQUEST", {
message: e.message,
code: e.code,
});
});
return ctx.json({
url,
redirect: true,
});
}
let subscription: Subscription | undefined =
activeOrTrialingSubscription || incompleteSubscription;
if (incompleteSubscription && !activeOrTrialingSubscription) {
const updated = await ctx.context.adapter.update<InputSubscription>({
model: "subscription",
update: {
plan: plan.name.toLowerCase(),
seats: ctx.body.seats || 1,
updatedAt: new Date(),
},
where: [
{
field: "id",
value: incompleteSubscription.id,
},
],
});
subscription = (updated as Subscription) || incompleteSubscription;
}
if (!subscription) {
subscription = await ctx.context.adapter.create<
InputSubscription,
Subscription
>({
model: "subscription",
data: {
plan: plan.name.toLowerCase(),
stripeCustomerId: customerId,
status: "incomplete",
referenceId,
seats: ctx.body.seats || 1,
},
});
}
if (!subscription) {
ctx.context.logger.error("Subscription ID not found");
throw new APIError("INTERNAL_SERVER_ERROR");
}
const params = await options.subscription?.getCheckoutSessionParams?.(
{
user,
session,
plan,
subscription,
},
ctx.request,
//@ts-expect-error
ctx,
);
const hasEverTrialed = subscriptions.some((s) => {
// Check if user has ever had a trial for any plan (not just the same plan)
// This prevents users from getting multiple trials by switching plans
const hadTrial =
!!(s.trialStart || s.trialEnd) || s.status === "trialing";
return hadTrial;
});
const freeTrial =
!hasEverTrialed && plan.freeTrial
? { trial_period_days: plan.freeTrial.days }
: undefined;
let priceIdToUse: string | undefined = undefined;
if (ctx.body.annual) {
priceIdToUse = plan.annualDiscountPriceId;
if (!priceIdToUse && plan.annualDiscountLookupKey) {
priceIdToUse = await resolvePriceIdFromLookupKey(
client,
plan.annualDiscountLookupKey,
);
}
} else {
priceIdToUse = plan.priceId;
if (!priceIdToUse && plan.lookupKey) {
priceIdToUse = await resolvePriceIdFromLookupKey(
client,
plan.lookupKey,
);
}
}
const checkoutSession = await client.checkout.sessions
.create(
{
...(customerId
? {
customer: customerId,
customer_update: {
name: "auto",
address: "auto",
},
}
: {
customer_email: session.user.email,
}),
success_url: getUrl(
ctx,
`${
ctx.context.baseURL
}/subscription/success?callbackURL=${encodeURIComponent(
ctx.body.successUrl,
)}&subscriptionId=${encodeURIComponent(subscription.id)}`,
),
cancel_url: getUrl(ctx, ctx.body.cancelUrl),
line_items: [
{
price: priceIdToUse,
quantity: ctx.body.seats || 1,
},
],
subscription_data: {
...freeTrial,
},
mode: "subscription",
client_reference_id: referenceId,
...params?.params,
metadata: {
userId: user.id,
subscriptionId: subscription.id,
referenceId,
...params?.params?.metadata,
},
},
params?.options,
)
.catch(async (e) => {
throw ctx.error("BAD_REQUEST", {
message: e.message,
code: e.code,
});
});
return ctx.json({
...checkoutSession,
redirect: !ctx.body.disableRedirect,
});
},
),
cancelSubscriptionCallback: createAuthEndpoint(
"/subscription/cancel/callback",
{
method: "GET",
query: z.record(z.string(), z.any()).optional(),
use: [originCheck((ctx) => ctx.query.callbackURL)],
},
async (ctx) => {
if (!ctx.query || !ctx.query.callbackURL || !ctx.query.subscriptionId) {
throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
}
const session = await getSessionFromCtx<{ stripeCustomerId: string }>(
ctx,
);
if (!session) {
throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
}
const { user } = session;
const { callbackURL, subscriptionId } = ctx.query;
if (user?.stripeCustomerId) {
try {
const subscription =
await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: subscriptionId,
},
],
});
if (
!subscription ||
subscription.cancelAtPeriodEnd ||
subscription.status === "canceled"
) {
throw ctx.redirect(getUrl(ctx, callbackURL));
}
const stripeSubscription = await client.subscriptions.list({
customer: user.stripeCustomerId,
status: "active",
});
const currentSubscription = stripeSubscription.data.find(
(sub) => sub.id === subscription.stripeSubscriptionId,
);
if (currentSubscription?.cancel_at_period_end === true) {
await ctx.context.adapter.update({
model: "subscription",
update: {
status: currentSubscription?.status,
cancelAtPeriodEnd: true,
},
where: [
{
field: "id",
value: subscription.id,
},
],
});
await options.subscription?.onSubscriptionCancel?.({
subscription,
cancellationDetails: currentSubscription.cancellation_details,
stripeSubscription: currentSubscription,
event: undefined,
});
}
} catch (error) {
ctx.context.logger.error(
"Error checking subscription status from Stripe",
error,
);
}
}
throw ctx.redirect(getUrl(ctx, callbackURL));
},
),
/**
* ### Endpoint
*
* POST `/subscription/cancel`
*
* ### API Methods
*
* **server:**
* `auth.api.cancelSubscription`
*
* **client:**
* `authClient.subscription.cancel`
*
* @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/stripe#api-method-subscription-cancel)
*/
cancelSubscription: createAuthEndpoint(
"/subscription/cancel",
{
method: "POST",
body: z.object({
referenceId: z
.string()
.meta({
description:
"Reference id of the subscription to cancel. Eg: '123'",
})
.optional(),
subscriptionId: z
.string()
.meta({
description:
"The id of the subscription to cancel. Eg: 'sub_123'",
})
.optional(),
returnUrl: z.string().meta({
description:
'URL to take customers to when they click on the billing portal’s link to return to your website. Eg: "https://example.com/dashboard"',
}),
}),
use: [
sessionMiddleware,
originCheck((ctx) => ctx.body.returnUrl),
referenceMiddleware("cancel-subscription"),
],
},
async (ctx) => {
const referenceId =
ctx.body?.referenceId || ctx.context.session.user.id;
const subscription = ctx.body.subscriptionId
? await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: ctx.body.subscriptionId,
},
],
})
: await ctx.context.adapter
.findMany<Subscription>({
model: "subscription",
where: [{ field: "referenceId", value: referenceId }],
})
.then((subs) =>
subs.find(
(sub) => sub.status === "active" || sub.status === "trialing",
),
);
if (!subscription || !subscription.stripeCustomerId) {
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
const activeSubscriptions = await client.subscriptions
.list({
customer: subscription.stripeCustomerId,
})
.then((res) =>
res.data.filter(
(sub) => sub.status === "active" || sub.status === "trialing",
),
);
if (!activeSubscriptions.length) {
/**
* If the subscription is not found, we need to delete the subscription
* from the database. This is a rare case and should not happen.
*/
await ctx.context.adapter.deleteMany({
model: "subscription",
where: [
{
field: "referenceId",
value: referenceId,
},
],
});
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
const activeSubscription = activeSubscriptions.find(
(sub) => sub.id === subscription.stripeSubscriptionId,
);
if (!activeSubscription) {
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
const { url } = await client.billingPortal.sessions
.create({
customer: subscription.stripeCustomerId,
return_url: getUrl(
ctx,
`${
ctx.context.baseURL
}/subscription/cancel/callback?callbackURL=${encodeURIComponent(
ctx.body?.returnUrl || "/",
)}&subscriptionId=${encodeURIComponent(subscription.id)}`,
),
flow_data: {
type: "subscription_cancel",
subscription_cancel: {
subscription: activeSubscription.id,
},
},
})
.catch(async (e) => {
if (e.message.includes("already set to be cancel")) {
/**
* incase we missed the event from stripe, we set it manually
* this is a rare case and should not happen
*/
if (!subscription.cancelAtPeriodEnd) {
await ctx.context.adapter.update({
model: "subscription",
update: {
cancelAtPeriodEnd: true,
},
where: [
{
field: "referenceId",
value: referenceId,
},
],
});
}
}
throw ctx.error("BAD_REQUEST", {
message: e.message,
code: e.code,
});
});
return {
url,
redirect: true,
};
},
),
restoreSubscription: createAuthEndpoint(
"/subscription/restore",
{
method: "POST",
body: z.object({
referenceId: z
.string()
.meta({
description:
"Reference id of the subscription to restore. Eg: '123'",
})
.optional(),
subscriptionId: z
.string()
.meta({
description:
"The id of the subscription to restore. Eg: 'sub_123'",
})
.optional(),
}),
use: [sessionMiddleware, referenceMiddleware("restore-subscription")],
},
async (ctx) => {
const referenceId =
ctx.body?.referenceId || ctx.context.session.user.id;
const subscription = ctx.body.subscriptionId
? await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: ctx.body.subscriptionId,
},
],
})
: await ctx.context.adapter
.findMany<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: referenceId,
},
],
})
.then((subs) =>
subs.find(
(sub) => sub.status === "active" || sub.status === "trialing",
),
);
if (!subscription || !subscription.stripeCustomerId) {
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
if (
subscription.status != "active" &&
subscription.status != "trialing"
) {
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_ACTIVE,
});
}
if (!subscription.cancelAtPeriodEnd) {
throw ctx.error("BAD_REQUEST", {
message:
STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION,
});
}
const activeSubscription = await client.subscriptions
.list({
customer: subscription.stripeCustomerId,
})
.then(
(res) =>
res.data.filter(
(sub) => sub.status === "active" || sub.status === "trialing",
)[0],
);
if (!activeSubscription) {
throw ctx.error("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
});
}
try {
const newSub = await client.subscriptions.update(
activeSubscription.id,
{
cancel_at_period_end: false,
},
);
await ctx.context.adapter.update({
model: "subscription",
update: {
cancelAtPeriodEnd: false,
updatedAt: new Date(),
},
where: [
{
field: "id",
value: subscription.id,
},
],
});
return ctx.json(newSub);
} catch (error) {
ctx.context.logger.error("Error restoring subscription", error);
throw new APIError("BAD_REQUEST", {
message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER,
});
}
},
),
/**
* ### Endpoint
*
* GET `/subscription/list`
*
* ### API Methods
*
* **server:**
* `auth.api.listActiveSubscriptions`
*
* **client:**
* `authClient.subscription.list`
*
* @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/stripe#api-method-subscription-list)
*/
listActiveSubscriptions: createAuthEndpoint(
"/subscription/list",
{
method: "GET",
query: z.optional(
z.object({
referenceId: z
.string()
.meta({
description:
"Reference id of the subscription to list. Eg: '123'",
})
.optional(),
}),
),
use: [sessionMiddleware, referenceMiddleware("list-subscription")],
},
async (ctx) => {
const subscriptions = await ctx.context.adapter.findMany<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: ctx.query?.referenceId || ctx.context.session.user.id,
},
],
});
if (!subscriptions.length) {
return [];
}
const plans = await getPlans(options);
if (!plans) {
return [];
}
const subs = subscriptions
.map((sub) => {
const plan = plans.find(
(p) => p.name.toLowerCase() === sub.plan.toLowerCase(),
);
return {
...sub,
limits: plan?.limits,
priceId: plan?.priceId,
};
})
.filter((sub) => {
return sub.status === "active" || sub.status === "trialing";
});
return ctx.json(subs);
},
),
subscriptionSuccess: createAuthEndpoint(
"/subscription/success",
{
method: "GET",
query: z.record(z.string(), z.any()).optional(),
use: [originCheck((ctx) => ctx.query.callbackURL)],
},
async (ctx) => {
if (!ctx.query || !ctx.query.callbackURL || !ctx.query.subscriptionId) {
throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
}
const session = await getSessionFromCtx<{ stripeCustomerId: string }>(
ctx,
);
if (!session) {
throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
}
const { user } = session;
const { callbackURL, subscriptionId } = ctx.query;
const subscription = await ctx.context.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: subscriptionId,
},
],
});
if (
subscription?.status === "active" ||
subscription?.status === "trialing"
) {
return ctx.redirect(getUrl(ctx, callbackURL));
}
const customerId =
subscription?.stripeCustomerId || user.stripeCustomerId;
if (customerId) {
try {
const stripeSubscription = await client.subscriptions
.list({
customer: customerId,
status: "active",
})
.then((res) => res.data[0]);
if (stripeSubscription) {
const plan = await getPlanByPriceInfo(
options,
stripeSubscription.items.data[0]?.price.id!,
stripeSubscription.items.data[0]?.price.lookup_key!,
);
if (plan && subscription) {
await ctx.context.adapter.update({
model: "subscription",
update: {
status: stripeSubscription.status,
seats: stripeSubscription.items.data[0]?.quantity || 1,
plan: plan.name.toLowerCase(),
periodEnd: new Date(
stripeSubscription.items.data[0]?.current_period_end! *
1000,
),
periodStart: new Date(
stripeSubscription.items.data[0]?.current_period_start! *
1000,
),
stripeSubscriptionId: stripeSubscription.id,
...(stripeSubscription.trial_start &&
stripeSubscription.trial_end
? {
trialStart: new Date(
stripeSubscription.trial_start * 1000,
),
trialEnd: new Date(
stripeSubscription.trial_end * 1000,
),
}
: {}),
},
where: [
{
field: "id",
value: subscription.id,
},
],
});
}
}
} catch (error) {
ctx.context.logger.error(
"Error fetching subscription from Stripe",
error,
);
}
}
throw ctx.redirect(getUrl(ctx, callbackURL));
},
),
createBillingPortal: createAuthEndpoint(
"/subscription/billing-portal",
{
method: "POST",
body: z.object({
locale: z
.custom<StripeType.Checkout.Session.Locale>((localization) => {
return typeof localization === "string";
})
.optional(),
referenceId: z.string().optional(),
returnUrl: z.string().default("/"),
}),
use: [
sessionMiddleware,
originCheck((ctx) => ctx.body.returnUrl),
referenceMiddleware("billing-portal"),
],
},
async (ctx) => {
const { user } = ctx.context.session;
const referenceId = ctx.body.referenceId || user.id;
let customerId = user.stripeCustomerId;
if (!customerId) {
const subscription = await ctx.context.adapter
.findMany<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: referenceId,
},
],
})
.then((subs) =>
subs.find(
(sub) => sub.status === "active" || sub.status === "trialing",
),
);
customerId = subscription?.stripeCustomerId;
}
if (!customerId) {
throw new APIError("BAD_REQUEST", {
message: "No Stripe customer found for this user",
});
}
try {
const { url } = await client.billingPortal.sessions.create({
locale: ctx.body.locale,
customer: customerId,
return_url: getUrl(ctx, ctx.body.returnUrl),
});
return ctx.json({
url,
redirect: true,
});
} catch (error: any) {
ctx.context.logger.error(
"Error creating billing portal session",
error,
);
throw new APIError("BAD_REQUEST", {
message: error.message,
});
}
},
),
} as const;
return {
id: "stripe",
endpoints: {
stripeWebhook: createAuthEndpoint(
"/stripe/webhook",
{
method: "POST",
metadata: {
isAction: false,
},
cloneRequest: true,
//don't parse the body
disableBody: true,
},
async (ctx) => {
if (!ctx.request?.body) {
throw new APIError("INTERNAL_SERVER_ERROR");
}
const buf = await ctx.request.text();
const sig = ctx.request.headers.get("stripe-signature") as string;
const webhookSecret = options.stripeWebhookSecret;
let event: Stripe.Event;
try {
if (!sig || !webhookSecret) {
throw new APIError("BAD_REQUEST", {
message: "Stripe webhook secret not found",
});
}
event = await client.webhooks.constructEventAsync(
buf,
sig,
webhookSecret,
);
} catch (err: any) {
ctx.context.logger.error(`${err.message}`);
throw new APIError("BAD_REQUEST", {
message: `Webhook Error: ${err.message}`,
});
}
if (!event) {
throw new APIError("BAD_REQUEST", {
message: "Failed to construct event",
});
}
try {
switch (event.type) {
case "checkout.session.completed":
await onCheckoutSessionCompleted(ctx, options, event);
await options.onEvent?.(event);
break;
case "customer.subscription.updated":
await onSubscriptionUpdated(ctx, options, event);
await options.onEvent?.(event);
break;
case "customer.subscription.deleted":
await onSubscriptionDeleted(ctx, options, event);
await options.onEvent?.(event);
break;
default:
await options.onEvent?.(event);
break;
}
} catch (e: any) {
ctx.context.logger.error(
`Stripe webhook failed. Error: ${e.message}`,
);
throw new APIError("BAD_REQUEST", {
message: "Webhook error: See server logs for more information.",
});
}
return ctx.json({ success: true });
},
),
...((options.subscription?.enabled
? subscriptionEndpoints
: {}) as O["subscription"] extends {
enabled: boolean;
}
? typeof subscriptionEndpoints
: {}),
},
init(ctx) {
return {
options: {
databaseHooks: {
user: {
create: {
async after(user, ctx) {
if (ctx && options.createCustomerOnSignUp) {
let extraCreateParams: Partial<Stripe.CustomerCreateParams> =
{};
if (options.getCustomerCreateParams) {
extraCreateParams = await options.getCustomerCreateParams(
user,
ctx,
);
}
const params: Stripe.CustomerCreateParams = defu(
{
email: user.email,
name: user.name,
metadata: {
userId: user.id,
},
},
extraCreateParams,
);
const stripeCustomer =
await client.customers.create(params);
await ctx.context.internalAdapter.updateUser(user.id, {
stripeCustomerId: stripeCustomer.id,
});
await options.onCustomerCreate?.(
{
stripeCustomer,
user: {
...user,
stripeCustomerId: stripeCustomer.id,
},
},
ctx,
);
}
},
},
update: {
async after(user, ctx) {
if (!ctx) return;
try {
// Cast user to include stripeCustomerId (added by the stripe plugin schema)
const userWithStripe = user as typeof user & {
stripeCustomerId?: string;
};
// Only proceed if user has a Stripe customer ID
if (!userWithStripe.stripeCustomerId) return;
// Get the user from the database to check if email actually changed
// The 'user' parameter here is the freshly updated user
// We need to check if the Stripe customer's email matches
const stripeCustomer = await client.customers.retrieve(
userWithStripe.stripeCustomerId,
);
// Check if customer was deleted
if (stripeCustomer.deleted) {
ctx.context.logger.warn(
`Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`,
);
return;
}
// If Stripe customer email doesn't match the user's current email, update it
if (stripeCustomer.email !== user.email) {
await client.customers.update(
userWithStripe.stripeCustomerId,
{
email: user.email,
},
);
ctx.context.logger.info(
`Updated Stripe customer email from ${stripeCustomer.email} to ${user.email}`,
);
}
} catch (e: any) {
// Ignore errors - this is a best-effort sync
// Email might have been deleted or Stripe customer might not exist
ctx.context.logger.error(
`Failed to sync email to Stripe customer: ${e.message}`,
e,
);
}
},
},
},
},
},
};
},
schema: getSchema(options),
} satisfies BetterAuthPlugin;
};
export type { Subscription, StripePlan };
```
--------------------------------------------------------------------------------
/packages/stripe/src/stripe.test.ts:
--------------------------------------------------------------------------------
```typescript
import { betterAuth, type User } from "better-auth";
import { memoryAdapter } from "better-auth/adapters/memory";
import { createAuthClient } from "better-auth/client";
import { setCookieToHeader } from "better-auth/cookies";
import { bearer } from "better-auth/plugins";
import Stripe from "stripe";
import { vi } from "vitest";
import { stripe } from ".";
import { stripeClient } from "./client";
import type { StripeOptions, Subscription } from "./types";
import { expect, describe, it, beforeEach } from "vitest";
import { runWithEndpointContext } from "@better-auth/core/context";
import type { GenericEndpointContext } from "@better-auth/core";
describe("stripe", async () => {
const mockStripe = {
prices: {
list: vi.fn().mockResolvedValue({ data: [{ id: "price_lookup_123" }] }),
},
customers: {
create: vi.fn().mockResolvedValue({ id: "cus_mock123" }),
list: vi.fn().mockResolvedValue({ data: [] }),
retrieve: vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
deleted: false,
}),
update: vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
}),
},
checkout: {
sessions: {
create: vi.fn().mockResolvedValue({
url: "https://checkout.stripe.com/mock",
id: "",
}),
},
},
billingPortal: {
sessions: {
create: vi
.fn()
.mockResolvedValue({ url: "https://billing.stripe.com/mock" }),
},
},
subscriptions: {
retrieve: vi.fn(),
list: vi.fn().mockResolvedValue({ data: [] }),
update: vi.fn(),
},
webhooks: {
constructEvent: vi.fn(),
},
};
const _stripe = mockStripe as unknown as Stripe;
const data = {
user: [],
session: [],
verification: [],
account: [],
customer: [],
subscription: [],
};
const memory = memoryAdapter(data);
const stripeOptions = {
stripeClient: _stripe,
stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
createCustomerOnSignUp: true,
subscription: {
enabled: true,
plans: [
{
priceId: process.env.STRIPE_PRICE_ID_1!,
name: "starter",
lookupKey: "lookup_key_123",
},
{
priceId: process.env.STRIPE_PRICE_ID_2!,
name: "premium",
lookupKey: "lookup_key_234",
},
],
},
} satisfies StripeOptions;
const auth = betterAuth({
database: memory,
baseURL: "http://localhost:3000",
// database: new Database(":memory:"),
emailAndPassword: {
enabled: true,
},
plugins: [stripe(stripeOptions)],
});
const ctx = await auth.$context;
const authClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [
bearer(),
stripeClient({
subscription: true,
}),
],
fetchOptions: {
customFetchImpl: async (url, init) => {
return auth.handler(new Request(url, init));
},
},
});
const testUser = {
email: "[email protected]",
password: "password",
name: "Test User",
};
beforeEach(() => {
data.user = [];
data.session = [];
data.verification = [];
data.account = [];
data.customer = [];
data.subscription = [];
vi.clearAllMocks();
});
async function getHeader() {
const headers = new Headers();
const userRes = await authClient.signIn.email(testUser, {
throw: true,
onSuccess: setCookieToHeader(headers),
});
return {
headers,
response: userRes,
};
}
it("should create a customer on sign up", async () => {
const userRes = await authClient.signUp.email(testUser, {
throw: true,
});
const res = await ctx.adapter.findOne<User>({
model: "user",
where: [
{
field: "id",
value: userRes.user.id,
},
],
});
expect(res).toMatchObject({
id: expect.any(String),
stripeCustomerId: expect.any(String),
});
});
it("should create a subscription", async () => {
const userRes = await authClient.signUp.email(testUser, {
throw: true,
});
const headers = new Headers();
await authClient.signIn.email(testUser, {
throw: true,
onSuccess: setCookieToHeader(headers),
});
const res = await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: {
headers,
},
});
expect(res.data?.url).toBeDefined();
const subscription = await ctx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
expect(subscription).toMatchObject({
id: expect.any(String),
plan: "starter",
referenceId: userRes.user.id,
stripeCustomerId: expect.any(String),
status: "incomplete",
periodStart: undefined,
cancelAtPeriodEnd: false,
trialStart: undefined,
trialEnd: undefined,
});
});
it("should list active subscriptions", async () => {
const userRes = await authClient.signUp.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
},
);
const userId = userRes.user.id;
const headers = new Headers();
await authClient.signIn.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
const listRes = await authClient.subscription.list({
fetchOptions: {
headers,
},
});
expect(Array.isArray(listRes.data)).toBe(true);
await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: {
headers,
},
});
const listBeforeActive = await authClient.subscription.list({
fetchOptions: {
headers,
},
});
expect(listBeforeActive.data?.length).toBe(0);
// Update the subscription status to active
await ctx.adapter.update({
model: "subscription",
update: {
status: "active",
},
where: [
{
field: "referenceId",
value: userId,
},
],
});
const listAfterRes = await authClient.subscription.list({
fetchOptions: {
headers,
},
});
expect(listAfterRes.data?.length).toBeGreaterThan(0);
});
it("should handle subscription webhook events", async () => {
const { id: testReferenceId } = await ctx.adapter.create({
model: "user",
data: {
email: "[email protected]",
},
});
const { id: testSubscriptionId } = await ctx.adapter.create({
model: "subscription",
data: {
referenceId: testReferenceId,
stripeCustomerId: "cus_mock123",
status: "active",
plan: "starter",
},
});
const mockCheckoutSessionEvent = {
type: "checkout.session.completed",
data: {
object: {
mode: "subscription",
subscription: testSubscriptionId,
metadata: {
referenceId: testReferenceId,
subscriptionId: testSubscriptionId,
},
},
},
};
const mockSubscription = {
id: testSubscriptionId,
status: "active",
items: {
data: [
{
price: { id: process.env.STRIPE_PRICE_ID_1 },
quantity: 1,
},
],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
};
const stripeForTest = {
...stripeOptions.stripeClient,
subscriptions: {
...stripeOptions.stripeClient.subscriptions,
retrieve: vi.fn().mockResolvedValue(mockSubscription),
},
webhooks: {
constructEventAsync: vi
.fn()
.mockResolvedValue(mockCheckoutSessionEvent),
},
};
const testOptions = {
...stripeOptions,
stripeClient: stripeForTest as unknown as Stripe,
stripeWebhookSecret: "test_secret",
};
const testAuth = betterAuth({
baseURL: "http://localhost:3000",
database: memory,
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testCtx = await testAuth.$context;
const mockRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(mockCheckoutSessionEvent),
},
);
const response = await testAuth.handler(mockRequest);
expect(response.status).toBe(200);
const updatedSubscription = await testCtx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: testSubscriptionId,
},
],
});
expect(updatedSubscription).toMatchObject({
id: testSubscriptionId,
status: "active",
periodStart: expect.any(Date),
periodEnd: expect.any(Date),
plan: "starter",
});
});
it("should handle subscription webhook events with trial", async () => {
const { id: testReferenceId } = await ctx.adapter.create({
model: "user",
data: {
email: "[email protected]",
},
});
const { id: testSubscriptionId } = await ctx.adapter.create({
model: "subscription",
data: {
referenceId: testReferenceId,
stripeCustomerId: "cus_mock123",
status: "incomplete",
plan: "starter",
},
});
const mockCheckoutSessionEvent = {
type: "checkout.session.completed",
data: {
object: {
mode: "subscription",
subscription: testSubscriptionId,
metadata: {
referenceId: testReferenceId,
subscriptionId: testSubscriptionId,
},
},
},
};
const mockSubscription = {
id: testSubscriptionId,
status: "active",
items: {
data: [
{
price: { id: process.env.STRIPE_PRICE_ID_1 },
quantity: 1,
},
],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
trial_start: Math.floor(Date.now() / 1000),
trial_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
};
const stripeForTest = {
...stripeOptions.stripeClient,
subscriptions: {
...stripeOptions.stripeClient.subscriptions,
retrieve: vi.fn().mockResolvedValue(mockSubscription),
},
webhooks: {
constructEventAsync: vi
.fn()
.mockResolvedValue(mockCheckoutSessionEvent),
},
};
const testOptions = {
...stripeOptions,
stripeClient: stripeForTest as unknown as Stripe,
stripeWebhookSecret: "test_secret",
};
const testAuth = betterAuth({
baseURL: "http://localhost:3000",
database: memory,
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testCtx = await testAuth.$context;
const mockRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(mockCheckoutSessionEvent),
},
);
const response = await testAuth.handler(mockRequest);
expect(response.status).toBe(200);
const updatedSubscription = await testCtx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: testSubscriptionId,
},
],
});
expect(updatedSubscription).toMatchObject({
id: testSubscriptionId,
status: "active",
periodStart: expect.any(Date),
periodEnd: expect.any(Date),
plan: "starter",
trialStart: expect.any(Date),
trialEnd: expect.any(Date),
});
});
const { id: userId } = await ctx.adapter.create({
model: "user",
data: {
email: "[email protected]",
},
});
it("should handle subscription deletion webhook", async () => {
const subId = "test_sub_delete";
await ctx.adapter.create({
model: "subscription",
data: {
referenceId: userId,
stripeCustomerId: "cus_delete_test",
status: "active",
plan: "starter",
stripeSubscriptionId: "sub_delete_test",
},
});
const subscription = await ctx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: userId,
},
],
});
const mockDeleteEvent = {
type: "customer.subscription.deleted",
data: {
object: {
id: "sub_delete_test",
customer: subscription?.stripeCustomerId,
status: "canceled",
metadata: {
referenceId: subscription?.referenceId,
subscriptionId: subscription?.id,
},
},
},
};
const stripeForTest = {
...stripeOptions.stripeClient,
webhooks: {
constructEventAsync: vi.fn().mockResolvedValue(mockDeleteEvent),
},
subscriptions: {
retrieve: vi.fn().mockResolvedValue({
status: "canceled",
id: subId,
}),
},
};
const testOptions = {
...stripeOptions,
stripeClient: stripeForTest as unknown as Stripe,
stripeWebhookSecret: "test_secret",
};
const testAuth = betterAuth({
baseURL: "http://localhost:3000",
emailAndPassword: {
enabled: true,
},
database: memory,
plugins: [stripe(testOptions)],
});
const mockRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(mockDeleteEvent),
},
);
const response = await testAuth.handler(mockRequest);
expect(response.status).toBe(200);
if (subscription) {
const updatedSubscription = await ctx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "id",
value: subscription.id,
},
],
});
expect(updatedSubscription?.status).toBe("canceled");
}
});
it("should execute subscription event handlers", async () => {
const onSubscriptionComplete = vi.fn();
const onSubscriptionUpdate = vi.fn();
const onSubscriptionCancel = vi.fn();
const onSubscriptionDeleted = vi.fn();
const testOptions = {
...stripeOptions,
subscription: {
...stripeOptions.subscription,
onSubscriptionComplete,
onSubscriptionUpdate,
onSubscriptionCancel,
onSubscriptionDeleted,
},
stripeWebhookSecret: "test_secret",
} as unknown as StripeOptions;
const testAuth = betterAuth({
baseURL: "http://localhost:3000",
database: memory,
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
// Test subscription complete handler
const completeEvent = {
type: "checkout.session.completed",
data: {
object: {
mode: "subscription",
subscription: "sub_123",
metadata: {
referenceId: "user_123",
subscriptionId: "sub_123",
},
},
},
};
const mockSubscription = {
status: "active",
items: {
data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
};
const mockStripeForEvents = {
...testOptions.stripeClient,
subscriptions: {
retrieve: vi.fn().mockResolvedValue(mockSubscription),
},
webhooks: {
constructEventAsync: vi.fn().mockResolvedValue(completeEvent),
},
};
const eventTestOptions = {
...testOptions,
stripeClient: mockStripeForEvents as unknown as Stripe,
};
const eventTestAuth = betterAuth({
baseURL: "http://localhost:3000",
database: memory,
emailAndPassword: { enabled: true },
plugins: [stripe(eventTestOptions)],
});
const { id: testSubscriptionId } = await ctx.adapter.create({
model: "subscription",
data: {
referenceId: userId,
stripeCustomerId: "cus_123",
stripeSubscriptionId: "sub_123",
status: "incomplete",
plan: "starter",
},
});
const webhookRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(completeEvent),
},
);
await eventTestAuth.handler(webhookRequest);
expect(onSubscriptionComplete).toHaveBeenCalledWith(
expect.objectContaining({
event: expect.any(Object),
subscription: expect.any(Object),
stripeSubscription: expect.any(Object),
plan: expect.any(Object),
}),
expect.objectContaining({
context: expect.any(Object),
_flag: expect.any(String),
}),
);
const updateEvent = {
type: "customer.subscription.updated",
data: {
object: {
id: testSubscriptionId,
customer: "cus_123",
status: "active",
items: {
data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
},
},
};
const updateRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(updateEvent),
},
);
mockStripeForEvents.webhooks.constructEventAsync.mockReturnValue(
updateEvent,
);
await eventTestAuth.handler(updateRequest);
expect(onSubscriptionUpdate).toHaveBeenCalledWith(
expect.objectContaining({
event: expect.any(Object),
subscription: expect.any(Object),
}),
);
const userCancelEvent = {
type: "customer.subscription.updated",
data: {
object: {
id: testSubscriptionId,
customer: "cus_123",
status: "active",
cancel_at_period_end: true,
cancellation_details: {
reason: "cancellation_requested",
comment: "Customer canceled subscription",
},
items: {
data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
},
},
};
const userCancelRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(userCancelEvent),
},
);
mockStripeForEvents.webhooks.constructEventAsync.mockReturnValue(
userCancelEvent,
);
await eventTestAuth.handler(userCancelRequest);
const cancelEvent = {
type: "customer.subscription.updated",
data: {
object: {
id: testSubscriptionId,
customer: "cus_123",
status: "active",
cancel_at_period_end: true,
items: {
data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
},
current_period_start: Math.floor(Date.now() / 1000),
current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
},
},
};
const cancelRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(cancelEvent),
},
);
mockStripeForEvents.webhooks.constructEventAsync.mockReturnValue(
cancelEvent,
);
await eventTestAuth.handler(cancelRequest);
expect(onSubscriptionCancel).toHaveBeenCalled();
const deleteEvent = {
type: "customer.subscription.deleted",
data: {
object: {
id: testSubscriptionId,
customer: "cus_123",
status: "canceled",
metadata: {
referenceId: userId,
subscriptionId: testSubscriptionId,
},
},
},
};
const deleteRequest = new Request(
"http://localhost:3000/api/auth/stripe/webhook",
{
method: "POST",
headers: {
"stripe-signature": "test_signature",
},
body: JSON.stringify(deleteEvent),
},
);
mockStripeForEvents.webhooks.constructEventAsync.mockReturnValue(
deleteEvent,
);
await eventTestAuth.handler(deleteRequest);
expect(onSubscriptionDeleted).toHaveBeenCalled();
});
it("should allow seat upgrades for the same plan", async () => {
const userRes = await authClient.signUp.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
},
);
const headers = new Headers();
await authClient.signIn.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
await authClient.subscription.upgrade({
plan: "starter",
seats: 1,
fetchOptions: {
headers,
},
});
await ctx.adapter.update({
model: "subscription",
update: {
status: "active",
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
const upgradeRes = await authClient.subscription.upgrade({
plan: "starter",
seats: 5,
fetchOptions: {
headers,
},
});
expect(upgradeRes.data?.url).toBeDefined();
});
it("should prevent duplicate subscriptions with same plan and same seats", async () => {
const userRes = await authClient.signUp.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
},
);
const headers = new Headers();
await authClient.signIn.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
await authClient.subscription.upgrade({
plan: "starter",
seats: 3,
fetchOptions: {
headers,
},
});
await ctx.adapter.update({
model: "subscription",
update: {
status: "active",
seats: 3,
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
const upgradeRes = await authClient.subscription.upgrade({
plan: "starter",
seats: 3,
fetchOptions: {
headers,
},
});
expect(upgradeRes.error).toBeDefined();
expect(upgradeRes.error?.message).toContain("already subscribed");
});
it("should only call Stripe customers.create once for signup and upgrade", async () => {
const userRes = await authClient.signUp.email(
{ ...testUser, email: "[email protected]" },
{ throw: true },
);
const headers = new Headers();
await authClient.signIn.email(
{ ...testUser, email: "[email protected]" },
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
expect(mockStripe.customers.create).toHaveBeenCalledTimes(1);
});
it("should create billing portal session", async () => {
await authClient.signUp.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
},
);
const headers = new Headers();
await authClient.signIn.email(
{
...testUser,
email: "[email protected]",
},
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
const billingPortalRes = await authClient.subscription.billingPortal({
returnUrl: "/dashboard",
fetchOptions: {
headers,
},
});
expect(billingPortalRes.data?.url).toBe("https://billing.stripe.com/mock");
expect(billingPortalRes.data?.redirect).toBe(true);
expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalledWith({
customer: expect.any(String),
return_url: "http://localhost:3000/dashboard",
});
});
it("should not update personal subscription when upgrading with an org referenceId", async () => {
const orgId = "org_b67GF32Cljh7u588AuEblmLVobclDRcP";
const testOptions = {
...stripeOptions,
stripeClient: _stripe,
subscription: {
...stripeOptions.subscription,
authorizeReference: async () => true,
},
} as unknown as StripeOptions;
const testAuth = betterAuth({
baseURL: "http://localhost:3000",
database: memory,
emailAndPassword: { enabled: true },
plugins: [stripe(testOptions)],
});
const testCtx = await testAuth.$context;
const testAuthClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [bearer(), stripeClient({ subscription: true })],
fetchOptions: {
customFetchImpl: async (url, init) =>
testAuth.handler(new Request(url, init)),
},
});
// Sign up and sign in the user
const userRes = await testAuthClient.signUp.email(
{ ...testUser, email: "[email protected]" },
{ throw: true },
);
const headers = new Headers();
await testAuthClient.signIn.email(
{ ...testUser, email: "[email protected]" },
{ throw: true, onSuccess: setCookieToHeader(headers) },
);
// Create a personal subscription (referenceId = user id)
await testAuthClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
const personalSub = await testCtx.adapter.findOne<Subscription>({
model: "subscription",
where: [{ field: "referenceId", value: userRes.user.id }],
});
expect(personalSub).toBeTruthy();
await testCtx.adapter.update({
model: "subscription",
update: {
status: "active",
stripeSubscriptionId: "sub_personal_active_123",
},
where: [{ field: "id", value: personalSub!.id }],
});
mockStripe.subscriptions.list.mockResolvedValue({
data: [
{
id: "sub_personal_active_123",
status: "active",
items: {
data: [
{
id: "si_1",
price: { id: process.env.STRIPE_PRICE_ID_1 },
quantity: 1,
},
],
},
},
],
});
// Attempt to upgrade using an org referenceId
const upgradeRes = await testAuthClient.subscription.upgrade({
plan: "starter",
referenceId: orgId,
fetchOptions: { headers },
});
console.log(upgradeRes);
// // It should NOT go through billing portal (which would update the personal sub)
expect(mockStripe.billingPortal.sessions.create).not.toHaveBeenCalled();
expect(upgradeRes.data?.url).toBeDefined();
const orgSub = await testCtx.adapter.findOne<Subscription>({
model: "subscription",
where: [{ field: "referenceId", value: orgId }],
});
expect(orgSub).toMatchObject({
referenceId: orgId,
status: "incomplete",
plan: "starter",
});
const personalAfter = await testCtx.adapter.findOne<Subscription>({
model: "subscription",
where: [{ field: "id", value: personalSub!.id }],
});
expect(personalAfter?.status).toBe("active");
});
it("should prevent multiple free trials for the same user", async () => {
// Create a user
const userRes = await authClient.signUp.email(
{ ...testUser, email: "[email protected]" },
{ throw: true },
);
const headers = new Headers();
await authClient.signIn.email(
{ ...testUser, email: "[email protected]" },
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
// First subscription with trial
const firstUpgradeRes = await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
expect(firstUpgradeRes.data?.url).toBeDefined();
// Simulate the subscription being created with trial data
await ctx.adapter.update({
model: "subscription",
update: {
status: "trialing",
trialStart: new Date(),
trialEnd: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
// Cancel the subscription
await ctx.adapter.update({
model: "subscription",
update: {
status: "canceled",
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
// Try to subscribe again - should NOT get a trial
const secondUpgradeRes = await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
expect(secondUpgradeRes.data?.url).toBeDefined();
// Verify that the checkout session was created without trial_period_days
// We can't directly test the Stripe session, but we can verify the logic
// by checking that the user has trial history
const subscriptions = (await ctx.adapter.findMany({
model: "subscription",
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
})) as Subscription[];
// Should have 2 subscriptions (first canceled, second new)
expect(subscriptions).toHaveLength(2);
// At least one should have trial data
const hasTrialData = subscriptions.some(
(s: Subscription) => s.trialStart || s.trialEnd,
);
expect(hasTrialData).toBe(true);
});
it("should upgrade existing subscription instead of creating new one", async () => {
// Reset mocks for this test
vi.clearAllMocks();
// Create a user
const userRes = await authClient.signUp.email(
{ ...testUser, email: "[email protected]" },
{ throw: true },
);
const headers = new Headers();
await authClient.signIn.email(
{ ...testUser, email: "[email protected]" },
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
// Mock customers.list to find existing customer
mockStripe.customers.list.mockResolvedValueOnce({
data: [{ id: "cus_test_123" }],
});
// First create a starter subscription
await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
// Simulate the subscription being active
const starterSub = await ctx.adapter.findOne<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
await ctx.adapter.update({
model: "subscription",
update: {
status: "active",
stripeSubscriptionId: "sub_active_test_123",
stripeCustomerId: "cus_mock123", // Use the same customer ID as the mock
},
where: [
{
field: "id",
value: starterSub!.id,
},
],
});
// Also update the user with the Stripe customer ID
await ctx.adapter.update({
model: "user",
update: {
stripeCustomerId: "cus_mock123",
},
where: [
{
field: "id",
value: userRes.user.id,
},
],
});
// Mock Stripe subscriptions.list to return the active subscription
mockStripe.subscriptions.list.mockResolvedValueOnce({
data: [
{
id: "sub_active_test_123",
status: "active",
items: {
data: [
{
id: "si_test_123",
price: { id: process.env.STRIPE_PRICE_ID_1 },
quantity: 1,
current_period_start: Math.floor(Date.now() / 1000),
current_period_end:
Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
},
],
},
},
],
});
// Clear mock calls before the upgrade
mockStripe.checkout.sessions.create.mockClear();
mockStripe.billingPortal.sessions.create.mockClear();
// Now upgrade to premium plan - should use billing portal to update existing subscription
const upgradeRes = await authClient.subscription.upgrade({
plan: "premium",
fetchOptions: { headers },
});
// Verify that billing portal was called (indicating update, not new subscription)
expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalledWith(
expect.objectContaining({
customer: "cus_mock123",
flow_data: expect.objectContaining({
type: "subscription_update_confirm",
subscription_update_confirm: expect.objectContaining({
subscription: "sub_active_test_123",
}),
}),
}),
);
// Should not create a new checkout session
expect(mockStripe.checkout.sessions.create).not.toHaveBeenCalled();
// Verify the response has a redirect URL
expect(upgradeRes.data?.url).toBe("https://billing.stripe.com/mock");
expect(upgradeRes.data?.redirect).toBe(true);
// Verify no new subscription was created in the database
const allSubs = await ctx.adapter.findMany<Subscription>({
model: "subscription",
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
expect(allSubs).toHaveLength(1); // Should still have only one subscription
});
it("should prevent multiple free trials across different plans", async () => {
// Create a user
const userRes = await authClient.signUp.email(
{ ...testUser, email: "[email protected]" },
{ throw: true },
);
const headers = new Headers();
await authClient.signIn.email(
{ ...testUser, email: "[email protected]" },
{
throw: true,
onSuccess: setCookieToHeader(headers),
},
);
// First subscription with trial on starter plan
const firstUpgradeRes = await authClient.subscription.upgrade({
plan: "starter",
fetchOptions: { headers },
});
expect(firstUpgradeRes.data?.url).toBeDefined();
// Simulate the subscription being created with trial data
await ctx.adapter.update({
model: "subscription",
update: {
status: "trialing",
trialStart: new Date(),
trialEnd: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
// Cancel the subscription
await ctx.adapter.update({
model: "subscription",
update: {
status: "canceled",
},
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
});
// Try to subscribe to a different plan - should NOT get a trial
const secondUpgradeRes = await authClient.subscription.upgrade({
plan: "premium",
fetchOptions: { headers },
});
expect(secondUpgradeRes.data?.url).toBeDefined();
// Verify that the user has trial history from the first plan
const subscriptions = (await ctx.adapter.findMany({
model: "subscription",
where: [
{
field: "referenceId",
value: userRes.user.id,
},
],
})) as Subscription[];
// Should have at least 1 subscription (the starter with trial data)
expect(subscriptions.length).toBeGreaterThanOrEqual(1);
// The starter subscription should have trial data
const starterSub = subscriptions.find(
(s: Subscription) => s.plan === "starter",
) as Subscription | undefined;
expect(starterSub?.trialStart).toBeDefined();
expect(starterSub?.trialEnd).toBeDefined();
// Verify that the trial eligibility logic is working by checking
// that the user has ever had a trial (which should prevent future trials)
const hasEverTrialed = subscriptions.some((s: Subscription) => {
const hadTrial =
!!(s.trialStart || s.trialEnd) || s.status === "trialing";
return hadTrial;
});
expect(hasEverTrialed).toBe(true);
});
it("should update stripe customer email when user email changes", async () => {
// Setup mock for customer retrieve and update
mockStripe.customers.retrieve = vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
deleted: false,
});
mockStripe.customers.update = vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
});
// Sign up a user
const userRes = await authClient.signUp.email(testUser, {
throw: true,
});
expect(userRes.user).toBeDefined();
// Verify customer was created during signup
expect(mockStripe.customers.create).toHaveBeenCalledWith({
email: testUser.email,
name: testUser.name,
metadata: {
userId: userRes.user.id,
},
});
// Clear mocks to track the update
vi.clearAllMocks();
// Re-setup the retrieve mock for the update flow
mockStripe.customers.retrieve = vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
deleted: false,
});
mockStripe.customers.update = vi.fn().mockResolvedValue({
id: "cus_mock123",
email: "[email protected]",
});
// Update the user's email using internal adapter (which triggers hooks)
const endpointCtx = { context: ctx } as GenericEndpointContext;
await runWithEndpointContext(endpointCtx, () =>
ctx.internalAdapter.updateUserByEmail(testUser.email, {
email: "[email protected]",
}),
);
// Verify that Stripe customer.retrieve was called
expect(mockStripe.customers.retrieve).toHaveBeenCalledWith("cus_mock123");
// Verify that Stripe customer.update was called with the new email
expect(mockStripe.customers.update).toHaveBeenCalledWith("cus_mock123", {
email: "[email protected]",
});
});
describe("getCustomerCreateParams", () => {
it("should call getCustomerCreateParams and merge with default params", async () => {
const getCustomerCreateParamsMock = vi
.fn()
.mockResolvedValue({ metadata: { customField: "customValue" } });
const testOptions = {
...stripeOptions,
createCustomerOnSignUp: true,
getCustomerCreateParams: getCustomerCreateParamsMock,
} satisfies StripeOptions;
const testAuth = betterAuth({
database: memory,
baseURL: "http://localhost:3000",
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testAuthClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [bearer(), stripeClient({ subscription: true })],
fetchOptions: {
customFetchImpl: async (url, init) =>
testAuth.handler(new Request(url, init)),
},
});
// Sign up a user
const userRes = await testAuthClient.signUp.email(
{
email: "[email protected]",
password: "password",
name: "Custom User",
},
{
throw: true,
},
);
// Verify getCustomerCreateParams was called
expect(getCustomerCreateParamsMock).toHaveBeenCalledWith(
expect.objectContaining({
id: userRes.user.id,
email: "[email protected]",
name: "Custom User",
}),
expect.objectContaining({
context: expect.any(Object),
}),
);
// Verify customer was created with merged params
expect(mockStripe.customers.create).toHaveBeenCalledWith(
expect.objectContaining({
email: "[email protected]",
name: "Custom User",
metadata: expect.objectContaining({
userId: userRes.user.id,
customField: "customValue",
}),
}),
);
});
it("should use getCustomerCreateParams to add custom address", async () => {
const getCustomerCreateParamsMock = vi.fn().mockResolvedValue({
address: {
line1: "123 Main St",
city: "San Francisco",
state: "CA",
postal_code: "94111",
country: "US",
},
});
const testOptions = {
...stripeOptions,
createCustomerOnSignUp: true,
getCustomerCreateParams: getCustomerCreateParamsMock,
} satisfies StripeOptions;
const testAuth = betterAuth({
database: memory,
baseURL: "http://localhost:3000",
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testAuthClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [bearer(), stripeClient({ subscription: true })],
fetchOptions: {
customFetchImpl: async (url, init) =>
testAuth.handler(new Request(url, init)),
},
});
// Sign up a user
await testAuthClient.signUp.email(
{
email: "[email protected]",
password: "password",
name: "Address User",
},
{
throw: true,
},
);
// Verify customer was created with address
expect(mockStripe.customers.create).toHaveBeenCalledWith(
expect.objectContaining({
email: "[email protected]",
name: "Address User",
address: {
line1: "123 Main St",
city: "San Francisco",
state: "CA",
postal_code: "94111",
country: "US",
},
metadata: expect.objectContaining({
userId: expect.any(String),
}),
}),
);
});
it("should properly merge nested objects using defu", async () => {
const getCustomerCreateParamsMock = vi.fn().mockResolvedValue({
metadata: {
customField: "customValue",
anotherField: "anotherValue",
},
phone: "+1234567890",
});
const testOptions = {
...stripeOptions,
createCustomerOnSignUp: true,
getCustomerCreateParams: getCustomerCreateParamsMock,
} satisfies StripeOptions;
const testAuth = betterAuth({
database: memory,
baseURL: "http://localhost:3000",
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testAuthClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [bearer(), stripeClient({ subscription: true })],
fetchOptions: {
customFetchImpl: async (url, init) =>
testAuth.handler(new Request(url, init)),
},
});
// Sign up a user
const userRes = await testAuthClient.signUp.email(
{
email: "[email protected]",
password: "password",
name: "Merge User",
},
{
throw: true,
},
);
// Verify customer was created with properly merged params
// defu merges objects and preserves all fields
expect(mockStripe.customers.create).toHaveBeenCalledWith(
expect.objectContaining({
email: "[email protected]",
name: "Merge User",
phone: "+1234567890",
metadata: {
userId: userRes.user.id,
customField: "customValue",
anotherField: "anotherValue",
},
}),
);
});
it("should work without getCustomerCreateParams", async () => {
// This test ensures backward compatibility
const testOptions = {
...stripeOptions,
createCustomerOnSignUp: true,
// No getCustomerCreateParams provided
} satisfies StripeOptions;
const testAuth = betterAuth({
database: memory,
baseURL: "http://localhost:3000",
emailAndPassword: {
enabled: true,
},
plugins: [stripe(testOptions)],
});
const testAuthClient = createAuthClient({
baseURL: "http://localhost:3000",
plugins: [bearer(), stripeClient({ subscription: true })],
fetchOptions: {
customFetchImpl: async (url, init) =>
testAuth.handler(new Request(url, init)),
},
});
// Sign up a user
const userRes = await testAuthClient.signUp.email(
{
email: "[email protected]",
password: "password",
name: "Default User",
},
{
throw: true,
},
);
// Verify customer was created with default params only
expect(mockStripe.customers.create).toHaveBeenCalledWith({
email: "[email protected]",
name: "Default User",
metadata: {
userId: userRes.user.id,
},
});
});
});
});
```