Capstone: CLI tool + API Go idiomática

shorty/
├── go.mod
├── cmd/
│   ├── shorty/          # API server
│   │   └── main.go
│   └── shortyctl/       # CLI admin
│       └── main.go
├── internal/
│   ├── link/
│   │   ├── link.go       # domain
│   │   ├── service.go
│   │   ├── repo.go       # interface
│   │   └── pg_repo.go    # impl Postgres
│   ├── http/
│   │   ├── handler.go
│   │   └── middleware.go
│   └── config/
│       └── config.go
├── migrations/
│   └── 001_init.sql
├── Dockerfile
└── loadtest/
    └── bench.go

func main() {
    cfg := config.Load()
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

    db, err := sql.Open("pgx", cfg.DatabaseURL)
    if err != nil { logger.Error("db open", "err", err); os.Exit(1) }
    defer db.Close()

    repo := link.NewPGRepo(db)
    svc  := link.NewService(repo)

    r := chi.NewRouter()
    r.Use(middleware.RequestID, middleware.Recoverer, httpmw.Logging(logger))
    r.Mount("/api/v1", httpapi.Routes(svc))
    r.Handle("/metrics", promhttp.Handler())
    r.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(200) })

    srv := &http.Server{
        Addr: cfg.Addr, Handler: r,
        ReadHeaderTimeout: 5*time.Second,
        WriteTimeout:     10*time.Second,
    }

    ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    go func() {
        logger.Info("listening", "addr", cfg.Addr)
        if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
            logger.Error("listen", "err", err)
        }
    }()

    <-ctx.Done()
    logger.Info("shutting down")
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    if err := srv.Shutdown(shutdownCtx); err != nil {
        logger.Error("shutdown", "err", err)
    }
}

var rootCmd = &cobra.Command{Use: "shortyctl"}

var createCmd = &cobra.Command{
    Use: "create <url>",
    Args: cobra.ExactArgs(1),
    RunE: func(cmd *cobra.Command, args []string) error {
        body, _ := json.Marshal(map[string]string{"url": args[0]})
        resp, err := http.Post(apiURL+"/api/v1/links", "application/json", bytes.NewReader(body))
        if err != nil { return err }
        defer resp.Body.Close()
        _, err = io.Copy(os.Stdout, resp.Body)
        return err
    },
}

func main() {
    rootCmd.AddCommand(createCmd)
    if err := rootCmd.Execute(); err != nil { os.Exit(1) }
}

FROM golang:1.23-alpine AS build
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /out/shorty ./cmd/shorty

FROM gcr.io/distroless/static
COPY --from=build /out/shorty /shorty
EXPOSE 8080
ENTRYPOINT ["/shorty"]

func TestCreateAndResolve(t *testing.T) {
    ctx := context.Background()
    pg, err := postgres.Run(ctx, "postgres:16-alpine")
    if err != nil { t.Fatal(err) }
    defer pg.Terminate(ctx)

    db := openAndMigrate(t, pg)
    repo := link.NewPGRepo(db)
    svc  := link.NewService(repo)

    l, err := svc.Create(ctx, "https://ffv.com")
    if err != nil { t.Fatal(err) }
    got, err := svc.Resolve(ctx, l.Code)
    if err != nil { t.Fatal(err) }
    if got.URL != "https://ffv.com" { t.Fatalf("got %s", got.URL) }
}