digital-products 2.1.3 → 2.4.0

package/test/pricing/billing.test.ts

@@ -1,287 +0,0 @@
-/**
- * Tests for Billing functionality
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  BillingService,
-  createBillingService,
-  Subscription,
-  Invoice,
-  PaymentMethod,
-  BillingEvent,
-} from '../../src/pricing/billing.js'
-
-describe('Billing', () => {
-  describe('BillingService', () => {
-    let billing: BillingService
-
-    beforeEach(() => {
-      billing = createBillingService()
-    })
-
-    describe('Subscriptions', () => {
-      it('creates a new subscription', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-123',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        expect(sub.id).toBeDefined()
-        expect(sub.customerId).toBe('cust-123')
-        expect(sub.planId).toBe('pro-monthly')
-        expect(sub.status).toBe('active')
-      })
-
-      it('creates subscription with trial', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-456',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-          trialDays: 14,
-        })
-
-        expect(sub.status).toBe('trialing')
-        expect(sub.trialEnd).toBeDefined()
-      })
-
-      it('cancels subscription', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-789',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const canceled = billing.cancelSubscription(sub.id, { immediate: false })
-        expect(canceled.status).toBe('active')
-        expect(canceled.cancelAtPeriodEnd).toBe(true)
-      })
-
-      it('cancels subscription immediately', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-101',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const canceled = billing.cancelSubscription(sub.id, { immediate: true })
-        expect(canceled.status).toBe('canceled')
-      })
-
-      it('upgrades subscription', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-102',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const upgraded = billing.changeSubscription(sub.id, {
-          newPlanId: 'enterprise-monthly',
-          prorate: true,
-        })
-
-        expect(upgraded.planId).toBe('enterprise-monthly')
-      })
-
-      it('downgrades subscription at period end', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-103',
-          planId: 'enterprise-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const downgraded = billing.changeSubscription(sub.id, {
-          newPlanId: 'pro-monthly',
-          prorate: false,
-        })
-
-        expect(downgraded.scheduledPlanId).toBe('pro-monthly')
-      })
-
-      it('retrieves subscription by customer', () => {
-        billing.createSubscription({
-          customerId: 'cust-200',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const subs = billing.getSubscriptionsByCustomer('cust-200')
-        expect(subs).toHaveLength(1)
-      })
-    })
-
-    describe('Invoices', () => {
-      it('generates invoice for subscription', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-300',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const invoice = billing.generateInvoice(sub.id)
-        expect(invoice.subscriptionId).toBe(sub.id)
-        expect(invoice.status).toBe('draft')
-      })
-
-      it('calculates invoice total', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-301',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const invoice = billing.generateInvoice(sub.id)
-        expect(invoice.total).toBeGreaterThan(0)
-      })
-
-      it('applies discount to invoice', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-302',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const invoice = billing.generateInvoice(sub.id, {
-          couponCode: 'SAVE20',
-        })
-
-        expect(invoice.discountAmount).toBeGreaterThan(0)
-        expect(invoice.total).toBeLessThan(invoice.subtotal)
-      })
-
-      it('adds usage charges to invoice', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-303',
-          planId: 'metered',
-          startDate: new Date('2024-01-01'),
-        })
-
-        billing.recordUsage(sub.id, {
-          metric: 'api-calls',
-          quantity: 15000,
-          timestamp: new Date(),
-        })
-
-        const invoice = billing.generateInvoice(sub.id)
-        expect(invoice.usageCharges).toBeDefined()
-      })
-
-      it('marks invoice as paid', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-304',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        const invoice = billing.generateInvoice(sub.id)
-        const paid = billing.markInvoicePaid(invoice.id, {
-          paymentMethodId: 'pm-123',
-          paidAt: new Date(),
-        })
-
-        expect(paid.status).toBe('paid')
-        expect(paid.paidAt).toBeDefined()
-      })
-
-      it('retrieves invoices by customer', () => {
-        const sub = billing.createSubscription({
-          customerId: 'cust-305',
-          planId: 'pro-monthly',
-          startDate: new Date('2024-01-01'),
-        })
-
-        billing.generateInvoice(sub.id)
-        billing.generateInvoice(sub.id)
-
-        const invoices = billing.getInvoicesByCustomer('cust-305')
-        expect(invoices.length).toBeGreaterThanOrEqual(2)
-      })
-    })
-
-    describe('Payment Methods', () => {
-      it('adds payment method', () => {
-        const pm = billing.addPaymentMethod({
-          customerId: 'cust-400',
-          type: 'card',
-          details: {
-            last4: '4242',
-            brand: 'visa',
-            expMonth: 12,
-            expYear: 2025,
-          },
-        })
-
-        expect(pm.id).toBeDefined()
-        expect(pm.type).toBe('card')
-      })
-
-      it('sets default payment method', () => {
-        const pm1 = billing.addPaymentMethod({
-          customerId: 'cust-401',
-          type: 'card',
-          details: { last4: '4242', brand: 'visa', expMonth: 12, expYear: 2025 },
-        })
-
-        const pm2 = billing.addPaymentMethod({
-          customerId: 'cust-401',
-          type: 'card',
-          details: { last4: '5555', brand: 'mastercard', expMonth: 6, expYear: 2026 },
-        })
-
-        billing.setDefaultPaymentMethod('cust-401', pm2.id)
-        const defaultPm = billing.getDefaultPaymentMethod('cust-401')
-        expect(defaultPm?.id).toBe(pm2.id)
-      })
-
-      it('removes payment method', () => {
-        const pm = billing.addPaymentMethod({
-          customerId: 'cust-402',
-          type: 'card',
-          details: { last4: '4242', brand: 'visa', expMonth: 12, expYear: 2025 },
-        })
-
-        billing.removePaymentMethod(pm.id)
-        const methods = billing.getPaymentMethods('cust-402')
-        expect(methods).toHaveLength(0)
-      })
-    })
-
-    describe('Events', () => {
-      it('emits subscription created event', () => {
-        const events: BillingEvent[] = []
-        billing.on('subscription.created', (e) => events.push(e))
-
-        billing.createSubscription({
-          customerId: 'cust-500',
-          planId: 'pro-monthly',
-          startDate: new Date(),
-        })
-
-        expect(events).toHaveLength(1)
-        expect(events[0].type).toBe('subscription.created')
-      })
-
-      it('emits invoice paid event', () => {
-        const events: BillingEvent[] = []
-        billing.on('invoice.paid', (e) => events.push(e))
-
-        const sub = billing.createSubscription({
-          customerId: 'cust-501',
-          planId: 'pro-monthly',
-          startDate: new Date(),
-        })
-
-        const invoice = billing.generateInvoice(sub.id)
-        billing.markInvoicePaid(invoice.id, {
-          paymentMethodId: 'pm-123',
-          paidAt: new Date(),
-        })
-
-        expect(events).toHaveLength(1)
-        expect(events[0].type).toBe('invoice.paid')
-      })
-    })
-  })
-})

package/test/pricing/plans.test.ts

@@ -1,307 +0,0 @@
-/**
- * Tests for Pricing Plans
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect } from 'vitest'
-import {
-  PricingPlan,
-  createPricingPlan,
-  PlanRegistry,
-  createPlanRegistry,
-  BillingInterval,
-  Currency,
-} from '../../src/pricing/plans.js'
-
-describe('Pricing Plans', () => {
-  describe('PricingPlan()', () => {
-    it('creates a monthly plan', () => {
-      const plan = PricingPlan({
-        id: 'pro-monthly',
-        name: 'Pro Monthly',
-        tierId: 'pro',
-        price: 29,
-        currency: 'USD',
-        interval: 'monthly',
-      })
-
-      expect(plan.id).toBe('pro-monthly')
-      expect(plan.price).toBe(29)
-      expect(plan.currency).toBe('USD')
-      expect(plan.interval).toBe('monthly')
-    })
-
-    it('creates a yearly plan with discount', () => {
-      const plan = PricingPlan({
-        id: 'pro-yearly',
-        name: 'Pro Yearly',
-        tierId: 'pro',
-        price: 290,
-        currency: 'USD',
-        interval: 'yearly',
-        discount: {
-          percentage: 17,
-          monthlyEquivalent: 24.17,
-        },
-      })
-
-      expect(plan.interval).toBe('yearly')
-      expect(plan.discount?.percentage).toBe(17)
-    })
-
-    it('creates a free plan', () => {
-      const plan = PricingPlan({
-        id: 'free',
-        name: 'Free',
-        tierId: 'free',
-        price: 0,
-        currency: 'USD',
-        interval: 'monthly',
-      })
-
-      expect(plan.price).toBe(0)
-    })
-
-    it('supports custom billing cycles', () => {
-      const plan = PricingPlan({
-        id: 'quarterly',
-        name: 'Quarterly Plan',
-        tierId: 'pro',
-        price: 75,
-        currency: 'USD',
-        interval: 'custom',
-        intervalMonths: 3,
-      })
-
-      expect(plan.interval).toBe('custom')
-      expect(plan.intervalMonths).toBe(3)
-    })
-
-    it('supports trial periods', () => {
-      const plan = PricingPlan({
-        id: 'with-trial',
-        name: 'Pro with Trial',
-        tierId: 'pro',
-        price: 29,
-        currency: 'USD',
-        interval: 'monthly',
-        trial: {
-          days: 14,
-          requiresPaymentMethod: false,
-        },
-      })
-
-      expect(plan.trial?.days).toBe(14)
-      expect(plan.trial?.requiresPaymentMethod).toBe(false)
-    })
-
-    it('supports multiple currencies', () => {
-      const plan = PricingPlan({
-        id: 'pro-eur',
-        name: 'Pro EUR',
-        tierId: 'pro',
-        price: 27,
-        currency: 'EUR',
-        interval: 'monthly',
-      })
-
-      expect(plan.currency).toBe('EUR')
-    })
-
-    it('supports usage-based pricing', () => {
-      const plan = PricingPlan({
-        id: 'metered',
-        name: 'Usage Based',
-        tierId: 'pro',
-        price: 0,
-        currency: 'USD',
-        interval: 'monthly',
-        usageBased: {
-          metric: 'api-calls',
-          unitPrice: 0.001,
-          includedUnits: 10000,
-        },
-      })
-
-      expect(plan.usageBased?.metric).toBe('api-calls')
-      expect(plan.usageBased?.unitPrice).toBe(0.001)
-    })
-
-    it('supports addons', () => {
-      const plan = PricingPlan({
-        id: 'with-addons',
-        name: 'Customizable',
-        tierId: 'pro',
-        price: 29,
-        currency: 'USD',
-        interval: 'monthly',
-        addons: [
-          { id: 'extra-storage', price: 5 },
-          { id: 'priority-support', price: 10 },
-        ],
-      })
-
-      expect(plan.addons).toHaveLength(2)
-    })
-  })
-
-  describe('createPricingPlan()', () => {
-    it('validates price is non-negative', () => {
-      expect(() =>
-        createPricingPlan({
-          id: 'invalid',
-          name: 'Invalid',
-          tierId: 'pro',
-          price: -10,
-          currency: 'USD',
-          interval: 'monthly',
-        })
-      ).toThrow('Price must be non-negative')
-    })
-
-    it('validates interval months for custom interval', () => {
-      expect(() =>
-        createPricingPlan({
-          id: 'invalid',
-          name: 'Invalid',
-          tierId: 'pro',
-          price: 50,
-          currency: 'USD',
-          interval: 'custom',
-          // Missing intervalMonths
-        })
-      ).toThrow('Custom interval requires intervalMonths')
-    })
-  })
-
-  describe('PlanRegistry', () => {
-    it('registers and retrieves plans', () => {
-      const registry = createPlanRegistry()
-
-      const plan = PricingPlan({
-        id: 'basic',
-        name: 'Basic',
-        tierId: 'basic',
-        price: 9,
-        currency: 'USD',
-        interval: 'monthly',
-      })
-
-      registry.register(plan)
-      expect(registry.get('basic')).toEqual(plan)
-    })
-
-    it('lists plans by tier', () => {
-      const registry = createPlanRegistry()
-
-      registry.register(
-        PricingPlan({
-          id: 'pro-monthly',
-          name: 'Pro Monthly',
-          tierId: 'pro',
-          price: 29,
-          currency: 'USD',
-          interval: 'monthly',
-        })
-      )
-      registry.register(
-        PricingPlan({
-          id: 'pro-yearly',
-          name: 'Pro Yearly',
-          tierId: 'pro',
-          price: 290,
-          currency: 'USD',
-          interval: 'yearly',
-        })
-      )
-      registry.register(
-        PricingPlan({
-          id: 'free',
-          name: 'Free',
-          tierId: 'free',
-          price: 0,
-          currency: 'USD',
-          interval: 'monthly',
-        })
-      )
-
-      const proPlans = registry.listByTier('pro')
-      expect(proPlans).toHaveLength(2)
-    })
-
-    it('lists plans by interval', () => {
-      const registry = createPlanRegistry()
-
-      registry.register(
-        PricingPlan({
-          id: 'p1',
-          name: 'P1',
-          tierId: 'pro',
-          price: 29,
-          currency: 'USD',
-          interval: 'monthly',
-        })
-      )
-      registry.register(
-        PricingPlan({
-          id: 'p2',
-          name: 'P2',
-          tierId: 'pro',
-          price: 290,
-          currency: 'USD',
-          interval: 'yearly',
-        })
-      )
-
-      const monthly = registry.listByInterval('monthly')
-      expect(monthly).toHaveLength(1)
-    })
-
-    it('calculates monthly equivalent price', () => {
-      const registry = createPlanRegistry()
-
-      registry.register(
-        PricingPlan({
-          id: 'yearly',
-          name: 'Yearly',
-          tierId: 'pro',
-          price: 240,
-          currency: 'USD',
-          interval: 'yearly',
-        })
-      )
-
-      const monthly = registry.getMonthlyEquivalent('yearly')
-      expect(monthly).toBe(20)
-    })
-
-    it('compares plan pricing', () => {
-      const registry = createPlanRegistry()
-
-      registry.register(
-        PricingPlan({
-          id: 'monthly',
-          name: 'Monthly',
-          tierId: 'pro',
-          price: 29,
-          currency: 'USD',
-          interval: 'monthly',
-        })
-      )
-      registry.register(
-        PricingPlan({
-          id: 'yearly',
-          name: 'Yearly',
-          tierId: 'pro',
-          price: 290,
-          currency: 'USD',
-          interval: 'yearly',
-        })
-      )
-
-      const savings = registry.calculateSavings('monthly', 'yearly')
-      expect(savings.percentage).toBeCloseTo(17, 0)
-      expect(savings.amount).toBeCloseTo(58, 0)
-    })
-  })
-})