@equilateral_ai/mindmeld 3.0.0

package/src/handlers/stripe/seatsUpdatePost.js

@@ -0,0 +1,185 @@
+/**
+ * Seats Update Handler
+ * Adjust seat count for enterprise subscriptions
+ *
+ * POST /api/stripe/subscription/seats
+ * Body: { seatCount: 50 }
+ * Auth: Cognito JWT required
+ */
+
+const {
+    wrapHandler,
+    executeQuery,
+    createSuccessResponse,
+    createErrorResponse,
+    handleError,
+    validateSeatCount,
+    calculateEnterpriseCost,
+    getVolumeDiscount
+} = 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);
+}
+
+/**
+ * Update enterprise seat count
+ */
+async function updateSeats({ 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 { seatCount } = requestBody;
+
+        // Validate seat count
+        const seatValidation = validateSeatCount(seatCount);
+        if (!seatValidation.valid) {
+            return createErrorResponse(400, seatValidation.message, {
+                requested: seatCount,
+                corrected: seatValidation.correctedCount,
+                minimum: 25,
+                increment: 25
+            });
+        }
+
+        // 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, 'Seat updates only available for enterprise subscriptions');
+        }
+
+        if (!client.stripe_subscription_id) {
+            return createErrorResponse(400, 'No active Stripe subscription found');
+        }
+
+        const currentSeats = client.seat_count || 25;
+        const newSeats = seatValidation.correctedCount;
+
+        if (newSeats === currentSeats) {
+            return createSuccessResponse(
+                { message: 'No change in seat count', seatCount: currentSeats },
+                'Seat count unchanged'
+            );
+        }
+
+        // Calculate new seat packs
+        const currentPacks = currentSeats / 25;
+        const newPacks = newSeats / 25;
+
+        // Get subscription from Stripe
+        const subscription = await stripe.subscriptions.retrieve(client.stripe_subscription_id);
+
+        // Update all subscription items with new quantity
+        const updates = subscription.items.data.map(item => ({
+            id: item.id,
+            quantity: newPacks
+        }));
+
+        // Check if volume discount changes
+        const currentDiscount = getVolumeDiscount(currentSeats);
+        const newDiscount = getVolumeDiscount(newSeats);
+        const discountChanged = currentDiscount.discount !== newDiscount.discount;
+
+        // Update subscription
+        const updateParams = {
+            items: updates,
+            proration_behavior: 'create_prorations'
+        };
+
+        // Update volume discount coupon if needed
+        if (discountChanged && newDiscount.discount > 0) {
+            const couponId = `VOLUME_${Math.round(newDiscount.discount * 100)}`;
+            try {
+                await stripe.coupons.retrieve(couponId);
+            } catch (e) {
+                if (e.code === 'resource_missing') {
+                    await stripe.coupons.create({
+                        id: couponId,
+                        percent_off: newDiscount.discount * 100,
+                        duration: 'forever',
+                        name: newDiscount.label
+                    });
+                }
+            }
+            updateParams.coupon = couponId;
+        } else if (discountChanged && newDiscount.discount === 0) {
+            // Remove discount
+            updateParams.coupon = '';
+        }
+
+        await stripe.subscriptions.update(client.stripe_subscription_id, updateParams);
+
+        // Update client record
+        await executeQuery(`
+            UPDATE rapport.clients
+            SET seat_count = $2, last_updated = CURRENT_TIMESTAMP
+            WHERE client_id = $1
+        `, [client.client_id, newSeats]);
+
+        // Calculate new pricing
+        const addons = client.subscribed_addons || [];
+        const newCost = calculateEnterpriseCost(
+            client.enterprise_package,
+            newSeats,
+            addons,
+            'monthly' // Assuming monthly for display
+        );
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    previousSeatCount: currentSeats,
+                    newSeatCount: newSeats,
+                    change: newSeats - currentSeats,
+                    volumeDiscount: newDiscount.discount > 0 ? newDiscount : null,
+                    discountChanged,
+                    newMonthlyTotal: newCost.total,
+                    prorated: true
+                }]
+            },
+            `Seat count updated from ${currentSeats} to ${newSeats}`,
+            {
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(updateSeats);

package/src/handlers/stripe/subscriptionCancelDelete.js

@@ -0,0 +1,169 @@
+/**
+ * Subscription Cancel Handler
+ * Cancels subscription (immediately or at period end)
+ *
+ * DELETE /api/stripe/subscription/cancel
+ * Query: { immediately: boolean }
+ * 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);
+}
+
+/**
+ * Cancel subscription
+ */
+async function cancelSubscription({ queryStringParameters = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        // REST API: requestContext.authorizer.claims.email
+        // HTTP API: requestContext.authorizer.jwt.claims.email
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const immediately = queryStringParameters.immediately === 'true';
+
+        if (!stripe) {
+            return createErrorResponse(503, 'Payment system not configured');
+        }
+
+        // Get user's client and subscription
+        const userQuery = `
+            SELECT
+                u.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 userResult = await executeQuery(userQuery, [email]);
+
+        if (userResult.rowCount === 0) {
+            return createErrorResponse(404, 'User not found');
+        }
+
+        const user = userResult.rows[0];
+
+        if (!user.stripe_customer_id || user.subscription_status !== 'active') {
+            return createErrorResponse(400, 'No active subscription to cancel');
+        }
+
+        // Get subscription from Stripe
+        const subscriptions = await stripe.subscriptions.list({
+            customer: user.stripe_customer_id,
+            status: 'active',
+            limit: 1
+        });
+
+        if (subscriptions.data.length === 0) {
+            // Update local state to match Stripe
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET subscription_status = 'canceled',
+                    subscription_tier = 'free',
+                    last_updated = CURRENT_TIMESTAMP
+                WHERE client_id = $1
+            `, [user.client_id]);
+
+            return createErrorResponse(400, 'No active subscription found in Stripe');
+        }
+
+        const subscription = subscriptions.data[0];
+        let canceledSubscription;
+        let accessEndsAt;
+
+        if (immediately) {
+            // Cancel immediately with proration
+            canceledSubscription = await stripe.subscriptions.cancel(subscription.id, {
+                prorate: true
+            });
+            accessEndsAt = new Date();
+
+            // Update client immediately
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET subscription_status = 'canceled',
+                    subscription_tier = 'free',
+                    subscription_ends_at = CURRENT_TIMESTAMP,
+                    last_updated = CURRENT_TIMESTAMP
+                WHERE client_id = $1
+            `, [user.client_id]);
+
+        } else {
+            // Cancel at end of billing period
+            canceledSubscription = await stripe.subscriptions.update(subscription.id, {
+                cancel_at_period_end: true
+            });
+            accessEndsAt = new Date(subscription.current_period_end * 1000);
+
+            // Update client to canceling status
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET subscription_status = 'canceling',
+                    subscription_ends_at = $2,
+                    last_updated = CURRENT_TIMESTAMP
+                WHERE client_id = $1
+            `, [user.client_id, accessEndsAt]);
+        }
+
+        // Check data limits for free tier
+        const usageQuery = `
+            SELECT
+                (SELECT COUNT(*) FROM rapport.user_entitlements WHERE client_id = $1) as collaborators,
+                (SELECT COUNT(*) FROM rapport.projects p
+                 JOIN rapport.companies co ON p.company_id = co.company_id
+                 WHERE co.client_id = $1 AND p.archived = false) as projects
+        `;
+        const usageResult = await executeQuery(usageQuery, [user.client_id]);
+        const usage = usageResult.rows[0];
+
+        const warnings = [];
+        if (parseInt(usage.collaborators) > 1) {
+            warnings.push(`You have ${usage.collaborators} collaborators. Free tier allows 1.`);
+        }
+        if (parseInt(usage.projects) > 3) {
+            warnings.push(`You have ${usage.projects} projects. Free tier allows 3.`);
+        }
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    status: immediately ? 'canceled' : 'canceling',
+                    access_ends_at: accessEndsAt.toISOString(),
+                    immediately,
+                    previous_tier: user.subscription_tier,
+                    new_tier: 'free',
+                    warnings
+                }]
+            },
+            immediately
+                ? 'Subscription canceled immediately'
+                : 'Subscription will cancel at end of billing period',
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(cancelSubscription);

package/src/handlers/stripe/subscriptionCreatePost.js

@@ -0,0 +1,221 @@
+/**
+ * Subscription Create Handler
+ * Creates Stripe Checkout session for new subscription
+ *
+ * POST /api/stripe/subscription/create
+ * Body: { tier, billingPeriod }
+ * Auth: Cognito JWT required
+ *
+ * Following HoneyDo subscriptionCreatePost.js pattern
+ */
+
+const {
+    wrapHandler,
+    executeQuery,
+    createSuccessResponse,
+    createErrorResponse,
+    handleError,
+    getTierConfig,
+    getStripePriceId,
+    checkEarlyAdopterEligibility,
+    getEarlyAdopterDiscount,
+    calculateEarlyAdopterPrice
+} = 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 subscription checkout session
+ */
+async function createSubscription({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        // REST API: requestContext.authorizer.claims.email
+        // HTTP API: requestContext.authorizer.jwt.claims.email
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const { tier, billingPeriod = 'monthly' } = requestBody;
+
+        // Validate tier
+        const tierConfig = getTierConfig(tier);
+        if (!tierConfig) {
+            return createErrorResponse(400, 'Invalid subscription tier', {
+                valid_tiers: ['team', 'professional', 'enterprise']
+            });
+        }
+
+        if (tier === 'free') {
+            return createErrorResponse(400, 'Cannot subscribe to free tier');
+        }
+
+        // Check Stripe is configured
+        if (!stripe) {
+            return createErrorResponse(503, 'Payment system not configured', {
+                code: 'STRIPE_NOT_CONFIGURED'
+            });
+        }
+
+        // Get user's client and account creation date
+        const userQuery = `
+            SELECT u.client_id, u.create_date as account_created,
+                   c.client_name, c.stripe_customer_id, 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 userResult = await executeQuery(userQuery, [email]);
+
+        if (userResult.rowCount === 0) {
+            return createErrorResponse(404, 'User not found');
+        }
+
+        const user = userResult.rows[0];
+
+        // Check early adopter eligibility
+        const earlyAdopterStatus = checkEarlyAdopterEligibility(user.account_created);
+        const discountConfig = getEarlyAdopterDiscount();
+
+        // Check for existing active subscription
+        if (user.subscription_status === 'active' && user.stripe_customer_id) {
+            return createErrorResponse(400, 'Already have active subscription. Use update to change tier.', {
+                code: 'SUBSCRIPTION_EXISTS'
+            });
+        }
+
+        // Get Stripe price ID
+        const priceId = getStripePriceId(tier, billingPeriod);
+        if (!priceId) {
+            return createErrorResponse(500, 'Stripe price not configured for this tier');
+        }
+
+        // Count billable users for per-seat pricing
+        const usageQuery = `
+            SELECT COUNT(*) as user_count
+            FROM rapport.user_entitlements
+            WHERE client_id = $1
+        `;
+        const usageResult = await executeQuery(usageQuery, [user.client_id]);
+        const userCount = parseInt(usageResult.rows[0].user_count) || 1;
+
+        // Create Stripe Checkout session
+        const sessionParams = {
+            mode: 'subscription',
+            payment_method_types: ['card'],
+            customer_email: email,
+            line_items: [{
+                price: priceId,
+                quantity: tierConfig.perUser ? userCount : 1
+            }],
+            success_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/subscription/success?session_id={CHECKOUT_SESSION_ID}`,
+            cancel_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/subscription/cancel`,
+            metadata: {
+                client_id: user.client_id,
+                user_email: email,
+                tier: tier,
+                billing_period: billingPeriod,
+                early_adopter: earlyAdopterStatus.eligible ? 'true' : 'false'
+            },
+            subscription_data: {
+                metadata: {
+                    client_id: user.client_id,
+                    tier: tier
+                }
+            }
+        };
+
+        // Auto-apply early adopter discount if eligible
+        if (earlyAdopterStatus.eligible && discountConfig.autoApply) {
+            sessionParams.discounts = [{
+                coupon: discountConfig.stripeCouponId
+            }];
+            console.log(`[Subscription] Auto-applying ${discountConfig.stripeCouponId} for ${email}`);
+        }
+
+        // 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
+        const sessionQuery = `
+            INSERT INTO rapport.stripe_checkout_sessions (
+                session_id,
+                client_id,
+                user_email,
+                tier,
+                billing_period,
+                status
+            )
+            VALUES ($1, $2, $3, $4, $5, 'pending')
+        `;
+        await executeQuery(sessionQuery, [
+            session.id,
+            user.client_id,
+            email,
+            tier,
+            billingPeriod
+        ]);
+
+        // Calculate pricing with potential discount
+        const basePrice = tierConfig.perUser
+            ? tierConfig.priceMonthly * userCount
+            : tierConfig.priceMonthly;
+
+        const discountInfo = earlyAdopterStatus.eligible
+            ? calculateEarlyAdopterPrice(tier, userCount, billingPeriod)
+            : null;
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    checkoutUrl: session.url,
+                    sessionId: session.id,
+                    tier: tierConfig.displayName,
+                    price: basePrice,
+                    billingPeriod,
+                    userCount: tierConfig.perUser ? userCount : null,
+                    discount: earlyAdopterStatus.eligible ? {
+                        applied: true,
+                        code: discountConfig.shareableCode,
+                        message: discountConfig.displayMessage,
+                        originalPrice: discountInfo.originalPrice,
+                        discountedPrice: discountInfo.discountedPrice,
+                        savings: discountInfo.savings,
+                        percent: discountInfo.discountPercent,
+                        duration: discountInfo.discountDuration,
+                        daysRemaining: earlyAdopterStatus.daysRemaining
+                    } : null
+                }]
+            },
+            earlyAdopterStatus.eligible
+                ? `Checkout session created - ${discountConfig.displayMessage}`
+                : 'Checkout session created',
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createSubscription);