Implement initial subscription-backed license flow

src/server.js

@@ -2,9 +2,10 @@ import express from 'express';
 import { config } from './config.js';
 import { getPlan, listPlans, PREMIUM_FEATURES } from './plans.js';
 import { getStripe } from './stripe.js';
+import { getStoreSnapshot, upsertCustomer, upsertSubscription } from './store.js';
+import { syncLicenseFromSubscription, validateLicense, deactivateLicense } from './licenseLogic.js';
 
 const app = express();
-
 app.use('/api/stripe/webhook', express.raw({ type: 'application/json' }));
 app.use(express.json());
 
@@ -13,70 +14,43 @@ app.get('/health', (_req, res) => {
 });
 
 app.get('/api/public/config', (_req, res) => {
-  res.json({
-    ok: true,
-    publishableKeyPresent: Boolean(config.stripePublishableKey),
-    websiteUrl: config.websiteUrl
-  });
+  res.json({ ok: true, publishableKeyPresent: Boolean(config.stripePublishableKey), websiteUrl: config.websiteUrl });
 });
 
 app.get('/api/public/plans', (_req, res) => {
-  res.json({
-    ok: true,
-    tier: 'premium',
-    features: PREMIUM_FEATURES,
-    plans: listPlans()
-  });
+  res.json({ ok: true, tier: 'premium', features: PREMIUM_FEATURES, plans: listPlans() });
+});
+
+app.get('/api/admin/debug/store', (_req, res) => {
+  res.json({ ok: true, store: getStoreSnapshot() });
 });
 
 app.post('/api/checkout/session', async (req, res) => {
   try {
     const { planCode, customerEmail } = req.body || {};
     const plan = getPlan(planCode);
-
-    if (!plan) {
-      return res.status(400).json({ ok: false, error: 'Invalid planCode' });
-    }
+    if (!plan) return res.status(400).json({ ok: false, error: 'Invalid planCode' });
 
     const stripe = getStripe();
-
     const session = await stripe.checkout.sessions.create({
       mode: 'subscription',
       payment_method_types: ['card'],
-      line_items: [
-        {
-          price_data: {
-            currency: 'usd',
-            product_data: {
-              name: plan.label,
-              description: 'DashCaddy Premium subscription'
-            },
-            recurring: {
-              interval: plan.interval,
-              interval_count: plan.intervalCount
-            },
-            unit_amount: plan.amountUsd * 100
-          },
-          quantity: 1
-        }
-      ],
+      line_items: [{
+        price_data: {
+          currency: 'usd',
+          product_data: { name: plan.label, description: 'DashCaddy Premium subscription' },
+          recurring: { interval: plan.interval, interval_count: plan.intervalCount },
+          unit_amount: plan.amountUsd * 100
+        },
+        quantity: 1
+      }],
       success_url: `${config.websiteUrl}/success?session_id={CHECKOUT_SESSION_ID}`,
       cancel_url: `${config.websiteUrl}/pricing`,
       allow_promotion_codes: true,
       billing_address_collection: 'required',
       customer_email: customerEmail || undefined,
-      metadata: {
-        source: 'dashcaddy.net',
-        planCode: plan.code,
-        tier: plan.tier
-      },
-      subscription_data: {
-        metadata: {
-          source: 'dashcaddy.net',
-          planCode: plan.code,
-          tier: plan.tier
-        }
-      }
+      metadata: { source: 'dashcaddy.net', planCode: plan.code, tier: plan.tier },
+      subscription_data: { metadata: { source: 'dashcaddy.net', planCode: plan.code, tier: plan.tier } }
     });
 
     return res.json({ ok: true, url: session.url, sessionId: session.id });
@@ -88,18 +62,89 @@ app.post('/api/checkout/session', async (req, res) => {
 
 app.post('/api/stripe/webhook', async (req, res) => {
   try {
-    return res.json({ ok: true, message: 'Webhook endpoint scaffolded, handler next' });
+    if (!config.stripeWebhookSecret) {
+      return res.status(500).json({ ok: false, error: 'Missing STRIPE_WEBHOOK_SECRET' });
+    }
+
+    const signature = req.headers['stripe-signature'];
+    if (!signature) {
+      return res.status(400).json({ ok: false, error: 'Missing stripe-signature header' });
+    }
+
+    const stripe = getStripe();
+    const event = stripe.webhooks.constructEvent(req.body, signature, config.stripeWebhookSecret);
+
+    switch (event.type) {
+      case 'checkout.session.completed': {
+        const session = event.data.object;
+        if (session.customer) {
+          upsertCustomer({ id: String(session.customer), email: session.customer_email || null, checkoutSessionId: session.id });
+        }
+        break;
+      }
+
+      case 'customer.subscription.created':
+      case 'customer.subscription.updated':
+      case 'customer.subscription.deleted': {
+        const subscription = event.data.object;
+        const customerId = typeof subscription.customer === 'string' ? subscription.customer : subscription.customer?.id;
+        const customerEmail = subscription.customer_email || null;
+        const planCode = subscription.metadata?.planCode || 'premium_1m';
+        const currentPeriodEnd = subscription.current_period_end
+          ? new Date(subscription.current_period_end * 1000).toISOString()
+          : null;
+
+        upsertSubscription({
+          id: subscription.id,
+          customerId,
+          status: subscription.status,
+          planCode,
+          currentPeriodEnd,
+          cancelAtPeriodEnd: Boolean(subscription.cancel_at_period_end)
+        });
+
+        const license = syncLicenseFromSubscription({
+          subscriptionId: subscription.id,
+          customerId,
+          customerEmail,
+          planCode,
+          status: subscription.status,
+          currentPeriodEnd
+        });
+
+        console.log('License synced from subscription', { subscriptionId: subscription.id, licenseKey: license.key, status: license.status });
+        break;
+      }
+
+      case 'invoice.payment_failed': {
+        const invoice = event.data.object;
+        console.warn('Payment failed', { invoiceId: invoice.id, customerId: invoice.customer });
+        break;
+      }
+
+      default:
+        console.log('Unhandled Stripe event', event.type);
+    }
+
+    return res.json({ ok: true });
   } catch (error) {
-    return res.status(500).json({ ok: false, error: error.message || 'Webhook failed' });
+    console.error('Webhook processing error:', error);
+    return res.status(400).json({ ok: false, error: error.message || 'Webhook failed' });
   }
 });
 
-app.post('/api/license/validate', async (_req, res) => {
-  return res.status(501).json({ ok: false, error: 'License validation not implemented yet' });
+app.post('/api/license/validate', async (req, res) => {
+  const { code, machine } = req.body || {};
+  if (!code) return res.status(400).json({ ok: false, error: 'License code is required' });
+  const result = validateLicense({ code, machine });
+  return res.status(result.success ? 200 : 400).json(result);
 });
 
-app.post('/api/license/deactivate', async (_req, res) => {
-  return res.status(501).json({ ok: false, error: 'License deactivation not implemented yet' });
+app.post('/api/license/deactivate', async (req, res) => {
+  const { code, machine } = req.body || {};
+  if (!code) return res.status(400).json({ ok: false, error: 'License code is required' });
+  const result = deactivateLicense({ code, machine });
+  return res.status(result.success ? 200 : 400).json(result);
 });
 
 app.listen(config.port, () => {