@equilateral_ai/mindmeld 3.0.0

package/src/handlers/stripe/addonManagePost.js

@@ -0,0 +1,240 @@
+/**
+ * Add-on Management Handler
+ * Add or remove enterprise add-ons
+ *
+ * POST /api/stripe/subscription/addons
+ * Body: { action: 'add'|'remove', addonId: 'engineering_intelligence' }
+ * Auth: Cognito JWT required
+ */
+
+const {
+    wrapHandler,
+    executeQuery,
+    createSuccessResponse,
+    createErrorResponse,
+    handleError,
+    getEnterpriseAddon,
+    getAddonPriceId,
+    calculateEnterpriseCost
+} = require('./helpers');
+
+// Stripe is optional
+let stripe = null;
+try {
+    if (process.env.STRIPE_SECRET_KEY) {
+        stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+    }
+} catch (e) {
+    console.warn('Stripe not available:', e.message);
+}
+
+/**
+ * Add or remove enterprise add-on
+ */
+async function manageAddon({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const { action, addonId } = requestBody;
+
+        // Validate action
+        if (!['add', 'remove'].includes(action)) {
+            return createErrorResponse(400, 'Invalid action', {
+                valid_actions: ['add', 'remove']
+            });
+        }
+
+        // Validate add-on ID
+        const addon = getEnterpriseAddon(addonId);
+        if (!addon) {
+            return createErrorResponse(400, `Invalid add-on: ${addonId}`, {
+                valid_addons: ['engineering_intelligence', 'knowledge_continuity']
+            });
+        }
+
+        // Check Stripe is configured
+        if (!stripe) {
+            return createErrorResponse(503, 'Payment system not configured');
+        }
+
+        // Get client with enterprise subscription
+        const clientQuery = `
+            SELECT c.client_id, c.subscription_tier, c.subscription_status,
+                   c.stripe_subscription_id, c.seat_count, c.enterprise_package,
+                   c.subscribed_addons, c.stripe_customer_id
+            FROM rapport.users u
+            JOIN rapport.clients c ON u.client_id = c.client_id
+            WHERE u.email_address = $1 AND u.active = true
+        `;
+        const clientResult = await executeQuery(clientQuery, [email]);
+
+        if (clientResult.rowCount === 0) {
+            return createErrorResponse(404, 'User not found');
+        }
+
+        const client = clientResult.rows[0];
+
+        // Verify enterprise subscription
+        if (client.subscription_tier !== 'enterprise') {
+            return createErrorResponse(400, 'Add-ons only available for enterprise subscriptions');
+        }
+
+        if (!client.stripe_subscription_id) {
+            return createErrorResponse(400, 'No active Stripe subscription found');
+        }
+
+        // Check if using Full Platform (already includes all add-ons)
+        if (client.enterprise_package === 'full') {
+            return createErrorResponse(400, 'Full Platform package already includes all add-ons', {
+                tip: 'Downgrade to base package to manage add-ons separately'
+            });
+        }
+
+        const currentAddons = client.subscribed_addons || [];
+        const hasAddon = currentAddons.includes(addonId);
+        const seatCount = client.seat_count || 25;
+        const seatPacks = seatCount / 25;
+
+        if (action === 'add') {
+            if (hasAddon) {
+                return createErrorResponse(400, `Add-on ${addon.name} is already active`);
+            }
+
+            // Get subscription to add item
+            const subscription = await stripe.subscriptions.retrieve(client.stripe_subscription_id);
+
+            // Determine billing interval from existing subscription
+            const existingItem = subscription.items.data[0];
+            const billingInterval = existingItem?.price?.recurring?.interval || 'month';
+            const priceId = getAddonPriceId(addonId, billingInterval === 'year' ? 'annual' : 'monthly');
+
+            if (!priceId) {
+                return createErrorResponse(500, 'Add-on price not configured');
+            }
+
+            // Add subscription item
+            const newItem = await stripe.subscriptionItems.create({
+                subscription: client.stripe_subscription_id,
+                price: priceId,
+                quantity: seatPacks,
+                proration_behavior: 'create_prorations'
+            });
+
+            // Update client record
+            const updatedAddons = [...currentAddons, addonId];
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET subscribed_addons = $2, last_updated = CURRENT_TIMESTAMP
+                WHERE client_id = $1
+            `, [client.client_id, JSON.stringify(updatedAddons)]);
+
+            // Record in addon_entitlements
+            await executeQuery(`
+                INSERT INTO rapport.addon_entitlements (
+                    client_id, addon_id, stripe_subscription_item_id, seat_count, status
+                )
+                VALUES ($1, $2, $3, $4, 'active')
+                ON CONFLICT (client_id, addon_id) DO UPDATE SET
+                    stripe_subscription_item_id = EXCLUDED.stripe_subscription_item_id,
+                    seat_count = EXCLUDED.seat_count,
+                    status = 'active',
+                    updated_at = CURRENT_TIMESTAMP
+            `, [client.client_id, addonId, newItem.id, seatCount]);
+
+            // Calculate new cost
+            const newCost = calculateEnterpriseCost(
+                client.enterprise_package,
+                seatCount,
+                updatedAddons,
+                'monthly'
+            );
+
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        action: 'added',
+                        addon: addon.name,
+                        addonId,
+                        seatCount,
+                        monthlyAddonCost: addon.pricePerSeat * seatCount,
+                        newMonthlyTotal: newCost.total,
+                        prorated: true
+                    }]
+                },
+                `Added ${addon.name} add-on`,
+                { Request_ID, Timestamp: new Date().toISOString() }
+            );
+
+        } else if (action === 'remove') {
+            if (!hasAddon) {
+                return createErrorResponse(400, `Add-on ${addon.name} is not active`);
+            }
+
+            // Find the subscription item for this add-on
+            const entitlementQuery = `
+                SELECT stripe_subscription_item_id
+                FROM rapport.addon_entitlements
+                WHERE client_id = $1 AND addon_id = $2 AND status = 'active'
+            `;
+            const entitlementResult = await executeQuery(entitlementQuery, [client.client_id, addonId]);
+
+            if (entitlementResult.rowCount > 0 && entitlementResult.rows[0].stripe_subscription_item_id) {
+                // Remove subscription item from Stripe
+                await stripe.subscriptionItems.del(
+                    entitlementResult.rows[0].stripe_subscription_item_id,
+                    { proration_behavior: 'create_prorations' }
+                );
+            }
+
+            // Update client record
+            const updatedAddons = currentAddons.filter(id => id !== addonId);
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET subscribed_addons = $2, last_updated = CURRENT_TIMESTAMP
+                WHERE client_id = $1
+            `, [client.client_id, JSON.stringify(updatedAddons)]);
+
+            // Update addon_entitlements
+            await executeQuery(`
+                UPDATE rapport.addon_entitlements
+                SET status = 'canceled', updated_at = CURRENT_TIMESTAMP
+                WHERE client_id = $1 AND addon_id = $2
+            `, [client.client_id, addonId]);
+
+            // Calculate new cost
+            const newCost = calculateEnterpriseCost(
+                client.enterprise_package,
+                seatCount,
+                updatedAddons,
+                'monthly'
+            );
+
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        action: 'removed',
+                        addon: addon.name,
+                        addonId,
+                        monthlyAddonCost: addon.pricePerSeat * seatCount,
+                        newMonthlyTotal: newCost.total,
+                        prorated: true,
+                        creditIssued: true
+                    }]
+                },
+                `Removed ${addon.name} add-on`,
+                { Request_ID, Timestamp: new Date().toISOString() }
+            );
+        }
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(manageAddon);

package/src/handlers/stripe/billingPortalPost.js

@@ -0,0 +1,93 @@
+/**
+ * Billing Portal Handler
+ * Creates Stripe Customer Portal session for self-service subscription management
+ *
+ * POST /api/stripe/billing-portal
+ * Body: { returnUrl?: string }
+ * Auth: Cognito JWT required
+ */
+
+const {
+    wrapHandler,
+    executeQuery,
+    createSuccessResponse,
+    createErrorResponse,
+    handleError
+} = require('./helpers');
+
+// Stripe is optional
+let stripe = null;
+try {
+    if (process.env.STRIPE_SECRET_KEY) {
+        stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+    }
+} catch (e) {
+    console.warn('Stripe not available:', e.message);
+}
+
+/**
+ * Create billing portal session
+ */
+async function createBillingPortal({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const { returnUrl } = requestBody;
+
+        // Check Stripe is configured
+        if (!stripe) {
+            return createErrorResponse(503, 'Payment system not configured');
+        }
+
+        // Get client with Stripe customer ID
+        const clientQuery = `
+            SELECT c.client_id, c.stripe_customer_id, c.subscription_tier,
+                   c.subscription_status
+            FROM rapport.users u
+            JOIN rapport.clients c ON u.client_id = c.client_id
+            WHERE u.email_address = $1 AND u.active = true
+        `;
+        const clientResult = await executeQuery(clientQuery, [email]);
+
+        if (clientResult.rowCount === 0) {
+            return createErrorResponse(404, 'User not found');
+        }
+
+        const client = clientResult.rows[0];
+
+        if (!client.stripe_customer_id) {
+            return createErrorResponse(400, 'No billing account found. Subscribe to a plan first.');
+        }
+
+        // Create billing portal session
+        const session = await stripe.billingPortal.sessions.create({
+            customer: client.stripe_customer_id,
+            return_url: returnUrl || `${process.env.APP_URL || 'https://mindmeld.dev'}/settings/billing`
+        });
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    portalUrl: session.url,
+                    returnUrl: session.return_url
+                }]
+            },
+            'Billing portal session created',
+            {
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createBillingPortal);

package/src/handlers/stripe/enterpriseCheckoutPost.js

@@ -0,0 +1,272 @@
+/**
+ * Enterprise Checkout Handler
+ * Creates Stripe Checkout session for enterprise subscriptions
+ *
+ * POST /api/stripe/enterprise/checkout
+ * Body: { package: 'base'|'full', seatCount: 25, addons: [], billingPeriod: 'monthly'|'annual' }
+ * Auth: Cognito JWT required
+ */
+
+const {
+    wrapHandler,
+    executeQuery,
+    createSuccessResponse,
+    createErrorResponse,
+    handleError,
+    validateSeatCount,
+    calculateEnterpriseCost,
+    getEnterprisePackage,
+    getEnterpriseAddon,
+    getEnterprisePriceId,
+    getAddonPriceId,
+    getVolumeDiscount
+} = require('./helpers');
+
+// Stripe is optional - will be null if not configured
+let stripe = null;
+try {
+    if (process.env.STRIPE_SECRET_KEY) {
+        stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+    }
+} catch (e) {
+    console.warn('Stripe not available:', e.message);
+}
+
+/**
+ * Create enterprise checkout session
+ */
+async function createEnterpriseCheckout({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const {
+            package: packageType = 'base',
+            seatCount = 25,
+            addons = [],
+            billingPeriod = 'monthly'
+        } = requestBody;
+
+        // Validate package type
+        const pkgConfig = getEnterprisePackage(packageType);
+        if (!pkgConfig) {
+            return createErrorResponse(400, 'Invalid enterprise package', {
+                valid_packages: ['base', 'full'],
+                provided: packageType
+            });
+        }
+
+        // Validate seat count (must be >= 25 and multiple of 25)
+        const seatValidation = validateSeatCount(seatCount);
+        if (!seatValidation.valid) {
+            return createErrorResponse(400, seatValidation.message, {
+                requested: seatCount,
+                corrected: seatValidation.correctedCount,
+                minimum: 25,
+                increment: 25
+            });
+        }
+
+        // Validate add-ons (only valid for 'base' package)
+        if (packageType === 'full' && addons.length > 0) {
+            return createErrorResponse(400, 'Full Platform package already includes all add-ons', {
+                tip: 'Use base package if you want to select specific add-ons'
+            });
+        }
+
+        // Validate add-on IDs
+        for (const addonId of addons) {
+            const addon = getEnterpriseAddon(addonId);
+            if (!addon) {
+                return createErrorResponse(400, `Invalid add-on: ${addonId}`, {
+                    valid_addons: ['engineering_intelligence', 'knowledge_continuity']
+                });
+            }
+        }
+
+        // Check Stripe is configured
+        if (!stripe) {
+            return createErrorResponse(503, 'Payment system not configured', {
+                code: 'STRIPE_NOT_CONFIGURED'
+            });
+        }
+
+        // Get user's client
+        const userQuery = `
+            SELECT u.client_id, u.create_date as account_created,
+                   c.client_name, c.stripe_customer_id, c.subscription_status,
+                   c.subscription_tier
+            FROM rapport.users u
+            JOIN rapport.clients c ON u.client_id = c.client_id
+            WHERE u.email_address = $1 AND u.active = true
+        `;
+        const userResult = await executeQuery(userQuery, [email]);
+
+        if (userResult.rowCount === 0) {
+            return createErrorResponse(404, 'User not found');
+        }
+
+        const user = userResult.rows[0];
+
+        // Check for existing active enterprise subscription
+        if (user.subscription_tier === 'enterprise' && user.subscription_status === 'active') {
+            return createErrorResponse(400, 'Already have active enterprise subscription. Use seats/addons endpoints to modify.', {
+                code: 'ENTERPRISE_SUBSCRIPTION_EXISTS'
+            });
+        }
+
+        // Calculate pricing
+        const costBreakdown = calculateEnterpriseCost(packageType, seatCount, addons, billingPeriod);
+        const volumeDiscount = getVolumeDiscount(seatCount);
+
+        // Build line items for Stripe checkout
+        const lineItems = [];
+
+        // Get seat pack quantity (1 pack = 25 seats)
+        const seatPacks = seatCount / 25;
+
+        // Main package line item
+        const mainPriceId = getEnterprisePriceId(packageType, billingPeriod);
+        if (!mainPriceId) {
+            return createErrorResponse(500, 'Enterprise price not configured');
+        }
+
+        lineItems.push({
+            price: mainPriceId,
+            quantity: seatPacks
+        });
+
+        // Add-on line items (only for 'base' package)
+        if (packageType === 'base') {
+            for (const addonId of addons) {
+                const addonPriceId = getAddonPriceId(addonId, billingPeriod);
+                if (addonPriceId) {
+                    lineItems.push({
+                        price: addonPriceId,
+                        quantity: seatPacks
+                    });
+                }
+            }
+        }
+
+        // Create Stripe Checkout session
+        const sessionParams = {
+            mode: 'subscription',
+            payment_method_types: ['card'],
+            customer_email: email,
+            line_items: lineItems,
+            success_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/enterprise/success?session_id={CHECKOUT_SESSION_ID}`,
+            cancel_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/enterprise/cancel`,
+            metadata: {
+                client_id: user.client_id,
+                user_email: email,
+                tier: 'enterprise',
+                enterprise_package: packageType,
+                seat_count: seatCount.toString(),
+                addons: JSON.stringify(addons),
+                billing_period: billingPeriod
+            },
+            subscription_data: {
+                metadata: {
+                    client_id: user.client_id,
+                    tier: 'enterprise',
+                    enterprise_package: packageType,
+                    seat_count: seatCount.toString(),
+                    addons: JSON.stringify(addons)
+                }
+            }
+        };
+
+        // Apply volume discount as coupon if applicable
+        if (volumeDiscount.discount > 0) {
+            // Look up or create volume discount coupon
+            const couponId = `VOLUME_${Math.round(volumeDiscount.discount * 100)}`;
+            try {
+                await stripe.coupons.retrieve(couponId);
+            } catch (e) {
+                // Create coupon if it doesn't exist
+                if (e.code === 'resource_missing') {
+                    await stripe.coupons.create({
+                        id: couponId,
+                        percent_off: volumeDiscount.discount * 100,
+                        duration: 'forever',
+                        name: volumeDiscount.label
+                    });
+                }
+            }
+            sessionParams.discounts = [{ coupon: couponId }];
+        }
+
+        // If customer already exists in Stripe, use that
+        if (user.stripe_customer_id) {
+            delete sessionParams.customer_email;
+            sessionParams.customer = user.stripe_customer_id;
+        }
+
+        const session = await stripe.checkout.sessions.create(sessionParams);
+
+        // Store pending session with enterprise details
+        const sessionQuery = `
+            INSERT INTO rapport.stripe_checkout_sessions (
+                session_id,
+                client_id,
+                user_email,
+                tier,
+                billing_period,
+                seat_count,
+                enterprise_package,
+                addons,
+                status
+            )
+            VALUES ($1, $2, $3, 'enterprise', $4, $5, $6, $7, 'pending')
+        `;
+        await executeQuery(sessionQuery, [
+            session.id,
+            user.client_id,
+            email,
+            billingPeriod,
+            seatCount,
+            packageType,
+            JSON.stringify(addons)
+        ]);
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    checkoutUrl: session.url,
+                    sessionId: session.id,
+                    package: pkgConfig.displayName,
+                    seatCount,
+                    addons: addons.map(id => getEnterpriseAddon(id)?.name),
+                    pricing: {
+                        subtotal: costBreakdown.subtotal,
+                        volumeDiscount: volumeDiscount.discount > 0 ? {
+                            percent: volumeDiscount.discount * 100,
+                            label: volumeDiscount.label,
+                            amount: costBreakdown.discountAmount
+                        } : null,
+                        total: costBreakdown.total,
+                        billingPeriod,
+                        breakdown: costBreakdown.breakdown
+                    }
+                }]
+            },
+            `Enterprise checkout session created - ${pkgConfig.displayName} with ${seatCount} seats`,
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createEnterpriseCheckout);