@goscribe/server 1.5.0 → 1.7.0

package/dist/src/services/billing/payment.service.js

@@ -0,0 +1,365 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { stripe } from '../../lib/stripe.js';
+import { env } from '../../lib/env.js';
+import { getAccountSummary } from './usage.service.js';
+import { notifyPaymentSucceeded, notifySubscriptionActivated, notifySubscriptionPaymentSucceeded, } from '../notifications/notification.service.js';
+import { upsertSubscriptionFromStripe } from './subscription.service.js';
+/** Stripe Checkout URLs contain the session id (cs_…); we only store the URL in DB. */
+const CHECKOUT_SESSION_ID_IN_URL = /cs_[a-zA-Z0-9]+/;
+async function reuseCheckoutUrlIfSessionStillOpen(stripeClient, db, existing, lockKey) {
+    const url = existing.stripeSessionId;
+    if (!url)
+        return null;
+    const idMatch = url.match(CHECKOUT_SESSION_ID_IN_URL);
+    if (!idMatch) {
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: { activeLockKey: null, status: 'expired' },
+        });
+        return null;
+    }
+    try {
+        const session = await stripeClient.checkout.sessions.retrieve(idMatch[0]);
+        if (session.status === 'open') {
+            return url;
+        }
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: {
+                activeLockKey: null,
+                status: session.status === 'complete' ? 'completed' : 'expired',
+            },
+        });
+        return null;
+    }
+    catch {
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: { activeLockKey: null, status: 'expired' },
+        });
+        return null;
+    }
+}
+export class PaymentService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getPlans(userId) {
+        const plans = await this.db.plan.findMany({
+            where: { active: true },
+            include: { limit: true },
+            orderBy: { price: 'asc' },
+        });
+        // Anonymous callers (pricing page) don't get per-user `isActive`.
+        if (!userId) {
+            return plans.map((plan) => ({ ...plan, isActive: false }));
+        }
+        const activeSubscriptions = await this.db.subscription.findMany({
+            where: { userId, status: 'active' },
+        });
+        return plans.map((plan) => ({
+            ...plan,
+            isActive: activeSubscriptions.some((sub) => sub.planId === plan.id),
+        }));
+    }
+    async createCheckoutSession(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe not configured',
+            });
+        }
+        const user = await this.db.user.findUnique({ where: { id: userId } });
+        if (!user)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+        const lockKey = `pending_${userId}_${input.planId}`;
+        let attempt = null;
+        let retryCount = 0;
+        while (retryCount < 3) {
+            try {
+                attempt = await this.db.idempotencyRecord.create({
+                    data: {
+                        userId,
+                        planId: input.planId,
+                        activeLockKey: lockKey,
+                        status: 'pending',
+                    },
+                });
+                break;
+            }
+            catch (err) {
+                if (err.code === 'P2002') {
+                    const existing = await this.db.idempotencyRecord.findUnique({
+                        where: { activeLockKey: lockKey },
+                    });
+                    if (!existing) {
+                        retryCount++;
+                        continue;
+                    }
+                    const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+                    if (isStale) {
+                        const result = await this.db.idempotencyRecord.updateMany({
+                            where: { id: existing.id, activeLockKey: lockKey },
+                            data: { activeLockKey: null, status: 'expired' },
+                        });
+                        if (result.count > 0) {
+                            retryCount++;
+                            continue;
+                        }
+                    }
+                    if (existing.stripeSessionId && stripe) {
+                        const reusable = await reuseCheckoutUrlIfSessionStillOpen(stripe, this.db, existing, lockKey);
+                        if (reusable)
+                            return { url: reusable };
+                        retryCount++;
+                        continue;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 800));
+                    retryCount++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+        if (!attempt) {
+            throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+        }
+        const plan = await this.db.plan.findUnique({ where: { id: input.planId } });
+        if (!plan)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Plan not found' });
+        try {
+            const successUrl = env.STRIPE_SUCCESS_URL.includes('session_id=')
+                ? env.STRIPE_SUCCESS_URL
+                : `${env.STRIPE_SUCCESS_URL}${env.STRIPE_SUCCESS_URL.includes('?') ? '&' : '?'}session_id={CHECKOUT_SESSION_ID}`;
+            const session = await stripe.checkout.sessions.create({
+                customer: user.stripe_customer_id || undefined,
+                customer_email: user.stripe_customer_id ? undefined : user.email || undefined,
+                line_items: [{ price: plan.stripePriceId, quantity: 1 }],
+                mode: plan.interval ? 'subscription' : 'payment',
+                subscription_data: plan.interval
+                    ? {
+                        metadata: {
+                            userId,
+                            planId: plan.id,
+                            attemptId: attempt.id,
+                        },
+                    }
+                    : undefined,
+                success_url: successUrl,
+                cancel_url: env.STRIPE_CANCEL_URL,
+                metadata: {
+                    userId,
+                    planId: plan.id,
+                    attemptId: attempt.id,
+                },
+            }, {
+                idempotencyKey: attempt.id,
+            });
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { stripeSessionId: session.url },
+            });
+            return { url: session.url };
+        }
+        catch (error) {
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { status: 'failed', activeLockKey: null },
+            });
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: error.message,
+            });
+        }
+    }
+    async confirmCheckoutSuccess(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe not configured',
+            });
+        }
+        const session = await stripe.checkout.sessions.retrieve(input.sessionId, {
+            expand: ['line_items', 'subscription'],
+        });
+        const metadata = session.metadata || {};
+        if (metadata.userId !== userId) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'This checkout session does not belong to the current user',
+            });
+        }
+        if (session.status !== 'complete') {
+            return { confirmed: false, reason: 'checkout_not_complete' };
+        }
+        const plan = metadata.planId
+            ? await this.db.plan.findUnique({ where: { id: metadata.planId } })
+            : null;
+        if (session.mode === 'payment' && session.payment_status === 'paid') {
+            await notifyPaymentSucceeded(this.db, {
+                userId,
+                planId: metadata.planId,
+                planName: plan?.name || metadata.planType,
+                stripeSessionId: session.id,
+                amountPaid: session.amount_total ?? undefined,
+            });
+            return { confirmed: true, kind: 'payment' };
+        }
+        if (session.mode === 'subscription') {
+            const stripeSubscriptionId = typeof session.subscription === 'string'
+                ? session.subscription
+                : session.subscription?.id;
+            if (stripeSubscriptionId) {
+                await upsertSubscriptionFromStripe(stripeSubscriptionId);
+                await notifySubscriptionActivated(this.db, {
+                    userId,
+                    planId: metadata.planId,
+                    planName: plan?.name || metadata.planType,
+                    stripeSubscriptionId,
+                });
+                if (session.payment_status === 'paid') {
+                    await notifySubscriptionPaymentSucceeded(this.db, {
+                        userId,
+                        planId: metadata.planId,
+                        planName: plan?.name || metadata.planType,
+                        stripeInvoiceId: `checkout_${session.id}`,
+                        amountPaid: session.amount_total ?? undefined,
+                    });
+                }
+            }
+            return { confirmed: true, kind: 'subscription' };
+        }
+        return { confirmed: false, reason: 'unsupported_mode' };
+    }
+    async createResourcePurchaseSession(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe is not configured on the server',
+            });
+        }
+        const user = await this.db.user.findUnique({ where: { id: userId } });
+        if (!user) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+        }
+        const resourcePrice = await this.db.resourcePrice.findUnique({
+            where: { resourceType: input.resourceType },
+        });
+        if (!resourcePrice) {
+            throw new TRPCError({
+                code: 'PRECONDITION_FAILED',
+                message: 'Price not set',
+            });
+        }
+        const lockKey = `topup_${userId}_${input.resourceType}`;
+        let attempt = null;
+        let retryCount = 0;
+        while (retryCount < 3) {
+            try {
+                attempt = await this.db.idempotencyRecord.create({
+                    data: {
+                        userId,
+                        resourceType: input.resourceType,
+                        activeLockKey: lockKey,
+                        status: 'pending',
+                    },
+                });
+                break;
+            }
+            catch (err) {
+                if (err.code === 'P2002') {
+                    const existing = await this.db.idempotencyRecord.findUnique({
+                        where: { activeLockKey: lockKey },
+                    });
+                    if (!existing) {
+                        retryCount++;
+                        continue;
+                    }
+                    const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+                    if (isStale) {
+                        const result = await this.db.idempotencyRecord.updateMany({
+                            where: { id: existing.id, activeLockKey: lockKey },
+                            data: { activeLockKey: null, status: 'expired' },
+                        });
+                        if (result.count > 0) {
+                            retryCount++;
+                            continue;
+                        }
+                    }
+                    if (existing.stripeSessionId && stripe) {
+                        const reusable = await reuseCheckoutUrlIfSessionStillOpen(stripe, this.db, existing, lockKey);
+                        if (reusable)
+                            return { url: reusable };
+                        retryCount++;
+                        continue;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 800));
+                    retryCount++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+        if (!attempt) {
+            throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+        }
+        try {
+            const resourceName = input.resourceType
+                .split('_')
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+                .join(' ');
+            const session = await stripe.checkout.sessions.create({
+                customer: user.stripe_customer_id || undefined,
+                line_items: [
+                    {
+                        price_data: {
+                            currency: 'usd',
+                            product_data: {
+                                name: `Add-on: extra ${resourceName}s`,
+                                description: `Purchase of ${input.quantity} additional ${resourceName}(s)`,
+                            },
+                            unit_amount: resourcePrice.priceCents,
+                        },
+                        quantity: input.quantity,
+                    },
+                ],
+                mode: 'payment',
+                success_url: `${env.STRIPE_SUCCESS_URL}?success=true`,
+                cancel_url: env.STRIPE_CANCEL_URL,
+                metadata: {
+                    userId,
+                    resourceType: input.resourceType,
+                    quantity: input.quantity.toString(),
+                    isPurchase: 'true',
+                    attemptId: attempt.id,
+                },
+                invoice_creation: { enabled: true },
+            }, {
+                idempotencyKey: attempt.id,
+            });
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { stripeSessionId: session.url },
+            });
+            return { url: session.url };
+        }
+        catch (error) {
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { status: 'failed', activeLockKey: null },
+            });
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: error.message,
+            });
+        }
+    }
+    async getUsageOverview(userId) {
+        const { usage, limits, hasActivePlan } = await getAccountSummary(userId);
+        return { usage, limits, hasActivePlan };
+    }
+    getResourcePrices() {
+        return this.db.resourcePrice.findMany();
+    }
+}

package/dist/src/services/billing/subscription.service.d.ts

@@ -0,0 +1,37 @@
+import Stripe from 'stripe';
+/**
+ * Handle checkout.session.completed event
+ */
+export declare function handleCheckoutCompleted(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.created event
+ */
+export declare function handleSubscriptionCreated(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.updated event
+ */
+export declare function handleSubscriptionUpdated(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.deleted event
+ */
+export declare function handleSubscriptionDeleted(event: Stripe.Event): Promise<void>;
+/**
+ * Handle invoice.paid event
+ */
+export declare function handleInvoicePaid(event: Stripe.Event): Promise<void>;
+/**
+ * Handle invoice.payment_failed event
+ */
+export declare function handlePaymentFailed(event: Stripe.Event): Promise<void>;
+/**
+ * Handle payment_intent.payment_failed event (One-time payments)
+ */
+export declare function handlePaymentIntentFailed(event: Stripe.Event): Promise<void>;
+/**
+ * Get the storage limit for a user based on their active subscription
+ */
+export declare function getUserStorageLimit(userId: string): Promise<number>;
+/**
+ * Core logic to sync Stripe subscription state with Prisma database
+ */
+export declare function upsertSubscriptionFromStripe(subscriptionIdOrObject: Stripe.Subscription | string): Promise<void>;