Building API Server Using Bun🚀

Introduction

What is Bun?

Bun is a modern, high-performance JavaScript runtime designed to simplify and accelerate JavaScript and TypeScript development ⚡. Built using the Zig programming language, Bun combines a runtime, package manager, test runner, and bundler into a single executable 🔧.

Unlike Node.js, which uses the V8 engine, Bun leverages JavaScriptCore (the engine behind Safari) 🍏, offering faster startup times and reduced memory usage 🚀. This makes it particularly efficient for serverless functions, microservices, and cloud-native applications ☁️.

With native support for JavaScript and TypeScript, Bun eliminates the need for tools like Babel or Webpack 🛠️. Features like live reloading 🔄, .env file handling, and compatibility with Node.js APIs make Bun a great alternative and a drop-in replacement for Node.js 🔄.

Steps to Set Up the Environment for Bun

Install Bun🛠️:
- Use the following command to install Bun on your system:
```
  bashcurl -fsSL https://bun.sh/install | bash
```
- Alternatively, you can install it via npm:
```
  npm install -g bun
```
Create a Project Directory📂:
- Set up a new directory for your project:
```
  mkdir my-bun-project
  cd my-bun-project
```
Initialize a New Bun Project🚀:
- Run the following command to scaffold a new project:
```
  bun init
```
Install Required Packages (Optional)📦:
- If you need additional packages, you can install them using:
```
  bun add package-name
```
Write Your Code✍️:
- Open the generated index.ts or create an index.js file and start writing your application code.
Run Your Application▶️:
- Execute your application using the command:
```
  bun run index.js
```

3. Writing The First API Endpoint

Create index.js📝: Serves as the entry point for the API.

  Bun.serve({
    fetch(req) {
      return new Response("Bun!");
    },
  });

  serve({
    port: 3000, // The port to run your API on
    fetch(req) {
      const url = new URL(req.url);

      // Handle "/api/hello" endpoint
      if (url.pathname === "/api/hello" && req.method === "GET") {
        return new Response(
          JSON.stringify({ message: "Hello, Bun!" }),
          { headers: { "Content-Type": "application/json" } }
        );
      }

      // Default response for unhandled routes
      return new Response(
        JSON.stringify({ error: "Not Found" }),
        { status: 404, headers: { "Content-Type": "application/json" } }
      );
    },
  });

  console.log("Server running on http://localhost:3000");

Use Bun.serve🚀: Starts the server and listens for requests on a specified port.
Define Endpoints🌐:
Root (/) → Responds with "Hello, World!".

Dynamic Route (/greet/:name) → Responds with "Hello, [name]!", where [name] is dynamically captured from the URL.
Handle 404 Errors❌: Return "Not Found" for unmatched routes.
Console Log💬: Confirm server is running with a message like "Server running on http://localhost:3000".

4. Running Our Server

How to start the server▶️:
```
  bun run index.ts
```

If everything works, we should see💻:

  Server running on http://localhost:3000

5. Testing Our API

Provide instructions for testing endpoints🧪:
- Use a browser or tools like Postman or curl.
```
  curl http://localhost:3000/
  curl http://localhost:3000/greet/John
```
The expected outputs🖥️:
- / → Returns "Hello, World!".
- /greet/:name → Returns "Hello, John!" (or the name provided in the URL).

6. Adding More Routes➕

We can also add more routes for different HTTP methods (e.g., GET, POST, PUT, DELETE). Example:

javascriptCopyEditif (url.pathname === '/data' && req.method === 'POST') {
    return new Response('Data received!', { status: 200 });

7. Advanced Features🔧

Briefly touch on advanced features like:
- Middleware Usage🛠️: Implement middleware for request validation or logging.
- Static File Serving📁: Use Bun.serve to handle static files.
- Swagger Integration📚: Add Swagger for API documentation.

8. Conclusion🎯

Creating API endpoints using Bun is simple, lightweight, and efficient 🌟. Bun's built-in Bun.serve method allows you to quickly set up a high-performance server, define routes, handle dynamic parameters, and manage errors—all without the need for additional libraries or frameworks 🔥. With its seamless support for JavaScript and TypeScript, Bun is an excellent choice for building modern web APIs 🚀.