FAQ

// This requires Go 1.22+
app.Get("/users/{id}", getUser)

// Use any http.Handler
app.Mount("/legacy", existingHandler)

// Use any http middleware
app.Use(func(next mizu.Handler) mizu.Handler {
    return func(c *mizu.Ctx) error {
        // Wrap existing middleware
        existingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            next(&mizu.Ctx{...})
        })).ServeHTTP(c.Writer(), c.Request())
        return nil
    }
})

// Access standard types
func handler(c *mizu.Ctx) error {
    r := c.Request()   // *http.Request
    w := c.Writer()    // http.ResponseWriter
    return nil
}

// Each request is independent
func handler(c *mizu.Ctx) error {
    // c is unique to this request
    // Safe to use without locks
    return c.JSON(200, data)
}

import "github.com/go-mizu/mizu/middlewares/websocket"

app.Get("/ws", websocket.New(func(c *websocket.Conn) {
    for {
        msg, _ := c.ReadMessage()
        c.WriteMessage(msg)
    }
}))

import "database/sql"
import _ "github.com/lib/pq"

func main() {
    db, _ := sql.Open("postgres", "...")

    app := mizu.New()
    app.Get("/users", func(c *mizu.Ctx) error {
        rows, _ := db.QueryContext(c.Context(), "SELECT ...")
        // ...
    })
}

import "github.com/go-mizu/mizu/middlewares/jwt"

app.Use(jwt.New(jwt.Config{
    Secret: []byte("your-secret"),
}))

import "github.com/99designs/gqlgen/graphql/handler"

h := handler.NewDefaultServer(schema)
app.Mount("/graphql", h)

mizu dev

go install github.com/cosmtrek/air@latest
air

func TestHandler(t *testing.T) {
    app := mizu.New()
    app.Get("/users", listUsers)

    req := httptest.NewRequest("GET", "/users", nil)
    rec := httptest.NewRecorder()

    app.ServeHTTP(rec, req)

    if rec.Code != 200 {
        t.Errorf("expected 200, got %d", rec.Code)
    }
}

app := mizu.New()
app.Use(logger.New(logger.Config{
    Level: slog.LevelDebug,
}))

import "github.com/go-mizu/mizu/middlewares/bodydump"

app.Use(bodydump.New())

FROM golang:1.22 AS builder
WORKDIR /app
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o server ./cmd/server

FROM alpine:3.19
COPY --from=builder /app/server /server
EXPOSE 3000
CMD ["/server"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 3000
        livenessProbe:
          httpGet:
            path: /livez
            port: 3000
        readinessProbe:
          httpGet:
            path: /readyz
            port: 3000

// These conflict:
app.Get("/users/{id}", getUser)
app.Get("/users/{name}", getUserByName)  // Error!

// Fix: Use different paths or query params
app.Get("/users/{id}", getUser)
app.Get("/users", func(c *mizu.Ctx) error {
    if name := c.Query("name"); name != "" {
        return getUserByName(c)
    }
    return listUsers(c)
})

func handler(c *mizu.Ctx) error {
    ctx := c.Context()

    result, err := longOperation(ctx)
    if err != nil {
        if errors.Is(err, context.Canceled) {
            // Client disconnected - just return
            return nil
        }
        return err
    }
    return c.JSON(200, result)
}

// Middleware is applied to routes AFTER it's added
app.Get("/public", publicHandler)  // No auth!

app.Use(authMiddleware)

app.Get("/private", privateHandler)  // Has auth

// Wrong
func handler(c *mizu.Ctx) error {
    c.JSON(200, data1)
    return c.JSON(200, data2)  // Error!
}

// Right
func handler(c *mizu.Ctx) error {
    return c.JSON(200, data)
}