go-jwt-auth

KO | EN

gitlite — search

#java #php #python #android #dotfiles #html #javascript #ruby #cpp #swift #symfony #mongodb

★ 103 Open GitHub ↗

Template create for use as CookieCutter for my Golang projects, I decided to create a template with everything already working. 🚀

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Go JWT Auth (Fiber & Mongo)

Template create for use as CookieCutter for my Golang projects. 
The hardest part for start a project for me was to chose Stack and create the initial login and integrations
like logger, database, etc. So I decided to create a template with everything already working.

All the project is based in interfaces that mean you can implement your own logic and use it in the project.
example: you can use different database like Postgres, MySQL, etc. Just implement the interface and use it.

## Stack
- Router: [Fiber 🚀](https://gofiber.io)
- Database: [Mongo 💾](https://www.mongodb.com/docs/drivers/go/current/) 
- Doc: [Swagger 📄](https://github.com/swaggo/swag)
- Logger: [Zap ⚡](https://github.com/uber-go/zap)
- Mocks: [gomock 💀](https://github.com/uber-go/mock)
- Deploy: [Docker 🐳](https://www.docker.com)
- CI: [Github Actions 🐙](https://docs.github.com/en/actions)

## Before the execution
- Modify the file `./config/env.json` with your parameters
- Install gomock `go install go.uber.org/mock/mockgen@latest`
- Install swag `go install github.com/swaggo/swag/cmd/swag@latest`

## Routes
You can also check in the route /swagger/index.html after run the project 🤩.

Note 📝: For add a private route you need to create it in the private router `v1Private`
inside the pkg/server/server.go file.

| Name          | Path             | Method | Description          | Request        | Response |
|---------------|------------------|--------|----------------------|----------------|----------|
| Register      | /api/v1/register | POST   | Create a new user    | email,password |          |
| Login         | /api/v1/login    | POST   | Login a user         | email,password | token    |
| Metrics       | /metrics         | GET    | Monitor for your API |                | html     |
| Documentation | /docs            | GET    | Documentation        |                | html     |

## How to use
For this example we will make suppose that you want to create endpoints for Blog Posts.
1. Create a new folder inside the internal folder with the name of your entity. In this case `post`.
2. Create tree folders inside the entity folder: `application`, `domain` and `infrastructure`.
3. Create two folders inside the domain folder: `ports` and `model`.
4. Create a file inside the model folder with the name of your entity. In this case `post.go` and define your struct `Post`.
    ```go
    package model
   
   import "time"

type Post struct {
        ID        string `json:"id" bson:"_id"`
        Title     string             `json:"title" bson:"title"`
        Content   string             `json:"content" bson:"content"`
        CreatedAt time.Time          `json:"created_at" bson:"created_at"`
        UpdatedAt time.Time          `json:"updated_at" bson:"updated_at"`
    }
    ```

5. Create 3 files inside the ports folder: `repository.go`, `handlers.go` and `application.go`.
6. Define your interfaces inside the `repository.go`,`handlers.go` and `application.go` file.
   ```go
   package ports
   
   import "github.com/your_user/your_project/internal/post/domain/model"
   
   type PostRepository interface {
        Create(post *model.Post) error
        FindAll() ([]*model.Post, error)
        FindByID(id string) (*model.Post, error)
        Update(post *model.Post) error
        Delete(id string) error
    }
    ```
7. Modify the `scripts/generate-mocks.sh` file and add your three new interfaces.
   ```sh
   mockgen -destination=pkg/mocks/mock_post_application.go -package=mocks --build_flags=--mod=mod github.com/solrac97gr/go-jwt-auth/internal/post/domain/ports PostApplication &&
   mockgen -destination=pkg/mocks/mock_post_repository.go -package=mocks --build_flags=--mod=mod github.com/solrac97gr/go-jwt-auth/internal/post/domain/ports PostRepository &&
   mockgen -destination=pkg/mocks/mock_post_handlers.go -package=mocks --build_flags=--mod=mod github.com/solrac97gr/go-jwt-auth/internal/post/domain/ports PostHandlers
   ```
8. Run the `scripts/generate-mocks.sh` file.
9. Now is time for implement your interfaces. Create two folders inside the `infrastructure` folder with the name of `repositories` and `handlers`.
10. Create a file inside the `repositories` folder with the name of your interface implementation. In this case `mongo.go` and implement the `PostRepository` interface.
   ```go
    package repositories

type MongoPostRepository struct {
        db *mongo.Database
        logger logger.LoggerApplication
        configurator config.ConfigApplication
    }
    
    func NewMongoPostRepository(db *mongo.Database) *MongoPostRepository {
        return &MongoPostRepository{db: db}
    }

func (m *MongoPostRepository) Create(post *model.Post) error {
        _, err := m.db.Collection("posts").InsertOne(context.Background(), post)
        if err != nil {
			m.logger.Error("Error creating post", err)
            return err
        }
        return nil
    }
    .
    .
    .
   ```
11. Create a file inside the `handlers` folder with the name of your interface implementation. In this case `http.go` and implement the `PostHandler` interface.
   ```go
   package handlers

type HTTPPostHandler struct {
        postApplication ports.PostApplication
        logger logger.LoggerApplication
        validator validator.ValidatorApplication
    }
    
    func NewHTTPPostHandler(postApplication ports.PostApplication) *HTTPPostHandler {
        return &HTTPPostHandler{postApplication: postApplication}
    }

func (h *HTTPPostHandler) CreatePost(c *fiber.Ctx) error {
        post := &model.Post{}
        if err := c.BodyParser(post); err != nil {
            h.logger.Error("Error parsing post", err)
            return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
        }
        if err := h.postApplication.Create(post); err != nil {
            h.logger.Error("Error creating post", err)
            return c.Status(http.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
        }
        return c.Status(http.StatusCreated).JSON(fiber.Map{"message": "Post created successfully"})
    }
    .
    .
    .
   ```
12. Add your handlers to new routes depends on if it's public or private. In this case we will add it to the private routes in file `pkg/server/server.go` .
   ```go
   v1Private.Post("/posts", h.postHandler.CreatePost)
   ```
13. If you want to add it to the swagger documentation view use comment with special annotation for your handlers.
   ```go
   // @Summary Create a new post
   // @Description Create a new post
   // @Tags posts
   // @Accept json
   // @Produce json
   // @Param post body model.Post true "Post"
   // @Success 201 {object} fiber.Map
   // @Failure 400 {object} fiber.Map
   // @Failure 500 {object} fiber.Map
   // @Router /posts [post]
   func (h *HTTPPostHandler) CreatePost(c *fiber.Ctx) error {
        .
        .
        .
   }
   ```
14. Generate the swagger documentation with the command `/scripts/generate-docs.sh`.
15. Run the project with the command `go run cmd/http/main.go` or with the script `scripts/run.sh`.

## Considerations
- The `scripts/generate-mocks.sh` file is used to generate the mocks of the interfaces.
- The `scripts/generate-docs.sh` file is used to generate the swagger documentation.
- The `scripts/run.sh` file is used to run the project.
- The `scripts/run-tests.sh` file is used to run the tests.
- The `scripts/run-tests-coverage.sh` file is used to run the tests with coverage.
- For avoid create users with same mail, make the mail field unique in the database (mongo index in this case).

## License
[Apache License 2.0]()

go-jwt-auth

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README