@deiondz/better-auth-razorpay 2.0.5 → 2.0.7

package/client/types.ts

@@ -1,154 +0,0 @@
-/**
- * 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
-
-/** 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.
- * Primary: razorpay is set when razorpayClientPlugin() is used in createAuthClient({ plugins: [...] }); prefer it so requests hit the correct paths.
- * Fallback: api is optional for custom clients that implement path-based api.get/api.post.
- */
-export interface RazorpayAuthClient {
-  /** Set when razorpayClientPlugin() is used in createAuthClient({ plugins: [razorpayClientPlugin()] }). Prefer these methods over api.get/post. */
-  razorpay?: RazorpayClientActions
-  /** Optional; for custom clients that implement path-based api.get/post. */
-  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
-}
-
-/** Input for verify-payment (Razorpay checkout success callback payload). */
-export interface VerifyPaymentInput {
-  razorpay_payment_id: string
-  razorpay_subscription_id: string
-  razorpay_signature: string
-}
-
-/** Response shape for verify-payment (success). */
-export interface VerifyPaymentResponse {
-  success: true
-  data: {
-    message: string
-    payment_id: string
-    subscription_id: string
-  }
-}

package/client.ts

@@ -1,105 +0,0 @@
-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/index.ts

@@ -1,162 +0,0 @@
-import type { BetterAuthPlugin } from 'better-auth'
-import {
-  cancelSubscription,
-  createOrUpdateSubscription,
-  getPlans,
-  listSubscriptions,
-  restoreSubscription,
-  verifyPayment,
-  webhook,
-} from './api'
-import type { RazorpayPluginOptions, RazorpayUserRecord } from './lib'
-
-/**
- * Razorpay plugin for Better Auth.
- *
- * 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
- * @param options.razorpayClient - Initialized Razorpay instance (key_id, key_secret)
- * @param options.razorpayWebhookSecret - Webhook secret for signature verification
- * @param options.razorpayKeySecret - API key secret for payment signature verification (optional; when set, enables POST /razorpay/verify-payment)
- * @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 {
-    razorpayClient,
-    razorpayWebhookSecret,
-    razorpayKeySecret,
-    createCustomerOnSignUp = false,
-    onCustomerCreate,
-    getCustomerCreateParams,
-    subscription: subOpts,
-    onEvent,
-  } = options
-
-  if (!razorpayClient) {
-    throw new Error('Razorpay plugin: razorpayClient is required')
-  }
-
-  const razorpay = razorpayClient as import('razorpay')
-
-  const plugin = {
-    id: 'razorpay-plugin',
-
-    schema: {
-      user: {
-        fields: {
-          razorpayCustomerId: { type: 'string', required: false },
-        },
-      },
-      subscription: {
-        fields: {
-          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: {
-      '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 }),
-      ...(razorpayKeySecret
-        ? { 'verify-payment': verifyPayment(razorpayKeySecret) }
-        : {}),
-      webhook: webhook(razorpayWebhookSecret, options.onWebhookEvent ?? undefined, {
-        subscription: subOpts,
-        onEvent,
-      }),
-    },
-
-    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
-}
-
-export type {
-  OnWebhookEventCallback,
-  RazorpayApiResponse,
-  RazorpayErrorResponse,
-  RazorpayPlan,
-  RazorpayPluginOptions,
-  RazorpaySubscription,
-  RazorpaySuccessResponse,
-  RazorpayUserRecord,
-  RazorpayWebhookContext,
-  RazorpayWebhookEvent,
-  RazorpayWebhookPayload,
-  SubscriptionRecord,
-  SubscriptionStatus,
-} from './lib'
-export type { WebhookResult } from './api/webhook'

package/lib/error-handler.ts

@@ -1,99 +0,0 @@
-import { z } from 'zod'
-
-/**
- * Helper function to handle Razorpay-related errors and reduce complexity.
- * Handles various error types including validation, network, timeout, and Razorpay API errors.
- */
-function handleRazorpayError(error: unknown): {
-  success: false
-  error: { code: string; description: string }
-} {
-  // Handle Zod validation errors
-  if (error instanceof z.ZodError) {
-    return {
-      success: false,
-      error: {
-        code: 'INVALID_REQUEST',
-        description: error.issues[0]?.message || 'Validation failed',
-      },
-    }
-  }
-
-  // Handle network errors (fetch/axios network failures)
-  if (error && typeof error === 'object') {
-    // Check for network error indicators
-    const errorObj = error as Record<string, unknown>
-    if (
-      'code' in errorObj &&
-      (errorObj.code === 'ECONNREFUSED' ||
-        errorObj.code === 'ENOTFOUND' ||
-        errorObj.code === 'ETIMEDOUT' ||
-        errorObj.code === 'ECONNRESET')
-    ) {
-      return {
-        success: false,
-        error: {
-          code: 'NETWORK_ERROR',
-          description: 'Network connection failed. Please check your internet connection and try again.',
-        },
-      }
-    }
-
-    // Handle timeout errors
-    if (
-      'name' in errorObj &&
-      (errorObj.name === 'TimeoutError' ||
-        errorObj.name === 'AbortError' ||
-        (typeof errorObj.message === 'string' &&
-          errorObj.message.toLowerCase().includes('timeout')))
-    ) {
-      return {
-        success: false,
-        error: {
-          code: 'TIMEOUT_ERROR',
-          description: 'Request timed out. Please try again.',
-        },
-      }
-    }
-
-    // Handle Razorpay error format: { error: { code: string, description: string } }
-    if ('error' in errorObj) {
-      const razorpayError = errorObj as {
-        error?: { code?: string; description?: string; field?: string }
-      }
-      return {
-        success: false,
-        error: {
-          code: razorpayError.error?.code || 'RAZORPAY_ERROR',
-          description:
-            razorpayError.error?.description ||
-            razorpayError.error?.field
-              ? `Razorpay error: ${razorpayError.error.field}`
-              : 'Razorpay request failed',
-        },
-      }
-    }
-
-    // Handle standard error objects with message
-    if ('message' in errorObj && typeof errorObj.message === 'string') {
-      return {
-        success: false,
-        error: {
-          code: 'UNKNOWN_ERROR',
-          description: errorObj.message,
-        },
-      }
-    }
-  }
-
-  // Fallback for unknown error types
-  return {
-    success: false,
-    error: {
-      code: 'UNKNOWN_ERROR',
-      description: 'An unexpected error occurred. Please try again or contact support.',
-    },
-  }
-}
-
-export { handleRazorpayError }

package/lib/index.ts

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

package/lib/schemas.ts

@@ -1,34 +0,0 @@
-import { z } from 'zod'
-
-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),
-})
-
-export const cancelSubscriptionSchema = z.object({
-  subscriptionId: z.string().min(1, 'Subscription ID (local) is required'),
-  immediately: z.boolean().optional().default(false),
-})
-
-export const restoreSubscriptionSchema = z.object({
-  subscriptionId: z.string().min(1, 'Subscription ID (local) is required'),
-})
-
-export const listSubscriptionsSchema = z.object({
-  referenceId: z.string().optional(),
-})
-
-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 {
-  createOrUpdateSubscriptionSchema as subscribeSchema,
-}
-export type CreateOrUpdateSubscriptionInput = z.infer<typeof createOrUpdateSubscriptionSchema>