Building REST APIs

export interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
  updatedAt: Date;
}

export interface CreateUserInput {
  name: string;
  email: string;
}

export interface UpdateUserInput {
  name?: string;
  email?: string;
}

import type { User, CreateUserInput, UpdateUserInput } from '../types/user';

// In-memory store for demonstration
const users = new Map<string, User>();

export const userService = {
  findAll(): User[] {
    return Array.from(users.values());
  },

  findById(id: string): User | undefined {
    return users.get(id);
  },

  create(input: CreateUserInput): User {
    const id = crypto.randomUUID();
    const now = new Date();

    const user: User = {
      id,
      name: input.name,
      email: input.email,
      createdAt: now,
      updatedAt: now,
    };

    users.set(id, user);
    return user;
  },

  update(id: string, input: UpdateUserInput): User | undefined {
    const existing = users.get(id);
    if (!existing) return undefined;

    const updated: User = {
      ...existing,
      ...input,
      updatedAt: new Date(),
    };

    users.set(id, updated);
    return updated;
  },

  delete(id: string): boolean {
    return users.delete(id);
  },
};

import { createRouter, NotFoundError, BadRequestError } from 'nextrush';
import { userService } from '../services/user';
import type { CreateUserInput, UpdateUserInput } from '../types/user';

export const usersRouter = createRouter();

// GET /api/users
usersRouter.get('/', (ctx) => {
  const users = userService.findAll();
  ctx.json({
    data: users,
    total: users.length,
  });
});

// GET /api/users/:id
usersRouter.get('/:id', (ctx) => {
  const { id } = ctx.params;
  const user = userService.findById(id);

  if (!user) {
    throw new NotFoundError(`User with ID "${id}" not found`);
  }

  ctx.json({ data: user });
});

// POST /api/users
usersRouter.post('/', (ctx) => {
  const body = ctx.body as CreateUserInput;

  if (!body.name || !body.email) {
    throw new BadRequestError('Name and email are required');
  }

  const user = userService.create(body);

  ctx.status = 201;
  ctx.json({ data: user });
});

// PUT /api/users/:id
usersRouter.put('/:id', (ctx) => {
  const { id } = ctx.params;
  const body = ctx.body as UpdateUserInput;

  const user = userService.update(id, body);

  if (!user) {
    throw new NotFoundError(`User with ID "${id}" not found`);
  }

  ctx.json({ data: user });
});

// DELETE /api/users/:id
usersRouter.delete('/:id', (ctx) => {
  const { id } = ctx.params;
  const deleted = userService.delete(id);

  if (!deleted) {
    throw new NotFoundError(`User with ID "${id}" not found`);
  }

  ctx.status = 204;
  ctx.send('');
});

import { createApp, listen, errorHandler, notFoundHandler } from 'nextrush';
import { json } from '@nextrush/body-parser';
import { usersRouter } from './routes/users';

const app = createApp();

// Error handling (must be first)
app.use(errorHandler({
  includeStack: process.env.NODE_ENV !== 'production',
}));

// Parse JSON bodies
app.use(json());

// Mount routes
app.route('/api/users', usersRouter);

// 404 handler (must be last)
app.use(notFoundHandler());

// Start server
await listen(app, 8080);

# Create a user
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

# List all users
curl http://localhost:8080/api/users

# Get a specific user (replace with a real ID from the create response)
curl http://localhost:8080/api/users/<id>

# Update a user
curl -X PUT http://localhost:8080/api/users/<id> \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice Updated"}'

# Delete a user
curl -X DELETE http://localhost:8080/api/users/<id>