@deiondz/better-auth-razorpay 1.0.0

package/api/cancel-subscription.ts

@@ -0,0 +1,135 @@
+import { createAuthEndpoint, sessionMiddleware } from 'better-auth/api'
+import type Razorpay from 'razorpay'
+import {
+  cancelSubscriptionSchema,
+  handleRazorpayError,
+  type RazorpaySubscription,
+  type RazorpaySubscriptionRecord,
+} from '../lib'
+
+/**
+ * Cancels a subscription at the end of the current billing period.
+ *
+ * @param razorpay - The Razorpay instance initialized with API credentials
+ * @returns A Better Auth endpoint handler
+ *
+ * @remarks
+ * This endpoint:
+ * - Requires user authentication via session
+ * - Verifies subscription ownership before cancellation
+ * - Cancels subscription at period end (not immediately)
+ * - Updates user record with cancellation flag and period end date
+ * - Subscription remains active until the current period ends
+ *
+ * @example
+ * Request body:
+ * ```json
+ * {
+ *   "subscription_id": "sub_1234567890"
+ * }
+ * ```
+ */
+export const cancelSubscription = (razorpay: Razorpay) =>
+  createAuthEndpoint(
+    '/razorpay/cancel-subscription',
+    { method: 'POST', use: [sessionMiddleware] },
+    async (_ctx) => {
+      try {
+        // Validate input using Zod schema
+        const validatedInput = cancelSubscriptionSchema.parse(_ctx.body)
+
+        // Get user ID from session
+        const userId = _ctx.context.session?.user?.id
+
+        if (!userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'User not authenticated',
+            },
+          }
+        }
+
+        // Get subscription record to verify it belongs to the user
+        const subscriptionRecord = (await _ctx.context.adapter.findOne({
+          model: 'razorpaySubscription',
+          where: [{ field: 'subscriptionId', value: validatedInput.subscription_id }],
+        })) as RazorpaySubscriptionRecord | null
+
+        if (!subscriptionRecord) {
+          return {
+            success: false,
+            error: {
+              code: 'SUBSCRIPTION_NOT_FOUND',
+              description: 'Subscription not found',
+            },
+          }
+        }
+
+        // Verify that the subscription belongs to the authenticated user
+        const subscriptionUserId = subscriptionRecord.userId
+        if (subscriptionUserId !== userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'Subscription does not belong to authenticated user',
+            },
+          }
+        }
+
+        // Cancel subscription via Razorpay API (cancel at period end)
+        const subscription = (await razorpay.subscriptions.cancel(
+          validatedInput.subscription_id,
+          true
+        )) as RazorpaySubscription
+
+        // Update user table with cancellation info (keep active status)
+        await _ctx.context.adapter.update({
+          model: 'user',
+          where: [{ field: 'id', value: userId }],
+          update: {
+            data: {
+              cancelAtPeriodEnd: true,
+              subscriptionCurrentPeriodEnd: subscription.current_end
+                ? new Date(subscription.current_end * 1000)
+                : null,
+            },
+          },
+        })
+
+        return {
+          success: true,
+          data: {
+            id: subscription.id,
+            entity: subscription.entity,
+            plan_id: subscription.plan_id,
+            status: subscription.status,
+            current_start: subscription.current_start,
+            current_end: subscription.current_end,
+            ended_at: subscription.ended_at,
+            quantity: subscription.quantity,
+            notes: subscription.notes,
+            charge_at: subscription.charge_at,
+            start_at: subscription.start_at,
+            end_at: subscription.end_at,
+            auth_attempts: subscription.auth_attempts,
+            total_count: subscription.total_count,
+            paid_count: subscription.paid_count,
+            customer_notify: subscription.customer_notify,
+            created_at: subscription.created_at,
+            expire_by: subscription.expire_by,
+            short_url: subscription.short_url,
+            has_scheduled_changes: subscription.has_scheduled_changes,
+            change_scheduled_at: subscription.change_scheduled_at,
+            source: subscription.source,
+            offer_id: subscription.offer_id,
+            remaining_count: subscription.remaining_count,
+          },
+        }
+      } catch (error) {
+        return handleRazorpayError(error)
+      }
+    }
+  )

package/api/get-plans.ts

@@ -0,0 +1,63 @@
+import { createAuthEndpoint } from 'better-auth/api'
+import type Razorpay from 'razorpay'
+import { getPlansSchema, handleRazorpayError } from '../lib'
+
+/**
+ * Retrieves plan details from Razorpay for configured plan IDs.
+ *
+ * @param razorpay - The Razorpay instance initialized with API credentials
+ * @param planIds - Array of plan IDs configured in the plugin options
+ * @returns A Better Auth endpoint handler
+ *
+ * @remarks
+ * This endpoint:
+ * - Fetches plan details from Razorpay API
+ * - Silently skips plans that fail to fetch (filters them out)
+ * - Returns all successfully fetched plans
+ * - Does not require authentication (public endpoint)
+ *
+ * @example
+ * Response (success):
+ * ```json
+ * {
+ *   "success": true,
+ *   "data": [
+ *     {
+ *       "id": "plan_1234567890",
+ *       "name": "Premium Plan",
+ *       "amount": 1000,
+ *       ...
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export const getPlans = (razorpay: Razorpay, planIds: string[]) =>
+  createAuthEndpoint('/razorpay/get-plans', { method: 'GET' }, async (_ctx) => {
+    try {
+      // GET requests don't have a body, so validation is optional
+      // Schema allows undefined for GET requests
+      getPlansSchema.parse(_ctx.body)
+
+      // Fetch plan details from Razorpay API using configured plan IDs
+      const plans = await Promise.all(
+        planIds.map(async (planId) => {
+          try {
+            const plan = await razorpay.plans.fetch(planId)
+            return plan
+          } catch {
+            // Silently skip failed plan fetches - they will be filtered out
+            // Individual plan fetch failures shouldn't break the entire request
+            return null
+          }
+        })
+      )
+
+      // Filter out any null values from failed fetches
+      const validPlans = plans.filter((plan) => plan !== null)
+
+      return { success: true, data: validPlans }
+    } catch (error) {
+      return handleRazorpayError(error)
+    }
+  })

package/api/get-subscription.ts

@@ -0,0 +1,174 @@
+import { createAuthEndpoint, sessionMiddleware } from 'better-auth/api'
+import type Razorpay from 'razorpay'
+import {
+  handleRazorpayError,
+  type RazorpaySubscription,
+  type RazorpayUserRecord,
+} from '../lib'
+
+/**
+ * Retrieves the current subscription details for the authenticated user.
+ *
+ * @param razorpay - The Razorpay instance initialized with API credentials
+ * @returns A Better Auth endpoint handler
+ *
+ * @remarks
+ * This endpoint:
+ * - Requires user authentication via session
+ * - Fetches subscription details from Razorpay API
+ * - Includes cancellation status and period end information
+ * - Returns null if user has no active subscription
+ * - Provides detailed error messages in development mode
+ *
+ * @example
+ * Response (success):
+ * ```json
+ * {
+ *   "success": true,
+ *   "data": {
+ *     "id": "sub_1234567890",
+ *     "status": "active",
+ *     "plan_id": "plan_1234567890",
+ *     "cancel_at_period_end": false,
+ *     ...
+ *   }
+ * }
+ * ```
+ */
+export const getSubscription = (razorpay: Razorpay) =>
+  createAuthEndpoint(
+    '/razorpay/get-subscription',
+    { method: 'GET', use: [sessionMiddleware] },
+    async (_ctx) => {
+      try {
+        // Get user ID from session
+        const userId = _ctx.context.session?.user?.id
+
+        if (!userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'User not authenticated',
+            },
+          }
+        }
+
+        // Get user record to check subscription status
+        const user = (await _ctx.context.adapter.findOne({
+          model: 'user',
+          where: [{ field: 'id', value: userId }],
+        })) as RazorpayUserRecord | null
+
+        if (!user) {
+          return {
+            success: false,
+            error: {
+              code: 'USER_NOT_FOUND',
+              description: 'User not found',
+            },
+          }
+        }
+
+        // Check subscription status from user table
+        const subscriptionId = user.subscriptionId
+
+        if (!subscriptionId) {
+          return {
+            success: true,
+            data: null,
+          }
+        }
+
+        // Fetch full subscription details from Razorpay API
+        try {
+          const subscription = (await razorpay.subscriptions.fetch(
+            subscriptionId
+          )) as RazorpaySubscription
+
+          // Read cancellation status from user table
+          const cancelAtPeriodEnd = user.cancelAtPeriodEnd ?? false
+          const subscriptionCurrentPeriodEnd = user.subscriptionCurrentPeriodEnd
+
+          return {
+            success: true,
+            data: {
+              id: subscription.id,
+              entity: subscription.entity,
+              plan_id: subscription.plan_id,
+              status: subscription.status,
+              current_start: subscription.current_start,
+              current_end: subscription.current_end,
+              ended_at: subscription.ended_at,
+              quantity: subscription.quantity,
+              notes: subscription.notes,
+              charge_at: subscription.charge_at,
+              start_at: subscription.start_at,
+              end_at: subscription.end_at,
+              auth_attempts: subscription.auth_attempts,
+              total_count: subscription.total_count,
+              paid_count: subscription.paid_count,
+              customer_notify: subscription.customer_notify,
+              created_at: subscription.created_at,
+              expire_by: subscription.expire_by,
+              short_url: subscription.short_url,
+              has_scheduled_changes: subscription.has_scheduled_changes,
+              change_scheduled_at: subscription.change_scheduled_at,
+              source: subscription.source,
+              offer_id: subscription.offer_id,
+              remaining_count: subscription.remaining_count,
+              cancel_at_period_end: cancelAtPeriodEnd,
+              subscription_current_period_end: subscriptionCurrentPeriodEnd
+                ? Math.floor(new Date(subscriptionCurrentPeriodEnd).getTime() / 1000)
+                : null,
+            },
+          }
+        } catch (razorpayError) {
+          // Handle Razorpay-specific errors with subscription ID context
+          const isDev = process.env.NODE_ENV === 'development'
+
+          // Extract error message from Razorpay error
+          let errorMessage = 'Failed to fetch subscription'
+          let errorCode = 'SUBSCRIPTION_FETCH_FAILED'
+
+          if (razorpayError && typeof razorpayError === 'object') {
+            // Razorpay error format: { error: { code: string, description: string } }
+            if ('error' in razorpayError) {
+              const razorpayErr = razorpayError as {
+                error?: { code?: string; description?: string }
+              }
+              errorCode = razorpayErr.error?.code || errorCode
+              errorMessage = razorpayErr.error?.description || errorMessage
+            } else if ('message' in razorpayError) {
+              errorMessage = (razorpayError as { message: string }).message
+            }
+          }
+
+          // Check if error is specifically about subscription not existing
+          const isNotFoundError =
+            errorMessage.toLowerCase().includes('does not exist') ||
+            errorMessage.toLowerCase().includes('not found') ||
+            errorCode === 'BAD_REQUEST_ERROR'
+
+          // Include subscription ID in error for debugging
+          const description = isDev
+            ? `${errorMessage} (Subscription ID: ${subscriptionId})`
+            : isNotFoundError
+              ? 'The subscription could not be found. This may indicate the subscription was deleted or the ID is invalid. Please contact support if this issue persists.'
+              : 'Unable to retrieve subscription information. Please try again or contact support if this issue persists.'
+
+          return {
+            success: false,
+            error: {
+              code: errorCode,
+              description,
+              // Include subscription ID in metadata for development
+              ...(isDev && { subscriptionId }),
+            },
+          }
+        }
+      } catch (error) {
+        return handleRazorpayError(error)
+      }
+    }
+  )

package/api/index.ts

@@ -0,0 +1,8 @@
+export { cancelSubscription } from './cancel-subscription'
+export { getPlans } from './get-plans'
+export { getSubscription } from './get-subscription'
+export { pauseSubscription } from './pause-subscription'
+export { resumeSubscription } from './resume-subscription'
+export { subscribe } from './subscribe'
+export { verifyPayment } from './verify-payment'
+export { webhook } from './webhook'

package/api/pause-subscription.ts

@@ -0,0 +1,138 @@
+import { createAuthEndpoint, sessionMiddleware } from 'better-auth/api'
+import type Razorpay from 'razorpay'
+import {
+  handleRazorpayError,
+  pauseSubscriptionSchema,
+  type RazorpaySubscription,
+  type RazorpaySubscriptionRecord,
+} from '../lib'
+
+/**
+ * Pauses an active subscription.
+ *
+ * @param razorpay - The Razorpay instance initialized with API credentials
+ * @returns A Better Auth endpoint handler
+ *
+ * @remarks
+ * This endpoint:
+ * - Requires user authentication via session
+ * - Verifies subscription ownership before pausing
+ * - Pauses the subscription via Razorpay API
+ * - Updates subscription and user records with paused status
+ * - Paused subscriptions can be resumed later
+ *
+ * @example
+ * Request body:
+ * ```json
+ * {
+ *   "subscription_id": "sub_1234567890"
+ * }
+ * ```
+ */
+export const pauseSubscription = (razorpay: Razorpay) =>
+  createAuthEndpoint(
+    '/razorpay/pause-subscription',
+    { method: 'POST', use: [sessionMiddleware] },
+    async (_ctx) => {
+      try {
+        // Validate input using Zod schema
+        const validatedInput = pauseSubscriptionSchema.parse(_ctx.body)
+
+        // Get user ID from session
+        const userId = _ctx.context.session?.user?.id
+
+        if (!userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'User not authenticated',
+            },
+          }
+        }
+
+        // Get subscription record to verify it belongs to the user
+        const subscriptionRecord = (await _ctx.context.adapter.findOne({
+          model: 'razorpaySubscription',
+          where: [{ field: 'subscriptionId', value: validatedInput.subscription_id }],
+        })) as RazorpaySubscriptionRecord | null
+
+        if (!subscriptionRecord) {
+          return {
+            success: false,
+            error: {
+              code: 'SUBSCRIPTION_NOT_FOUND',
+              description: 'Subscription not found',
+            },
+          }
+        }
+
+        // Verify that the subscription belongs to the authenticated user
+        const subscriptionUserId = subscriptionRecord.userId
+        if (subscriptionUserId !== userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'Subscription does not belong to authenticated user',
+            },
+          }
+        }
+
+        // Pause subscription via Razorpay API
+        const subscription = (await razorpay.subscriptions.pause(
+          validatedInput.subscription_id
+        )) as RazorpaySubscription
+
+        // Update subscription status in database
+        await _ctx.context.adapter.update({
+          model: 'razorpaySubscription',
+          where: [{ field: 'subscriptionId', value: validatedInput.subscription_id }],
+          update: { status: subscription.status },
+        })
+
+        // Update user table with subscription status
+        await _ctx.context.adapter.update({
+          model: 'user',
+          where: [{ field: 'id', value: userId }],
+          update: {
+            data: {
+              subscriptionStatus: subscription.status,
+            },
+          },
+        })
+
+        return {
+          success: true,
+          data: {
+            id: subscription.id,
+            entity: subscription.entity,
+            plan_id: subscription.plan_id,
+            status: subscription.status,
+            current_start: subscription.current_start,
+            current_end: subscription.current_end,
+            ended_at: subscription.ended_at,
+            quantity: subscription.quantity,
+            notes: subscription.notes,
+            charge_at: subscription.charge_at,
+            start_at: subscription.start_at,
+            end_at: subscription.end_at,
+            auth_attempts: subscription.auth_attempts,
+            total_count: subscription.total_count,
+            paid_count: subscription.paid_count,
+            customer_notify: subscription.customer_notify,
+            created_at: subscription.created_at,
+            expire_by: subscription.expire_by,
+            short_url: subscription.short_url,
+            has_scheduled_changes: subscription.has_scheduled_changes,
+            change_scheduled_at: subscription.change_scheduled_at,
+            source: subscription.source,
+            offer_id: subscription.offer_id,
+            remaining_count: subscription.remaining_count,
+          },
+        }
+      } catch (error) {
+        return handleRazorpayError(error)
+      }
+    }
+  )

package/api/resume-subscription.ts

@@ -0,0 +1,150 @@
+import { createAuthEndpoint, sessionMiddleware } from 'better-auth/api'
+import type Razorpay from 'razorpay'
+import {
+  handleRazorpayError,
+  type RazorpaySubscription,
+  resumeSubscriptionSchema,
+  type RazorpaySubscriptionRecord,
+} from '../lib'
+
+/**
+ * Resumes a paused subscription.
+ *
+ * @param razorpay - The Razorpay instance initialized with API credentials
+ * @returns A Better Auth endpoint handler
+ *
+ * @remarks
+ * This endpoint:
+ * - Requires user authentication via session
+ * - Verifies subscription ownership before resuming
+ * - Validates that subscription is in paused status
+ * - Resumes the subscription via Razorpay API
+ * - Updates subscription and user records with active status
+ *
+ * @example
+ * Request body:
+ * ```json
+ * {
+ *   "subscription_id": "sub_1234567890"
+ * }
+ * ```
+ */
+export const resumeSubscription = (razorpay: Razorpay) =>
+  createAuthEndpoint(
+    '/razorpay/resume-subscription',
+    { method: 'POST', use: [sessionMiddleware] },
+    async (_ctx) => {
+      try {
+        // Validate input using Zod schema
+        const validatedInput = resumeSubscriptionSchema.parse(_ctx.body)
+
+        // Get user ID from session
+        const userId = _ctx.context.session?.user?.id
+
+        if (!userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'User not authenticated',
+            },
+          }
+        }
+
+        // Get subscription record to verify it belongs to the user
+        const subscriptionRecord = (await _ctx.context.adapter.findOne({
+          model: 'razorpaySubscription',
+          where: [{ field: 'subscriptionId', value: validatedInput.subscription_id }],
+        })) as RazorpaySubscriptionRecord | null
+
+        if (!subscriptionRecord) {
+          return {
+            success: false,
+            error: {
+              code: 'SUBSCRIPTION_NOT_FOUND',
+              description: 'Subscription not found',
+            },
+          }
+        }
+
+        // Verify that the subscription belongs to the authenticated user
+        const subscriptionUserId = subscriptionRecord.userId
+        if (subscriptionUserId !== userId) {
+          return {
+            success: false,
+            error: {
+              code: 'UNAUTHORIZED',
+              description: 'Subscription does not belong to authenticated user',
+            },
+          }
+        }
+
+        // Check if subscription is paused
+        const subscriptionStatus = subscriptionRecord.status
+        if (subscriptionStatus !== 'paused') {
+          return {
+            success: false,
+            error: {
+              code: 'INVALID_STATUS',
+              description: 'Subscription is not paused. Only paused subscriptions can be resumed.',
+            },
+          }
+        }
+
+        // Resume subscription via Razorpay API
+        const subscription = (await razorpay.subscriptions.resume(
+          validatedInput.subscription_id
+        )) as RazorpaySubscription
+
+        // Update subscription status in database
+        await _ctx.context.adapter.update({
+          model: 'razorpaySubscription',
+          where: [{ field: 'subscriptionId', value: validatedInput.subscription_id }],
+          update: { status: subscription.status },
+        })
+
+        // Update user table with subscription status
+        await _ctx.context.adapter.update({
+          model: 'user',
+          where: [{ field: 'id', value: userId }],
+          update: {
+            data: {
+              subscriptionStatus: subscription.status,
+            },
+          },
+        })
+
+        return {
+          success: true,
+          data: {
+            id: subscription.id,
+            entity: subscription.entity,
+            plan_id: subscription.plan_id,
+            status: subscription.status,
+            current_start: subscription.current_start,
+            current_end: subscription.current_end,
+            ended_at: subscription.ended_at,
+            quantity: subscription.quantity,
+            notes: subscription.notes,
+            charge_at: subscription.charge_at,
+            start_at: subscription.start_at,
+            end_at: subscription.end_at,
+            auth_attempts: subscription.auth_attempts,
+            total_count: subscription.total_count,
+            paid_count: subscription.paid_count,
+            customer_notify: subscription.customer_notify,
+            created_at: subscription.created_at,
+            expire_by: subscription.expire_by,
+            short_url: subscription.short_url,
+            has_scheduled_changes: subscription.has_scheduled_changes,
+            change_scheduled_at: subscription.change_scheduled_at,
+            source: subscription.source,
+            offer_id: subscription.offer_id,
+            remaining_count: subscription.remaining_count,
+          },
+        }
+      } catch (error) {
+        return handleRazorpayError(error)
+      }
+    }
+  )