dartmind 17.0.0

package/dist/saas/billing/BillingService.js

@@ -0,0 +1,672 @@
+/**
+ * FlutterAI V16 - Billing Service
+ * Issue 14.1: Stripe Billing Integration
+ * Issue 14.2: Subscription Management
+ *
+ * Provides Stripe-based billing with subscription management
+ *
+ * @module saas/billing/BillingService
+ * @version 16.0.0
+ */
+import { EventEmitter } from 'events';
+import * as crypto from 'crypto';
+// ============================================================================
+// Pricing Tiers
+// ============================================================================
+export const PRICING_TIERS = {
+    free: {
+        id: 'free',
+        name: 'Free',
+        description: 'Perfect for trying out FlutterAI',
+        monthlyPrice: 0,
+        annualPrice: 0,
+        features: [
+            'Basic code generation',
+            '100 requests per day',
+            '50,000 tokens per month',
+            'Community support',
+        ],
+        dailyRequestLimit: 100,
+        monthlyTokenLimit: 50000,
+        prioritySupport: false,
+        customIntegrations: false,
+    },
+    pro: {
+        id: 'pro',
+        name: 'Pro',
+        description: 'For professional developers',
+        monthlyPrice: 2900, // $29/month
+        annualPrice: 29000, // $290/year (save ~17%)
+        stripePriceIdMonthly: 'price_pro_monthly',
+        stripePriceIdAnnual: 'price_pro_annual',
+        features: [
+            'Advanced code generation',
+            '1,000 requests per day',
+            '500,000 tokens per month',
+            'Priority support',
+            'Custom templates',
+            'API access',
+        ],
+        dailyRequestLimit: 1000,
+        monthlyTokenLimit: 500000,
+        prioritySupport: true,
+        customIntegrations: false,
+    },
+    team: {
+        id: 'team',
+        name: 'Team',
+        description: 'For development teams',
+        monthlyPrice: 9900, // $99/month
+        annualPrice: 99000, // $990/year (save ~17%)
+        stripePriceIdMonthly: 'price_team_monthly',
+        stripePriceIdAnnual: 'price_team_annual',
+        features: [
+            'Everything in Pro',
+            '5,000 requests per day',
+            '2,000,000 tokens per month',
+            'Up to 10 team members',
+            'Team analytics',
+            'Shared templates',
+            'Admin dashboard',
+        ],
+        dailyRequestLimit: 5000,
+        monthlyTokenLimit: 2000000,
+        maxTeamMembers: 10,
+        prioritySupport: true,
+        customIntegrations: true,
+    },
+    enterprise: {
+        id: 'enterprise',
+        name: 'Enterprise',
+        description: 'For large organizations',
+        monthlyPrice: 49900, // $499/month
+        annualPrice: 499000, // $4,990/year (save ~17%)
+        stripePriceIdMonthly: 'price_enterprise_monthly',
+        stripePriceIdAnnual: 'price_enterprise_annual',
+        features: [
+            'Everything in Team',
+            'Unlimited requests',
+            'Unlimited tokens',
+            'Unlimited team members',
+            'SSO integration',
+            'Custom deployment',
+            'Dedicated support',
+            'SLA guarantee',
+            'HIPAA compliance',
+            'SOC 2 compliance',
+        ],
+        dailyRequestLimit: Infinity,
+        monthlyTokenLimit: Infinity,
+        maxTeamMembers: Infinity,
+        prioritySupport: true,
+        customIntegrations: true,
+    },
+};
+// ============================================================================
+// BillingService Class
+// ============================================================================
+export class BillingService extends EventEmitter {
+    config;
+    subscriptions = new Map();
+    userSubscriptions = new Map(); // userId -> subscriptionId
+    invoices = new Map();
+    paymentMethods = new Map();
+    checkoutSessions = new Map();
+    constructor(config = {}) {
+        super();
+        this.config = {
+            trialDays: config.trialDays ?? 14,
+            ...config,
+        };
+    }
+    // ==========================================================================
+    // Pricing Information
+    // ==========================================================================
+    /**
+     * Get all pricing tiers
+     */
+    getPricingTiers() {
+        return Object.values(PRICING_TIERS);
+    }
+    /**
+     * Get specific tier
+     */
+    getTier(tierId) {
+        return PRICING_TIERS[tierId];
+    }
+    /**
+     * Compare tiers
+     */
+    compareTiers(tier1, tier2) {
+        const tierOrder = ['free', 'pro', 'team', 'enterprise'];
+        const index1 = tierOrder.indexOf(tier1);
+        const index2 = tierOrder.indexOf(tier2);
+        return {
+            higher: index1 > index2 ? tier1 : tier2,
+            isUpgrade: index2 > index1,
+        };
+    }
+    // ==========================================================================
+    // Subscription Management
+    // ==========================================================================
+    /**
+     * Create a new subscription
+     */
+    async createSubscription(userId, tier, interval = 'monthly') {
+        // Check if user already has subscription
+        const existingSubId = this.userSubscriptions.get(userId);
+        if (existingSubId) {
+            const existing = this.subscriptions.get(existingSubId);
+            if (existing && existing.status === 'active') {
+                throw new Error('User already has an active subscription');
+            }
+        }
+        const now = new Date();
+        const periodEnd = new Date(now);
+        if (interval === 'monthly') {
+            periodEnd.setMonth(periodEnd.getMonth() + 1);
+        }
+        else {
+            periodEnd.setFullYear(periodEnd.getFullYear() + 1);
+        }
+        // Apply trial for paid tiers
+        let trialEnd;
+        if (tier !== 'free' && this.config.trialDays && this.config.trialDays > 0) {
+            trialEnd = new Date(now);
+            trialEnd.setDate(trialEnd.getDate() + this.config.trialDays);
+        }
+        const subscription = {
+            id: this.generateId(),
+            userId,
+            tier,
+            interval,
+            status: trialEnd ? 'trialing' : 'active',
+            currentPeriodStart: now,
+            currentPeriodEnd: periodEnd,
+            cancelAtPeriodEnd: false,
+            createdAt: now,
+            updatedAt: now,
+            trialEnd,
+        };
+        this.subscriptions.set(subscription.id, subscription);
+        this.userSubscriptions.set(userId, subscription.id);
+        this.emit('subscription-created', { subscription });
+        return subscription;
+    }
+    /**
+     * Get user subscription
+     */
+    getSubscription(userId) {
+        const subId = this.userSubscriptions.get(userId);
+        if (!subId)
+            return undefined;
+        return this.subscriptions.get(subId);
+    }
+    /**
+     * Get subscription by ID
+     */
+    getSubscriptionById(subscriptionId) {
+        return this.subscriptions.get(subscriptionId);
+    }
+    /**
+     * Update subscription tier (upgrade/downgrade)
+     */
+    async updateSubscription(userId, newTier, newInterval) {
+        const subscription = this.getSubscription(userId);
+        if (!subscription) {
+            throw new Error('No subscription found for user');
+        }
+        const oldTier = subscription.tier;
+        const comparison = this.compareTiers(oldTier, newTier);
+        subscription.tier = newTier;
+        if (newInterval) {
+            subscription.interval = newInterval;
+        }
+        subscription.updatedAt = new Date();
+        // If upgrading, immediate effect
+        // If downgrading, takes effect at end of period
+        if (!comparison.isUpgrade) {
+            subscription.cancelAtPeriodEnd = false; // Reset if was set
+        }
+        this.emit('subscription-updated', {
+            subscription,
+            oldTier,
+            newTier,
+            isUpgrade: comparison.isUpgrade,
+        });
+        return subscription;
+    }
+    /**
+     * Cancel subscription
+     */
+    async cancelSubscription(userId, immediately = false) {
+        const subscription = this.getSubscription(userId);
+        if (!subscription) {
+            throw new Error('No subscription found for user');
+        }
+        if (immediately) {
+            subscription.status = 'canceled';
+            subscription.tier = 'free';
+        }
+        else {
+            subscription.cancelAtPeriodEnd = true;
+        }
+        subscription.updatedAt = new Date();
+        this.emit('subscription-canceled', {
+            subscription,
+            immediately,
+        });
+        return subscription;
+    }
+    /**
+     * Reactivate canceled subscription
+     */
+    async reactivateSubscription(userId) {
+        const subscription = this.getSubscription(userId);
+        if (!subscription) {
+            throw new Error('No subscription found for user');
+        }
+        if (subscription.status === 'canceled') {
+            throw new Error('Cannot reactivate a fully canceled subscription');
+        }
+        subscription.cancelAtPeriodEnd = false;
+        subscription.updatedAt = new Date();
+        this.emit('subscription-reactivated', { subscription });
+        return subscription;
+    }
+    // ==========================================================================
+    // Checkout Sessions
+    // ==========================================================================
+    /**
+     * Create checkout session for subscription
+     */
+    async createCheckoutSession(userId, tier, interval = 'monthly') {
+        if (tier === 'free') {
+            throw new Error('Cannot create checkout for free tier');
+        }
+        const now = new Date();
+        const expiresAt = new Date(now);
+        expiresAt.setHours(expiresAt.getHours() + 24); // 24 hour expiry
+        const session = {
+            id: this.generateId(),
+            userId,
+            tier,
+            interval,
+            url: `https://checkout.stripe.com/pay/${this.generateId()}`, // Mock URL
+            status: 'pending',
+            createdAt: now,
+            expiresAt,
+        };
+        this.checkoutSessions.set(session.id, session);
+        this.emit('checkout-created', { session });
+        return session;
+    }
+    /**
+     * Complete checkout session
+     */
+    async completeCheckout(sessionId) {
+        const session = this.checkoutSessions.get(sessionId);
+        if (!session) {
+            throw new Error('Checkout session not found');
+        }
+        if (session.status !== 'pending') {
+            throw new Error('Checkout session is not pending');
+        }
+        if (session.expiresAt < new Date()) {
+            session.status = 'expired';
+            throw new Error('Checkout session has expired');
+        }
+        session.status = 'complete';
+        // Create subscription
+        const subscription = await this.createSubscription(session.userId, session.tier, session.interval);
+        this.emit('checkout-completed', { session, subscription });
+        return subscription;
+    }
+    // ==========================================================================
+    // Invoices
+    // ==========================================================================
+    /**
+     * Create invoice for subscription
+     */
+    async createInvoice(subscriptionId) {
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (!subscription) {
+            throw new Error('Subscription not found');
+        }
+        const tier = PRICING_TIERS[subscription.tier];
+        const amount = subscription.interval === 'monthly' ? tier.monthlyPrice : tier.annualPrice;
+        const now = new Date();
+        const dueDate = new Date(now);
+        dueDate.setDate(dueDate.getDate() + 30);
+        const invoice = {
+            id: this.generateId(),
+            userId: subscription.userId,
+            subscriptionId,
+            amount,
+            currency: 'usd',
+            status: 'open',
+            invoiceDate: now,
+            dueDate,
+        };
+        this.invoices.set(invoice.id, invoice);
+        this.emit('invoice-created', { invoice });
+        return invoice;
+    }
+    /**
+     * Get user invoices
+     */
+    getUserInvoices(userId) {
+        const invoices = [];
+        for (const invoice of this.invoices.values()) {
+            if (invoice.userId === userId) {
+                invoices.push(invoice);
+            }
+        }
+        return invoices.sort((a, b) => b.invoiceDate.getTime() - a.invoiceDate.getTime());
+    }
+    /**
+     * Mark invoice as paid
+     */
+    async payInvoice(invoiceId) {
+        const invoice = this.invoices.get(invoiceId);
+        if (!invoice) {
+            throw new Error('Invoice not found');
+        }
+        invoice.status = 'paid';
+        invoice.paidAt = new Date();
+        this.emit('invoice-paid', { invoice });
+        return invoice;
+    }
+    // ==========================================================================
+    // Payment Methods
+    // ==========================================================================
+    /**
+     * Add payment method
+     */
+    async addPaymentMethod(userId, cardDetails) {
+        const paymentMethod = {
+            id: this.generateId(),
+            userId,
+            brand: cardDetails.brand,
+            last4: cardDetails.last4,
+            expMonth: cardDetails.expMonth,
+            expYear: cardDetails.expYear,
+            isDefault: this.getUserPaymentMethods(userId).length === 0,
+            createdAt: new Date(),
+        };
+        this.paymentMethods.set(paymentMethod.id, paymentMethod);
+        this.emit('payment-method-added', { paymentMethod });
+        return paymentMethod;
+    }
+    /**
+     * Get user payment methods
+     */
+    getUserPaymentMethods(userId) {
+        const methods = [];
+        for (const method of this.paymentMethods.values()) {
+            if (method.userId === userId) {
+                methods.push(method);
+            }
+        }
+        return methods;
+    }
+    /**
+     * Set default payment method
+     */
+    async setDefaultPaymentMethod(userId, paymentMethodId) {
+        const methods = this.getUserPaymentMethods(userId);
+        for (const method of methods) {
+            method.isDefault = method.id === paymentMethodId;
+        }
+        this.emit('default-payment-method-changed', { userId, paymentMethodId });
+    }
+    /**
+     * Remove payment method
+     */
+    async removePaymentMethod(paymentMethodId) {
+        const method = this.paymentMethods.get(paymentMethodId);
+        if (!method)
+            return false;
+        if (method.isDefault) {
+            // Set another method as default
+            const otherMethods = this.getUserPaymentMethods(method.userId).filter((m) => m.id !== paymentMethodId);
+            if (otherMethods.length > 0) {
+                otherMethods[0].isDefault = true;
+            }
+        }
+        this.paymentMethods.delete(paymentMethodId);
+        this.emit('payment-method-removed', { paymentMethodId });
+        return true;
+    }
+    // ==========================================================================
+    // Billing Cycle Management
+    // ==========================================================================
+    /**
+     * Process subscription renewals
+     */
+    async processRenewals() {
+        let renewed = 0;
+        let failed = 0;
+        const now = new Date();
+        for (const subscription of this.subscriptions.values()) {
+            if (subscription.status === 'active' &&
+                subscription.currentPeriodEnd <= now) {
+                if (subscription.cancelAtPeriodEnd) {
+                    // Cancel the subscription
+                    subscription.status = 'canceled';
+                    subscription.tier = 'free';
+                    failed++;
+                }
+                else {
+                    // Renew the subscription
+                    try {
+                        await this.renewSubscription(subscription);
+                        renewed++;
+                    }
+                    catch {
+                        subscription.status = 'past_due';
+                        failed++;
+                    }
+                }
+            }
+        }
+        this.emit('renewals-processed', { renewed, failed });
+        return { renewed, failed };
+    }
+    /**
+     * Renew subscription
+     */
+    async renewSubscription(subscription) {
+        const now = new Date();
+        const newPeriodEnd = new Date(now);
+        if (subscription.interval === 'monthly') {
+            newPeriodEnd.setMonth(newPeriodEnd.getMonth() + 1);
+        }
+        else {
+            newPeriodEnd.setFullYear(newPeriodEnd.getFullYear() + 1);
+        }
+        subscription.currentPeriodStart = now;
+        subscription.currentPeriodEnd = newPeriodEnd;
+        subscription.updatedAt = now;
+        // Create invoice
+        await this.createInvoice(subscription.id);
+        this.emit('subscription-renewed', { subscription });
+    }
+    // ==========================================================================
+    // Usage-Based Billing
+    // ==========================================================================
+    /**
+     * Calculate prorated amount for upgrade
+     */
+    calculateProratedAmount(currentTier, newTier, daysRemaining, interval) {
+        const currentPrice = interval === 'monthly'
+            ? PRICING_TIERS[currentTier].monthlyPrice
+            : PRICING_TIERS[currentTier].annualPrice;
+        const newPrice = interval === 'monthly'
+            ? PRICING_TIERS[newTier].monthlyPrice
+            : PRICING_TIERS[newTier].annualPrice;
+        const totalDays = interval === 'monthly' ? 30 : 365;
+        const dailyDifference = (newPrice - currentPrice) / totalDays;
+        return Math.round(dailyDifference * daysRemaining);
+    }
+    // ==========================================================================
+    // Stripe Webhook Handling
+    // ==========================================================================
+    /**
+     * Handle Stripe webhook event
+     */
+    async handleWebhook(payload, signature) {
+        // Verify webhook signature
+        if (this.config.stripeWebhookSecret) {
+            const isValid = this.verifyWebhookSignature(payload, signature);
+            if (!isValid) {
+                throw new Error('Invalid webhook signature');
+            }
+        }
+        const event = JSON.parse(payload);
+        const eventType = event.type;
+        switch (eventType) {
+            case 'checkout.session.completed':
+                await this.handleCheckoutCompleted(event.data.object);
+                break;
+            case 'invoice.paid':
+                await this.handleInvoicePaid(event.data.object);
+                break;
+            case 'invoice.payment_failed':
+                await this.handlePaymentFailed(event.data.object);
+                break;
+            case 'customer.subscription.updated':
+                await this.handleSubscriptionUpdated(event.data.object);
+                break;
+            case 'customer.subscription.deleted':
+                await this.handleSubscriptionDeleted(event.data.object);
+                break;
+            default:
+                return { handled: false, eventType };
+        }
+        return { handled: true, eventType };
+    }
+    async handleCheckoutCompleted(data) {
+        // Find checkout session by Stripe ID and complete it
+        for (const session of this.checkoutSessions.values()) {
+            if (session.stripeSessionId === data.id) {
+                await this.completeCheckout(session.id);
+                break;
+            }
+        }
+    }
+    async handleInvoicePaid(data) {
+        for (const invoice of this.invoices.values()) {
+            if (invoice.stripeInvoiceId === data.id) {
+                await this.payInvoice(invoice.id);
+                break;
+            }
+        }
+    }
+    async handlePaymentFailed(data) {
+        for (const subscription of this.subscriptions.values()) {
+            if (subscription.stripeSubscriptionId === data.subscription) {
+                subscription.status = 'past_due';
+                this.emit('payment-failed', { subscription });
+                break;
+            }
+        }
+    }
+    async handleSubscriptionUpdated(data) {
+        for (const subscription of this.subscriptions.values()) {
+            if (subscription.stripeSubscriptionId === data.id) {
+                subscription.status = data.status;
+                subscription.cancelAtPeriodEnd = data.cancel_at_period_end;
+                subscription.updatedAt = new Date();
+                break;
+            }
+        }
+    }
+    async handleSubscriptionDeleted(data) {
+        for (const subscription of this.subscriptions.values()) {
+            if (subscription.stripeSubscriptionId === data.id) {
+                subscription.status = 'canceled';
+                subscription.tier = 'free';
+                subscription.updatedAt = new Date();
+                break;
+            }
+        }
+    }
+    /**
+     * Verify Stripe webhook signature
+     */
+    verifyWebhookSignature(payload, signature) {
+        if (!this.config.stripeWebhookSecret)
+            return true;
+        const elements = signature.split(',');
+        const timestamp = elements.find((e) => e.startsWith('t='))?.slice(2);
+        const v1Signature = elements.find((e) => e.startsWith('v1='))?.slice(3);
+        if (!timestamp || !v1Signature)
+            return false;
+        const signedPayload = `${timestamp}.${payload}`;
+        const expectedSignature = crypto
+            .createHmac('sha256', this.config.stripeWebhookSecret)
+            .update(signedPayload)
+            .digest('hex');
+        return v1Signature === expectedSignature;
+    }
+    // ==========================================================================
+    // Statistics
+    // ==========================================================================
+    /**
+     * Get billing statistics
+     */
+    getStats() {
+        let activeSubscriptions = 0;
+        let mrr = 0;
+        const subscriptionsByTier = {
+            free: 0,
+            pro: 0,
+            team: 0,
+            enterprise: 0,
+        };
+        for (const subscription of this.subscriptions.values()) {
+            subscriptionsByTier[subscription.tier]++;
+            if (subscription.status === 'active' || subscription.status === 'trialing') {
+                activeSubscriptions++;
+                const tier = PRICING_TIERS[subscription.tier];
+                if (subscription.interval === 'monthly') {
+                    mrr += tier.monthlyPrice;
+                }
+                else {
+                    mrr += tier.annualPrice / 12;
+                }
+            }
+        }
+        return {
+            totalSubscriptions: this.subscriptions.size,
+            activeSubscriptions,
+            subscriptionsByTier,
+            mrr: Math.round(mrr),
+            arr: Math.round(mrr * 12),
+        };
+    }
+    // ==========================================================================
+    // Internal Helpers
+    // ==========================================================================
+    /**
+     * Generate unique ID
+     */
+    generateId() {
+        return crypto.randomBytes(16).toString('hex');
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create BillingService with configuration
+ */
+export function createBillingService(config) {
+    return new BillingService(config);
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export default BillingService;
+//# sourceMappingURL=BillingService.js.map