CRUD para Posts

Clase 18 de 26 • Curso de Go Avanzado: REST y WebSockets

Carlos Nexans

student•

Para reutilizar los métodos de firmar y decodificar tokens cree un struct que tiene estos métodos. Se inyecta como dependencia en los handlers y middlewares. Por ahora solo contemplo el método HS256 y se puede mejorar para que contemple RS256.

package server

import (
	"fmt"
	"github.com/golang-jwt/jwt"
	"go-rest-websockets/1-http-rest-server/models"
	"time"
)

type Authorization struct{}

func NewAuthorization() Authorization {
	return Authorization{}
}

func (a Authorization) SignToken(secretKey string, userId string) (string, error) {
	claims := models.AppClaims{
		StandardClaims: jwt.StandardClaims{
			ExpiresAt: time.Now().Add(time.Hour).Unix(),
		},
		UserId: userId,
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString([]byte(secretKey))
}

func (a Authorization) ParseAndVerifyToken(secretKey string, tokenString string) (*models.AppClaims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(secretKey), nil
	})
	if err != nil {
		return nil, err
	}
	claims, ok := token.Claims.(*models.AppClaims)

	if !ok || !token.Valid {
		return nil, fmt.Errorf("token is not valid")
	}

	return claims, nil
}

Àlex Grau Roca

student•

En GetPostById hace falta un elemento importante, que es el de validar que el post con ese id exista. Si se deja tal y como está, se devuelve un 200 con un post con valores por defecto, pero esto es incorrecto, ya que la respuesta correcta debería de ser un 404 Not found.

func GetPostByIdHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		params := mux.Vars(r)
		post, err := repository.GetPostById(r.Context(), params["id"])

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if len(post.Id) == 0 {
			http.Error(w, "post not found", http.StatusNotFound)
			return
		}

		helpers.HttpJsonResponse(w, post)
	}
}

Esto mismo aplica también a los getters de usuario. Hay algunas funciones especiales que las he creado yo para no tener que ir repitiendo todo el rato el mismo código (como añadir el content-type json)

Mauro Muñoz

student•

Para chequear si el post a actualizar existe, sin hacer un SELECT, pueden escribir algo como:

// database/postgres.go
func (repo *PostgresRepository) UpdatePost(ctx context.Context, post *models.Post) error {
     res, err := repo.db.ExecContext(ctx, 
          "UPDATE posts SET post_content = $1 WHERE id = $2 AND user_id = $3",
          post.PostContent,
          post.Id,
          post.UserId)
      if err != nil {
          return err
      }
      // `n` es el numero de filas afectadas. 
      n, err := res.RowsAffected()
      if err != nil {
          return err
      }
      // Si `n` es 0, significa que no actualizamos nada
      if n == 0 {
         // Acá pueden retornar cualquier error, 
         // para después controlar qué hacer en handlers/post.go
          return sql.ErrNoRows
      }
      return nil
  }

// handlers/post.go
var PostNotFound = errors.New("post not found")
func UpdatePostHandler(s server.Server) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
       // ...
       if err = repository.UpdatePost(r.Context(), &post); err != nil {
          // Chequeamos cuál error retornó
           if errors.Is(err, sql.ErrNoRows) {
               // En este caso, es el error que nosotros elegimos retornar 
               // Entonces, respondemos con http.StatusNotFound
               helpers.NewResponseError(PostNotFound).Send(w, http.StatusNotFound)
           } else {
               // Y en cualquier otro caso, respondemos con http.StatusInternalServerError
               helpers.NewResponseError(err).Send(w, http.StatusInternalServerError)
           }
            return
        }
       // Si no hubo error, http.StatusOK
       helpers.NewResponse(post).Send(w, http.StatusOK)
   }
 }

Gabriel Calvo Vargas

student•

Hay varios aspectos importantes a destacar:

Es fundamental desacoplar los modelos de los controladores. En otras palabras, el controlador/handler debería tener su propia estructura de datos, en lugar de depender directamente del modelo de la base de datos.
También es crucial validar que los recursos solicitados, como un post, realmente pertenezcan al usuario que realiza la solicitud, para garantizar la seguridad y consistencia de la aplicación.

Diego Posada

student•

Alguien depronto sabe, ¿Por qué me permite utilizar el endpoint de GET /posts/{id} sin tener token en el header de authorization cuando tengo esta parametrización?

var ( NO_AUTH_NEEDED = []string{ "login", "signup", "/", } )

Es decir me retorna información en el response sin estar autenticado y sin tener excluída este endpoint en NO_AUTH_NEEDED

{ "id": "2BvAS8AXkpT5SHWuPQ6TzKEm0dG", "post_content": "Forest rains", "created_at": "2022-07-14T05:23:01.412645Z", "user_id": "2Bs5iGzSBX1LfiNdnIPzGwhZJik" }

Muchas gracias.

Alejandro Atria

student•

Esto es porque pusiste "/" en los NO_AUTH_NEEDED. Es decir, cuando revisa los paths utilizados, cualquiera que tenga un "/" no va a pedir autenticación... como todas las rutas lo tienen, te deja pasar

Carlos Arturo Pimentel

student•

Se podría decir que el patrón de Arquitectura que sigue el proyecto es MVC? En caso afirmativo, El bloque del proyecto encargado de albergar los controladores estaría en los Handlers ??

Diego Posada

student•

Alguien podría explicarme por que no es recomendable devolver tanta data en el mismo Request ??

Obviamente por razones de cantidad de información a mostrar, pero depronto hay algun tema de limite de transferencia de infoprmación en un request o algo así?

Victor Manuel Martin Matey

student•

Estoy pensando meter un CRUD con el stack MERN y que se pueda publicar en el fron una card que se guarde en una collection de mongo db. ¿Como se hace?

Pablo Jesús Rosales Juárez

student•

Podríamos estandarizar las respuestas, mi aporte:

package apiResponse

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

type responseOK struct {
	Status string      `json:"status"`
	Data   interface{} `json:"data"`
}

type responseError struct {
	Status       string   `json:"status"`
	ErrorMessage string   `json:"error_mssg"`
	ErrorData    []string `json:"error_data"`
}

func ResponseOk(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(responseOK{
		Status: "success",
		Data:   data,
	})
}

func ResponseErr(w http.ResponseWriter, status int, errorMssg string, errorData []string) {
	w.Header().Set("ContentType", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(responseError{
		Status:       "error",
		ErrorMessage: errorMssg,
		ErrorData:    errorData,
	})
}

package server

import (
	"fmt"
	"github.com/golang-jwt/jwt"
	"go-rest-websockets/1-http-rest-server/models"
	"time"
)

type Authorization struct{}

func NewAuthorization() Authorization {
	return Authorization{}
}

func (a Authorization) SignToken(secretKey string, userId string) (string, error) {
	claims := models.AppClaims{
		StandardClaims: jwt.StandardClaims{
			ExpiresAt: time.Now().Add(time.Hour).Unix(),
		},
		UserId: userId,
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString([]byte(secretKey))
}

func (a Authorization) ParseAndVerifyToken(secretKey string, tokenString string) (*models.AppClaims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(secretKey), nil
	})
	if err != nil {
		return nil, err
	}
	claims, ok := token.Claims.(*models.AppClaims)

	if !ok || !token.Valid {
		return nil, fmt.Errorf("token is not valid")
	}

	return claims, nil
}

func GetPostByIdHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		params := mux.Vars(r)
		post, err := repository.GetPostById(r.Context(), params["id"])

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if len(post.Id) == 0 {
			http.Error(w, "post not found", http.StatusNotFound)
			return
		}

		helpers.HttpJsonResponse(w, post)
	}
}

// database/postgres.go
func (repo *PostgresRepository) UpdatePost(ctx context.Context, post *models.Post) error {
     res, err := repo.db.ExecContext(ctx, 
          "UPDATE posts SET post_content = $1 WHERE id = $2 AND user_id = $3",
          post.PostContent,
          post.Id,
          post.UserId)
      if err != nil {
          return err
      }
      // `n` es el numero de filas afectadas. 
      n, err := res.RowsAffected()
      if err != nil {
          return err
      }
      // Si `n` es 0, significa que no actualizamos nada
      if n == 0 {
         // Acá pueden retornar cualquier error, 
         // para después controlar qué hacer en handlers/post.go
          return sql.ErrNoRows
      }
      return nil
  }

// handlers/post.go
var PostNotFound = errors.New("post not found")
func UpdatePostHandler(s server.Server) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
       // ...
       if err = repository.UpdatePost(r.Context(), &post); err != nil {
          // Chequeamos cuál error retornó
           if errors.Is(err, sql.ErrNoRows) {
               // En este caso, es el error que nosotros elegimos retornar 
               // Entonces, respondemos con http.StatusNotFound
               helpers.NewResponseError(PostNotFound).Send(w, http.StatusNotFound)
           } else {
               // Y en cualquier otro caso, respondemos con http.StatusInternalServerError
               helpers.NewResponseError(err).Send(w, http.StatusInternalServerError)
           }
            return
        }
       // Si no hubo error, http.StatusOK
       helpers.NewResponse(post).Send(w, http.StatusOK)
   }
 }

package apiResponse

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

type responseOK struct {
	Status string      `json:"status"`
	Data   interface{} `json:"data"`
}

type responseError struct {
	Status       string   `json:"status"`
	ErrorMessage string   `json:"error_mssg"`
	ErrorData    []string `json:"error_data"`
}

func ResponseOk(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(responseOK{
		Status: "success",
		Data:   data,
	})
}

func ResponseErr(w http.ResponseWriter, status int, errorMssg string, errorData []string) {
	w.Header().Set("ContentType", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(responseError{
		Status:       "error",
		ErrorMessage: errorMssg,
		ErrorData:    errorData,
	})
}

CRUD para Posts

Introducción

Introducción al curso

¿Qué estaremos construyendo?

HTTP y REST

CRUD

REST

Inicialización de módulo e instalación de dependencias

Struct Server

Nuestro primer endpoint

Definiendo el modelo de usuarios

Patrón repository

Registro de usuarios

Implementando el registro

Probando los registros

Autenticación de usuarios

Probando el login

Middleware de validación de autenticación

Implementando el middleware

Modelo Posts

CRUD para Posts

Paginación para Posts

WebSockets

Websockets

Upgrader y Endpoint para Websocket

Struct de Hub para conexiones

Implementando el Broadcast

Cierre

Ejemplo de implementación frontend

Docker file para producción

Siguientes pasos y mejoras