Add stripe

template/apps/api/.env.example

@@ -48,3 +48,8 @@ WEB_URL=http://localhost:3002
 
 # Google AI (Gemini)
 # GOOGLE_GENERATIVE_AI_API_KEY=...
+
+# Stripe
+# Get your API keys from https://dashboard.stripe.com/test/apikeys
+# STRIPE_SECRET_KEY=sk_test_...
+# STRIPE_WEBHOOK_SECRET=whsec_...

template/apps/api/package.json

@@ -38,6 +38,7 @@
     "ioredis": "5.6.1",
     "koa": "3.0.3",
     "koa-body": "6.0.1",
+    "koa-bodyparser": "4.4.1",
     "koa-compose": "4.1.0",
     "koa-helmet": "8.0.1",
     "koa-logger": "4.0.0",
@@ -49,13 +50,16 @@
     "mixpanel": "0.18.1",
     "node-schedule": "2.1.1",
     "resend": "4.5.2",
+    "shared": "workspace:*",
     "socket.io": "4.8.1",
+    "stripe": "20.3.1",
     "tldts": "7.0.8",
     "winston": "3.17.0",
     "zod": "catalog:"
   },
   "devDependencies": {
     "@types/koa": "2.15.0",
+    "@types/koa-bodyparser": "4.3.13",
     "@types/koa-compose": "3.2.8",
     "@types/koa-logger": "3.1.5",
     "@types/koa-mount": "4.0.5",

template/apps/api/src/app.ts

@@ -1,5 +1,6 @@
 import cors from '@koa/cors';
 import { koaBody } from 'koa-body';
+import bodyParser from 'koa-bodyparser';
 import helmet from 'koa-helmet';
 import koaLogger from 'koa-logger';
 import qs from 'koa-qs';
@@ -25,16 +26,23 @@ const initKoa = async () => {
   app.use(helmet());
   qs(app);
   app.use(
-    koaBody({
-      multipart: true,
-      onError: (error, ctx) => {
-        const errText: string = error.stack || error.toString();
-
+    bodyParser({
+      enableTypes: ['json', 'form', 'text'],
+      onerror: (err, ctx) => {
+        const errText: string = err.stack || err.toString();
         logger.warn(`Unable to parse request body. ${errText}`);
         ctx.throw(422, 'Unable to parse request JSON.');
       },
     }),
   );
+  app.use(
+    koaBody({
+      multipart: true,
+      json: false,
+      urlencoded: false,
+      text: false,
+    }),
+  );
   app.use(
     koaLogger({
       transporter: (message, args) => {

template/apps/api/src/config/index.ts

@@ -27,6 +27,8 @@ const schema = z.object({
   GOOGLE_CLIENT_ID: z.string().optional(),
   GOOGLE_CLIENT_SECRET: z.string().optional(),
   GOOGLE_GENERATIVE_AI_API_KEY: z.string().optional(),
+  STRIPE_SECRET_KEY: z.string().optional(),
+  STRIPE_WEBHOOK_SECRET: z.string().optional(),
 });
 
 type Config = z.infer<typeof schema>;

template/apps/api/src/resources/account/endpoints/verifyEmail.ts

@@ -6,7 +6,7 @@ import { userService } from 'resources/users';
 
 import isPublic from 'middlewares/isPublic';
 import rateLimitMiddleware from 'middlewares/rateLimit';
-import { authService, emailService } from 'services';
+import { authService, emailService, stripeService } from 'services';
 import createEndpoint from 'routes/createEndpoint';
 
 import config from 'config';
@@ -45,6 +45,10 @@ export default createEndpoint({
 
       await userService.updateOne({ _id: user._id }, () => ({ isEmailVerified: true }));
 
+      if (!user.stripeId) {
+        await stripeService.createCustomer(user);
+      }
+
       await authService.setAccessToken({ ctx, userId: user._id });
 
       await emailService.sendTemplate<Template.SIGN_UP_WELCOME>({

template/apps/api/src/resources/subscriptions/endpoints/createPortalSession.ts

@@ -0,0 +1,26 @@
+import { stripeService } from 'services';
+import createEndpoint from 'routes/createEndpoint';
+
+import config from 'config';
+
+export default createEndpoint({
+  method: 'post',
+  path: '/create-portal-session',
+
+  async handler(ctx) {
+    const { user } = ctx.state;
+
+    const stripeId = user.stripeId || (await stripeService.createCustomer(user));
+
+    if (!stripeId) {
+      return ctx.throwError('Failed to create Stripe customer');
+    }
+
+    const session = await stripeService.billingPortal.sessions.create({
+      customer: stripeId,
+      return_url: `${config.WEB_URL}/pricing?portal=true`,
+    });
+
+    return { portalUrl: session.url };
+  },
+});

template/apps/api/src/resources/subscriptions/endpoints/getCurrent.ts

@@ -0,0 +1,65 @@
+import Stripe from 'stripe';
+
+import { userService } from 'resources/users';
+
+import { stripeService } from 'services';
+import createEndpoint from 'routes/createEndpoint';
+
+export default createEndpoint({
+  method: 'get',
+  path: '/current',
+
+  async handler(ctx) {
+    const { user } = ctx.state;
+
+    if (!user.subscription) {
+      return null;
+    }
+
+    const stripeSubscription = (await stripeService.subscriptions.retrieve(
+      user.subscription.subscriptionId,
+    )) as Stripe.Subscription;
+
+    if (stripeSubscription.status === 'canceled') {
+      await userService.atomic.updateOne({ _id: user._id }, { $unset: { subscription: '' } });
+      return null;
+    }
+
+    const isCanceled = stripeSubscription.cancel_at_period_end || stripeSubscription.cancel_at !== null;
+
+    const stripePeriodEnd =
+      stripeSubscription.cancel_at ??
+      (stripeSubscription as unknown as { current_period_end: number }).current_period_end;
+
+    const needsUpdate =
+      user.subscription.cancelAtPeriodEnd !== isCanceled ||
+      user.subscription.status !== stripeSubscription.status ||
+      user.subscription.priceId !== (stripeSubscription.items.data[0]?.price.id ?? user.subscription.priceId) ||
+      user.subscription.currentPeriodEndDate !== stripePeriodEnd;
+
+    if (needsUpdate) {
+      const updatedSubscription = {
+        ...user.subscription,
+        priceId: stripeSubscription.items.data[0]?.price.id ?? user.subscription.priceId,
+        cancelAtPeriodEnd: isCanceled,
+        status: stripeSubscription.status,
+        currentPeriodStartDate: (stripeSubscription as unknown as { current_period_start: number })
+          .current_period_start,
+        currentPeriodEndDate: stripePeriodEnd,
+      };
+
+      await userService.atomic.updateOne({ _id: user._id }, { $set: { subscription: updatedSubscription } });
+      user.subscription = updatedSubscription;
+    }
+
+    const product = await stripeService.products.retrieve(user.subscription.productId);
+
+    return {
+      ...user.subscription,
+      product: {
+        name: product.name,
+        images: product.images,
+      },
+    };
+  },
+});

template/apps/api/src/resources/subscriptions/endpoints/previewUpgrade.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+import { stripeService } from 'services';
+import createEndpoint from 'routes/createEndpoint';
+
+const schema = z.object({
+  priceId: z.string().min(1, 'Price ID is required'),
+});
+
+export default createEndpoint({
+  method: 'get',
+  path: '/preview-upgrade',
+  schema,
+
+  async handler(ctx) {
+    const { user } = ctx.state;
+    const { priceId } = ctx.validatedData;
+
+    if (!user.stripeId) {
+      return ctx.throwError('Stripe account not found.');
+    }
+
+    if (!user.subscription?.subscriptionId) {
+      return ctx.throwError('No active subscription found.');
+    }
+
+    const subscriptionId = user.subscription.subscriptionId;
+    const subscriptionDetails = await stripeService.subscriptions.retrieve(subscriptionId);
+
+    const invoice = await stripeService.invoices.createPreview({
+      customer: user.stripeId,
+      subscription: subscriptionId,
+      subscription_details: {
+        proration_behavior: 'always_invoice',
+        items: [
+          {
+            id: subscriptionDetails.items.data[0].id,
+            price: priceId,
+          },
+        ],
+      },
+    });
+
+    return {
+      subtotal: invoice.subtotal,
+      total: invoice.total,
+      amountDue: invoice.amount_due,
+      currency: invoice.currency,
+    };
+  },
+});

template/apps/api/src/resources/subscriptions/endpoints/subscribe.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+
+import { stripeService } from 'services';
+import createEndpoint from 'routes/createEndpoint';
+
+import config from 'config';
+
+const schema = z.object({
+  priceId: z.string().min(1, 'Price ID is required'),
+});
+
+export default createEndpoint({
+  method: 'post',
+  path: '/subscribe',
+  schema,
+
+  async handler(ctx) {
+    const { user } = ctx.state;
+    const { priceId } = ctx.validatedData;
+
+    const stripeId = user.stripeId || (await stripeService.createCustomer(user));
+
+    if (!stripeId) {
+      return ctx.throwError('Failed to create Stripe customer');
+    }
+
+    if (user.subscription) {
+      return ctx.throwError('You already have an active subscription. Please upgrade instead.');
+    }
+
+    const session = await stripeService.checkout.sessions.create({
+      mode: 'subscription',
+      customer: stripeId,
+      line_items: [
+        {
+          quantity: 1,
+          price: priceId,
+        },
+      ],
+      success_url: `${config.WEB_URL}/pricing?success=true`,
+      cancel_url: `${config.WEB_URL}/pricing?canceled=true`,
+    });
+
+    if (!session.url) {
+      return ctx.throwError('Unable to create checkout session');
+    }
+
+    return { checkoutUrl: session.url };
+  },
+});

template/apps/api/src/resources/subscriptions/endpoints/upgrade.ts

@@ -0,0 +1,66 @@
+import Stripe from 'stripe';
+import { z } from 'zod';
+
+import { userService } from 'resources/users';
+
+import { stripeService } from 'services';
+import createEndpoint from 'routes/createEndpoint';
+
+const schema = z.object({
+  priceId: z.string().min(1, 'Price ID is required'),
+});
+
+export default createEndpoint({
+  method: 'post',
+  path: '/upgrade',
+  schema,
+
+  async handler(ctx) {
+    const { user } = ctx.state;
+    const { priceId } = ctx.validatedData;
+
+    if (!user.stripeId) {
+      return ctx.throwError('Stripe account not found. Please contact support.');
+    }
+
+    if (!user.subscription?.subscriptionId) {
+      return ctx.throwError('No active subscription found.');
+    }
+
+    const subscriptionId = user.subscription.subscriptionId;
+
+    if (priceId === 'free') {
+      await stripeService.subscriptions.cancel(subscriptionId);
+      await userService.atomic.updateOne({ _id: user._id }, { $unset: { subscription: '' } });
+      return { success: true, message: 'Subscription canceled' };
+    }
+
+    const subscriptionDetails = (await stripeService.subscriptions.retrieve(subscriptionId)) as Stripe.Subscription;
+
+    const updatedStripeSubscription = (await stripeService.subscriptions.update(subscriptionId, {
+      proration_behavior: 'always_invoice',
+      cancel_at_period_end: false,
+      items: [
+        {
+          id: subscriptionDetails.items.data[0].id,
+          price: priceId,
+        },
+      ],
+    })) as Stripe.Subscription;
+
+    const updatedSubscription = {
+      ...user.subscription,
+      priceId: updatedStripeSubscription.items.data[0]?.price.id ?? priceId,
+      productId: updatedStripeSubscription.items.data[0]?.price.product as string,
+      status: updatedStripeSubscription.status,
+      cancelAtPeriodEnd: updatedStripeSubscription.cancel_at_period_end,
+      currentPeriodStartDate: (updatedStripeSubscription as unknown as { current_period_start: number })
+        .current_period_start,
+      currentPeriodEndDate: (updatedStripeSubscription as unknown as { current_period_end: number }).current_period_end,
+    };
+
+    await userService.atomic.updateOne({ _id: user._id }, { $set: { subscription: updatedSubscription } });
+
+    return { success: true };
+  },
+});

template/apps/api/src/resources/users/user.schema.ts

@@ -1,3 +1,4 @@
+import { subscriptionSchema } from 'shared';
 import { z } from 'zod';
 
 import { dbSchema, emailSchema } from '../base.schema';
@@ -25,6 +26,9 @@ export const userSchema = dbSchema.extend({
     .optional(),
 
   lastRequest: z.date().optional(),
+
+  stripeId: z.string().optional().nullable(),
+  subscription: subscriptionSchema.optional().nullable(),
 });
 
 export type User = z.infer<typeof userSchema>;