Stripe Subscription Licensing

// app/api/webhooks/stripe-licensing/route.ts
import { NextRequest } from "next/server";
import Stripe from "stripe";
import { KeyMint } from "keymint";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const keymint = new KeyMint(process.env.KEYMINT_ADMIN_API_KEY!);

export async function POST(req: NextRequest) {
  const payload = await req.text();
  const sig = req.headers.get("stripe-signature")!;

  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      payload,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch (err) {
    console.error("Stripe signature verification failed:", err);
    return Response.json({ error: "Invalid signature" }, { status: 400 });
  }

  try {
    switch (event.type) {
      case "checkout.session.completed": {
        const session = event.data.object as Stripe.Checkout.Session;
        if (!session.subscription) break;

        const subscription = await stripe.subscriptions.retrieve(
          session.subscription as string
        );
        await handleNewSubscription(subscription);
        break;
      }

      case "invoice.paid": {
        const invoice = event.data.object as Stripe.Invoice;
        if (!invoice.subscription) break;

        const subscription = await stripe.subscriptions.retrieve(
          invoice.subscription as string
        );
        await handleSubscriptionRenewal(subscription);
        break;
      }

      case "customer.subscription.updated": {
        const subscription = event.data.object as Stripe.Subscription;
        await handleSubscriptionChange(subscription);
        break;
      }

      case "customer.subscription.deleted": {
        const subscription = event.data.object as Stripe.Subscription;
        await handleSubscriptionCancelled(subscription);
        break;
      }
    }

    return Response.json({ received: true });
  } catch (error) {
    console.error("Webhook handler error:", error);
    return Response.json(
      { error: "Internal server error" },
      { status: 500 }
    );
  }
}

async function handleNewSubscription(subscription: Stripe.Subscription) {
  const customerEmail = await getCustomerEmail(subscription.customer as string);
  const existingLicense = await findExistingLicense(customerEmail);

  if (existingLicense) {
    await keymint.updateKey({
      productId: process.env.KEYMINT_PRODUCT_ID!,
      licenseKey: existingLicense,
      expiryDate: new Date(subscription.current_period_end * 1000).toISOString(),
    });
    return;
  }

  const license = await keymint.createKey({
    productId: process.env.KEYMINT_PRODUCT_ID!,
    maxActivations: "1",
    expiryDate: new Date(subscription.current_period_end * 1000).toISOString(),
    newCustomer: {
      name: customerEmail,
      email: customerEmail,
    },
  }, { idempotencyKey: `stripe-sub-${subscription.id}` });

  if (license.key) await sendLicenseEmail(customerEmail, license.key);
}

async function handleSubscriptionRenewal(subscription: Stripe.Subscription) {
  const customerEmail = await getCustomerEmail(subscription.customer as string);
  const licenseKey = await findExistingLicense(customerEmail);
  if (!licenseKey) return;

  await keymint.updateKey({
    productId: process.env.KEYMINT_PRODUCT_ID!,
    licenseKey,
    expiryDate: new Date(subscription.current_period_end * 1000).toISOString(),
  });
}

async function handleSubscriptionChange(subscription: Stripe.Subscription) {
  const customerEmail = await getCustomerEmail(subscription.customer as string);
  const licenseKey = await findExistingLicense(customerEmail);
  if (!licenseKey) return;

  const isActive = subscription.status === "active" || subscription.status === "trialing";
  if (isActive) {
    await keymint.unblockKey({
      productId: process.env.KEYMINT_PRODUCT_ID!,
      licenseKey,
    });
    await keymint.updateKey({
      productId: process.env.KEYMINT_PRODUCT_ID!,
      licenseKey,
      expiryDate: new Date(subscription.current_period_end * 1000).toISOString(),
    });
  } else {
    await keymint.blockKey({
      productId: process.env.KEYMINT_PRODUCT_ID!,
      licenseKey,
    });
  }
}

async function handleSubscriptionCancelled(subscription: Stripe.Subscription) {
  const customerEmail = await getCustomerEmail(subscription.customer as string);
  const licenseKey = await findExistingLicense(customerEmail);
  if (!licenseKey) return;

  await keymint.blockKey({
    productId: process.env.KEYMINT_PRODUCT_ID!,
    licenseKey,
  });
}

async function getCustomerEmail(customerId: string): Promise<string> {
  const customer = await stripe.customers.retrieve(customerId);
  if ("deleted" in customer) throw new Error("Customer deleted");
  return customer.email!;
}

// You must implement these based on your database
async function findExistingLicense(email: string): Promise<string | null> {
  // Query your DB: which license key is assigned to this Stripe customer email?
  return null;
}

async function sendLicenseEmail(email: string, licenseKey: string) {
  // Send email via SendGrid, Resend, Amazon SES, etc.
  console.log(`Sending license ${licenseKey} to ${email}`);
}

// license.ts — bundled in your desktop app
import { KeyMint } from 'keymint';

const client = new KeyMint(process.env.KEYMINT_CLIENT_API_KEY!);
const PRODUCT_ID = process.env.KEYMINT_PRODUCT_ID!;

let cachedValidation = false;

export async function checkLicense(licenseKey: string): Promise<boolean> {
  if (cachedValidation) return true;

  try {
    await client.activateKey({
      productId: PRODUCT_ID,
      licenseKey,
      hostId: KeyMint.getOrCreateInstallationId(),
    });
    cachedValidation = true;
    return true;
  } catch (error: any) {
    // The SDK throws on every non-2xx response.
    if ([401, 402, 403, 404].includes(error?.status)) {
      console.error(`License invalid: ${error.errorCode} (HTTP ${error.status})`);
      return false;
    }
    // Offline or Keymint unavailable: decide whether to allow a grace period.
    console.error('License check failed:', error?.message);
    return false;
  }
}

// Call on app startup
export async function startLicenseCheck(licenseKey: string) {
  const valid = await checkLicense(licenseKey);
  if (!valid) {
    console.error("License check failed. Exiting.");
    process.exit(1);
  }
  console.log("License validated successfully.");
}