updated

Author: wpcodevo

.air.toml

@@ -0,0 +1,36 @@
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+  bin = "tmp\\main.exe"
+  cmd = "go build -o ./tmp/main.exe ./cmd/server/main.go"
+  delay = 1000
+  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
+  exclude_file = []
+  exclude_regex = ["_test.go"]
+  exclude_unchanged = false
+  follow_symlink = false
+  full_bin = ""
+  include_dir = []
+  include_ext = ["go", "tpl", "tmpl", "html"]
+  kill_delay = "0s"
+  log = "build-errors.log"
+  send_interrupt = false
+  stop_on_error = true
+
+[color]
+  app = ""
+  build = "yellow"
+  main = "magenta"
+  runner = "green"
+  watcher = "cyan"
+
+[log]
+  time = false
+
+[misc]
+  clean_on_exit = false
+
+[screen]
+  clear_on_rebuild = false

Makefile

@@ -1,13 +1,16 @@
-.PHONY: dev dev-down go proto
+.PHONY: dev dev-down proto server-go client-go
 
 dev:
 	docker-compose up -d
 
 dev-down:
 	docker-compose down
 
-go:
-	air
+server-go:
+	air cmd/server/main.go
+
+client-go:
+	go run cmd/client/main.go
 
 proto:
 	protoc --proto_path=proto --go_out=pb --go_opt=paths=source_relative \

client/geMe_client.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/wpcodevo/golang-mongodb/pb"
+	"google.golang.org/grpc"
+)
+
+type GetMeClient struct {
+	service pb.UserServiceClient
+}
+
+func NewGetMeClient(conn *grpc.ClientConn) *GetMeClient {
+	service := pb.NewUserServiceClient(conn)
+
+	return &GetMeClient{service}
+}
+
+func (getMeClient *GetMeClient) GetMeUser(credentials *pb.GetMeRequest) {
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*5000))
+	defer cancel()
+
+	res, err := getMeClient.service.GetMe(ctx, credentials)
+
+	if err != nil {
+		log.Fatalf("GeMe: %v", err)
+	}
+
+	fmt.Println(res)
+}

client/main.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/wpcodevo/golang-mongodb/pb"
+	"google.golang.org/grpc"
+)
+
+type SignUpUserClient struct {
+	service pb.AuthServiceClient
+}
+
+func NewSignUpUserClient(conn *grpc.ClientConn) *SignUpUserClient {
+	service := pb.NewAuthServiceClient(conn)
+
+	return &SignUpUserClient{service}
+}
+
+func (signUpUserClient *SignUpUserClient) SignUpUser(credentials *pb.SignUpUserInput) {
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*5000))
+	defer cancel()
+
+	res, err := signUpUserClient.service.SignUpUser(ctx, credentials)
+
+	if err != nil {
+		log.Fatalf("SignUpUser: %v", err)
+	}
+
+	fmt.Println(res)
+}

client/signup_client.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"log"
+
+	"github.com/wpcodevo/golang-mongodb/client"
+	"github.com/wpcodevo/golang-mongodb/pb"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+const (
+	address = "0.0.0.0:8080"
+)
+
+func main() {
+	conn, err := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock())
+
+	if err != nil {
+		log.Fatalf("failed to connect: %v", err)
+	}
+
+	defer conn.Close()
+
+	if false {
+		signUpUserClient := client.NewSignUpUserClient(conn)
+		newUser := &pb.SignUpUserInput{
+			Name:            "Micheal Smith",
+			Email:           "[email protected]",
+			Password:        "password123",
+			PasswordConfirm: "password123",
+		}
+		signUpUserClient.SignUpUser(newUser)
+	}
+
+	getMeClient := client.NewGetMeClient(conn)
+	id := &pb.GetMeRequest{
+		Id: "628cffb91e50302d360c1a2c",
+	}
+	getMeClient.GetMeUser(id)
+
+}

cmd/client/main.go

@@ -103,14 +103,31 @@ func main() {
 	startGrpcServer(config)
 }
 
+func allowedRoles() map[string][]string {
+	const userServicePath = "/pb.UserService/"
+	return map[string][]string{
+		userServicePath + "GetMe": {"user"},
+	}
+}
+
 func startGrpcServer(config config.Config) {
-	server, err := gapi.NewGrpcServer(config, authService, userService, authCollection)
+	authServer, err := gapi.NewGrpcAuthServer(config, authService, userService, authCollection)
 	if err != nil {
-		log.Fatal("cannot create grpc server: ", err)
+		log.Fatal("cannot create grpc authServer: ", err)
 	}
 
-	grpcServer := grpc.NewServer()
-	pb.RegisterAuthServiceServer(grpcServer, server)
+	userServer, err := gapi.NewGrpcUserServer(config, userService, authCollection)
+	if err != nil {
+		log.Fatal("cannot create grpc userServer: ", err)
+	}
+
+	interceptor := services.NewAuthInterceptor(allowedRoles(), &config, userService)
+	grpcServer := grpc.NewServer(
+		grpc.UnaryInterceptor(interceptor.Unary()),
+	)
+
+	pb.RegisterAuthServiceServer(grpcServer, authServer)
+	pb.RegisterUserServiceServer(grpcServer, userServer)
 	reflection.Register(grpcServer)
 
 	listener, err := net.Listen("tcp", config.GrpcServerAddress)

main.go renamed to cmd/server/main.go

@@ -7,23 +7,23 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
-type Server struct {
+type AuthServer struct {
 	pb.UnimplementedAuthServiceServer
 	config         config.Config
 	authService    services.AuthService
 	userService    services.UserService
 	userCollection *mongo.Collection
 }
 
-func NewGrpcServer(config config.Config, authService services.AuthService,
-	userService services.UserService, userCollection *mongo.Collection) (*Server, error) {
+func NewGrpcAuthServer(config config.Config, authService services.AuthService,
+	userService services.UserService, userCollection *mongo.Collection) (*AuthServer, error) {
 
-	server := &Server{
+	authServer := &AuthServer{
 		config:         config,
 		authService:    authService,
 		userService:    userService,
 		userCollection: userCollection,
 	}
 
-	return server, nil
+	return authServer, nil
 }

gapi/server.go renamed to gapi/auth-server.go

@@ -0,0 +1,31 @@
+package gapi
+
+import (
+	"context"
+
+	"github.com/wpcodevo/golang-mongodb/pb"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func (userServer *UserServer) GetMe(ctx context.Context, req *pb.GetMeRequest) (*pb.UserResponse, error) {
+	id := req.GetId()
+	user, err := userServer.userService.FindUserById(id)
+
+	if err != nil {
+		return nil, status.Errorf(codes.Unimplemented, err.Error())
+	}
+
+	res := &pb.UserResponse{
+		User: &pb.User{
+			Id:        user.ID.Hex(),
+			Name:      user.Name,
+			Email:     user.Email,
+			Role:      user.Role,
+			CreatedAt: timestamppb.New(user.CreatedAt),
+			UpdatedAt: timestamppb.New(user.UpdatedAt),
+		},
+	}
+	return res, nil
+}

gapi/get_me.go

@@ -10,8 +10,8 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func (server *Server) SignInUser(ctx context.Context, req *pb.SignInUserInput) (*pb.SignInUserResponse, error) {
-	user, err := server.userService.FindUserByEmail(req.GetEmail())
+func (authServer *AuthServer) SignInUser(ctx context.Context, req *pb.SignInUserInput) (*pb.SignInUserResponse, error) {
+	user, err := authServer.userService.FindUserByEmail(req.GetEmail())
 	if err != nil {
 		if err == mongo.ErrNoDocuments {
 
@@ -36,14 +36,14 @@ func (server *Server) SignInUser(ctx context.Context, req *pb.SignInUserInput) (
 	}
 
 	// Generate Tokens
-	access_token, err := utils.CreateToken(server.config.AccessTokenExpiresIn, user.ID, server.config.AccessTokenPrivateKey)
+	access_token, err := utils.CreateToken(authServer.config.AccessTokenExpiresIn, user.ID, authServer.config.AccessTokenPrivateKey)
 	if err != nil {
 
 		return nil, status.Errorf(codes.PermissionDenied, err.Error())
 
 	}
 
-	refresh_token, err := utils.CreateToken(server.config.RefreshTokenExpiresIn, user.ID, server.config.RefreshTokenPrivateKey)
+	refresh_token, err := utils.CreateToken(authServer.config.RefreshTokenExpiresIn, user.ID, authServer.config.RefreshTokenPrivateKey)
 	if err != nil {
 		return nil, status.Errorf(codes.PermissionDenied, err.Error())
 	}

gapi/rpc_signin_user.go

@@ -12,7 +12,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func (server *Server) SignUpUser(ctx context.Context, req *pb.SignUpUserInput) (*pb.GenericResponse, error) {
+func (authServer *AuthServer) SignUpUser(ctx context.Context, req *pb.SignUpUserInput) (*pb.GenericResponse, error) {
 	if req.GetPassword() != req.GetPasswordConfirm() {
 		return nil, status.Errorf(codes.InvalidArgument, "passwords do not match")
 	}
@@ -24,7 +24,7 @@ func (server *Server) SignUpUser(ctx context.Context, req *pb.SignUpUserInput) (
 		PasswordConfirm: req.GetPasswordConfirm(),
 	}
 
-	newUser, err := server.authService.SignUpUser(&user)
+	newUser, err := authServer.authService.SignUpUser(&user)
 
 	if err != nil {
 		if strings.Contains(err.Error(), "email already exist") {
@@ -40,7 +40,7 @@ func (server *Server) SignUpUser(ctx context.Context, req *pb.SignUpUserInput) (
 	verificationCode := utils.Encode(code)
 
 	// Update User in Database
-	server.userService.UpdateUserById(newUser.ID.Hex(), "verificationCode", verificationCode)
+	authServer.userService.UpdateUserById(newUser.ID.Hex(), "verificationCode", verificationCode)
 
 	var firstName = newUser.Name
 
@@ -50,7 +50,7 @@ func (server *Server) SignUpUser(ctx context.Context, req *pb.SignUpUserInput) (
 
 	// 👇 Send Email
 	emailData := utils.EmailData{
-		URL:       server.config.Origin + "/verifyemail/" + code,
+		URL:       authServer.config.Origin + "/verifyemail/" + code,
 		FirstName: firstName,
 		Subject:   "Your account verification code",
 	}

gapi/rpc_signup_user.go

@@ -11,14 +11,14 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func (server *Server) VerifyEmail(ctx context.Context, req *pb.VerifyEmailRequest) (*pb.GenericResponse, error) {
+func (authServer *AuthServer) VerifyEmail(ctx context.Context, req *pb.VerifyEmailRequest) (*pb.GenericResponse, error) {
 	code := req.GetVerificationCode()
 
 	verificationCode := utils.Encode(code)
 
 	query := bson.D{{Key: "verificationCode", Value: verificationCode}}
 	update := bson.D{{Key: "$set", Value: bson.D{{Key: "verified", Value: true}, {Key: "updated_at", Value: time.Now()}}}, {Key: "$unset", Value: bson.D{{Key: "verificationCode", Value: ""}}}}
-	result, err := server.userCollection.UpdateOne(ctx, query, update)
+	result, err := authServer.userCollection.UpdateOne(ctx, query, update)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, err.Error())
 	}