Stripe

stripe({
    // ... 其他选项
    createCustomerOnSignUp: true,
    onCustomerCreate: async ({ stripeCustomer, user }, ctx) => {
        // 处理新创建的客户
        console.log(`客户 ${stripeCustomer.id} 已为用户 ${user.id} 创建`);
    },
    getCustomerCreateParams: async (user, ctx) => {
        // 定制 Stripe 客户创建参数
        return {
            metadata: {
                referralSource: user.metadata?.referralSource
            }
        };
    }
})

// 静态定义
subscription: {
    enabled: true,
    plans: [
        {
            name: "basic", // 计划名称，存入数据库时自动转为小写
            priceId: "price_1234567890", // Stripe 价格 ID
            annualDiscountPriceId: "price_1234567890", // （可选）年付折扣价格 ID
            limits: {
                projects: 5,
                storage: 10
            }
        },
        {
            name: "pro",
            priceId: "price_0987654321",
            limits: {
                projects: 20,
                storage: 50
            },
            freeTrial: {
                days: 14,
            }
        }
    ]
}

// 动态定义（从数据库或接口获取）
subscription: {
    enabled: true,
    plans: async () => {
        const plans = await db.query("SELECT * FROM plans");
        return plans.map(plan => ({
            name: plan.name,
            priceId: plan.stripe_price_id,
            limits: JSON.parse(plan.limits)
        }));
    }
}

await authClient.subscription.upgrade({
    plan: "pro",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
    annual: true, // 可选：升级为年付计划
    referenceId: "org_123", // 可选：默认为 customerType 的值
    seats: 5, // 可选：团队计划席位数量
    locale: "en" // 可选：用英文显示 Checkout
});

const { error } = await authClient.subscription.upgrade({
    plan: "pro",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
});
if(error) {
    alert(error.message);
}

await authClient.subscription.upgrade({
    plan: "pro",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
    subscriptionId: "sub_123", // 当前用户计划的 Stripe 订阅 ID
});

await authClient.subscription.upgrade({
    plan: "pro",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
    returnUrl: "/billing",
    scheduleAtPeriodEnd: true, // 默认 false
});

stripe({
    // ... 其他选项
    subscription: {
        // ... 其他订阅配置
        authorizeReference: async ({ user, session, referenceId, action }) => {
            if(action === "list-subscription") {
                const org = await db.member.findFirst({
                    where: {
                        organizationId: referenceId,
                        userId: user.id
                    }   
                });
                return org?.role === "owner"
            }
            // 检查用户是否有权限列出此引用的订阅
            return true;
        }
    }
})

// 为组织创建订阅
await authClient.subscription.upgrade({
    plan: "pro",
    referenceId: "org_123456",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
    seats: 5 // 团队计划席位数量
});

// 列出组织的订阅
const { data: subscriptions } = await authClient.subscription.list({
    query: {
        referenceId: "org_123456"
    }
});

await authClient.subscription.upgrade({
    plan: "team",
    referenceId: "org_123456",
    seats: 10, // 10 个团队成员
    successUrl: "/org/billing/success",
    cancelUrl: "/org/billing"
});

subscription: {
    // ... 其他选项
    authorizeReference: async ({ user, session, referenceId, action }) => {
        // 检查用户是否有权限管理此引用的订阅
        if (action === "upgrade-subscription" || action === "cancel-subscription" || action === "restore-subscription") {
            const org = await db.member.findFirst({
                where: {
                    organizationId: referenceId,
                    userId: user.id
                }   
            });
            return org?.role === "owner"
        }
        return true;
    }
}

stripe({
    // ... 其他选项
    onEvent: async (event) => {
        // 处理任何 Stripe 事件
        switch (event.type) {
            case "invoice.paid":
                // 处理已付款发票
                break;
            case "payment_intent.succeeded":
                // 处理支付成功
                break;
        }
    }
})

subscription: {
    // ... 其他选项
    onSubscriptionComplete: async ({ event, subscription, stripeSubscription, plan }) => {
        // 结账方式成功创建订阅时调用
        await sendWelcomeEmail(subscription.referenceId, plan.name);
    },
    onSubscriptionCreated: async ({ event, subscription, stripeSubscription, plan }) => {
        // 订阅在结账外创建时调用（比如后台仪表盘）
        await sendSubscriptionCreatedEmail(subscription.referenceId, plan.name);
    },
    onSubscriptionUpdate: async ({ event, subscription, stripeSubscription }) => {
        // 订阅更新时调用。使用 `stripeSubscription` 获取原始 Stripe 字段，例如 `cancellation_details`。
        console.log(`订阅 ${subscription.id} 已更新`);
    },
    onSubscriptionCancel: async ({ event, subscription, stripeSubscription, cancellationDetails }) => {
        // 订阅取消时调用
        await sendCancellationEmail(subscription.referenceId);
    },
    onSubscriptionDeleted: async ({ event, subscription, stripeSubscription }) => {
        // 订阅删除时调用
        console.log(`订阅 ${subscription.id} 已删除`);
    }
}

{
    name: "pro",
    priceId: "price_0987654321",
    freeTrial: {
        days: 14,
        onTrialStart: async (subscription) => {
            // 试用期开始时调用
            await sendTrialStartEmail(subscription.referenceId);
        },
        onTrialEnd: async ({ subscription }, ctx) => {
            // 试用期结束时调用
            await sendTrialEndEmail(subscription.referenceId);
        },
        onTrialExpired: async (subscription, ctx) => {
            // 试用到期未转换时调用
            await sendTrialExpiredEmail(subscription.referenceId);
        }
    }
}

stripe({
    // ... 其他选项
    schema: {
        subscription: {
            modelName: "stripeSubscriptions", // 将订阅表映射为 stripeSubscriptions
            fields: {
                plan: "planName" // 将 plan 字段映射为 planName
            }
        }
    }
})

subscription: {
    // ... 其他订阅选项
    authorizeReference: async ({ user, referenceId, action }) => {
        const member = await db.members.findFirst({
            where: {
                userId: user.id,
                organizationId: referenceId
            }
        });

        return member?.role === "owner" || member?.role === "admin";
    }
}

await stripeClient.customers.update(organization.stripeCustomerId, {
    email: "billing@company.com"
});

import { betterAuth } from "better-auth";
import { APIError } from "better-auth/api";

export const auth = betterAuth({
    user: {
        deleteUser: {
            enabled: true,
            beforeDelete: async (user) => {
                if (!user.stripeCustomerId) return;

                for await (const sub of stripeClient.subscriptions.list({
                    customer: user.stripeCustomerId,
                    status: "all",
                })) {
                    if (["canceled", "incomplete", "incomplete_expired"].includes(sub.status)) continue;

                    throw new APIError("BAD_REQUEST", {
                        message: "请在删除账户前取消当前活跃订阅",
                    });
                    // 或立即取消：await stripeClient.subscriptions.cancel(sub.id);
                    // 或在周期结束时取消：      await stripeClient.subscriptions.update(sub.id, { cancel_at_period_end: true });
                }
            },
        },
    },
});

getCheckoutSessionParams: async ({ user, session, plan, subscription }, ctx) => {
    return {
        params: {
            allow_promotion_codes: true,
            tax_id_collection: {
                enabled: true
            },
            billing_address_collection: "required",
            custom_text: {
                submit: {
                    message: "我们将立即为您启用订阅"
                }
            },
            metadata: {
                planType: "business",
                referralCode: user.metadata?.referralCode
            }
        },
        options: {
            idempotencyKey: `sub_${user.id}_${plan.name}_${Date.now()}`
        }
    };
}

subscription: {
    // ... 其他选项
    getCheckoutSessionParams: async ({ user, session, plan, subscription }, ctx) => {
        return {
            params: {
                tax_id_collection: {
                    enabled: true
                }
            }
        };
    }
}

subscription: {
    // ... 其他选项
    getCheckoutSessionParams: async ({ user, session, plan, subscription }, ctx) => {
        return {
            params: {
                automatic_tax: {
                    enabled: true
                }
            }
        };
    }
}

stripe listen --forward-to localhost:3000/api/auth/stripe/webhook