Put project modules under pkg directory

pkg/cgnolink/config.go

@@ -0,0 +1,22 @@
+package cgnolink
+
+import (
+	"github.com/knadh/koanf"
+	"github.com/knadh/koanf/providers/env"
+	"strings"
+)
+
+func NewConfig() *koanf.Koanf {
+	config := koanf.New(".")
+
+	loadValues(config)
+
+	return config
+}
+
+func loadValues(c *koanf.Koanf) {
+	envProvider := env.Provider("", ".", func(s string) string {
+		return strings.Replace(strings.ToLower(s), "_", ".", -1)
+	})
+	_ = c.Load(envProvider, nil)
+}

pkg/cgnolink/database/database.go

@@ -0,0 +1,65 @@
+package database
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"github.com/knadh/koanf"
+	"github.com/rs/zerolog/log"
+	"time"
+)
+
+func InitPool(config *koanf.Koanf) *pgxpool.Pool {
+	pool := NewPool(config)
+
+	if err := runMigrations(pool); err != nil {
+		log.Fatal().Err(err).Msg("Couldn't apply migrations")
+		panic(err)
+	}
+
+	return pool
+}
+
+func NewPool(config *koanf.Koanf) *pgxpool.Pool {
+	connStr, err := getConnectionString(config)
+	if err != nil {
+		log.Fatal().Err(err).Msg("Couldn't construct DB connection string")
+		panic(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	pool, err := pgxpool.Connect(ctx, connStr)
+	if err != nil {
+		log.Fatal().Err(err).Msg("Couldn't connect to DB")
+		panic(err)
+	}
+
+	return pool
+}
+
+func getConnectionString(config *koanf.Koanf) (string, error) {
+	username := config.String("db.username")
+	if username == "" {
+		return "", errors.New("database username is missing")
+	}
+
+	password := config.String("db.password")
+	if password == "" {
+		return "", errors.New("database password is missing")
+	}
+
+	name := config.String("db.name")
+	if name == "" {
+		return "", errors.New("database name is missing")
+	}
+
+	host := config.String("db.host")
+	if name == "" {
+		return "", errors.New("database host is missing")
+	}
+
+	return fmt.Sprintf("postgresql://%s:%s@%s/%s", username, password, host, name), nil
+}

pkg/cgnolink/database/migrate.go

@@ -0,0 +1,33 @@
+package database
+
+import (
+	"context"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"github.com/jackc/tern/migrate"
+	"time"
+)
+
+func runMigrations(pool *pgxpool.Pool) (err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	conn, err := pool.Acquire(ctx)
+	if err != nil {
+		return
+	}
+
+	migrator, err := migrate.NewMigrator(ctx, conn.Conn(), "schema_version")
+	if err != nil {
+		return
+	}
+
+	if err = migrator.LoadMigrations("./migrations"); err != nil {
+		return
+	}
+
+	if err = migrator.Migrate(ctx); err != nil {
+		return
+	}
+
+	return
+}

pkg/cgnolink/database/util.go

@@ -0,0 +1,15 @@
+package database
+
+import (
+	"github.com/jackc/pgx/v4/pgxpool"
+	"github.com/rs/zerolog/log"
+)
+
+func LogPoolState(pool *pgxpool.Pool, message string) {
+	stat := pool.Stat()
+	log.Info().
+		Int32("acquired_conns", stat.AcquiredConns()).
+		Int32("idle_conns", stat.IdleConns()).
+		Int32("total_conns", stat.TotalConns()).
+		Msg(message)
+}

pkg/cgnolink/errors/errors.go

@@ -0,0 +1,29 @@
+package errors
+
+type UnknownError struct {
+	Err error
+}
+
+func (err UnknownError) Error() string {
+	return err.Err.Error()
+}
+
+func (err UnknownError) Unwrap() error {
+	return err.Err
+}
+
+type NotFoundError struct {
+	Message string
+}
+
+func (err NotFoundError) Error() string {
+	return err.Message
+}
+
+type AlreadyExistsError struct {
+	Message string
+}
+
+func (err AlreadyExistsError) Error() string {
+	return err.Message
+}

pkg/cgnolink/link/dto.go

@@ -0,0 +1,50 @@
+package link
+
+import (
+	"net/url"
+	"time"
+)
+
+type CreationModel struct {
+	Id          string `json:"id"`
+	Name        string `json:"name"`
+	RedirectURL string `json:"redirectUrl"`
+	Password    string `json:"password"`
+}
+
+type ResourceModel struct {
+	Id           string `json:"id"`
+	Name         string `json:"name"`
+	RedirectURL  string `json:"redirectUrl"`
+	CreationTime int64  `json:"creationTime"`
+}
+
+type UpdateModel struct {
+	Name        string `json:"name,omitempty"`
+	RedirectURL string `json:"redirectUrl,omitempty"`
+	Password    string `json:"password"`
+}
+
+func (m *CreationModel) MapModelToEntity() (*Link, error) {
+	u, err := url.Parse(m.RedirectURL)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Link{
+		Id:           m.Id,
+		Name:         m.Name,
+		RedirectURL:  *u,
+		Password:     m.Password,
+		CreationTime: time.Now().UTC(),
+	}, nil
+}
+
+func MapEntityToModel(entity *Link) ResourceModel {
+	return ResourceModel{
+		Id:           entity.Id,
+		Name:         entity.Name,
+		RedirectURL:  entity.RedirectURL.String(),
+		CreationTime: entity.CreationTime.Unix(),
+	}
+}

pkg/cgnolink/link/entity.go

@@ -0,0 +1,16 @@
+package link
+
+import (
+	"net/url"
+	"time"
+)
+
+type Link struct {
+	Id           string
+	Name         string
+	RedirectURL  url.URL
+	Password     string
+	CreationTime time.Time
+}
+
+type Links = []*Link

pkg/cgnolink/link/handlers.go

@@ -0,0 +1,151 @@
+package link
+
+import (
+	"encoding/json"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"github.com/labstack/echo/v4"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+func redirectHandler(ctx echo.Context, serv Service) error {
+	linkId := ctx.Param("id")
+	linkPassword := ctx.QueryParam("password")
+
+	redirectUrl, err := serv.AccessLink(linkId, linkPassword)
+	if err != nil {
+		return err
+	}
+
+	return ctx.Redirect(http.StatusSeeOther, redirectUrl.String())
+}
+
+func creationHandler(ctx echo.Context, serv Service) error {
+	var model CreationModel
+	if err := json.NewDecoder(ctx.Request().Body).Decode(&model); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid data format.")
+	}
+
+	entity, err := model.MapModelToEntity()
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid URL.")
+	}
+
+	if err = serv.Create(entity); err != nil {
+		return err
+	}
+
+	return ctx.NoContent(http.StatusCreated)
+}
+
+func retrievalByIdHandler(ctx echo.Context, serv Service) error {
+	linkId := ctx.Param("id")
+
+	l, err := serv.GetById(linkId)
+	if err != nil {
+		return err
+	}
+
+	return ctx.JSON(http.StatusOK, MapEntityToModel(l))
+}
+
+func allRetrievalHandler(ctx echo.Context, serv Service) error {
+	limit := 20
+	if v := ctx.QueryParam("limit"); v != "" {
+		num, err := strconv.Atoi(v)
+		if err != nil || num < 0 {
+			return echo.NewHTTPError(http.StatusBadRequest, "Invalid limit value.")
+		}
+
+		limit = num
+	}
+
+	offset := 0
+	if v := ctx.QueryParam("offset"); v != "" {
+		num, err := strconv.Atoi(v)
+		if err != nil || num < 0 {
+			return echo.NewHTTPError(http.StatusBadRequest, "Invalid offset value.")
+		}
+
+		offset = num
+	}
+
+	links, err := serv.GetAll(limit, offset)
+	if err != nil {
+		return err
+	}
+
+	models := make([]ResourceModel, len(links))
+	for i, v := range links {
+		models[i] = MapEntityToModel(v)
+	}
+
+	return ctx.JSON(http.StatusOK, models)
+}
+
+func updateHandler(ctx echo.Context, serv Service) error {
+	linkId := ctx.Param("id")
+
+	var model UpdateModel
+	if err := json.NewDecoder(ctx.Request().Body).Decode(&model); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid data format.")
+	}
+
+	var parsedUrl *url.URL
+	parsedUrl, err := url.Parse(model.RedirectURL)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid URL value.")
+	}
+
+	if err := serv.UpdateById(linkId, struct {
+		Name        string
+		Password    string
+		RedirectURL *url.URL
+	}{Name: model.Name, Password: model.Password, RedirectURL: parsedUrl}); err != nil {
+		return err
+	}
+
+	return ctx.NoContent(http.StatusOK)
+}
+
+func removalHandler(ctx echo.Context, serv Service) error {
+	linkId := ctx.Param("id")
+
+	if err := serv.DeleteById(linkId); err != nil {
+		return err
+	}
+
+	return ctx.NoContent(http.StatusNoContent)
+}
+
+func AddHandlers(server *echo.Echo, pool *pgxpool.Pool) {
+	serv := NewService(NewRepository(pool))
+
+	linksGroup := server.Group("/links")
+	exactLinkGroup := linksGroup.Group("/:id")
+
+	linksGroup.POST("", func(ctx echo.Context) error {
+		return creationHandler(ctx, serv)
+	})
+
+	linksGroup.GET("", func(ctx echo.Context) error {
+		return allRetrievalHandler(ctx, serv)
+	})
+
+	exactLinkGroup.GET("", func(ctx echo.Context) error {
+		return retrievalByIdHandler(ctx, serv)
+	})
+
+	exactLinkGroup.PATCH("", func(ctx echo.Context) error {
+		return updateHandler(ctx, serv)
+	})
+
+	exactLinkGroup.DELETE("", func(ctx echo.Context) error {
+		return removalHandler(ctx, serv)
+	})
+
+	server.GET("/:id", func(ctx echo.Context) error {
+		return redirectHandler(ctx, serv)
+	})
+}

pkg/cgnolink/link/repository.go

@@ -0,0 +1,182 @@
+package link
+
+import (
+	"cgnolink/pkg/cgnolink/database"
+	"context"
+	"errors"
+	"github.com/jackc/pgtype"
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"net/url"
+	"time"
+)
+
+const defaultContextTimeout = 10 * time.Second
+
+type Repository interface {
+	Save(link *Link) error
+	FindById(id string) (*Link, error)
+	GetAll(limit int, offset int) (Links, error)
+	Update(link *Link) error
+	DeleteById(id string) error
+}
+
+type PgRepository struct {
+	pool *pgxpool.Pool
+}
+
+func NewRepository(pool *pgxpool.Pool) Repository {
+	return &PgRepository{pool: pool}
+}
+
+func (r *PgRepository) Save(link *Link) error {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
+	defer cancel()
+
+	sql := `
+		INSERT INTO links (id, name, redirect_url, password, creation_time) 
+		VALUES ($1, $2, $3, $4, $5::timestamp)
+	`
+
+	database.LogPoolState(r.pool, "Saving link")
+	_, err := r.pool.Exec(ctx, sql, link.Id, link.Name, link.RedirectURL.String(), link.Password, link.CreationTime.Format("2006-01-02 15:04:05"))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *PgRepository) FindById(id string) (*Link, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
+	defer cancel()
+
+	sql := `
+		SELECT id, name, redirect_url, password, creation_time
+		FROM links
+		WHERE id = $1
+	`
+
+	database.LogPoolState(r.pool, "Finding link by ID")
+	entity, err := mapRowToEntity(r.pool.QueryRow(ctx, sql, id))
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, nil
+		} else {
+			return nil, err
+		}
+	}
+
+	return entity, nil
+}
+
+func (r *PgRepository) GetAll(limit int, offset int) (Links, error) {
+	if limit < 0 {
+		return nil, errors.New("limit can't be negative")
+	}
+	if offset < 0 {
+		return nil, errors.New("offset can't be negative")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
+	defer cancel()
+
+	sql := `
+		SELECT id, name, redirect_url, password, creation_time
+		FROM links
+		LIMIT $1
+		OFFSET $2
+	`
+
+	database.LogPoolState(r.pool, "Getting all links")
+	rows, err := r.pool.Query(ctx, sql, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	links := make(Links, 0)
+	for rows.Next() {
+		link, err := mapRowToEntity(rows)
+		if err != nil {
+			return nil, err
+		}
+
+		links = append(links, link)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return links, nil
+}
+
+func (r *PgRepository) Update(link *Link) error {
+	if link.Id == "" {
+		return errors.New("link ID must not be empty")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
+	defer cancel()
+
+	sql := `
+		UPDATE links
+		SET name = $1, redirect_url = $2, password = $3
+		WHERE id = $4
+	`
+
+	database.LogPoolState(r.pool, "Updating link")
+	_, err := r.pool.Exec(ctx, sql, link.Name, link.RedirectURL.String(), link.Password, link.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *PgRepository) DeleteById(id string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
+	defer cancel()
+
+	sql := `
+		DELETE FROM links WHERE id = $1
+	`
+
+	database.LogPoolState(r.pool, "Deleting link")
+	_, err := r.pool.Exec(ctx, sql, id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func mapRowToEntity(r interface{}) (*Link, error) {
+	var entity Link
+	var urlStr string
+	var t pgtype.Timestamp
+
+	switch v := r.(type) {
+	case pgx.Row:
+		if err := v.Scan(&entity.Id, &entity.Name, &urlStr, &entity.Password, &t); err != nil {
+			return nil, err
+		}
+	case pgx.Rows:
+		if err := v.Scan(&entity.Id, &entity.Name, &urlStr, &entity.Password, &t); err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errors.New("unsupported type")
+	}
+
+	u, err := url.Parse(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	entity.RedirectURL = *u
+	entity.CreationTime = t.Time
+
+	return &entity, nil
+}

pkg/cgnolink/link/service.go

@@ -0,0 +1,171 @@
+package link
+
+import (
+	apperrors "cgnolink/pkg/cgnolink/errors"
+	"github.com/patrickmn/go-cache"
+	"golang.org/x/crypto/bcrypt"
+	"net/url"
+)
+
+var linkNotFoundError = apperrors.NotFoundError{Message: "Link with given ID was not found."}
+
+type Service interface {
+	Create(link *Link) error
+	GetById(id string) (*Link, error)
+	AccessLink(id string, password string) (*url.URL, error)
+	GetAll(limit int, offset int) (Links, error)
+	UpdateById(
+		id string,
+		data struct {
+			Name        string
+			Password    string
+			RedirectURL *url.URL
+		},
+	) error
+	DeleteById(id string) error
+}
+
+type PgService struct {
+	rep   Repository
+	cache *cache.Cache
+}
+
+func (service *PgService) AccessLink(id string, password string) (*url.URL, error) {
+	link, err := service.GetById(id)
+	if err != nil {
+		return nil, err
+	}
+
+	if link.Password != "" {
+		if password == "" || bcrypt.CompareHashAndPassword([]byte(link.Password), []byte(password)) != nil {
+			return nil, linkNotFoundError
+		}
+	}
+
+	return &link.RedirectURL, nil
+}
+
+func NewService(rep Repository) Service {
+	return &PgService{
+		rep:   rep,
+		cache: cache.New(cache.NoExpiration, 0),
+	}
+}
+
+func (service *PgService) Create(link *Link) error {
+	existingLink, err := service.rep.FindById(link.Id)
+	if err != nil {
+		return apperrors.UnknownError{Err: err}
+	}
+
+	if existingLink != nil {
+		return apperrors.AlreadyExistsError{Message: "Link with given ID already exists."}
+	}
+
+	if link.Password != "" {
+		hashedPassword, err := HashPassword(link.Password)
+		if err != nil {
+			return err
+		}
+
+		link.Password = hashedPassword
+	}
+
+	if err = service.rep.Save(link); err != nil {
+		return apperrors.UnknownError{Err: err}
+	}
+
+	return nil
+}
+
+func (service *PgService) GetById(id string) (*Link, error) {
+	if v, found := service.cache.Get(id); found {
+		if link, ok := v.(*Link); ok {
+			return link, nil
+		}
+	}
+
+	link, err := service.rep.FindById(id)
+	if err != nil {
+		return nil, apperrors.UnknownError{Err: err}
+	}
+
+	if link == nil {
+		return nil, linkNotFoundError
+	}
+
+	service.cache.Set(id, link, cache.DefaultExpiration)
+
+	return link, nil
+}
+
+func (service *PgService) GetAll(limit int, offset int) (Links, error) {
+	links, err := service.rep.GetAll(limit, offset)
+	if err != nil {
+		return nil, apperrors.UnknownError{Err: err}
+	}
+
+	return links, nil
+}
+
+func (service *PgService) UpdateById(
+	id string,
+	data struct {
+		Name        string
+		Password    string
+		RedirectURL *url.URL
+	},
+) error {
+	link, err := service.GetById(id)
+	if err != nil {
+		return err
+	}
+
+	hasChanges := false
+	switch {
+	case data.Name != "":
+		link.Name = data.Name
+
+		hasChanges = true
+	case data.RedirectURL != nil:
+		link.RedirectURL = *data.RedirectURL
+
+		hasChanges = true
+	case data.Password != "":
+		hashedPw, err := HashPassword(data.Password)
+		if err != nil {
+			return err
+		}
+
+		link.Password = hashedPw
+
+		hasChanges = true
+	}
+
+	if hasChanges {
+		if err := service.rep.Update(link); err != nil {
+			return apperrors.UnknownError{Err: err}
+		}
+		service.cache.Delete(link.Id)
+	}
+
+	return nil
+}
+
+func (service *PgService) DeleteById(id string) error {
+	if err := service.rep.DeleteById(id); err != nil {
+		return apperrors.UnknownError{Err: err}
+	}
+	service.cache.Delete(id)
+
+	return nil
+}
+
+func HashPassword(password string) (string, error) {
+	hashedPw, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return "", apperrors.UnknownError{Err: err}
+	}
+
+	return string(hashedPw), nil
+}

pkg/cgnolink/server/middleware.go

@@ -0,0 +1,34 @@
+package server
+
+import (
+	"github.com/labstack/echo/v4"
+	"github.com/rs/zerolog/log"
+	"time"
+)
+
+func Logger() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) (err error) {
+			req := c.Request()
+			res := c.Response()
+			start := time.Now()
+			if err = next(c); err != nil {
+				c.Error(err)
+			}
+			stop := time.Now()
+
+			log.Info().
+				Str("remote_ip", c.RealIP()).
+				Str("host", req.Host).
+				Str("uri", req.RequestURI).
+				Str("method", req.Method).
+				Str("path", req.URL.Path).
+				Str("user_agent", req.UserAgent()).
+				Int("status", res.Status).
+				Str("latency", stop.Sub(start).String()).
+				Msg("Request")
+
+			return
+		}
+	}
+}

pkg/cgnolink/server/server.go

@@ -0,0 +1,70 @@
+package server
+
+import (
+	apperrors "cgnolink/pkg/cgnolink/errors"
+	"cgnolink/pkg/cgnolink/link"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"github.com/knadh/koanf"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"github.com/rs/zerolog/log"
+	"net/http"
+	"regexp"
+)
+
+func NewServer(conf *koanf.Koanf, pool *pgxpool.Pool) *echo.Echo {
+	server := echo.New()
+
+	server.HTTPErrorHandler = errorHandler(server)
+
+	addMiddleware(server, conf)
+	addHandlers(server, pool)
+
+	return server
+}
+
+func addMiddleware(s *echo.Echo, conf *koanf.Koanf) {
+	s.Use(middleware.CORS())
+
+	s.Use(Logger())
+
+	s.Use(middleware.JWTWithConfig(middleware.JWTConfig{
+		Skipper: func(ctx echo.Context) bool {
+			matchesLinks, _ := regexp.MatchString("^/links", ctx.Request().URL.Path)
+
+			return ctx.Request().Method == "GET" && !matchesLinks
+		},
+		SigningMethod: conf.String("jwt.method"),
+		SigningKey:    conf.Bytes("jwt.key"),
+	}))
+}
+
+func addHandlers(s *echo.Echo, pool *pgxpool.Pool) {
+	s.GET("", func(ctx echo.Context) error {
+		return ctx.JSON(http.StatusOK, struct {
+			Message string `json:"message"`
+		}{
+			Message: "Hello. This is my (https://cognio.dev/) URL shortener for easy access to my socials, projects and other resources.",
+		})
+	})
+
+	link.AddHandlers(s, pool)
+}
+
+func errorHandler(s *echo.Echo) echo.HTTPErrorHandler {
+	return func(err error, c echo.Context) {
+		mappedErr := err
+
+		switch v := err.(type) {
+		case apperrors.NotFoundError:
+			mappedErr = echo.NewHTTPError(http.StatusNotFound, v.Error())
+		case apperrors.UnknownError:
+			log.Err(v.Err).Send()
+			mappedErr = echo.NewHTTPError(http.StatusInternalServerError)
+		case apperrors.AlreadyExistsError:
+			mappedErr = echo.NewHTTPError(http.StatusBadRequest, v.Error())
+		}
+
+		s.DefaultHTTPErrorHandler(mappedErr, c)
+	}
+}