Stripe

stripe({
    // ... 其他选项
    createCustomerOnSignUp: true,
    onCustomerCreate: async ({ customer, stripeCustomer, user }, request) => {
        // 对新建的客户执行一些操作
        console.log(`为用户 ${user.id} 创建了客户 ${customer.id}`);
    },
    getCustomerCreateParams: async ({ user, session }, request) => {
        // 自定义 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, // 免费试用天数
            }
        }
    ]
}

// 动态方案（从数据库或API获取）
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 client.subscription.upgrade({
    plan: "pro",
    successUrl: "/dashboard",
    cancelUrl: "/pricing",
    annual: true, // 可选：升级到年度计划
    referenceId: "org_123" // 可选：默认为当前登录用户 ID
    seats: 5 // 可选：适用于团队计划
});

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

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

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

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

await client.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);
    },
    onSubscriptionUpdate: async ({ event, subscription }) => {
        // 当订阅更新时调用
        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, user }, request) => {
            // 试用结束时调用
            await sendTrialEndEmail(user.email);
        },
        onTrialExpired: async (subscription) => {
            // 试用过期未转化时调用
            await sendTrialExpiredEmail(subscription.referenceId);
        }
    }
}

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

// 获取当前活跃组织
const { data: activeOrg } = client.useActiveOrganization();

// 为组织创建订阅
await client.subscription.upgrade({
    plan: "team",
    referenceId: activeOrg.id,
    seats: 10,
    annual: true, // 升级为年度计划（可选）
    successUrl: "/org/billing/success",
    cancelUrl: "/org/billing"
});

authorizeReference: async ({ user, referenceId, action }) => {
    const member = await db.members.findFirst({
        where: {
            userId: user.id,
            organizationId: referenceId
        }
    });
    
    return member?.role === "owner" || member?.role === "admin";
}

getCheckoutSessionParams: async ({ user, session, plan, subscription }, request) => {
    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 }, request) => {
        return {
            params: {
                tax_id_collection: {
                    enabled: true
                }
            }
        };
    }
}

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

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