Credit-System

Abonnement erstellt
    |
    v
Credits initialisiert (Stufen-Zuteilung)
    |--- Free: 500 Credits
    |--- Basic: 1.500 Credits
    |--- Pro: 5.000 Credits
    |--- Enterprise: 15.000 Credits
    |
    v
Nutzer führt KI-Operationen durch
    |--- Jede Operation kostet Credits (5 - 80)
    |--- Atomare Abbuchung mit SELECT FOR UPDATE
    |--- Unveränderlicher CreditTransaction-Logeintrag
    |
    v
Monatlicher Reset (ausgelöst durch Abrechnungszahlung)
    |--- subscription_payment_success-Webhook
    |--- Credits auf Stufen-Zuteilung zurückgesetzt
    |--- creditsResetAt auf NOW aktualisiert
    |--- Automatischer Reset-Backup nach 30 Tagen
    |
    v
Zyklus wiederholt sich

export function getDefaultCreditsByTier(tier: SubscriptionTier): number {
  const tierCredits: CreditTierMap = {
    free: parseCreditsWithFallback(process.env.CREDIT_SYSTEM_FREE_CREDITS, 500),
    basic: parseCreditsWithFallback(
      process.env.CREDIT_SYSTEM_BASIC_CREDITS,
      1500
    ),
    pro: parseCreditsWithFallback(process.env.CREDIT_SYSTEM_PRO_CREDITS, 5000),
    enterprise: parseCreditsWithFallback(
      process.env.CREDIT_SYSTEM_ENTERPRISE_CREDITS,
      15000
    ),
  }

  return tierCredits[tier]
}

export function isCreditSystemEnabled(): boolean {
  // Return cached value if available
  if (creditSystemEnabledCache !== null) {
    return creditSystemEnabledCache
  }

  // Check pricing model (credit_based = credits enabled, classic_saas = unlimited)
  const pricingModel = process.env.NEXT_PUBLIC_PRICING_MODEL

  // CRITICAL: Distinguish between test types (unit vs E2E)
  // Unit tests (Vitest): ENABLE credit system to test credit logic
  //   - Set ENABLE_CREDIT_SYSTEM_IN_TESTS=true in vitest.config.ts
  //   - Mock Prisma directly for controlled testing
  // E2E tests (Playwright): DISABLE credit system (no database in CI)
  //   - Do NOT set ENABLE_CREDIT_SYSTEM_IN_TESTS flag
  //   - Tests run without database write operations
  const isUnitTest = process.env.ENABLE_CREDIT_SYSTEM_IN_TESTS === 'true'
  const isE2ETest = process.env.NODE_ENV === 'test' && !isUnitTest

  const enabled = pricingModel === 'credit_based' && !isE2ETest

  // Cache the result
  creditSystemEnabledCache = enabled

  // Log status once in development
  if (
    process.env.NODE_ENV === 'development' &&
    !globalThis.__creditSystemLoggedOnce
  ) {
    console.log(
      `[Credit System] ${enabled ? 'Enabled' : 'Disabled'} ` +
        `(MODEL=${pricingModel || 'undefined'}, isUnitTest=${isUnitTest}, isE2ETest=${isE2ETest})`
    )
    globalThis.__creditSystemLoggedOnce = true
  }

  return enabled
}

export async function deductCredits(params: {
  userId: string
  operation: CreditOperation
  quantity?: number
  metadata?: Prisma.InputJsonValue
}): Promise<CreditOperationResult> {
  const { userId, operation, quantity = 1, metadata } = params

  // Calculate cost based on operation type and quantity
  const cost = calculateBatchCost(operation, quantity)

  console.log(
    `[Credits] Deducting ${cost} credits for ${operation} (x${quantity})`
  )

  // Skip if credit system disabled
  if (!isCreditSystemEnabled()) {
    console.log('[Credits] System disabled - skipping deduction')
    return {
      success: true,
      balance: 999999, // Unlimited
      message: 'Credit system disabled',
    }
  }

  try {
    // Ensure credits initialized before deducting
    await ensureUserCreditsInitializedSafe(userId)

    // Use transaction to atomically check balance and deduct credits
    const result = await prisma.$transaction(
      async (tx) => {
        // CRITICAL: Lock user row with SELECT FOR UPDATE to prevent race conditions
        // This ensures only ONE transaction can read and modify the balance at a time
        const userRows = await tx.$queryRaw<
          Array<{ creditBalance: Decimal; creditsPerMonth: Decimal }>
        >`
        SELECT "creditBalance", "creditsPerMonth"
        FROM "User"
        WHERE "id" = ${userId}
        FOR UPDATE
      `

        if (!userRows || userRows.length === 0) {

import { deductCredits } from '@/lib/credits/credit-manager'

const result = await deductCredits({
  userId: 'user_database_id',
  operation: 'chat_message',  // Typsicherer Operationsname
  quantity: 1,                 // Anzahl der Operationen (Standard: 1)
  metadata: { model: 'gpt-4' } // Optionale Metadaten für das Ledger
})

if (result.success) {
  // Mit der KI-Operation fortfahren
  console.log(`Verbleibendes Guthaben: ${result.balance}`)
} else {
  // Unzureichende Credits behandeln
  console.log(result.message) // "Insufficient credits. Required: 1, Available: 0"
}

const result = await deductCredits({ userId, operation: 'image_gen' })

if (!result.success) {
  return NextResponse.json(
    {
      error: 'Insufficient credits',
      required: getCreditCost('image_gen'),
      available: result.balance,
      upgradeUrl: '/dashboard/billing',
    },
    { status: 402 }
  )
}

# Basic-Stufe-Pakete
NEXT_PUBLIC_BONUS_BASIC_PACKAGE1_CREDITS="500"
NEXT_PUBLIC_BONUS_BASIC_PACKAGE1_PRICE="4.99"
NEXT_PUBLIC_BONUS_BASIC_PACKAGE1_VARIANT_ID="334455"

NEXT_PUBLIC_BONUS_BASIC_PACKAGE2_CREDITS="1200"
NEXT_PUBLIC_BONUS_BASIC_PACKAGE2_PRICE="9.99"
NEXT_PUBLIC_BONUS_BASIC_PACKAGE2_VARIANT_ID="334456"

/dashboard/credits
    |
    v
BonusPackages-Komponente (lädt via GET /api/credits/bonus-packages)
    |--- Zeigt stufenspezifische Pakete mit Preisen an
    |--- Zeigt "Bestes Preis-Leistungs-Verhältnis"-Badge auf dem günstigsten Paket pro Credit
    |--- Deaktiviert Käufe, wenn monatliches Limit erreicht
    |
    v
Nutzer klickt "Kaufen" → POST /api/credits/checkout
    |--- Validiert Variant-ID gegen Stufen-Pakete
    |--- Prüft monatliches Kauflimit
    |--- Erstellt Lemon Squeezy Checkout (Einmalkauf)
    |
    v
Lemon Squeezy Checkout-Seite → Nutzer schließt Zahlung ab
    |
    v
order_created-Webhook → purchaseBonusCredits()
    |--- Idempotenzprüfung (lemonSqueezyId-Unique-Constraint)
    |--- Erhöht user.bonusCredits atomar
    |--- Erstellt BonusCreditPurchase mit Ablaufdatum
    |--- Protokolliert "purchase"-Transaktion im Credit-Ledger
    |--- Sendet Bestätigungs-E-Mail (nicht-blockierend)
    |
    v
Weiterleitung zu /dashboard/credits?purchase=success
    |--- Erfolgsbanner mit automatischer Ausblendung nach 30 Sekunden
    |--- Pollt Credit-Guthaben für 30 s, um neuen Kauf zu spiegeln

Nutzer hat: 50 Bonus-Credits + 100 Abonnement-Credits
75 Credits abbuchen:

1. Nur Bonus (wenn Bonus >= Kosten)
   → 75 Bonus-Credits verwenden

2. Gemischt (wenn Bonus < Kosten, aber Gesamt >= Kosten)
   → 50 Bonus + 25 Abonnement-Credits verwenden

3. Unzureichend (wenn Gesamt < Kosten)
   → Abbuchung schlägt fehl, keine Credits verbraucht

Nutzer hat: 50 Bonus-Credits + 100 Abonnement-Credits
75 Credits abbuchen:

1. Nur Abonnement (wenn Abonnement >= Kosten)
   → 75 Abonnement-Credits verwenden

2. Bonus als Fallback (wenn Abonnement < Kosten, aber Gesamt >= Kosten)
   → 100 Abonnement-Credits verwenden + Restbetrag von Bonus nehmen

3. Unzureichend (wenn Gesamt < Kosten)
   → Abbuchung schlägt fehl, keine Credits verbraucht

// Alle Transaktionen für einen Nutzer abrufen
const transactions = await prisma.creditTransaction.findMany({
  where: { userId },
  orderBy: { createdAt: 'desc' },
  take: 50,
})

// Nutzungszusammenfassung nach Operationstyp
const usageSummary = await prisma.creditTransaction.groupBy({
  by: ['operation'],
  where: { userId, type: 'usage' },
  _sum: { amount: true },
  _count: true,
})