@deiondz/better-auth-razorpay 2.0.2 → 2.0.4

package/README.md

@@ -112,7 +112,9 @@ export const auth = betterAuth({
 })
 ```
 
-3. **Add Client Plugin**
+3. **Add Client Plugin (required to avoid 404s)**
+
+Add the Razorpay client plugin so requests use the correct paths. **Without it, calls like `authClient.api.get('/razorpay/get-plans')` can hit wrong URLs (e.g. `POST /api/auth/api/get` 404).** The plugin exposes `authClient.razorpay.*` methods that use the plugin’s route map.
 
 ```typescript
 // src/lib/auth-client.ts
@@ -668,23 +670,42 @@ Handle Razorpay webhook events (automatically called by Razorpay).
 
 ## Client Usage
 
-### Better Auth Client Methods
+### Preferred: authClient.razorpay.* (method-based API)
 
-The plugin integrates with Better Auth's client API. Use `authClient.api` for all endpoint calls:
+When you add `razorpayClientPlugin()` to `createAuthClient({ plugins: [...] })`, the client gets `authClient.razorpay` with explicit methods. **Use these so requests hit the correct paths** (avoids 404s like `POST /api/auth/api/get`):
 
 ```typescript
 import { authClient } from '@/lib/auth-client'
 
-// GET request
-const plans = await authClient.api.get('/razorpay/get-plans')
+// GET plans
+const plansRes = await authClient.razorpay.getPlans()
+if (plansRes.success) console.log(plansRes.data)
+
+// List subscriptions
+const listRes = await authClient.razorpay.listSubscriptions({ referenceId: 'optional' })
 
-// POST request (create or update subscription)
-const result = await authClient.api.post('/razorpay/subscription/create-or-update', {
-  body: { plan: 'Starter', annual: false, seats: 1 },
+// Create or update subscription (returns checkoutUrl for Razorpay payment page)
+const result = await authClient.razorpay.createOrUpdateSubscription({
+  plan: 'Starter',
+  annual: false,
+  seats: 1,
+})
+if (result.success) window.location.href = result.data.checkoutUrl
+
+// Cancel, restore, verify payment
+await authClient.razorpay.cancelSubscription({ subscriptionId: 'sub_xxx', immediately: false })
+await authClient.razorpay.restoreSubscription({ subscriptionId: 'sub_xxx' })
+await authClient.razorpay.verifyPayment({
+  razorpay_payment_id: 'pay_xxx',
+  razorpay_subscription_id: 'sub_xxx',
+  razorpay_signature: '...',
 })
-// result.data.checkoutUrl -> redirect user to Razorpay payment page
 ```
 
+### Fallback: authClient.api (only if client plugin is not used)
+
+If you do not add the client plugin, you can use `authClient.api.get/post` with the Razorpay paths. **This can lead to 404s** (e.g. `POST /api/auth/api/get`) depending on how your auth client resolves paths. Prefer adding the client plugin and using `authClient.razorpay.*` instead.
+
 ### Type Safety
 
 Infer types from your auth configuration:
@@ -704,7 +725,7 @@ type User = typeof authClient.$Infer.Session.user
 
 ## TanStack Query Hooks
 
-The plugin works with **TanStack Query**: you can use it with `useQuery`/`useMutation` and `authClient.api` in any way you like. We provide optional pre-built hooks below; if you prefer a different setup, build your own hooks around the same endpoints (e.g. `authClient.api.get('/razorpay/get-plans')`, `authClient.api.post('/razorpay/subscription/create-or-update', { body })`, etc.).
+The plugin works with **TanStack Query**. We provide optional pre-built hooks that accept your auth client; when you use `razorpayClientPlugin()`, the hooks call `authClient.razorpay.*` so requests hit the correct paths. If you prefer a different setup, use `authClient.razorpay.getPlans()`, `authClient.razorpay.createOrUpdateSubscription(...)`, etc., or build your own hooks around those methods.
 
 To use our pre-built hooks, install peer dependencies:
 
@@ -1357,38 +1378,43 @@ async function initializeRazorpayCheckout(subscriptionId: string) {
 
 ### Common Issues
 
-**1. "Plan not found in configured plans"**
+**1. "POST /api/auth/api/get 404" or Razorpay requests returning 404**
+- Add the **client plugin** to your auth client: `createAuthClient({ plugins: [razorpayClientPlugin(), ...] })`
+- Use **method-based API** instead of `authClient.api.get/post`: call `authClient.razorpay.getPlans()`, `authClient.razorpay.createOrUpdateSubscription(...)`, etc., so requests use the plugin’s route map and hit the correct paths
+- The TanStack hooks (`usePlans`, `useSubscriptions`, etc.) use `authClient.razorpay` when present, so they work correctly once the client plugin is added
+
+**2. "Plan not found in configured plans"**
 - Ensure the plan ID exists in Razorpay dashboard
 - Add the plan ID to the `plans` array in plugin configuration
 - Re-run Better Auth CLI after updating plans
 
-**2. "Webhook signature verification failed"**
+**3. "Webhook signature verification failed"**
 - Verify webhook secret matches Razorpay dashboard
 - Ensure webhook URL is correct: `https://yourdomain.com/api/auth/razorpay/webhook`
 - Check that request body is not modified
 - Verify `x-razorpay-signature` header is present
 
-**3. "Subscription already exists"**
+**4. "Subscription already exists"**
 - User already has an active subscription
 - Cancel or pause existing subscription first
 - Check subscription status before creating new one
 
-**4. "User not authenticated"**
+**5. "User not authenticated"**
 - Ensure user is logged in via Better Auth
 - Check session middleware is properly configured
 - Verify `sessionMiddleware` is used in endpoint configuration
 
-**5. "Subscription not found"**
+**6. "Subscription not found"**
 - Subscription may have been deleted
 - Check subscription ID is correct
 - Verify subscription belongs to the user
 
-**6. Database Schema Issues**
+**7. Database Schema Issues**
 - Run `npx @better-auth/cli@latest migrate` after adding plugin
 - For Prisma/Drizzle: Run `npx @better-auth/cli@latest generate`
 - Check that user additional fields are properly configured
 
-**7. Type Errors**
+**8. Type Errors**
 - Ensure you're using `createAuthClient<typeof auth>()` for type inference
 - Import types from `@deiondz/better-auth-razorpay`
 - Check that plugin is properly exported

package/client/hooks.ts

@@ -46,73 +46,86 @@ function assertSuccess<T>(res: unknown): asserts res is { success: true; data: T
   throw new Error('Invalid response')
 }
 
-/** Fetch plans (GET /razorpay/get-plans). */
+/** Fetch plans (GET /razorpay/get-plans). Prefers client.razorpay when available to avoid 404s. */
 async function fetchPlans(client: RazorpayAuthClient): Promise<PlanSummary[]> {
-  const res = await client.api.get(`${BASE}/get-plans`)
+  const res = client.razorpay
+    ? await client.razorpay.getPlans()
+    : await client.api.get(`${BASE}/get-plans`)
   assertSuccess<PlanSummary[]>(res)
   return res.data
 }
 
-/** Fetch subscriptions list (GET /razorpay/subscription/list). */
+/** Fetch subscriptions list (GET /razorpay/subscription/list). Prefers client.razorpay when available. */
 async function fetchSubscriptions(
   client: RazorpayAuthClient,
   input?: ListSubscriptionsInput
 ): Promise<ListSubscriptionsResponse['data']> {
-  const query: Record<string, string> = {}
-  if (input?.referenceId) query.referenceId = input.referenceId
-  const path = `${BASE}/subscription/list`
-  const res =
-    Object.keys(query).length > 0
-      ? await client.api.get(path, { query })
-      : await client.api.get(path)
+  const res = client.razorpay
+    ? await client.razorpay.listSubscriptions(input)
+    : (() => {
+      const query: Record<string, string> = {}
+      if (input?.referenceId) query.referenceId = input.referenceId
+      const path = `${BASE}/subscription/list`
+      return Object.keys(query).length > 0
+        ? client.api.get(path, { query })
+        : client.api.get(path)
+    })()
   assertSuccess<ListSubscriptionsResponse['data']>(res)
   return res.data
 }
 
-/** Create or update subscription (POST /razorpay/subscription/create-or-update). */
+/** Create or update subscription (POST /razorpay/subscription/create-or-update). Prefers client.razorpay when available. */
 async function createOrUpdateSubscription(
   client: RazorpayAuthClient,
   input: CreateOrUpdateSubscriptionInput
 ): Promise<CreateOrUpdateSubscriptionResponse['data']> {
-  const res = await client.api.post(`${BASE}/subscription/create-or-update`, {
-    body: input as unknown as Record<string, unknown>,
-  })
+  const res = client.razorpay
+    ? await client.razorpay.createOrUpdateSubscription(input)
+    : await client.api.post(`${BASE}/subscription/create-or-update`, {
+      body: input as unknown as Record<string, unknown>,
+    })
   assertSuccess<CreateOrUpdateSubscriptionResponse['data']>(res)
   return res.data
 }
 
-/** Cancel subscription (POST /razorpay/subscription/cancel). */
+/** Cancel subscription (POST /razorpay/subscription/cancel). Prefers client.razorpay when available. */
 async function cancelSubscription(
   client: RazorpayAuthClient,
   input: CancelSubscriptionInput
 ): Promise<CancelSubscriptionResponse['data']> {
-  const res = await client.api.post(`${BASE}/subscription/cancel`, {
-    body: input as unknown as Record<string, unknown>,
-  })
+  const res = client.razorpay
+    ? await client.razorpay.cancelSubscription(input)
+    : await client.api.post(`${BASE}/subscription/cancel`, {
+      body: input as unknown as Record<string, unknown>,
+    })
   assertSuccess<CancelSubscriptionResponse['data']>(res)
   return res.data
 }
 
-/** Restore subscription (POST /razorpay/subscription/restore). */
+/** Restore subscription (POST /razorpay/subscription/restore). Prefers client.razorpay when available. */
 async function restoreSubscription(
   client: RazorpayAuthClient,
   input: RestoreSubscriptionInput
 ): Promise<RestoreSubscriptionResponse['data']> {
-  const res = await client.api.post(`${BASE}/subscription/restore`, {
-    body: input as unknown as Record<string, unknown>,
-  })
+  const res = client.razorpay
+    ? await client.razorpay.restoreSubscription(input)
+    : await client.api.post(`${BASE}/subscription/restore`, {
+      body: input as unknown as Record<string, unknown>,
+    })
   assertSuccess<RestoreSubscriptionResponse['data']>(res)
   return res.data
 }
 
-/** Verify payment (POST /razorpay/verify-payment). */
+/** Verify payment (POST /razorpay/verify-payment). Prefers client.razorpay when available. */
 async function verifyPayment(
   client: RazorpayAuthClient,
   input: VerifyPaymentInput
 ): Promise<VerifyPaymentResponse['data']> {
-  const res = await client.api.post(`${BASE}/verify-payment`, {
-    body: input as unknown as Record<string, unknown>,
-  })
+  const res = client.razorpay
+    ? await client.razorpay.verifyPayment(input)
+    : await client.api.post(`${BASE}/verify-payment`, {
+      body: input as unknown as Record<string, unknown>,
+    })
   assertSuccess<VerifyPaymentResponse['data']>(res)
   return res.data
 }
@@ -228,6 +241,7 @@ export type UseRestoreSubscriptionOptions = UseMutationOptions<
 // Re-export client types for convenience when importing from this entry
 export type {
   RazorpayAuthClient,
+  RazorpayClientActions,
   PlanSummary,
   CreateOrUpdateSubscriptionInput,
   CancelSubscriptionInput,

package/client/types.ts

@@ -64,9 +64,34 @@ export type RazorpayApiResult<T = unknown> =
   | { success: true; data: T }
   | RazorpayApiError
 
+/** Razorpay API actions from the client plugin (authClient.razorpay). Use these so requests hit the correct paths. */
+export interface RazorpayClientActions {
+  getPlans: (fetchOptions?: { query?: Record<string, string> }) => Promise<RazorpayApiResult<PlanSummary[]>>
+  listSubscriptions: (
+    input?: ListSubscriptionsInput,
+    fetchOptions?: { query?: Record<string, string> }
+  ) => Promise<RazorpayApiResult<ListSubscriptionsResponse['data']>>
+  createOrUpdateSubscription: (
+    input: CreateOrUpdateSubscriptionInput,
+    fetchOptions?: { body?: Record<string, unknown> }
+  ) => Promise<RazorpayApiResult<CreateOrUpdateSubscriptionResponse['data']>>
+  cancelSubscription: (
+    input: CancelSubscriptionInput,
+    fetchOptions?: { body?: Record<string, unknown> }
+  ) => Promise<RazorpayApiResult<CancelSubscriptionResponse['data']>>
+  restoreSubscription: (
+    input: RestoreSubscriptionInput,
+    fetchOptions?: { body?: Record<string, unknown> }
+  ) => Promise<RazorpayApiResult<RestoreSubscriptionResponse['data']>>
+  verifyPayment: (
+    input: VerifyPaymentInput,
+    fetchOptions?: { body?: Record<string, unknown> }
+  ) => Promise<RazorpayApiResult<VerifyPaymentResponse['data']>>
+}
+
 /**
  * Minimal auth client interface for Razorpay hooks.
- * Compatible with Better Auth's createAuthClient() return type.
+ * When using the client plugin (razorpayClientPlugin()), authClient.razorpay is set and hooks use it so requests hit the correct paths (avoids 404s from api.get/post).
  */
 export interface RazorpayAuthClient {
   api: {
@@ -79,6 +104,8 @@ export interface RazorpayAuthClient {
       options?: { body?: Record<string, unknown> }
     ) => Promise<RazorpayApiResult<unknown>>
   }
+  /** Set when razorpayClientPlugin() is used in createAuthClient({ plugins: [razorpayClientPlugin()] }). Prefer these methods over api.get/post. */
+  razorpay?: RazorpayClientActions
 }
 
 /** Input for create-or-update subscription. */

package/client.ts

@@ -1,8 +1,105 @@
 import type { BetterAuthClientPlugin } from 'better-auth/client'
 import type { razorpayPlugin } from './index'
+import type {
+  PlanSummary,
+  CreateOrUpdateSubscriptionInput,
+  CancelSubscriptionInput,
+  RestoreSubscriptionInput,
+  ListSubscriptionsInput,
+  VerifyPaymentInput,
+  ListSubscriptionsResponse,
+  CreateOrUpdateSubscriptionResponse,
+  CancelSubscriptionResponse,
+  RestoreSubscriptionResponse,
+  VerifyPaymentResponse,
+  RazorpayApiResult,
+} from './client/types'
 
+type FetchFn = (
+  path: string,
+  options?: {
+    method?: string
+    body?: Record<string, unknown>
+    query?: Record<string, string>
+  }
+) => Promise<RazorpayApiResult<unknown>>
+
+const PATHS = {
+  getPlans: '/razorpay/get-plans',
+  listSubscriptions: '/razorpay/subscription/list',
+  createOrUpdateSubscription: '/razorpay/subscription/create-or-update',
+  cancelSubscription: '/razorpay/subscription/cancel',
+  restoreSubscription: '/razorpay/subscription/restore',
+  verifyPayment: '/razorpay/verify-payment',
+} as const
+
+/**
+ * Razorpay client plugin for Better Auth.
+ * Exposes authClient.razorpay.* so requests use the correct paths and avoid 404s from api.get/post.
+ * Add to createAuthClient: plugins: [razorpayClientPlugin()]
+ */
 export const razorpayClientPlugin = () =>
   ({
     id: 'razorpay-plugin',
     $InferServerPlugin: {} as ReturnType<typeof razorpayPlugin>,
+    getActions: ($fetch: FetchFn) => ({
+      razorpay: {
+        getPlans: (fetchOptions?: Parameters<FetchFn>[1]) =>
+          $fetch(PATHS.getPlans, { method: 'GET', ...fetchOptions }) as Promise<
+            RazorpayApiResult<PlanSummary[]>
+          >,
+
+        listSubscriptions: (
+          input?: ListSubscriptionsInput,
+          fetchOptions?: Parameters<FetchFn>[1]
+        ) =>
+          $fetch(PATHS.listSubscriptions, {
+            method: 'GET',
+            query: input?.referenceId ? { referenceId: input.referenceId } : undefined,
+            ...fetchOptions,
+          }) as Promise<RazorpayApiResult<ListSubscriptionsResponse['data']>>,
+
+        createOrUpdateSubscription: (
+          input: CreateOrUpdateSubscriptionInput,
+          fetchOptions?: Parameters<FetchFn>[1]
+        ) =>
+          $fetch(PATHS.createOrUpdateSubscription, {
+            method: 'POST',
+            body: input as unknown as Record<string, unknown>,
+            ...fetchOptions,
+          }) as Promise<
+            RazorpayApiResult<CreateOrUpdateSubscriptionResponse['data']>
+          >,
+
+        cancelSubscription: (
+          input: CancelSubscriptionInput,
+          fetchOptions?: Parameters<FetchFn>[1]
+        ) =>
+          $fetch(PATHS.cancelSubscription, {
+            method: 'POST',
+            body: input as unknown as Record<string, unknown>,
+            ...fetchOptions,
+          }) as Promise<RazorpayApiResult<CancelSubscriptionResponse['data']>>,
+
+        restoreSubscription: (
+          input: RestoreSubscriptionInput,
+          fetchOptions?: Parameters<FetchFn>[1]
+        ) =>
+          $fetch(PATHS.restoreSubscription, {
+            method: 'POST',
+            body: input as unknown as Record<string, unknown>,
+            ...fetchOptions,
+          }) as Promise<RazorpayApiResult<RestoreSubscriptionResponse['data']>>,
+
+        verifyPayment: (
+          input: VerifyPaymentInput,
+          fetchOptions?: Parameters<FetchFn>[1]
+        ) =>
+          $fetch(PATHS.verifyPayment, {
+            method: 'POST',
+            body: input as unknown as Record<string, unknown>,
+            ...fetchOptions,
+          }) as Promise<RazorpayApiResult<VerifyPaymentResponse['data']>>,
+      },
+    }),
   }) satisfies BetterAuthClientPlugin

package/lib/types.ts

@@ -75,6 +75,7 @@ export interface RazorpayPlan {
   name: string
   monthlyPlanId: string
   annualPlanId?: string
+  description?: string
   limits?: PlanLimits
   freeTrial?: PlanFreeTrial
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deiondz/better-auth-razorpay",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Better Auth plugin for Razorpay subscriptions and payments",
   "type": "module",
   "main": "./index.ts",