@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/handlers/stripe/addonManagePost.js

@@ -1,240 +0,0 @@
-/**
- * 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

@@ -1,93 +0,0 @@
-/**
- * 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://app.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

@@ -1,272 +0,0 @@
-/**
- * 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://app.mindmeld.dev'}/enterprise/success?session_id={CHECKOUT_SESSION_ID}`,
-            cancel_url: `${process.env.APP_URL || 'https://app.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);