benchmark.js

import "reflect-metadata";
import { performance } from "perf_hooks";

import TypeORMBenchmark from "./orms/typeorm.js";
import SequelizeBenchmark from "./orms/sequelize.js";
import PrismaBenchmark from "./orms/prisma.js";
import ObjectionBenchmark from "./orms/objection.js";

// Generate test data
function generateTestData(count = 1000, iteration = 0) {
  const users = [];
  const timestamp = Date.now();
  const randomSuffix = Math.random().toString(36).substring(2, 15);
  for (let i = 0; i < count; i++) {
    users.push({
      email: `user${i}_${timestamp}_${iteration}_${randomSuffix}_${i}@example.com`,
      name: `User ${i}`,
      age: Math.floor(Math.random() * 50) + 18,
      isActive: Math.random() > 0.3,
    });
  }
  return users;
}

// Calculate statistics
function calculateStats(times) {
  const sorted = times.sort((a, b) => a - b);
  const sum = times.reduce((a, b) => a + b, 0);
  const avg = sum / times.length;
  const min = sorted[0];
  const max = sorted[sorted.length - 1];
  const median = sorted[Math.floor(sorted.length / 2)];

  return { avg, min, max, median };
}

// Format time in milliseconds
function formatTime(ms) {
  return `${ms.toFixed(2)}ms`;
}

// Print results table
function printResults(results) {
  console.log("\n" + "=".repeat(80));
  console.log("ORM BENCHMARKING RESULTS");
  console.log("=".repeat(80));

  const operations = [
    "bulkInsert",
    "individualInsert",
    "selectAll",
    "selectWithWhere",
    "update",
    "delete",
    "complexQuery",
  ];

  const orms = ["TypeORM", "Sequelize", "Prisma", "Objection.js"];

  operations.forEach((operation) => {
    console.log(`\n${operation.toUpperCase()}:`);
    console.log("-".repeat(40));

    const operationResults = orms
      .map((orm) => ({
        orm,
        stats:
          results[orm] && results[orm][operation]
            ? results[orm][operation]
            : null,
      }))
      .filter((result) => result.stats !== null);

    if (operationResults.length === 0) {
      console.log("❌ No results available for this operation");
      return;
    }

    // Sort by average time (fastest first)
    operationResults.sort((a, b) => a.stats.avg - b.stats.avg);

    operationResults.forEach((result, index) => {
      const { orm, stats } = result;
      const rank =
        index === 0 ? "🥇" : index === 1 ? "🥈" : index === 2 ? "🥉" : "  ";
      console.log(
        `${rank} ${orm.padEnd(12)} | ` +
          `Avg: ${formatTime(stats.avg).padEnd(10)} | ` +
          `Min: ${formatTime(stats.min).padEnd(10)} | ` +
          `Max: ${formatTime(stats.max).padEnd(10)} | ` +
          `Median: ${formatTime(stats.median)}`
      );
    });
  });

  console.log("\n" + "=".repeat(80));
}

// Run benchmark for a single ORM
async function runBenchmark(ormClass, ormName, testData, iterations = 5) {
  console.log(`\n🧪 Testing ${ormName}...`);

  const orm = new ormClass();
  const results = {
    bulkInsert: [],
    individualInsert: [],
    selectAll: [],
    selectWithWhere: [],
    update: [],
    delete: [],
    complexQuery: [],
  };

  try {
    await orm.initialize();

    for (let i = 0; i < iterations; i++) {
      console.log(`  Iteration ${i + 1}/${iterations}`);

      // Generate fresh test data for each iteration
      const iterationTestData = generateTestData(1000, i);
      const individualTestData = generateTestData(100, i);

      // Clear data before each iteration
      await orm.clearData();

      try {
        // Bulk Insert
        const bulkTime = await orm.bulkInsert(iterationTestData);
        results.bulkInsert.push(bulkTime);

        // Individual Insert
        const individualTime = await orm.individualInsert(individualTestData);
        results.individualInsert.push(individualTime);
      } catch (error) {
        console.error(`    Error in iteration ${i + 1}:`, error.message);
        throw error;
      }

      // Select All
      const selectAllTime = await orm.selectAll();
      results.selectAll.push(selectAllTime);

      // Select with Where
      const selectWhereTime = await orm.selectWithWhere();
      results.selectWithWhere.push(selectWhereTime);

      // Update
      const updateTime = await orm.update();
      results.update.push(updateTime);

      // Complex Query
      const complexTime = await orm.complexQuery();
      results.complexQuery.push(complexTime);

      // Delete
      const deleteTime = await orm.delete();
      results.delete.push(deleteTime);
    }

    // Calculate statistics for each operation
    const stats = {};
    Object.keys(results).forEach((operation) => {
      stats[operation] = calculateStats(results[operation]);
    });

    return stats;
  } finally {
    await orm.cleanup();
  }
}

// Main benchmark function
async function runAllBenchmarks() {
  console.log("🚀 Starting ORM Benchmarking Experiment");
  console.log("Node.js version:", process.version);
  console.log("Platform:", process.platform);
  console.log("Architecture:", process.arch);

  const testData = generateTestData(1000);
  const iterations = 5;

  console.log(`\n📊 Test Configuration:`);
  console.log(`  - Test data: ${testData.length} users`);
  console.log(`  - Iterations: ${iterations}`);
  console.log(`  - Database: SQLite`);

  const startTime = performance.now();

  const results = {};

  // Run benchmarks for each ORM
  const benchmarks = [
    { class: TypeORMBenchmark, name: "TypeORM" },
    { class: SequelizeBenchmark, name: "Sequelize" },
    { class: PrismaBenchmark, name: "Prisma" },
    { class: ObjectionBenchmark, name: "Objection.js" },
  ];

  for (const benchmark of benchmarks) {
    try {
      results[benchmark.name] = await runBenchmark(
        benchmark.class,
        benchmark.name,
        testData,
        iterations
      );
    } catch (error) {
      console.error(`❌ Error testing ${benchmark.name}:`, error.message);
      results[benchmark.name] = null;
    }
  }

  const totalTime = performance.now() - startTime;

  // Print results
  printResults(results);

  console.log(`\n⏱️  Total benchmark time: ${formatTime(totalTime)}`);
  console.log("\n✅ Benchmarking completed!");
}

// Handle errors and run benchmarks
process.on("unhandledRejection", (reason, promise) => {
  console.error("Unhandled Rejection at:", promise, "reason:", reason);
  process.exit(1);
});

runAllBenchmarks().catch((error) => {
  console.error("❌ Benchmark failed:", error);
  process.exit(1);
});