cfw-autumn/server/benchmarks/attach-benchmarks.ts

import chalk from 'chalk';
import { 
  BenchmarkRunner, 
  DryRunHelper, 
  createMockCustomer, 
  createMockProduct 
} from './benchmark-utils.js';

// Mock product attachment operations
const mockAttachProduct = async (params: any) => {
  const { customer_id, product_id, force_checkout } = params;
  
  // Simulate the attach workflow from existing tests
  DryRunHelper.mockDbOperation('getCustomer', { customerId: customer_id });
  DryRunHelper.mockDbOperation('getProduct', { productId: product_id });
  
  // Simulate pricing calculations
  DryRunHelper.mockComplexCalculation(300); // Price calculation logic
  
  if (force_checkout) {
    // Simulate Stripe checkout creation
    DryRunHelper.mockStripeOperation('createCheckout', {
      customer_id,
      product_id,
    });
  }
  
  // Simulate entitlement updates
  DryRunHelper.mockDbOperation('updateEntitlements', {
    customer_id,
    product_id,
    entitlements: ['premium_feature', 'advanced_api'],
  });
  
  return { success: true, attached: true };
};

const mockUpgradeProduct = async (params: any) => {
  const { customer_id, from_product_id, to_product_id } = params;
  
  // Simulate upgrade workflow
  DryRunHelper.mockDbOperation('getCurrentProduct', { customer_id, from_product_id });
  DryRunHelper.mockDbOperation('getTargetProduct', { to_product_id });
  
  // Simulate prorated billing calculation (CPU intensive)
  DryRunHelper.mockComplexCalculation(800);
  
  // Simulate Stripe subscription update
  DryRunHelper.mockStripeOperation('updateSubscription', {
    customer_id,
    from_product_id,
    to_product_id,
  });
  
  // Update entitlements
  DryRunHelper.mockDbOperation('migrateEntitlements', {
    customer_id,
    from_product_id,
    to_product_id,
  });
  
  return { success: true, upgraded: true };
};

const mockDowngradeProduct = async (params: any) => {
  const { customer_id, from_product_id, to_product_id } = params;
  
  // Similar to upgrade but with different calculations
  DryRunHelper.mockDbOperation('getCurrentProduct', { customer_id, from_product_id });
  DryRunHelper.mockDbOperation('getTargetProduct', { to_product_id });
  
  // Downgrade calculations (typically simpler)
  DryRunHelper.mockComplexCalculation(400);
  
  // Stripe operations
  DryRunHelper.mockStripeOperation('updateSubscription', {
    customer_id,
    from_product_id,
    to_product_id,
  });
  
  // Handle feature restrictions
  DryRunHelper.mockDbOperation('restrictEntitlements', {
    customer_id,
    restricted_features: ['premium_feature'],
  });
  
  return { success: true, downgraded: true };
};

const mockCalculatePricing = async (params: any) => {
  const { product_id, customer_id, usage_data } = params;
  
  // Simulate complex pricing calculation
  DryRunHelper.mockDbOperation('getProductPricing', { product_id });
  DryRunHelper.mockDbOperation('getCustomerUsage', { customer_id });
  
  // CPU-intensive pricing calculations
  DryRunHelper.mockComplexCalculation(600);
  
  // Simulate tier-based pricing logic
  const tiers = usage_data?.tiers || [100, 1000, 10000];
  let totalCost = 0;
  for (const tier of tiers) {
    totalCost += tier * 0.01; // Mock pricing calculation
  }
  
  return { totalCost, breakdown: tiers };
};

const mockEntityAttachment = async (params: any) => {
  const { customer_id, product_id, entity_id } = params;
  
  // Simulate entity-specific attachment
  DryRunHelper.mockDbOperation('getEntity', { entity_id });
  DryRunHelper.mockDbOperation('attachToEntity', {
    customer_id,
    product_id,
    entity_id,
  });
  
  // Entity-specific calculations
  DryRunHelper.mockComplexCalculation(200);
  
  return { success: true, entity_attached: true };
};

export const runAttachBenchmarks = async () => {
  const runner = new BenchmarkRunner({
    iterations: 50,
    warmupIterations: 5,
  });

  console.log(chalk.cyan('🔗 Product & Billing Operations'));
  console.log(chalk.gray('Measuring subscription and pricing workflows\n'));
  
  // Real-world product operations
  await runner.run('Free Plan Signup', async () => {
    await mockAttachProduct({
      customer_id: 'new_customer_123',
      product_id: 'starter_free',
      force_checkout: false,
    });
  });

  await runner.run('Paid Plan Subscription', async () => {
    await mockAttachProduct({
      customer_id: 'converting_customer_456',
      product_id: 'pro_monthly',
      force_checkout: true,
    });
  });

  await runner.run('Plan Upgrade (Basic → Pro)', async () => {
    await mockUpgradeProduct({
      customer_id: 'existing_customer_789',
      from_product_id: 'basic_monthly',
      to_product_id: 'pro_monthly',
    });
  });

  await runner.run('Plan Downgrade (Pro → Basic)', async () => {
    await mockDowngradeProduct({
      customer_id: 'downgrading_customer_321',
      from_product_id: 'pro_monthly',
      to_product_id: 'basic_monthly',
    });
  });

  await runner.run('Usage-Based Pricing Calc', async () => {
    await mockCalculatePricing({
      product_id: 'usage_tier_product',
      customer_id: 'heavy_user_654',
      usage_data: {
        tiers: [1000, 5000, 25000, 100000],
        features: ['api_requests', 'storage_gb', 'compute_hours'],
      },
    });
  });

  await runner.run('Team Plan Setup', async () => {
    await mockEntityAttachment({
      customer_id: 'team_lead_987',
      product_id: 'team_plan',
      entity_id: 'team_acme_corp',
    });
  });

  await runner.run('Bulk Plan Changes (5 customers)', async () => {
    const promises: Promise<any>[] = [];
    for (let i = 0; i < 5; i++) {
      promises.push(mockAttachProduct({
        customer_id: `bulk_customer_${i}`,
        product_id: 'standard_plan',
        force_checkout: false,
      }));
    }
    await Promise.all(promises);
  });

  runner.printSummary();
  return runner.getResults();
};