feat: complete getting my user and users with token

services/auth/internal/network/grpc/server.go

@@ -49,10 +49,10 @@ func (s *grpcServer) TokenMetadata(ctx context.Context, token *contracts.TokenCo
 		return nil, err
 	}
 
-	_, err = s.cache.GetUserId(accessDetails)
+	userId, err := s.cache.GetUserId(accessDetails)
 	if err != nil {
 		return nil, err
 	}
 
-	return &contracts.TokenMetadataResponse{IsValid: true}, nil
+	return &contracts.TokenMetadataResponse{IsValid: true, Id: userId}, nil
 }

services/user/.env.example

@@ -12,3 +12,5 @@ USER_DATABASE_SCHEMA=
 USER_REST_URL=
 
 USER_GRPC_URL=
+
+AUTH_GRPC_URL=

services/user/cmd/server/main.go

@@ -6,7 +6,8 @@ import (
 	"github.com/mohammadne/bookman/user/config"
 	"github.com/mohammadne/bookman/user/internal/database"
 	"github.com/mohammadne/bookman/user/internal/network"
-	grpc_server "github.com/mohammadne/bookman/user/internal/network/grpc/server"
+	"github.com/mohammadne/bookman/user/internal/network/grpc"
+	grpc_client "github.com/mohammadne/bookman/user/internal/network/grpc/clients"
 	"github.com/mohammadne/bookman/user/internal/network/rest"
 	"github.com/mohammadne/bookman/user/pkg/logger"
 	"github.com/spf13/cobra"
@@ -52,10 +53,13 @@ func main(environment config.Environment) {
 
 	db := database.NewMysqlDatabase(cfg.Database, log)
 
+	authGrpc := grpc_client.NewUser(cfg.GrpcAuth, log)
+	authGrpc.Setup()
+
 	// serving application servers
 	servers := []network.Server{
-		rest.New(cfg.Rest, log, db),
-		grpc_server.New(cfg.Grpc, log, db),
+		rest.New(cfg.Rest, log, db, authGrpc),
+		grpc.NewServer(cfg.GrpcServer, log, db),
 	}
 
 	for _, server := range servers {

services/user/config/config.go

@@ -2,14 +2,15 @@ package config
 
 import (
 	"github.com/mohammadne/bookman/user/internal/database"
-	grpc_server "github.com/mohammadne/bookman/user/internal/network/grpc/server"
+	"github.com/mohammadne/bookman/user/internal/network/grpc"
 	"github.com/mohammadne/bookman/user/internal/network/rest"
 	"github.com/mohammadne/bookman/user/pkg/logger"
 )
 
 type Config struct {
-	Logger   *logger.Config
-	Database *database.Config
-	Rest     *rest.Config
-	Grpc     *grpc_server.Config
+	Logger     *logger.Config
+	Database   *database.Config
+	Rest       *rest.Config
+	GrpcServer *grpc.Config
+	GrpcAuth   *grpc.Config
 }

services/user/config/load.go

@@ -4,7 +4,7 @@ import (
 	"github.com/joho/godotenv"
 	"github.com/kelseyhightower/envconfig"
 	"github.com/mohammadne/bookman/user/internal/database"
-	grpc_server "github.com/mohammadne/bookman/user/internal/network/grpc/server"
+	"github.com/mohammadne/bookman/user/internal/network/grpc"
 	"github.com/mohammadne/bookman/user/internal/network/rest"
 	"github.com/mohammadne/bookman/user/pkg/logger"
 )
@@ -23,14 +23,16 @@ func Load(env Environment) *Config {
 	cfg.Logger = &logger.Config{}
 	cfg.Database = &database.Config{}
 	cfg.Rest = &rest.Config{}
-	cfg.Grpc = &grpc_server.Config{}
+	cfg.GrpcServer = &grpc.Config{}
+	cfg.GrpcAuth = &grpc.Config{}
 
 	// process
 	envconfig.MustProcess("user", cfg)
 	envconfig.MustProcess("user_logger", cfg.Logger)
 	envconfig.MustProcess("user_database", cfg.Database)
 	envconfig.MustProcess("user_rest", cfg.Rest)
-	envconfig.MustProcess("user_grpc", cfg.Grpc)
+	envconfig.MustProcess("user_grpc", cfg.GrpcServer)
+	envconfig.MustProcess("auth_grpc", cfg.GrpcAuth)
 
 	return cfg
 }

services/user/internal/models/user.go

@@ -1,7 +1,5 @@
 package models
 
-import "encoding/json"
-
 type User struct {
 	Id          uint64 `json:"id"`
 	FirstName   string `json:"first_name"`
@@ -11,13 +9,12 @@ type User struct {
 	DateCreated string `json:"date_created,omitempty"`
 }
 
-func (user *User) Marshall(isPublic bool) interface{} {
+func (user *User) Marshall(isPublic bool) *User {
 	user.Password = ""
 	if isPublic {
 		user.Email = ""
 		user.DateCreated = ""
 	}
 
-	userJson, _ := json.Marshal(user)
-	return userJson
+	return user
 }

services/user/internal/network/grpc/clients/auth.go

@@ -0,0 +1,61 @@
+package grpc_clients
+
+import (
+	context "context"
+
+	"github.com/mohammadne/bookman/user/internal/network/grpc/contracts"
+
+	"github.com/mohammadne/bookman/user/internal/network/grpc"
+	"github.com/mohammadne/go-pkgs/failures"
+	"github.com/mohammadne/go-pkgs/logger"
+	grpcPkg "google.golang.org/grpc"
+)
+
+type Auth interface {
+	GetTokenMetadata(string) (uint64, failures.Failure)
+}
+
+type authClient struct {
+	logger logger.Logger
+	config *grpc.Config
+
+	client contracts.AuthClient
+}
+
+func NewUser(cfg *grpc.Config, log logger.Logger) *authClient {
+	return &authClient{config: cfg, logger: log}
+}
+
+func (g *authClient) Setup() {
+	authConnection, err := grpcPkg.Dial(g.config.Url, grpcPkg.WithInsecure())
+	if err != nil {
+		g.logger.Fatal(
+			"error getting auth grpc connection",
+			logger.String("address", g.config.Url),
+			logger.Error(err),
+		)
+	}
+
+	g.client = contracts.NewAuthClient(authConnection)
+}
+
+var (
+	errGettingToken = failures.Rest{}.NewInternalServer("error getting token metadata")
+	invalidToken    = failures.Rest{}.NewInternalServer("invalid token")
+)
+
+func (g *authClient) GetTokenMetadata(token string) (uint64, failures.Failure) {
+	contract := &contracts.TokenContract{Token: token}
+	response, err := g.client.TokenMetadata(context.Background(), contract)
+	if err != nil {
+		g.logger.Error("grpc get token metadata", logger.Error(err))
+		return 0, errGettingToken
+	}
+
+	if !response.IsValid {
+		g.logger.Error("not valid token metadata", logger.Error(err))
+		return 0, invalidToken
+	}
+
+	return response.Id, nil
+}

services/user/internal/network/grpc/config.go

@@ -0,0 +1,5 @@
+package grpc
+
+type Config struct {
+	Url string
+}

services/user/internal/network/grpc/server/server.go → services/user/internal/network/grpc/server.go

@@ -9,7 +9,7 @@ import (
 	"github.com/mohammadne/bookman/user/internal/network/grpc/contracts"
 	"github.com/mohammadne/go-pkgs/failures"
 	"github.com/mohammadne/go-pkgs/logger"
-	grpc "google.golang.org/grpc"
+	"google.golang.org/grpc"
 )
 
 type grpcServer struct {
@@ -23,7 +23,7 @@ type grpcServer struct {
 	contracts.UnimplementedUserServer
 }
 
-func New(cfg *Config, log logger.Logger, db database.Database) *grpcServer {
+func NewServer(cfg *Config, log logger.Logger, db database.Database) *grpcServer {
 	s := &grpcServer{config: cfg, logger: log, database: db}
 
 	s.server = grpc.NewServer()
@@ -33,7 +33,7 @@ func New(cfg *Config, log logger.Logger, db database.Database) *grpcServer {
 }
 
 func (s *grpcServer) Serve(<-chan struct{}) {
-	listener, err := net.Listen("tcp", s.config.URL)
+	listener, err := net.Listen("tcp", s.config.Url)
 	if err != nil {
 		panic(err)
 	}

services/user/internal/network/rest/handlers.go

@@ -5,34 +5,49 @@ import (
 	"strconv"
 
 	"github.com/labstack/echo/v4"
+	"github.com/mohammadne/bookman/user/internal/models"
+	"github.com/mohammadne/go-pkgs/failures"
+	"github.com/mohammadne/go-pkgs/logger"
 )
 
 // get is responsible to provide HTTP Get Location functionality
 func (rest *restEcho) getUser(ctx echo.Context) error {
-	idStr := ctx.Param("id")
-	if idStr == "" {
-		rest.logger.Error("user id is nil")
-		return ctx.String(http.StatusBadRequest, "bad request")
+	user, failure := rest.getUserByIdString(ctx.Param("id"))
+	if failure != nil {
+		return ctx.JSON(failure.Status(), failure)
 	}
 
-	id, parseErr := strconv.ParseInt(idStr, 10, 64)
-	if parseErr != nil {
-		rest.logger.Error("user id is malformed")
-		return ctx.String(http.StatusBadRequest, "bad request")
-	}
+	return ctx.JSON(http.StatusOK, user.Marshall(true))
+}
 
-	user, readErr := rest.database.FindUserById(id)
-	if readErr != nil {
-		return ctx.JSON(readErr.Status(), readErr)
+func (rest *restEcho) getMyUser(ctx echo.Context) error {
+	user, failure := rest.getUserByIdString(ctx.Get("token_user_id").(string))
+	if failure != nil {
+		rest.logger.Error(failure.Message(), logger.Error(failure))
+		return ctx.JSON(failure.Status(), failure)
 	}
 
 	return ctx.JSON(http.StatusOK, user.Marshall(false))
 }
 
-func (rest *restEcho) getMyUser(ctx echo.Context) error {
+func (rest *restEcho) searchUsers(ctx echo.Context) error {
 	return nil
 }
 
-func (rest *restEcho) searchUsers(ctx echo.Context) error {
-	return nil
+func (rest *restEcho) getUserByIdString(idStr string) (*models.User, failures.Failure) {
+	if idStr == "" {
+		return nil, failures.Rest{}.NewBadRequest("invalid user id is given")
+	}
+
+	id, parseErr := strconv.ParseInt(idStr, 10, 64)
+	if parseErr != nil {
+		return nil, failures.Rest{}.NewBadRequest("given user id is malformed")
+	}
+
+	user, failure := rest.database.FindUserById(id)
+	if failure != nil {
+		return nil, failure
+	}
+
+	return user, nil
 }