Node.jsからBun 1.2への本番環境移行：フルスタックHTTP、SQLite、パッケージパフォーマンス

// src/node-server.ts
import express from 'express';
import { readFileSync } from 'fs';
import path from 'path';

const app = express();
const port = process.env.PORT ? parseInt(process.env.PORT) : 3000;

app.use(express.json());

app.get('/', (req, res) => {
  res.send('Hello from Node.js Express!');
});

app.get('/data', (req, res) => {
  try {
    const data = readFileSync(path.join(__dirname, '../data.json'), 'utf8');
    res.json(JSON.parse(data));
  } catch (error) {
    console.error('Error reading data:', error);
    res.status(500).send('Internal Server Error');
  }
});

app.listen(port, () => {
  console.log(`Node.js Express server listening on port ${port}`);
});

// src/bun-server.ts
import { readFileSync } from 'fs';
import path from 'path';

const port = process.env.PORT ? parseInt(process.env.PORT) : 3000;

const server = Bun.serve({
  port,
  async fetch(req: Request): Promise<Response> {
    const url = new URL(req.url);

    if (url.pathname === '/') {
      return new Response('Hello from Bun!', { status: 200 });
    }

    if (url.pathname === '/data') {
      try {
        const dataPath = path.join(import.meta.dir, '../data.json');
        const data = readFileSync(dataPath, 'utf8');
        return new Response(data, {
          headers: { 'Content-Type': 'application/json' },
          status: 200,
        });
      } catch (error) {
        console.error('Error reading data:', error);
        return new Response('Internal Server Error', { status: 500 });
      }
    }

    // Example for POST request with JSON body
    if (url.pathname === '/submit' && req.method === 'POST') {
      try {
        const body = await req.json();
        console.log('Received JSON body:', body);
        return new Response(JSON.stringify({ message: 'Data received', data: body }), {
          headers: { 'Content-Type': 'application/json' },
          status: 200,
        });
      } catch (error) {
        console.error('Error parsing JSON body:', error);
        return new Response('Bad Request: Invalid JSON', { status: 400 });
      }
    }

    return new Response('Not Found', { status: 404 });
  },
  error(error: Error): Response {
    console.error('Bun server error:', error);
    return new Response('Internal Server Error', { status: 500 });
  },
});

console.log(`Bun server listening on port ${server.port}`);

// src/node-sqlite.ts
import Database from 'better-sqlite3';
import path from 'path';

const dbPath = path.join(__dirname, '../data.db');
const db = new Database(dbPath);

db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL
  );
`);

export function insertUser(name: string, email: string) {
  const stmt = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
  const info = stmt.run(name, email);
  return info.lastInsertRowid;
}

export function getUsers() {
  const stmt = db.prepare('SELECT * FROM users');
  return stmt.all();
}

// Example usage
if (require.main === module) {
  insertUser('Alice', 'alice@example.com');
  insertUser('Bob', 'bob@example.com');
  console.log('Users:', getUsers());
  db.close();
}

// src/bun-sqlite.ts
import { Database } from 'bun:sqlite';
import path from 'path';

const dbPath = path.join(import.meta.dir, '../data.db');
const db = new Database(dbPath);

db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL
  );
`);

export function insertUser(name: string, email: string) {
  const query = db.query('INSERT INTO users (name, email) VALUES (?, ?)');
  const result = query.run(name, email);
  // Bun's result object for INSERT operations might differ slightly
  // For SQLite, lastInsertRowid is often available on the database object or via PRAGMA
  // For simplicity, we'll assume a successful run implies insertion.
  // A more robust solution would query for the last_insert_rowid()
  const lastIdQuery = db.query('SELECT last_insert_rowid() as id;');
  return (lastIdQuery.get() as { id: number }).id;
}

export function getUsers() {
  const query = db.query('SELECT * FROM users');
  return query.all();
}

// Example usage
if (import.meta.main) {
  insertUser('Charlie', 'charlie@example.com');
  insertUser('David', 'david@example.com');
  console.log('Users:', getUsers());
  db.close();
}

// src/node-ws.ts
import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', ws => {
  console.log('Client connected (Node.js WS)');
  ws.on('message', message => {
    console.log(`Received: ${message}`);
    ws.send(`Echo: ${message}`);
  });
  ws.on('close', () => console.log('Client disconnected (Node.js WS)'));
  ws.on('error', error => console.error('WebSocket error (Node.js WS):', error));
});

console.log('Node.js WebSocket server listening on port 8080');

// src/bun-ws.ts
const server = Bun.serve({
  port: 8080,
  fetch(req, server) {
    const url = new URL(req.url);
    if (url.pathname === '/ws') {
      const success = server.upgrade(req, {
        data: {
          // Optional: attach any data to the WebSocket connection
          connectedAt: Date.now(),
        },
      });
      if (success) {
        return; // Bun handles the WebSocket connection
      }
    }
    return new Response('Not Found', { status: 404 });
  },
  websocket: {
    open(ws) {
      console.log(`Client connected (Bun WS). Connected at: ${ws.data.connectedAt}`);
      ws.send('Welcome to Bun WebSocket!');
    },
    message(ws, message) {
      console.log(`Received: ${message}`);
      ws.send(`Echo: ${message}`);
    },
    close(ws, code, message) {
      console.log(`Client disconnected (Bun WS). Code: ${code}, Message: ${message}`);
    },
    error(ws, error) {
      console.error('WebSocket error (Bun WS):', error);
    },
    // Optional: perMessageDeflate, maxPayloadLength, idleTimeout
    // idleTimeout: 30, // seconds
  },
});

console.log(`Bun WebSocket server listening on port ${server.port}`);

// src/node-bcrypt.ts
import bcrypt from 'bcrypt';

async function hashPassword(password: string) {
  const saltRounds = 10;
  const hashedPassword = await bcrypt.hash(password, saltRounds);
  console.log('Hashed password (Node.js):', hashedPassword);
  return hashedPassword;
}

async function verifyPassword(password: string, hash: string) {
  const isMatch = await bcrypt.compare(password, hash);
  console.log('Password match (Node.js):', isMatch);
  return isMatch;
}

if (require.main === module) {
  (async () => {
    const hash = await hashPassword('mysecretpassword');
    await verifyPassword('mysecretpassword', hash);
    await verifyPassword('wrongpassword', hash);
  })();
}

// src/bun-bcryptjs.ts
import bcrypt from 'bcryptjs'; // Using bcryptjs for Bun compatibility

async function hashPassword(password: string) {
  const saltRounds = 10;
  const hashedPassword = await bcrypt.hash(password, saltRounds);
  console.log('Hashed password (Bun/bcryptjs):', hashedPassword);
  return hashedPassword;
}

async function verifyPassword(password: string, hash: string) {
  const isMatch = await bcrypt.compare(password, hash);
  console.log('Password match (Bun/bcryptjs):', isMatch);
  return isMatch;
}

if (import.meta.main) {
  (async () => {
    const hash = await hashPassword('mysecretpassword');
    await verifyPassword('mysecretpassword', hash);
    await verifyPassword('wrongpassword', hash);
  })();
}

# Dockerfile.node
FROM node:20-alpine AS base

WORKDIR /app

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

COPY . .

EXPOSE 3000
CMD ["node", "src/node-server.ts"]

# Dockerfile.bun
FROM oven/bun:1.2.0-alpine AS base

WORKDIR /app

COPY package.json bun.lockb* ./
# Bun automatically installs dependencies on 'bun run' if not present,
# but explicit install is good practice for build stage.
RUN bun install --frozen-lockfile

COPY . .

EXPOSE 3000
CMD ["bun", "run", "src/bun-server.ts"]