go-backend-tool

Files (1)

• SKILL.md

SKILL.md (first lines)

# Go Backend Development

This skill provides guidance for building robust Go backend services, APIs, and microservices.

## Project Structure

```go
myproject/
├── cmd/
│   ├── server/
│   │   └── main.go
│   └── worker/
│       └── main.go
├── internal/
│   ├── handlers/
│   │   ├── user.go
│   │   └── order.go
│   ├── models/
│   │   ├── user.go
│   │   └── order.go
│   ├── repository/
│   │   ├── user.go
│   │   └── order.go
│   └── service/
│       ├── auth.go
│       └── email.go
├── pkg/
│   ├── database/
│   │   ├── postgres.go
│   │   └── redis.go
│   ├── middleware/
│   │   ├── auth.go
│   │   └── logging.go
│   └── util/
│       ├── validator.go
│       └── jwt.go
├── api/
│   ├── handlers.go
│   ├── routes.go
│   └── middleware.go
├── config/
│   └── config.go
├── migrations/
├── tests/
└── go.mod
```

## Standard Layouts

### 1. HTTP Handlers
```go
package handlers

import (
    "encoding/json"
    "net/http"
)

type UserHandler struct {
    logger Logger
}

func NewUserHandler(logger Logger) *UserHandler {
    return &UserHandler{logger: logger}
}

func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }

    if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        h.logger.Error("Failed to decode request", "handler", "create_user")
        return
    }

    // Validate input
    if input.Name == "" {
        http.Error(w, "Name is required", http.StatusBadRequest)
        return
    }

    // Process user creation
    user, err := h.userService.Create(input.Name, input.Email)
    if err != nil {
        h.logger.Error("Failed to create user", "handler", "create_user", err)
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}
```

### 2. Database Layer
```go
package repository

import (
    "context"
    "database/sql"
)

type UserRepository interface {
    Create(ctx context.Context, name, email string) (*User, error)
    FindByID(ctx context.Context, id int64) (*User, error)
    Update(ctx context.Context, user *User) error
    Delete(ctx context.Context, id int64) error
}

type PostgresUserRepository struct {
    db *sql.DB
}

func NewPostgresUserRepository(db *sql.DB) UserRepository {
    return &PostgresUserRepository{db: db}

From yasinnerten/temporal-openai-agents-sdk, Apache-2.0.

More from yasinnerten/temporal-openai-agents-sdk