@goscribe/server 1.1.7 → 1.3.0

package/src/lib/subscription_service.ts

@@ -0,0 +1,722 @@
+import { prisma } from './prisma.js';
+import { logger } from './logger.js';
+import { stripe } from './stripe.js';
+import Stripe from 'stripe';
+import {
+    notifyPaymentFailed,
+    notifyPaymentSucceeded,
+    notifySubscriptionActivated,
+    notifySubscriptionCanceled,
+    notifySubscriptionPaymentSucceeded,
+} from './notification-service.js';
+import { ArtifactType } from '@prisma/client';
+import PusherService from './pusher.js';
+
+/**
+ * Handle checkout.session.completed event
+ */
+export async function handleCheckoutCompleted(event: Stripe.Event) {
+    const session = event.data.object as Stripe.Checkout.Session;
+    const metadata = session.metadata;
+
+    // 0. Webhook Idempotency: We'll record this inside the fulfillment logic
+    // to ensure atomicity. If we record it too early and the DB crashes,
+    // we might skip a legitimate retry.
+
+    if (!metadata || !metadata.userId) {
+        logger.error('Missing userId metadata in Stripe checkout session', 'STRIPE', { sessionId: session.id });
+        return; // This is a permanent failure (misconfiguration), don't retry? 
+        // Actually, rethrowing might be better just in case it's transient, 
+        // but if metadata is missing, it's usually a bug.
+    }
+
+    const userId = metadata.userId;
+
+    // 1. Handle Resource Top-ups (One-time purchases)
+    if (metadata.isPurchase === 'true') {
+        const resourceType = metadata.resourceType as ArtifactType;
+        const quantity = parseInt(metadata.quantity || "1", 10);
+
+        try {
+            await prisma.$transaction(async (tx) => {
+                // 1. Release the Idempotency Lock
+                if (metadata.attemptId) {
+                    await tx.idempotencyRecord.update({
+                        where: { id: metadata.attemptId },
+                        data: { status: 'completed', activeLockKey: null }
+                    }).catch(err => logger.warn(`Could not release lock for attempt ${metadata.attemptId}: ${err.message}`, 'STRIPE'));
+                }
+
+                await tx.userCredit.create({
+                    data: {
+                        userId,
+                        resourceType,
+                        amount: quantity,
+                        stripeSessionId: session.id,
+                    }
+                });
+
+                // Create an Invoice record for top-up revenue tracking
+                const stripeInvoiceId = (session as any).invoice;
+                let invoicePdfUrl = null;
+                let hostedInvoiceUrl = null;
+
+                if (stripeInvoiceId && stripe) {
+                    try {
+                        const stripeInvoice = await stripe.invoices.retrieve(stripeInvoiceId);
+                        invoicePdfUrl = stripeInvoice.invoice_pdf;
+                        hostedInvoiceUrl = stripeInvoice.hosted_invoice_url;
+                    } catch (err) {
+                        logger.warn(`Could not retrieve stripe invoice ${stripeInvoiceId} for top-up`, 'STRIPE');
+                    }
+                }
+
+                await (tx as any).invoice.create({
+                    data: {
+                        userId,
+                        stripeInvoiceId: stripeInvoiceId || `session_${session.id}`,
+                        amountPaid: session.amount_total || 0,
+                        status: 'paid',
+                        type: 'TOPUP',
+                        paidAt: new Date(),
+                        invoicePdfUrl,
+                        hostedInvoiceUrl,
+                    }
+                });
+            });
+
+            logger.info(`✅ Resource Top-up fulfilled: User ${userId} gets ${quantity} ${resourceType}`, 'STRIPE');
+
+            // Notify UI
+            await PusherService.emitPaymentSuccess(userId, {
+                type: 'topup',
+                resourceType,
+                quantity: quantity.toString()
+            });
+
+        } catch (err: any) {
+            // Prisma error P2002 means duplicate stripeSessionId (already fulfilled)
+            if (err.code === 'P2002') {
+                logger.warn(`Top-up for session ${session.id} already fulfilled. Skipping.`, 'STRIPE');
+            } else {
+                logger.error('Failed to fulfill resource top-up', 'STRIPE', undefined, err);
+                throw err; // RETHROW: Trigger Stripe retry
+            }
+        }
+        return;
+    }
+
+    // 2. Handle Subscription Plans (Legacy or specific plan ID)
+    if (!metadata.planId) {
+        logger.error('Missing planId metadata in legacy checkout flow', 'STRIPE', { sessionId: session.id });
+        return;
+    }
+    const planId = metadata.planId;
+
+    logger.info(`Checkout completed for user ${userId}, plan ${planId}`, 'STRIPE', { sessionId: session.id });
+
+    // Release the Idempotency Lock for ALL successful checkouts
+    if (metadata.attemptId) {
+        await prisma.idempotencyRecord.update({
+            where: { id: metadata.attemptId },
+            data: { status: 'completed', activeLockKey: null }
+        }).catch(err => logger.warn(`Could not release lock for attempt ${metadata.attemptId}: ${err.message}`, 'STRIPE'));
+    }
+
+    // Handle one-time credit purchases (Starter plan)
+    // Subscription plans will be handled by customer.subscription.created
+    if (session.mode === 'payment' && metadata.isPurchase !== 'true') {
+        const now = new Date();
+        const distantFuture = new Date();
+        distantFuture.setFullYear(now.getFullYear() + 100);
+
+        try {
+            await prisma.subscription.create({
+                data: {
+                    userId,
+                    planId,
+                    stripeSubscriptionId: `ot_${session.id}`, // One-time identifier
+                    stripeCustomerId: session.customer as string,
+                    status: 'active',
+                    currentPeriodStart: now,
+                    currentPeriodEnd: distantFuture,
+                },
+            });
+            const plan = await prisma.plan.findUnique({ where: { id: planId } });
+            await notifyPaymentSucceeded(prisma, {
+                userId,
+                planId,
+                planName: plan?.name,
+                stripeSessionId: session.id,
+                amountPaid: session.amount_total ?? undefined,
+            });
+            logger.info(`One-time plan (credits) fulfilled for user ${userId}`, 'STRIPE');
+        } catch (err: any) {
+            if (err.code === 'P2002') {
+                logger.warn(`One-time sub for session ${session.id} already exists. Skipping.`, 'STRIPE');
+            } else {
+                logger.error('Failed to fulfill one-time checkout session', 'STRIPE', undefined, err);
+                throw err; // RETHROW: Trigger Stripe retry
+            }
+        }
+    }
+}
+
+/**
+ * Handle customer.subscription.created event
+ */
+export async function handleSubscriptionCreated(event: Stripe.Event) {
+    const subscription = event.data.object as Stripe.Subscription;
+
+    logger.info(`Subscription created: ${subscription.id}`, 'STRIPE');
+    // upsertSubscriptionFromStripe now handles its own transaction
+    await upsertSubscriptionFromStripe(subscription);
+    // 1. Keep the notification logic from 'main'
+    const dbSubscription = await prisma.subscription.findUnique({
+        where: { stripeSubscriptionId: subscription.id },
+        include: { plan: true },
+    });
+
+    if (dbSubscription) {
+        await notifySubscriptionActivated(prisma, {
+            userId: dbSubscription.userId,
+            planId: dbSubscription.planId,
+            planName: dbSubscription.plan.name,
+            stripeSubscriptionId: dbSubscription.stripeSubscriptionId,
+        });
+    }
+
+    // 2. Keep the event tracking logic from my fixes
+    await prisma.stripeEvent.create({
+        data: {
+            stripeEventId: event.id,
+            type: event.type,
+            status: 'processed',
+            processedAt: new Date(),
+        }
+    }).catch(err => {
+        if (err.code !== 'P2002') throw err;
+    });
+}
+
+/**
+ * Handle customer.subscription.updated event
+ */
+export async function handleSubscriptionUpdated(event: Stripe.Event) {
+    const subscription = event.data.object as Stripe.Subscription;
+
+    logger.info(`Subscription updated: ${subscription.id}`, 'STRIPE');
+    await upsertSubscriptionFromStripe(subscription);
+
+    await prisma.stripeEvent.create({
+        data: {
+            stripeEventId: event.id,
+            type: event.type,
+            status: 'processed',
+            processedAt: new Date(),
+        }
+    }).catch(err => {
+        if (err.code !== 'P2002') throw err;
+    });
+}
+
+/**
+ * Handle customer.subscription.deleted event
+ */
+export async function handleSubscriptionDeleted(event: Stripe.Event) {
+    const subscription = event.data.object as Stripe.Subscription;
+
+    logger.info(`Subscription deleted: ${subscription.id}`, 'STRIPE');
+    try {
+        const existing = await prisma.subscription.findUnique({
+            where: { stripeSubscriptionId: subscription.id },
+            include: { plan: true },
+        });
+
+        await prisma.$transaction(async (tx) => {
+            // Mark event as processed
+            await tx.stripeEvent.create({
+                data: {
+                    stripeEventId: event.id,
+                    type: event.type,
+                    status: 'processed',
+                    processedAt: new Date(),
+                }
+            });
+
+            await tx.subscription.update({
+                where: { stripeSubscriptionId: subscription.id },
+                data: {
+                    status: 'canceled',
+                    canceledAt: new Date(),
+                },
+            });
+        });
+
+        if (existing) {
+            await notifySubscriptionCanceled(prisma, {
+                userId: existing.userId,
+                planId: existing.planId,
+                planName: existing.plan.name,
+                stripeSubscriptionId: existing.stripeSubscriptionId,
+            });
+        }
+        logger.info(`Subscription ${subscription.id} marked as canceled in DB`, 'STRIPE');
+    } catch (err: any) {
+        if (err.code === 'P2002') return; // Event already processed
+        // If the subscription doesn't exist in our DB, just log it
+        logger.warn(`Could not mark subscription ${subscription.id} as canceled: ${err.message}`, 'STRIPE');
+        // We don't necessarily need to rethrow here if it's a 404 (P2025) on our end,
+        // but if it's a DB error, we should.
+        if (err.code !== 'P2025') throw err;
+    }
+}
+
+/**
+ * Handle invoice.paid event
+ */
+export async function handleInvoicePaid(event: Stripe.Event) {
+    const invoice = event.data.object as Stripe.Invoice;
+
+    const stripeInvoiceId = invoice.id;
+    const stripeSubscriptionId =
+        (invoice as any).subscription as string ||
+        (invoice as any).parent?.subscription_details?.subscription as string;
+    const stripeCustomerId = invoice.customer as string;
+    const amountPaid = invoice.amount_paid;
+    const status = 'paid';
+    const invoicePdfUrl = invoice.invoice_pdf;
+    const hostedInvoiceUrl = invoice.hosted_invoice_url;
+    const paidAt = invoice.status_transitions?.paid_at ? new Date(invoice.status_transitions.paid_at * 1000) : new Date();
+
+    logger.info(`Invoice paid: ${stripeInvoiceId} for customer ${stripeCustomerId}, sub ${stripeSubscriptionId}`, 'STRIPE');
+
+    let userId: string | null = null;
+    let subscriptionId: string | null = null;
+    let resolvedPlanId: string | undefined;
+    let resolvedPlanName: string | undefined;
+
+    // 1. If it's a subscription invoice, sync subscription first
+    if (stripeSubscriptionId) {
+        logger.info(`Syncing subscription ${stripeSubscriptionId} from Stripe...`, 'STRIPE');
+        await upsertSubscriptionFromStripe(stripeSubscriptionId);
+
+        const subscription = await prisma.subscription.findUnique({
+            where: { stripeSubscriptionId },
+            include: { plan: true },
+        });
+
+        if (subscription) {
+            userId = subscription.userId;
+            subscriptionId = subscription.id;
+            resolvedPlanId = subscription.planId;
+            resolvedPlanName = subscription.plan?.name;
+            logger.info(`Found existing subscription ${subscriptionId} for user ${userId}`, 'STRIPE');
+        } else {
+            logger.warn(`Subscription ${stripeSubscriptionId} STILL not found after sync attempt.`, 'STRIPE');
+        }
+    }
+
+    // 2. If no userId found yet (or one-time payment), try finding user by Stripe Customer ID
+    if (!userId && stripeCustomerId) {
+        const user = await prisma.user.findUnique({
+            where: { stripe_customer_id: stripeCustomerId }
+        });
+        userId = user?.id || null;
+    }
+
+    if (!userId) {
+        logger.error(`Could not determine user for invoice ${stripeInvoiceId} (Customer: ${stripeCustomerId}, Sub: ${stripeSubscriptionId})`, 'STRIPE');
+        return;
+    }
+
+    // 3. Create/Update Invoice record within transaction that marks event as processed
+    try {
+        logger.info(`Upserting invoice ${stripeInvoiceId} for user ${userId}...`, 'STRIPE');
+        await prisma.$transaction(async (tx) => {
+            // Mark event as processed
+            await tx.stripeEvent.create({
+                data: {
+                    stripeEventId: event.id,
+                    type: event.type,
+                    status: 'processed',
+                    processedAt: new Date(),
+                }
+            });
+
+            await (tx as any).invoice.upsert({
+                where: { stripeInvoiceId },
+                create: {
+                    userId,
+                    subscriptionId,
+                    stripeInvoiceId,
+                    amountPaid,
+                    status,
+                    type: 'SUBSCRIPTION',
+                    invoicePdfUrl,
+                    hostedInvoiceUrl,
+                    paidAt,
+                    createdAt: new Date(invoice.created * 1000),
+                },
+                update: {
+                    status,
+                    paidAt,
+                    invoicePdfUrl,
+                    hostedInvoiceUrl,
+                    ...(subscriptionId ? { subscriptionId } : {}),
+                }
+            });
+        });
+    } catch (err: any) {
+        if (err.code === 'P2002') return; // Already processed
+        logger.error(`Failed to upsert invoice ${stripeInvoiceId}`, 'STRIPE', undefined, err);
+        throw err;
+    }
+
+    logger.info(`Invoice ${stripeInvoiceId} saved successfully for user ${userId}`, 'STRIPE');
+    await notifySubscriptionPaymentSucceeded(prisma, {
+        userId,
+        planId: resolvedPlanId,
+        planName: resolvedPlanName,
+        stripeInvoiceId,
+        amountPaid,
+    });
+}
+
+/**
+ * Handle invoice.payment_failed event
+ */
+export async function handlePaymentFailed(event: Stripe.Event) {
+    const invoice = event.data.object as Stripe.Invoice;
+
+    const stripeInvoiceId = invoice.id;
+    const stripeSubscriptionId = (invoice as any).subscription as string;
+
+    logger.warn(`Invoice payment failed: ${stripeInvoiceId} for sub ${stripeSubscriptionId}`, 'STRIPE');
+
+    try {
+        await prisma.$transaction(async (tx) => {
+            // Mark event as processed
+            await tx.stripeEvent.create({
+                data: {
+                    stripeEventId: event.id,
+                    type: event.type,
+                    status: 'processed',
+                    processedAt: new Date(),
+                }
+            });
+
+            if (stripeSubscriptionId) {
+                // Mark subscription as past_due in DB
+                await tx.subscription.updateMany({
+                    where: { stripeSubscriptionId },
+                    data: { status: 'past_due' }
+                });
+            }
+
+            // Fetch info for legacy components if needed (main branch logic fallback)
+            const subscriptionInfo = await tx.subscription.findUnique({
+                where: { stripeSubscriptionId: stripeSubscriptionId || "" },
+                include: { plan: true },
+            });
+
+            // Create a failed invoice record for history
+            const subscription = await tx.subscription.findUnique({
+                where: { stripeSubscriptionId: stripeSubscriptionId || "" }
+            });
+
+            if (subscription) {
+                await (tx as any).invoice.upsert({
+                    where: { stripeInvoiceId },
+                    create: {
+                        userId: subscription.userId,
+                        subscriptionId: subscription.id,
+                        stripeInvoiceId,
+                        amountPaid: invoice.amount_paid,
+                        status: 'failed',
+                        type: 'SUBSCRIPTION',
+                        invoicePdfUrl: invoice.invoice_pdf,
+                        hostedInvoiceUrl: invoice.hosted_invoice_url,
+                        createdAt: new Date(invoice.created * 1000),
+                    },
+                    update: {
+                        status: 'failed'
+                    }
+                });
+            }
+        });
+        const targetSub = await prisma.subscription.findUnique({
+            where: { stripeSubscriptionId: stripeSubscriptionId || "" },
+            include: { plan: true }
+        });
+
+        if (targetSub) {
+            await notifyPaymentFailed(prisma, {
+                userId: targetSub.userId,
+                planId: targetSub.planId,
+                planName: targetSub.plan.name,
+                stripeInvoiceId,
+            });
+        }
+    } catch (err: any) {
+        if (err.code === 'P2002') return; // Already processed
+        logger.error(`Failed to record payment failure for invoice ${stripeInvoiceId}`, 'STRIPE', undefined, err);
+        throw err;
+    }
+}
+
+/**
+ * Handle payment_intent.payment_failed event (One-time payments)
+ */
+export async function handlePaymentIntentFailed(event: Stripe.Event) {
+    const paymentIntent = event.data.object as Stripe.PaymentIntent;
+
+    const stripePaymentIntentId = paymentIntent.id;
+    const stripeCustomerId = paymentIntent.customer as string;
+    const metadata = paymentIntent.metadata;
+    const userId = metadata?.userId;
+
+    logger.warn(`Payment Intent failed: ${stripePaymentIntentId} for user ${userId}`, 'STRIPE');
+
+    try {
+        await prisma.$transaction(async (tx) => {
+            // Mark event as processed
+            await tx.stripeEvent.create({
+                data: {
+                    stripeEventId: event.id,
+                    type: event.type,
+                    status: 'processed',
+                    processedAt: new Date(),
+                }
+            });
+
+            if (userId) {
+                // Create a failed invoice record for history (using PI ID as invoice ID placeholder for one-time failed attempts)
+                await (tx as any).invoice.upsert({
+                    where: { stripeInvoiceId: `pi_${stripePaymentIntentId}` },
+                    create: {
+                        userId,
+                        stripeInvoiceId: `pi_${stripePaymentIntentId}`,
+                        amountPaid: paymentIntent.amount,
+                        status: 'failed',
+                        type: 'TOPUP',
+                        createdAt: new Date(),
+                    },
+                    update: {
+                        status: 'failed'
+                    }
+                });
+
+                await notifyPaymentFailed(tx as any, {
+                    userId,
+                    planId: metadata?.planId,
+                    stripePaymentIntentId: stripePaymentIntentId,
+                });
+            } else if (stripeCustomerId) {
+                // Try finding user by customer ID if metadata missing
+                const user = await tx.user.findUnique({
+                    where: { stripe_customer_id: stripeCustomerId }
+                });
+                if (user) {
+                    await (tx as any).invoice.upsert({
+                        where: { stripeInvoiceId: `pi_${stripePaymentIntentId}` },
+                        create: {
+                            userId: user.id,
+                            stripeInvoiceId: `pi_${stripePaymentIntentId}`,
+                            amountPaid: paymentIntent.amount,
+                            status: 'failed',
+                            createdAt: new Date(),
+                        },
+                        update: {
+                            status: 'failed'
+                        }
+                    });
+
+                    await notifyPaymentFailed(tx as any, {
+                        userId: user.id,
+                        planId: metadata?.planId,
+                        stripePaymentIntentId: stripePaymentIntentId,
+                    });
+                }
+            }
+        });
+    } catch (err: any) {
+        if (err.code === 'P2002') return; // Already processed
+        logger.error(`Failed to record payment intent failure ${stripePaymentIntentId}`, 'STRIPE', undefined, err);
+        throw err;
+    }
+}
+
+/**
+ * Get the storage limit for a user based on their active subscription
+ */
+export async function getUserStorageLimit(userId: string): Promise<number> {
+    const activeSub = await prisma.subscription.findFirst({
+        where: {
+            userId,
+            status: 'active',
+        },
+        include: {
+            plan: {
+                include: {
+                    limit: true,
+                },
+            },
+        },
+        orderBy: {
+            createdAt: 'desc',
+        },
+    });
+
+    // If an active subscription with a plan limit exists, use it
+    if (activeSub?.plan?.limit?.maxStorageBytes) {
+        return Number(activeSub.plan.limit.maxStorageBytes);
+    }
+
+    // Default limit (fallback for users with no active subscription)
+    return 0;
+}
+
+/**
+ * Core logic to sync Stripe subscription state with Prisma database
+ */
+export async function upsertSubscriptionFromStripe(subscriptionIdOrObject: Stripe.Subscription | string) {
+    if (!stripe) {
+        logger.error('Stripe not initialized', 'STRIPE');
+        return;
+    }
+
+    try {
+        let subscription: Stripe.Subscription;
+
+        if (typeof subscriptionIdOrObject === 'string') {
+            subscription = await stripe.subscriptions.retrieve(subscriptionIdOrObject, {
+                expand: ['items.data.price'],
+            });
+        } else {
+            // Always retrieve fresh to ensure we have expanded fields and latest state
+            subscription = await stripe.subscriptions.retrieve(subscriptionIdOrObject.id, {
+                expand: ['items.data.price'],
+            });
+        }
+
+        const stripeSubscriptionId = subscription.id;
+        const stripeCustomerId = subscription.customer as string;
+        const status = subscription.status;
+
+        // Retrieve period fields from the first subscription item if available (newer API pattern)
+        // fall back to the main subscription object
+        const subItem = subscription.items.data[0];
+        const periodStartRaw = (subItem as any)?.current_period_start || (subscription as any).current_period_start;
+        const periodEndRaw = (subItem as any)?.current_period_end || (subscription as any).current_period_end;
+
+        const currentPeriodStart = new Date(periodStartRaw * 1000);
+        const currentPeriodEnd = new Date(periodEndRaw * 1000);
+        const cancelAt = subscription.cancel_at ? new Date(subscription.cancel_at * 1000) : null;
+        const canceledAt = subscription.canceled_at ? new Date(subscription.canceled_at * 1000) : null;
+
+        let userId = subscription.metadata?.userId;
+        let planId = subscription.metadata?.planId;
+
+        // Fallback: look up in DB if metadata is missing from Stripe object
+        if (!userId || !planId) {
+            const existing = await prisma.subscription.findUnique({
+                where: { stripeSubscriptionId },
+            });
+
+            if (existing) {
+                userId = userId || existing.userId;
+                planId = planId || existing.planId;
+            } else {
+                // If new subscription and metadata is missing, try matching by Customer ID
+                const user = await prisma.user.findUnique({
+                    where: { stripe_customer_id: stripeCustomerId },
+                });
+                if (user) {
+                    userId = userId || user.id;
+                }
+
+                // Match Plan by price ID
+                const priceId = subscription.items.data[0]?.price.id;
+                if (priceId) {
+                    const plan = await prisma.plan.findFirst({
+                        where: { stripePriceId: priceId },
+                    });
+                    if (plan) {
+                        planId = planId || plan.id;
+                    }
+                }
+            }
+        }
+
+        if (!userId || !planId) {
+            logger.error('ABORTING: Could not determine userId or planId for subscription', 'STRIPE', {
+                subscriptionId: stripeSubscriptionId,
+                customerId: stripeCustomerId,
+                priceId: subscription.items.data[0]?.price.id,
+                foundUserId: userId,
+                foundPlanId: planId
+            });
+            throw new Error(`Missing metadata for subscription ${stripeSubscriptionId}`);
+        }
+
+        logger.info(`SYNC: Valid data found for sub ${stripeSubscriptionId}. User: ${userId}, Plan: ${planId}`, 'STRIPE');
+
+        await prisma.$transaction(async (tx) => {
+            // Record the event if it was passed (for idempotency)
+            // Note: upsertSubscriptionFromStripe is sometimes called manually without an event
+            if (typeof subscriptionIdOrObject !== 'string' && (subscriptionIdOrObject as any).eventId) {
+                // Skip if already processed logic would go here if we wanted to be super strict
+                // but usually the calling handler handles it.
+            }
+
+            // Link Stripe Customer ID to User if not already linked
+            await tx.user.update({
+                where: { id: userId },
+                data: { stripe_customer_id: stripeCustomerId }
+            });
+
+            // Release the Idempotency Lock if this is a new sub being synced
+            // For subscriptions, we might find the attempt by metadata if available
+            const attemptId = subscription.metadata?.attemptId;
+            if (attemptId) {
+                await tx.idempotencyRecord.update({
+                    where: { id: attemptId },
+                    data: { status: 'completed', activeLockKey: null }
+                }).catch(() => { }); // SILENT: might already be released by checkout.completed
+            }
+
+            await tx.subscription.upsert({
+                where: { stripeSubscriptionId },
+                create: {
+                    userId,
+                    planId,
+                    stripeSubscriptionId,
+                    stripeCustomerId,
+                    status,
+                    currentPeriodStart,
+                    currentPeriodEnd,
+                    cancelAt,
+                    canceledAt,
+                },
+                update: {
+                    stripeCustomerId, // Keep customer ID synced in subscription row too
+                    status,
+                    currentPeriodStart,
+                    currentPeriodEnd,
+                    cancelAt,
+                    canceledAt,
+                },
+            });
+        });
+
+        logger.info(`Subscription ${stripeSubscriptionId} synced for user ${userId}`, 'STRIPE');
+
+        // Real-time UI refresh
+        await PusherService.emitPaymentSuccess(userId, { type: 'subscription' });
+
+    } catch (err: any) {
+        logger.error(`Error syncing subscription from Stripe: ${err.message}`, 'STRIPE');
+        throw err;
+    }
+}