import (
    "log"

    "entgo.io/ent/dialect"
    "entgo.io/ent/dialect/sql"
    "entgo.io/ent/dialect/sql/schema"
    "entgo.io/ent/dialect/sql/sqlgraph"
    _ "github.com/jackc/pgx/v4/stdlib"
)

func main() {
    drv, err := sql.Open("pgx", "postgres://user:password@host:port/database")
    if err != nil {
        log.Fatal(err)
    }
    client := sql.NewClient(drv, sql.Dialect(dialect.Postgres))
    defer client.Close()

    // 定义数据库模式
    schema := schema.Make(
        schema.Create(
            schema.Table("users").
                Fields(
                    schema.Field("id", schema.TypeInt).
                        Unique().
                        ID(),
                    schema.Field("name", schema.TypeString),
                    schema.Field("age", schema.TypeInt),
                ),
        ),
    )

    // 将模式转移到数据库
    if err := schemagraph.Migrate(ctx, client, schema); err != nil {
        log.Fatal(err)
    }

    // 生成 Go 代码
    codegen.TargetDir = "path/to/generated/code"
    if err := entc.Generate(ctx, client, codegen.WithSchema(schema)); err != nil {
        log.Fatal(err)
    }
}

import (
    "context"
    "fmt"
    "net/http"

    "github.com/labstack/echo/v4"
)

// User represents a user.
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

// UserRepository is an interface for user repository.
type UserRepository interface {
    GetAll(ctx context.Context) ([]*User, error)
    GetByID(ctx context.Context, id int) (*User, error)
    Create(ctx context.Context, u *User) error
    Update(ctx context.Context, u *User) error
    Delete(ctx context.Context, id int) error
}

// MemoryUserRepository is a memory-based user repository.
type MemoryUserRepository struct {
    users map[int]*User
}

// NewMemoryUserRepository creates a new MemoryUserRepository.
func NewMemoryUserRepository() *MemoryUserRepository {
    return &MemoryUserRepository{
        users: make(map[int]*User),
    }
}

// GetAll returns all users.
func (r *MemoryUserRepository) GetAll(ctx context.Context) ([]*User, error) {
    var users []*User
    for _, u := range r.users {
        users = append(users, u)
    }
    return users, nil
}

// GetByID returns a user by ID.
func (r *MemoryUserRepository) GetByID(ctx context.Context, id int) (*User, error) {
    u, ok := r.users[id]
    if !ok {
        return nil, fmt.Errorf("user not found: %d", id)
    }
    return u, nil
}

// Create creates a new user.
func (r *MemoryUserRepository) Create(ctx context.Context, u *User) error {
    r.users[u.ID] = u
    return nil
}

// Update updates a user.
func (r *MemoryUserRepository) Update(ctx context.Context, u *User) error {
    r.users[u.ID] = u
    return nil
}

// Delete deletes a user by ID.
func (r *MemoryUserRepository) Delete(ctx context.Context, id int) error {
    delete(r.users, id)
    return nil
}

// Main is the main function.
func main() {
    e := echo.New()
    r := NewMemoryUserRepository()

    // GET /users
    e.GET("/users", func(c echo.Context) error {
        users, err := r.GetAll(c.Request().Context())
        if err != nil {
            return c.JSON(http.StatusInternalServerError, err)
        }
        return c.JSON(http.StatusOK, users)
    })

    // GET /users/:id
    e.GET("/users/:id", func(c echo.Context) error {
        id, err := strconv.Atoi(c.Param("id"))
        if err != nil {
            return c.JSON(http.StatusBadRequest, err)
        }
        user, err := r.GetByID(c.Request().Context(), id)
        if err != nil {
            return c.JSON(http.StatusNotFound, err)
        }
        return c.JSON(http.StatusOK, user)
    })

    // POST /users
    e.POST("/users", func(c echo.Context) error {
        u := &User{}
        if err := c.Bind(u); err != nil {
            return c.JSON(http.StatusBadRequest, err)
        }
        if err := r.Create(c.Request().Context(), u); err != nil {
            return c.JSON(http.StatusInternalServerError, err)
        }
        return c.JSON(http.StatusCreated, u)
    })