@deiondz/better-auth-razorpay 1.0.0 → 2.0.1

package/client/types.ts

@@ -0,0 +1,108 @@
+/**
+ * Client-side types for Razorpay plugin hooks and API responses.
+ */
+
+import type { SubscriptionRecord } from '../lib/types'
+
+/** Plan summary returned by GET /razorpay/get-plans (client-safe shape). */
+export interface PlanSummary {
+  name: string
+  monthlyPlanId: string
+  annualPlanId?: string
+  limits?: Record<string, number>
+  freeTrial?: { days: number }
+}
+
+/** Response shape for get-plans (success). */
+export interface GetPlansResponse {
+  success: true
+  data: PlanSummary[]
+}
+
+/** Response shape for subscription/list (success). */
+export interface ListSubscriptionsResponse {
+  success: true
+  data: SubscriptionRecord[]
+}
+
+/** Response shape for create-or-update (success). */
+export interface CreateOrUpdateSubscriptionResponse {
+  success: true
+  data: {
+    checkoutUrl: string
+    subscriptionId: string
+    razorpaySubscriptionId: string
+  }
+}
+
+/** Response shape for cancel (success). */
+export interface CancelSubscriptionResponse {
+  success: true
+  data: {
+    id: string
+    status: string
+    plan_id: string
+    current_end?: number
+    ended_at?: number | null
+  }
+}
+
+/** Response shape for restore (success). */
+export interface RestoreSubscriptionResponse {
+  success: true
+  data: { id: string; status: string }
+}
+
+/** Error shape from plugin API. */
+export interface RazorpayApiError {
+  success: false
+  error: { code: string; description: string; [key: string]: unknown }
+}
+
+/** Any plugin API response (success or error). */
+export type RazorpayApiResult<T = unknown> =
+  | { success: true; data: T }
+  | RazorpayApiError
+
+/**
+ * Minimal auth client interface for Razorpay hooks.
+ * Compatible with Better Auth's createAuthClient() return type.
+ */
+export interface RazorpayAuthClient {
+  api: {
+    get: (
+      path: string,
+      options?: { query?: Record<string, string> }
+    ) => Promise<RazorpayApiResult<unknown>>
+    post: (
+      path: string,
+      options?: { body?: Record<string, unknown> }
+    ) => Promise<RazorpayApiResult<unknown>>
+  }
+}
+
+/** Input for create-or-update subscription. */
+export interface CreateOrUpdateSubscriptionInput {
+  plan: string
+  annual?: boolean
+  seats?: number
+  subscriptionId?: string
+  successUrl?: string
+  disableRedirect?: boolean
+}
+
+/** Input for cancel subscription. */
+export interface CancelSubscriptionInput {
+  subscriptionId: string
+  immediately?: boolean
+}
+
+/** Input for restore subscription. */
+export interface RestoreSubscriptionInput {
+  subscriptionId: string
+}
+
+/** Input for list subscriptions (query). */
+export interface ListSubscriptionsInput {
+  referenceId?: string
+}

package/index.ts

@@ -1,123 +1,156 @@
 import type { BetterAuthPlugin } from 'better-auth'
-import Razorpay from 'razorpay'
 import {
   cancelSubscription,
+  createOrUpdateSubscription,
   getPlans,
-  getSubscription,
-  pauseSubscription,
-  resumeSubscription,
-  subscribe,
-  verifyPayment,
+  listSubscriptions,
+  restoreSubscription,
   webhook,
 } from './api'
-import type { RazorpayPluginOptions } from './lib'
+import type { RazorpayPluginOptions, RazorpayUserRecord } from './lib'
 
 /**
  * Razorpay plugin for Better Auth.
  *
- * Provides subscription management functionality including:
- * - Creating subscriptions
- * - Managing subscription lifecycle (pause, resume, cancel)
- * - Payment verification
- * - Webhook handling for subscription events
- * - Plan retrieval
+ * Aligns with the subscription flow from the community plugin:
+ * - Subscription: create-or-update (checkout URL), cancel, restore, list
+ * - Customer: optional creation on sign-up, callbacks and params
+ * - Webhooks: subscription events (activated, cancelled, expired, etc.) with optional callbacks
+ * - Plans: named plans with monthly/annual IDs, limits, free trial
  *
- * @param options - Plugin configuration options
- * @param options.keyId - Razorpay key ID (required)
- * @param options.keySecret - Razorpay key secret (required)
- * @param options.webhookSecret - Webhook secret for signature verification (optional)
- * @param options.plans - Array of plan IDs from Razorpay dashboard (required)
- * @param options.onWebhookEvent - Optional callback for custom webhook event handling
- * @returns Better Auth plugin configuration
- *
- * @throws {Error} If keyId or keySecret are not provided
- *
- * @example
- * ```typescript
- * import { razorpayPlugin } from '@better-auth/razorpay'
- *
- * const auth = betterAuth({
- *   plugins: [
- *     razorpayPlugin({
- *       keyId: process.env.RAZORPAY_KEY_ID!,
- *       keySecret: process.env.RAZORPAY_KEY_SECRET!,
- *       webhookSecret: process.env.RAZORPAY_WEBHOOK_SECRET,
- *       plans: ['plan_1234567890', 'plan_0987654321'],
- *     }),
- *   ],
- * })
- * ```
+ * @param options - Plugin configuration
+ * @param options.razorpayClient - Initialized Razorpay instance (key_id, key_secret)
+ * @param options.razorpayWebhookSecret - Webhook secret for signature verification
+ * @param options.createCustomerOnSignUp - Create Razorpay customer when user signs up (default: false)
+ * @param options.onCustomerCreate - Callback after customer is created
+ * @param options.getCustomerCreateParams - Custom params when creating customer
+ * @param options.subscription - Subscription config (enabled, plans, callbacks, authorizeReference)
+ * @param options.onEvent - Global callback for all webhook events
  */
 export const razorpayPlugin = (options: RazorpayPluginOptions) => {
-  const { keyId, keySecret, webhookSecret, plans, onWebhookEvent } = options
+  const {
+    razorpayClient,
+    razorpayWebhookSecret,
+    createCustomerOnSignUp = false,
+    onCustomerCreate,
+    getCustomerCreateParams,
+    subscription: subOpts,
+    onEvent,
+  } = options
 
-  if (!keyId || !keySecret) {
-    throw new Error('Razorpay keyId and keySecret are required')
+  if (!razorpayClient) {
+    throw new Error('Razorpay plugin: razorpayClient is required')
   }
 
-  // Initialize Razorpay instance once in plugin closure
-  // This instance is accessible to all endpoints via closure scope
-  const razorpay = new Razorpay({
-    key_id: keyId,
-    key_secret: keySecret,
-  })
+  const razorpay = razorpayClient as import('razorpay')
 
-  return {
+  const plugin = {
     id: 'razorpay-plugin',
 
     schema: {
       user: {
         fields: {
-          subscriptionId: { type: 'string', required: false },
-          subscriptionPlanId: { type: 'string', required: false },
-          subscriptionStatus: { type: 'string', required: false },
-          subscriptionCurrentPeriodEnd: { type: 'date', required: false },
-          cancelAtPeriodEnd: { type: 'boolean', required: false },
-          lastPaymentDate: { type: 'date', required: false },
-          nextBillingDate: { type: 'date', required: false },
+          razorpayCustomerId: { type: 'string', required: false },
         },
       },
-      razorpayCustomer: {
+      subscription: {
         fields: {
-          userId: { type: 'string', unique: true },
-          razorpayCustomerId: { type: 'string', unique: true },
-        },
-      },
-      razorpaySubscription: {
-        fields: {
-          userId: { type: 'string' },
-          subscriptionId: { type: 'string' },
-          planId: { type: 'string' },
-          status: { type: 'string' },
+          id: { type: 'string', required: true },
+          plan: { type: 'string', required: true },
+          referenceId: { type: 'string', required: true },
+          razorpayCustomerId: { type: 'string', required: false },
+          razorpaySubscriptionId: { type: 'string', required: false },
+          status: { type: 'string', required: true },
+          trialStart: { type: 'date', required: false },
+          trialEnd: { type: 'date', required: false },
+          periodStart: { type: 'date', required: false },
+          periodEnd: { type: 'date', required: false },
+          cancelAtPeriodEnd: { type: 'boolean', required: false },
+          seats: { type: 'number', required: false },
+          groupId: { type: 'string', required: false },
+          createdAt: { type: 'date', required: true },
+          updatedAt: { type: 'date', required: true },
         },
       },
     },
 
     endpoints: {
-      subscribe: subscribe(razorpay, plans),
-      'get-plans': getPlans(razorpay, plans),
-      'verify-payment': verifyPayment(keySecret),
-      webhook: webhook(webhookSecret, onWebhookEvent),
-      'get-subscription': getSubscription(razorpay),
-      'pause-subscription': pauseSubscription(razorpay),
-      'cancel-subscription': cancelSubscription(razorpay),
-      'resume-subscription': resumeSubscription(razorpay),
+      'subscription/create-or-update': createOrUpdateSubscription(razorpay, {
+        subscription: subOpts,
+        createCustomerOnSignUp,
+      }),
+      'subscription/cancel': cancelSubscription(razorpay),
+      'subscription/restore': restoreSubscription(razorpay),
+      'subscription/list': listSubscriptions({ subscription: subOpts }),
+      'get-plans': getPlans({ subscription: subOpts }),
+      webhook: webhook(razorpayWebhookSecret, options.onWebhookEvent ?? undefined, {
+        subscription: subOpts,
+        onEvent,
+      }),
     },
-  } satisfies BetterAuthPlugin
+
+    databaseHooks: createCustomerOnSignUp
+      ? {
+          user: {
+            create: {
+              after: async (
+                user: RazorpayUserRecord & { id: string },
+                ctx: { context?: { adapter?: { update: (p: unknown) => Promise<unknown> } }; adapter?: { update: (p: unknown) => Promise<unknown> }; session?: unknown }
+              ) => {
+                const adapter = ctx.context?.adapter ?? (ctx as { adapter?: { update: (p: unknown) => Promise<unknown> } }).adapter
+                if (!adapter?.update) return
+                try {
+                  const params: { name?: string; email?: string; contact?: string; [key: string]: unknown } = {
+                    name: user.name ?? user.email ?? 'Customer',
+                    email: user.email ?? undefined,
+                  }
+                  if (getCustomerCreateParams) {
+                    const extra = await getCustomerCreateParams({
+                      user: user as RazorpayUserRecord,
+                      session: ctx.session,
+                    })
+                    if (extra?.params && typeof extra.params === 'object') {
+                      Object.assign(params, extra.params)
+                    }
+                  }
+                  const customer = await razorpay.customers.create(params)
+                  await adapter.update({
+                    model: 'user',
+                    where: [{ field: 'id', value: user.id }],
+                    update: { data: { razorpayCustomerId: customer.id } },
+                  })
+                  if (onCustomerCreate) {
+                    await onCustomerCreate({
+                      user: user as RazorpayUserRecord,
+                      razorpayCustomer: { id: customer.id, ...(customer as unknown as Record<string, unknown>) },
+                    })
+                  }
+                } catch (err) {
+                  console.error('[better-auth-razorpay] Create customer on sign-up failed:', err)
+                }
+              },
+            },
+          },
+        }
+      : undefined,
+  }
+
+  return plugin as BetterAuthPlugin
 }
 
-// Re-export types for external usage
 export type {
   OnWebhookEventCallback,
   RazorpayApiResponse,
   RazorpayErrorResponse,
+  RazorpayPlan,
   RazorpayPluginOptions,
   RazorpaySubscription,
-  RazorpaySubscriptionRecord,
   RazorpaySuccessResponse,
   RazorpayUserRecord,
   RazorpayWebhookContext,
   RazorpayWebhookEvent,
   RazorpayWebhookPayload,
+  SubscriptionRecord,
+  SubscriptionStatus,
 } from './lib'
 export type { WebhookResult } from './api/webhook'

package/lib/index.ts

@@ -1,22 +1,28 @@
 export { handleRazorpayError } from './error-handler'
 export {
   cancelSubscriptionSchema,
-  getPlansSchema,
-  pauseSubscriptionSchema,
-  resumeSubscriptionSchema,
+  createOrUpdateSubscriptionSchema,
+  listSubscriptionsSchema,
+  restoreSubscriptionSchema,
   subscribeSchema,
   verifyPaymentSchema,
 } from './schemas'
+export type { CreateOrUpdateSubscriptionInput } from './schemas'
 export type {
   OnWebhookEventCallback,
+  PlanFreeTrial,
+  PlanLimits,
   RazorpayApiResponse,
   RazorpayErrorResponse,
+  RazorpayPlan,
   RazorpayPluginOptions,
   RazorpaySubscription,
-  RazorpaySubscriptionRecord,
   RazorpaySuccessResponse,
   RazorpayUserRecord,
   RazorpayWebhookContext,
   RazorpayWebhookEvent,
   RazorpayWebhookPayload,
+  SubscriptionOptions,
+  SubscriptionRecord,
+  SubscriptionStatus,
 } from './types'

package/lib/schemas.ts

@@ -1,58 +1,34 @@
 import { z } from 'zod'
 
-// Schema for getPlans validation (GET requests don't have a body, so optional)
-const getPlansSchema = z.object({}).strict().optional()
-
-// Schema for subscribe validation
-const subscribeSchema = z.object({
-  plan_id: z.string().min(1, 'Plan ID is required'),
-  total_count: z.number().int().min(1, 'Total count must be at least 1').optional().default(12),
-  quantity: z.number().int().min(1, 'Quantity must be at least 1').optional().default(1),
-  start_at: z.number().int().optional(),
-  expire_by: z.number().int().optional(),
-  customer_notify: z.boolean().optional().default(true),
-  addons: z
-    .array(
-      z.object({
-        item: z.object({
-          name: z.string().min(1, 'Addon name is required'),
-          amount: z.number().int().positive('Addon amount must be positive'),
-          currency: z.string().min(1, 'Addon currency is required'),
-        }),
-      })
-    )
-    .optional(),
-  offer_id: z.string().optional(),
-  notes: z.record(z.string(), z.string()).optional(),
+export const createOrUpdateSubscriptionSchema = z.object({
+  plan: z.string().min(1, 'Plan name is required'),
+  annual: z.boolean().optional().default(false),
+  seats: z.number().int().min(1).optional().default(1),
+  subscriptionId: z.string().optional(),
+  successUrl: z.string().url().optional(),
+  disableRedirect: z.boolean().optional().default(false),
 })
 
-// Schema for verify payment validation
-const verifyPaymentSchema = z.object({
-  razorpay_payment_id: z.string().min(1, 'Payment ID is required'),
-  razorpay_subscription_id: z.string().min(1, 'Subscription ID is required'),
-  razorpay_signature: z.string().min(1, 'Signature is required'),
+export const cancelSubscriptionSchema = z.object({
+  subscriptionId: z.string().min(1, 'Subscription ID (local) is required'),
+  immediately: z.boolean().optional().default(false),
 })
 
-// Schema for pause subscription validation
-const pauseSubscriptionSchema = z.object({
-  subscription_id: z.string().min(1, 'Subscription ID is required'),
+export const restoreSubscriptionSchema = z.object({
+  subscriptionId: z.string().min(1, 'Subscription ID (local) is required'),
 })
 
-// Schema for cancel subscription validation
-const cancelSubscriptionSchema = z.object({
-  subscription_id: z.string().min(1, 'Subscription ID is required'),
+export const listSubscriptionsSchema = z.object({
+  referenceId: z.string().optional(),
 })
 
-// Schema for resume subscription validation
-const resumeSubscriptionSchema = z.object({
-  subscription_id: z.string().min(1, 'Subscription ID is required'),
+export const verifyPaymentSchema = z.object({
+  razorpay_payment_id: z.string().min(1, 'Payment ID is required'),
+  razorpay_subscription_id: z.string().min(1, 'Subscription ID is required'),
+  razorpay_signature: z.string().min(1, 'Signature is required'),
 })
 
 export {
-  getPlansSchema,
-  subscribeSchema,
-  verifyPaymentSchema,
-  pauseSubscriptionSchema,
-  cancelSubscriptionSchema,
-  resumeSubscriptionSchema,
+  createOrUpdateSubscriptionSchema as subscribeSchema,
 }
+export type CreateOrUpdateSubscriptionInput = z.infer<typeof createOrUpdateSubscriptionSchema>