madapes
Repositories
7
 Projects Packages

@aurora/runtime-http (0.3.3)

Published 2025-12-27 10:44:41 +00:00 by vlad

Installation

@aurora:registry=
npm install @aurora/runtime-http@0.3.3
"@aurora/runtime-http": "0.3.3"

About this package

@aurora/runtime-http

Bun HTTP adapter for Effect-based handlers in Aurora applications.

Overview

Aurora's HTTP runtime provides:

  • Bun-native HTTP server
  • Effect-based request/response handling
  • Type-safe routing with schema validation
  • WebSocket support
  • Middleware support

Installation

bun add @aurora/runtime-http

Quick Start

import { Server, Router } from "@aurora/runtime-http";
import { Effect, succeed } from "@aurora/runtime-effect";

// Create server
const server = new Server({ port: 3000 });

// Create router
const router = new Router();

// Add route
router.get("/hello", () =>
  succeed(new Response("Hello, World!"))
);

// Mount router
server.use(router);

// Start server
await server.start();

Server

import { Server } from "@aurora/runtime-http";

const server = new Server({
  port: 3000,
  host: "0.0.0.0",
});

// Start server
await server.start();

// Stop server
await server.stop();

Router

import { Router } from "@aurora/runtime-http";

const router = new Router();

// HTTP methods
router.get(path, handler)
router.post(path, handler)
router.put(path, handler)
router.patch(path, handler)
router.delete(path, handler)

// Middleware
router.use(middleware)

Request Handlers

Handlers return Effects that produce Responses:

import { Effect } from "@aurora/runtime-effect";
import { Request, Response } from "@aurora/runtime-http";

interface Dependencies {
  database: Database;
  logger: Logger;
}

function handleGetOrder(req: Request): Effect<Dependencies, Error, Response> {
  return async ({ database, logger }) => {
    const orderId = req.params.orderId;
    logger.log(`Fetching order ${orderId}`);
    
    const order = await database.findOrder(orderId);
    
    if (!order) {
      return new Response("Not found", { status: 404 });
    }
    
    return Response.json(order);
  };
}

Request/Response

Request

interface Request {
  method: string;
  url: string;
  headers: Headers;
  params: Record<string, string>;
  query: Record<string, string>;
  body: unknown;
}

Response

import { Response } from "@aurora/runtime-http";

// Text response
new Response("Hello", { status: 200 });

// JSON response
Response.json({ data: "value" }, { status: 200 });

// Custom headers
new Response("OK", {
  status: 200,
  headers: {
    "Content-Type": "text/plain",
    "X-Custom-Header": "value",
  },
});

Middleware

import { Middleware } from "@aurora/runtime-http";

const loggingMiddleware: Middleware = async (req, next) => {
  console.log(`${req.method} ${req.url}`);
  const response = await next(req);
  console.log(`Response: ${response.status}`);
  return response;
};

router.use(loggingMiddleware);

Authentication Middleware

const authMiddleware: Middleware = async (req, next) => {
  const token = req.headers.get("Authorization");
  
  if (!token) {
    return new Response("Unauthorized", { status: 401 });
  }
  
  // Verify token
  const user = await verifyToken(token);
  if (!user) {
    return new Response("Invalid token", { status: 401 });
  }
  
  // Attach user to request
  (req as any).user = user;
  
  return next(req);
};

router.use(authMiddleware);

Error Handling

import { Effect, fail } from "@aurora/runtime-effect";

function handleOrder(req: Request): Effect<Dependencies, Error, Response> {
  return async ({ database }) => {
    try {
      const order = await database.findOrder(req.params.orderId);
      return Response.json(order);
    } catch (error) {
      if (error instanceof NotFoundError) {
        return new Response("Not found", { status: 404 });
      }
      throw error; // Let server handle unexpected errors
    }
  };
}

WebSocket Support

import { WebSocketServer } from "@aurora/runtime-ws";

const ws = new WebSocketServer({ port: 3001 });

ws.onConnection((socket, req) => {
  console.log("Client connected");
  
  socket.onMessage((message) => {
    console.log("Received:", message);
    socket.send(JSON.stringify({ echo: message }));
  });
  
  socket.onClose(() => {
    console.log("Client disconnected");
  });
});

Integration with Schema DSL

Use with @aurora/schema for type-safe routes:

import { api } from "@aurora/schema";

export const routes = api.define({
  rest: (r) => ({
    getOrders: r.get("/api/v1/orders")
      .query((t) => t.object({
        limit: t.number().optional(),
      }))
      .response((t) => t.object({
        orders: t.array(t.object({})),
      })),
  }),
});

// Generate typed handler
import { generateHandler } from "@aurora/codegen";

const handler = generateHandler(routes.rest.getOrders);

Testing

import { Server } from "@aurora/runtime-http";
import { test, expect } from "bun:test";

test("GET /hello returns Hello World", async () => {
  const server = new Server({ port: 3000 });
  server.get("/hello", () => succeed(new Response("Hello, World!")));
  await server.start();
  
  const response = await fetch("http://localhost:3000/hello");
  const text = await response.text();
  
  expect(text).toBe("Hello, World!");
  
  await server.stop();
});

License

MIT

Dependencies

Dependencies

ID Version
@aurora/runtime-effect 0.3.3
Details
npm
2025-12-27 10:44:41 +00:00
3
latest
6.8 KiB
Assets (1)
runtime-http-0.3.3.tgz 6.8 KiB
Versions (5) View all
0.3.3 2025-12-27
0.3.2 2025-12-27
0.3.1 2025-12-27
0.3.0 2025-12-27
0.2.0 2025-12-26