# macOS, Linux, and WSL
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
winget install oven-sh.bun

bun --version
# Should output: 1.2.x or higher

# Create a new Nuxt project (uses Nitro internally)
bunx nuxi@latest init brewstop-bun

cd brewstop-bun

bun install

{
  "packageManager": "bun@1.2.0",
  "scripts": {
    "dev": "bunx nuxi dev",
    "build": "bunx nuxi build",
    "preview": "bunx nuxi preview",
    "start": "bunx nuxi start"
  }
}

export default defineNuxtConfig({
  nitro: {
    preset: "bun",
  },
  
  devtools: {
    enabled: true,
  },
});

export default defineEventHandler(() => {
  return {
    message: "Pong from Bun!",
    runtime: "Bun",
    timestamp: Date.now(),
  };
});

const products = [
  { id: 1, name: "Latte", price: 4.5, category: "coffee" },
  { id: 2, name: "Espresso", price: 3.0, category: "coffee" },
  { id: 3, name: "Croissant", price: 3.5, category: "food" },
  { id: 4, name: "Chai Tea", price: 4.0, category: "tea" },
  { id: 5, name: "Muffin", price: 3.0, category: "food" },
];

export default defineEventHandler(() => {
  return { products };
});

interface OrderItem {
  productId: number;
  quantity: number;
}

const orders: any[] = [];

export default defineEventHandler(async (event) => {
  const body = await readBody(event) as OrderItem[];
  
  if (!body || body.length === 0) {
    throw createError({
      statusCode: 400,
      statusMessage: "Order must contain at least one item",
    });
  }
  
  // Simulate database delay
  await new Promise((resolve) => setTimeout(resolve, 100));
  
  const order = {
    id: crypto.randomUUID(),
    items: body,
    status: "pending",
    createdAt: new Date().toISOString(),
  };
  
  orders.push(order);
  
  return order;
});

bun run dev

curl http://localhost:3000/api/ping
curl http://localhost:3000/api/products

import http from "http";

const HOST = "localhost";
const PORT = 3000;
const REQUESTS = 10000;
const CONCURRENCY = 100;

async function benchmark() {
  console.log(`Running benchmark: ${REQUESTS} requests with ${CONCURRENCY} concurrency\n`);
  
  const start = Date.now();
  let completed = 0;
  
  const promises = [];
  
  for (let i = 0; i < CONCURRENCY; i++) {
    promises.push(
      new Promise((resolve) => {
        const makeRequest = async () => {
          if (completed >= REQUESTS) {
            resolve(true);
            return;
          }
          
          try {
            await fetch(`http://${HOST}:${PORT}/api/products`);
            completed++;
            
            if (completed < REQUESTS) {
              makeRequest();
            } else {
              resolve(true);
            }
          } catch (e) {
            resolve(true);
          }
        };
        
        makeRequest();
      })
    );
  }
  
  await Promise.all(promises);
  
  const duration = Date.now() - start;
  const rps = Math.round(REQUESTS / (duration / 1000));
  
  console.log(`Results:`);
  console.log(`  Total time: ${duration}ms`);
  console.log(`  Requests/sec: ${rps}`);
  console.log(`  Avg latency: ${(duration / REQUESTS).toFixed(2)}ms`);
}

benchmark();

# First, start the server in one terminal
bun run dev

# Then run the benchmark in another
bun run benchmark.mjs

// This runs directly in Bun—no transpilation!
interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: "Latte", price: 4.5 },
  { id: 2, name: "Espresso", price: 3.0 },
];

export default defineEventHandler(() => {
  return {
    products,
    runtime: Bun.version,
    platform: Bun.environment.platform,
  };
});

export default defineEventHandler(async (event) => {
  const file = Bun.file("./server/data/products.json");
  const contents = await file.json();
  
  return contents;
});

export default defineEventHandler(async () => {
  const urls = [
    "https://api.github.com/users/okinea",
    "https://api.github.com/users/facebook",
    "https://api.github.com/users/nuxt",
  ];
  
  // Fetch all URLs in parallel - Bun optimizes this natively
  const responses = await Promise.all(
    urls.map((url) => fetch(url).then((r) => r.json()))
  );
  
  return {
    users: responses.map((r) => r.login),
    fetchedAt: new Date().toISOString(),
  };
});

# Vercel automatically detects Bun
vercel deploy

{
  "build": {
    "builder": "NIXPACKS_BUN"
  },
  "run": {
    "command": "bun run start"
  }
}

FROM oven/bun:1.2 AS base
WORKDIR /app

COPY package.json bun.lockb* ./
RUN bun install --frozen-lockfile

COPY . .
RUN bun run build

EXPOSE 3000
CMD ["bun", "run", "start"]

bunx nuxi build
bun run .output/server/index.mjs