@goscribe/server 1.3.4 → 1.6.0

package/src/services/billing/payment.service.ts

@@ -0,0 +1,433 @@
+import type { PrismaClient } from '@prisma/client';
+import type { ArtifactType } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { Stripe } from 'stripe';
+import { BaseService } from '../base.service.js';
+import { stripe } from '../../lib/stripe.js';
+import { env } from '../../lib/env.js';
+import { getAccountSummary, getUserUsage, getUserPlanLimits } from './usage.service.js';
+import {
+  notifyPaymentSucceeded,
+  notifySubscriptionActivated,
+  notifySubscriptionPaymentSucceeded,
+} from '../notifications/notification.service.js';
+import { upsertSubscriptionFromStripe } from './subscription.service.js';
+
+/** Stripe Checkout URLs contain the session id (cs_…); we only store the URL in DB. */
+const CHECKOUT_SESSION_ID_IN_URL = /cs_[a-zA-Z0-9]+/;
+
+async function reuseCheckoutUrlIfSessionStillOpen(
+  stripeClient: Stripe,
+  db: PrismaClient,
+  existing: { id: string; stripeSessionId: string | null },
+  lockKey: string,
+): Promise<string | null> {
+  const url = existing.stripeSessionId;
+  if (!url) return null;
+
+  const idMatch = url.match(CHECKOUT_SESSION_ID_IN_URL);
+  if (!idMatch) {
+    await db.idempotencyRecord.updateMany({
+      where: { id: existing.id, activeLockKey: lockKey },
+      data: { activeLockKey: null, status: 'expired' },
+    });
+    return null;
+  }
+
+  try {
+    const session = await stripeClient.checkout.sessions.retrieve(idMatch[0]);
+    if (session.status === 'open') {
+      return url;
+    }
+    await db.idempotencyRecord.updateMany({
+      where: { id: existing.id, activeLockKey: lockKey },
+      data: {
+        activeLockKey: null,
+        status: session.status === 'complete' ? 'completed' : 'expired',
+      },
+    });
+    return null;
+  } catch {
+    await db.idempotencyRecord.updateMany({
+      where: { id: existing.id, activeLockKey: lockKey },
+      data: { activeLockKey: null, status: 'expired' },
+    });
+    return null;
+  }
+}
+
+export class PaymentService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async getPlans(userId?: string) {
+    const plans = await this.db.plan.findMany({
+      where: { active: true },
+      include: { limit: true },
+      orderBy: { price: 'asc' },
+    });
+
+    // Anonymous callers (pricing page) don't get per-user `isActive`.
+    if (!userId) {
+      return plans.map((plan: any) => ({ ...plan, isActive: false }));
+    }
+
+    const activeSubscriptions = await this.db.subscription.findMany({
+      where: { userId, status: 'active' },
+    });
+
+    return plans.map((plan: any) => ({
+      ...plan,
+      isActive: activeSubscriptions.some((sub: any) => sub.planId === plan.id),
+    }));
+  }
+
+  async createCheckoutSession(userId: string, input: { planId: string }) {
+    if (!stripe) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Stripe not configured',
+      });
+    }
+
+    const user = await this.db.user.findUnique({ where: { id: userId } });
+    if (!user) throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+
+    const lockKey = `pending_${userId}_${input.planId}`;
+    let attempt = null;
+    let retryCount = 0;
+
+    while (retryCount < 3) {
+      try {
+        attempt = await this.db.idempotencyRecord.create({
+          data: {
+            userId,
+            planId: input.planId,
+            activeLockKey: lockKey,
+            status: 'pending',
+          },
+        });
+        break;
+      } catch (err: any) {
+        if (err.code === 'P2002') {
+          const existing = await this.db.idempotencyRecord.findUnique({
+            where: { activeLockKey: lockKey },
+          });
+          if (!existing) {
+            retryCount++;
+            continue;
+          }
+
+          const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+          if (isStale) {
+            const result = await this.db.idempotencyRecord.updateMany({
+              where: { id: existing.id, activeLockKey: lockKey },
+              data: { activeLockKey: null, status: 'expired' },
+            });
+            if (result.count > 0) {
+              retryCount++;
+              continue;
+            }
+          }
+
+          if (existing.stripeSessionId && stripe) {
+            const reusable = await reuseCheckoutUrlIfSessionStillOpen(
+              stripe,
+              this.db,
+              existing,
+              lockKey,
+            );
+            if (reusable) return { url: reusable };
+            retryCount++;
+            continue;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 800));
+          retryCount++;
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    if (!attempt) {
+      throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+    }
+
+    const plan = await this.db.plan.findUnique({ where: { id: input.planId } });
+    if (!plan) throw new TRPCError({ code: 'NOT_FOUND', message: 'Plan not found' });
+
+    try {
+      const successUrl = env.STRIPE_SUCCESS_URL.includes('session_id=')
+        ? env.STRIPE_SUCCESS_URL
+        : `${env.STRIPE_SUCCESS_URL}${env.STRIPE_SUCCESS_URL.includes('?') ? '&' : '?'}session_id={CHECKOUT_SESSION_ID}`;
+
+      const session = await stripe.checkout.sessions.create(
+        {
+          customer: user.stripe_customer_id || undefined,
+          customer_email: user.stripe_customer_id ? undefined : user.email || undefined,
+          line_items: [{ price: plan.stripePriceId, quantity: 1 }],
+          mode: plan.interval ? 'subscription' : 'payment',
+          subscription_data: plan.interval
+            ? {
+                metadata: {
+                  userId,
+                  planId: plan.id,
+                  attemptId: attempt.id,
+                },
+              }
+            : undefined,
+          success_url: successUrl,
+          cancel_url: env.STRIPE_CANCEL_URL,
+          metadata: {
+            userId,
+            planId: plan.id,
+            attemptId: attempt.id,
+          },
+        },
+        {
+          idempotencyKey: attempt.id,
+        },
+      );
+
+      await this.db.idempotencyRecord.update({
+        where: { id: attempt.id },
+        data: { stripeSessionId: session.url },
+      });
+
+      return { url: session.url };
+    } catch (error: any) {
+      await this.db.idempotencyRecord.update({
+        where: { id: attempt.id },
+        data: { status: 'failed', activeLockKey: null },
+      });
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error.message,
+      });
+    }
+  }
+
+  async confirmCheckoutSuccess(userId: string, input: { sessionId: string }) {
+    if (!stripe) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Stripe not configured',
+      });
+    }
+
+    const session = await stripe.checkout.sessions.retrieve(input.sessionId, {
+      expand: ['line_items', 'subscription'],
+    });
+
+    const metadata = session.metadata || {};
+    if (metadata.userId !== userId) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'This checkout session does not belong to the current user',
+      });
+    }
+
+    if (session.status !== 'complete') {
+      return { confirmed: false, reason: 'checkout_not_complete' };
+    }
+
+    const plan = metadata.planId
+      ? await this.db.plan.findUnique({ where: { id: metadata.planId } })
+      : null;
+
+    if (session.mode === 'payment' && session.payment_status === 'paid') {
+      await notifyPaymentSucceeded(this.db, {
+        userId,
+        planId: metadata.planId,
+        planName: plan?.name || metadata.planType,
+        stripeSessionId: session.id,
+        amountPaid: session.amount_total ?? undefined,
+      });
+      return { confirmed: true, kind: 'payment' as const };
+    }
+
+    if (session.mode === 'subscription') {
+      const stripeSubscriptionId =
+        typeof session.subscription === 'string'
+          ? session.subscription
+          : session.subscription?.id;
+
+      if (stripeSubscriptionId) {
+        await upsertSubscriptionFromStripe(stripeSubscriptionId);
+        await notifySubscriptionActivated(this.db, {
+          userId,
+          planId: metadata.planId,
+          planName: plan?.name || metadata.planType,
+          stripeSubscriptionId,
+        });
+
+        if (session.payment_status === 'paid') {
+          await notifySubscriptionPaymentSucceeded(this.db, {
+            userId,
+            planId: metadata.planId,
+            planName: plan?.name || metadata.planType,
+            stripeInvoiceId: `checkout_${session.id}`,
+            amountPaid: session.amount_total ?? undefined,
+          });
+        }
+      }
+      return { confirmed: true, kind: 'subscription' as const };
+    }
+
+    return { confirmed: false, reason: 'unsupported_mode' };
+  }
+
+  async createResourcePurchaseSession(
+    userId: string,
+    input: { resourceType: ArtifactType; quantity: number },
+  ) {
+    if (!stripe) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Stripe is not configured on the server',
+      });
+    }
+
+    const user = await this.db.user.findUnique({ where: { id: userId } });
+    if (!user) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+    }
+
+    const resourcePrice = await this.db.resourcePrice.findUnique({
+      where: { resourceType: input.resourceType },
+    });
+
+    if (!resourcePrice) {
+      throw new TRPCError({
+        code: 'PRECONDITION_FAILED',
+        message: 'Price not set',
+      });
+    }
+
+    const lockKey = `topup_${userId}_${input.resourceType}`;
+    let attempt = null;
+    let retryCount = 0;
+
+    while (retryCount < 3) {
+      try {
+        attempt = await this.db.idempotencyRecord.create({
+          data: {
+            userId,
+            resourceType: input.resourceType,
+            activeLockKey: lockKey,
+            status: 'pending',
+          },
+        });
+        break;
+      } catch (err: any) {
+        if (err.code === 'P2002') {
+          const existing = await this.db.idempotencyRecord.findUnique({
+            where: { activeLockKey: lockKey },
+          });
+          if (!existing) {
+            retryCount++;
+            continue;
+          }
+
+          const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+          if (isStale) {
+            const result = await this.db.idempotencyRecord.updateMany({
+              where: { id: existing.id, activeLockKey: lockKey },
+              data: { activeLockKey: null, status: 'expired' },
+            });
+            if (result.count > 0) {
+              retryCount++;
+              continue;
+            }
+          }
+
+          if (existing.stripeSessionId && stripe) {
+            const reusable = await reuseCheckoutUrlIfSessionStillOpen(
+              stripe,
+              this.db,
+              existing,
+              lockKey,
+            );
+            if (reusable) return { url: reusable };
+            retryCount++;
+            continue;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 800));
+          retryCount++;
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    if (!attempt) {
+      throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+    }
+
+    try {
+      const resourceName = input.resourceType
+        .split('_')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(' ');
+
+      const session = await stripe.checkout.sessions.create(
+        {
+          customer: user.stripe_customer_id || undefined,
+          line_items: [
+            {
+              price_data: {
+                currency: 'usd',
+                product_data: {
+                  name: `Add-on: extra ${resourceName}s`,
+                  description: `Purchase of ${input.quantity} additional ${resourceName}(s)`,
+                },
+                unit_amount: resourcePrice.priceCents,
+              },
+              quantity: input.quantity,
+            },
+          ],
+          mode: 'payment',
+          success_url: `${env.STRIPE_SUCCESS_URL}?success=true`,
+          cancel_url: env.STRIPE_CANCEL_URL,
+          metadata: {
+            userId,
+            resourceType: input.resourceType,
+            quantity: input.quantity.toString(),
+            isPurchase: 'true',
+            attemptId: attempt.id,
+          },
+          invoice_creation: { enabled: true },
+        },
+        {
+          idempotencyKey: attempt.id,
+        },
+      );
+
+      await this.db.idempotencyRecord.update({
+        where: { id: attempt.id },
+        data: { stripeSessionId: session.url },
+      });
+
+      return { url: session.url };
+    } catch (error: any) {
+      await this.db.idempotencyRecord.update({
+        where: { id: attempt.id },
+        data: { status: 'failed', activeLockKey: null },
+      });
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error.message,
+      });
+    }
+  }
+
+  async getUsageOverview(userId: string) {
+    const { usage, limits, hasActivePlan } = await getAccountSummary(userId);
+    return { usage, limits, hasActivePlan };
+  }
+
+  getResourcePrices() {
+    return this.db.resourcePrice.findMany();
+  }
+}

package/src/{lib/subscription_service.ts → services/billing/subscription.service.ts}

@@ -1,6 +1,6 @@
-import { prisma } from './prisma.js';
-import { logger } from './logger.js';
-import { stripe } from './stripe.js';
+import { prisma } from '../../lib/prisma.js';
+import { logger } from '../../lib/logger.js';
+import { stripe } from '../../lib/stripe.js';
 import Stripe from 'stripe';
 import {
     notifyPaymentFailed,
@@ -8,9 +8,9 @@ import {
     notifySubscriptionActivated,
     notifySubscriptionCanceled,
     notifySubscriptionPaymentSucceeded,
-} from './notification-service.js';
+} from '../notifications/notification.service.js';
 import { ArtifactType } from '@prisma/client';
-import PusherService from './pusher.js';
+import PusherService from '../../lib/pusher.js';
 
 /**
  * Handle checkout.session.completed event

package/src/services/billing/usage.service.ts

@@ -0,0 +1,207 @@
+import type { Prisma } from '@prisma/client';
+import { prisma } from '../../lib/prisma.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+
+export interface UserUsage {
+  flashcards: number;
+  worksheets: number;
+  studyGuides: number;
+  podcasts: number;
+  storageBytes: number;
+}
+
+export interface AccountStats {
+  workspaces: number;
+  folders: number;
+  lastUpdated: Date | null;
+  spaceUsed: number;
+  spaceTotal: number;
+}
+
+export interface UserPlanLimits {
+  id: string;
+  planId: string;
+  maxStorageBytes: bigint;
+  maxWorksheets: number;
+  maxFlashcards: number;
+  maxPodcasts: number;
+  maxStudyGuides: number;
+  createdAt: Date;
+  updatedAt: Date;
+  isFallbackPlan: boolean;
+}
+
+export interface AccountSummary {
+  stats: AccountStats;
+  usage: UserUsage;
+  limits: UserPlanLimits;
+  hasActivePlan: boolean;
+}
+
+const FALLBACK_PLAN_LIMITS = {
+  id: 'fallback-free',
+  planId: 'fallback-free',
+  maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
+  maxWorksheets: 3,
+  maxFlashcards: 20,
+  maxPodcasts: 0,
+  maxStudyGuides: 1,
+} as const;
+
+const CACHE_TTL_MS = 30_000;
+
+type CacheEntry<T> = { value: T; expiresAt: number };
+
+const usageCache = new Map<string, CacheEntry<UserUsage>>();
+const limitsCache = new Map<string, CacheEntry<UserPlanLimits>>();
+const accountSummaryCache = new Map<string, CacheEntry<AccountSummary>>();
+
+function readCache<T>(map: Map<string, CacheEntry<T>>, userId: string): T | null {
+  const entry = map.get(userId);
+  if (!entry || entry.expiresAt <= Date.now()) {
+    map.delete(userId);
+    return null;
+  }
+  return entry.value;
+}
+
+function writeCache<T>(map: Map<string, CacheEntry<T>>, userId: string, value: T) {
+  map.set(userId, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+
+/** Bust cached usage/limit reads after creates, deletes, or billing changes. */
+export function invalidateUserBillingCache(userId: string) {
+  usageCache.delete(userId);
+  limitsCache.delete(userId);
+  accountSummaryCache.delete(userId);
+}
+
+function workspaceAccessFilter(userId: string): Prisma.WorkspaceWhereInput {
+  return workspaceAccessWhere(userId);
+}
+
+/**
+ * Counts all resources consumed by a user across the platform.
+ */
+export async function getUserUsage(userId: string): Promise<UserUsage> {
+  const cached = readCache(usageCache, userId);
+  if (cached) return cached;
+
+  const [flashcards, worksheets, studyGuides, podcasts, storageResult] = await Promise.all([
+    prisma.artifact.count({ where: { createdById: userId, type: 'FLASHCARD_SET' } }),
+    prisma.artifact.count({ where: { createdById: userId, type: 'WORKSHEET' } }),
+    prisma.artifact.count({ where: { createdById: userId, type: 'STUDY_GUIDE' } }),
+    prisma.artifact.count({ where: { createdById: userId, type: 'PODCAST_EPISODE' } }),
+    prisma.fileAsset.aggregate({
+      _sum: { size: true },
+      where: { userId },
+    }),
+  ]);
+
+  const usage: UserUsage = {
+    flashcards,
+    worksheets,
+    studyGuides,
+    podcasts,
+    storageBytes: Number(storageResult._sum.size || 0),
+  };
+  writeCache(usageCache, userId, usage);
+  return usage;
+}
+
+/**
+ * Retrieves the specific plan limits for a user based on their active subscription
+ * PLUS any extra credits purchased.
+ */
+export async function getUserPlanLimits(userId: string): Promise<UserPlanLimits> {
+  const cached = readCache(limitsCache, userId);
+  if (cached) return cached;
+
+  const [activeSub, freePlan, userCredits] = await Promise.all([
+    prisma.subscription.findFirst({
+      where: { userId, status: 'active' },
+      include: { plan: { include: { limit: true } } },
+      orderBy: { createdAt: 'desc' },
+    }),
+    prisma.plan.findFirst({
+      where: {
+        active: true,
+        price: 0,
+        limit: { isNot: null },
+      },
+      include: { limit: true },
+      orderBy: { createdAt: 'asc' },
+    }),
+    prisma.userCredit.groupBy({
+      by: ['resourceType'],
+      where: { userId },
+      _sum: { amount: true },
+    }),
+  ]);
+
+  const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
+  const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
+
+  const getCreditSum = (type: string) =>
+    userCredits.find((c) => c.resourceType === type)?._sum.amount || 0;
+
+  const limits: UserPlanLimits = {
+    id: base.id,
+    planId: base.planId,
+    maxStorageBytes: BigInt(Number(base.maxStorageBytes) + getCreditSum('STORAGE') * 1024 * 1024),
+    maxWorksheets: base.maxWorksheets + getCreditSum('WORKSHEET'),
+    maxFlashcards: base.maxFlashcards + getCreditSum('FLASHCARD_SET'),
+    maxPodcasts: base.maxPodcasts + getCreditSum('PODCAST_EPISODE'),
+    maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
+    createdAt: baseLimit?.createdAt || new Date(),
+    updatedAt: baseLimit?.updatedAt || new Date(),
+    isFallbackPlan: !baseLimit,
+  };
+
+  writeCache(limitsCache, userId, limits);
+  return limits;
+}
+
+/**
+ * Sidebar/dashboard summary: stats + usage + limits in one parallel DB round-trip batch.
+ */
+export async function getAccountSummary(userId: string): Promise<AccountSummary> {
+  const cached = readCache(accountSummaryCache, userId);
+  if (cached) return cached;
+
+  const workspaceWhere = workspaceAccessFilter(userId);
+
+  const [workspaceMeta, folderCount, usage, limits, storageUsed] = await Promise.all([
+    prisma.workspace.aggregate({
+      where: workspaceWhere,
+      _count: { _all: true },
+      _max: { updatedAt: true },
+    }),
+    prisma.folder.count({ where: { ownerId: userId } }),
+    getUserUsage(userId),
+    getUserPlanLimits(userId),
+    prisma.fileAsset.aggregate({
+      where: {
+        userId,
+        workspace: workspaceWhere,
+      },
+      _sum: { size: true },
+    }),
+  ]);
+
+  const summary: AccountSummary = {
+    stats: {
+      workspaces: workspaceMeta._count._all,
+      folders: folderCount,
+      lastUpdated: workspaceMeta._max.updatedAt,
+      spaceUsed: Number(storageUsed._sum.size ?? 0),
+      spaceTotal: Number(limits.maxStorageBytes),
+    },
+    usage,
+    limits,
+    hasActivePlan: !limits.isFallbackPlan,
+  };
+
+  writeCache(accountSummaryCache, userId, summary);
+  return summary;
+}