+
+
package main
+
+import (
+ "context"
+ "os"
+ "os/signal"
+ "syscall"
+ "time"
+
+ repo "github.com/danilovid/linkkeeper/internal/api-service/repository"
+ "github.com/danilovid/linkkeeper/internal/api-service/transport/http"
+ "github.com/danilovid/linkkeeper/internal/api-service/usecase"
+ "github.com/danilovid/linkkeeper/pkg/config"
+ "github.com/danilovid/linkkeeper/pkg/database/postgresql"
+ "github.com/danilovid/linkkeeper/pkg/httpclient"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+)
+
+const shutdownTimeout = 5 * time.Second
+
+func main() {
+ cfg := config.New()
+
+ logger.Init()
+
+ db := postgresql.New(cfg.PostgresDSN, &repo.LinkModel{})
+ linkRepo := repo.NewLinkRepo(db)
+ linkSvc := usecase.NewLinkService(linkRepo)
+
+ httpSrv := http.NewServer(linkSvc)
+ srv := httpclient.New(cfg.HTTPAddr, httpSrv.Handler(), nil)
+
+ go func() {
+ logger.L().Info().Str("addr", cfg.HTTPAddr).Msg("api listening")
+ if err := srv.ListenAndServe(); err != nil {
+ logger.L().Fatal().Err(err).Msg("http server")
+ }
+ }()
+
+ waitForShutdown(func() {
+ ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
+ defer cancel()
+ _ = srv.Shutdown(ctx)
+ })
+}
+
+func waitForShutdown(fn func()) {
+ ch := make(chan os.Signal, 1)
+ signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+ <-ch
+ fn()
+}
+
+
+
package main
+
+import (
+ "os"
+ "strconv"
+ "time"
+
+ "github.com/danilovid/linkkeeper/internal/bot-service/bot"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+)
+
+const defaultTimeout = 10 * time.Second
+
+func main() {
+ logger.Init()
+
+ cfg := bot.Config{
+ Token: os.Getenv("TELEGRAM_TOKEN"),
+ APIBaseURL: os.Getenv("API_BASE_URL"),
+ UserServiceURL: os.Getenv("USER_SERVICE_URL"),
+ Timeout: readTimeout(),
+ }
+
+ w, err := bot.NewWrapper(&cfg)
+ if err != nil {
+ logger.L().Fatal().Err(err).Msg("init bot")
+ }
+
+ logger.L().Info().Msg("bot started")
+ if err := w.Start(); err != nil {
+ logger.L().Fatal().Err(err).Msg("bot stopped")
+ }
+}
+
+func readTimeout() time.Duration {
+ raw := os.Getenv("BOT_TIMEOUT_SECONDS")
+ if raw == "" {
+ return defaultTimeout
+ }
+ seconds, err := strconv.Atoi(raw)
+ if err != nil || seconds <= 0 {
+ return defaultTimeout
+ }
+ return time.Duration(seconds) * time.Second
+}
+
+
+
package main
+
+import (
+ "context"
+ "os"
+ "os/signal"
+ "syscall"
+ "time"
+
+ repo "github.com/danilovid/linkkeeper/internal/user-service/repository"
+ "github.com/danilovid/linkkeeper/internal/user-service/transport/http"
+ "github.com/danilovid/linkkeeper/internal/user-service/usecase"
+ "github.com/danilovid/linkkeeper/pkg/config"
+ "github.com/danilovid/linkkeeper/pkg/database/postgresql"
+ "github.com/danilovid/linkkeeper/pkg/httpclient"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+
+ userservice "github.com/danilovid/linkkeeper/internal/user-service"
+)
+
+const shutdownTimeout = 5 * time.Second
+
+func main() {
+ cfg := config.New()
+
+ logger.Init()
+
+ db := postgresql.New(cfg.PostgresDSN, &userservice.UserModel{})
+ userRepo := repo.NewUserRepo(db)
+ userSvc := usecase.NewUserService(userRepo)
+
+ httpSrv := http.NewServer(userSvc)
+ srv := httpclient.New(cfg.HTTPAddr, httpSrv.Handler(), nil)
+
+ go func() {
+ logger.L().Info().Str("addr", cfg.HTTPAddr).Msg("user-service listening")
+ if err := srv.ListenAndServe(); err != nil {
+ logger.L().Fatal().Err(err).Msg("http server")
+ }
+ }()
+
+ waitForShutdown(func() {
+ ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
+ defer cancel()
+ _ = srv.Shutdown(ctx)
+ })
+}
+
+func waitForShutdown(fn func()) {
+ ch := make(chan os.Signal, 1)
+ signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+ <-ch
+ fn()
+}
+
+
+
package repository
+
+import (
+ "context"
+ "errors"
+ "time"
+
+ "github.com/google/uuid"
+ "gorm.io/gorm"
+
+ apiservice "github.com/danilovid/linkkeeper/internal/api-service"
+)
+
+type LinkRepo struct {
+ db *gorm.DB
+}
+
+func NewLinkRepo(db *gorm.DB) *LinkRepo {
+ return &LinkRepo{db: db}
+}
+
+type LinkModel struct {
+ ID string `gorm:"type:uuid;primaryKey"`
+ URL string `gorm:"not null"`
+ Resource string `gorm:"not null;default:''"`
+ Views int64 `gorm:"not null;default:0"`
+ ViewedAt *time.Time `gorm:"default:null"`
+ CreatedAt time.Time `gorm:"autoCreateTime"`
+ UpdatedAt time.Time `gorm:"autoUpdateTime"`
+}
+
+func (r *LinkRepo) Create(ctx context.Context, input apiservice.LinkCreateInput) (apiservice.Link, error) {
+ model := LinkModel{
+ ID: uuid.NewString(),
+ URL: input.URL,
+ Resource: input.Resource,
+ }
+ if err := r.db.WithContext(ctx).Create(&model).Error; err != nil {
+ return apiservice.Link{}, err
+ }
+ return toLink(model), nil
+}
+
+func (r *LinkRepo) GetByID(ctx context.Context, id string) (apiservice.Link, error) {
+ var model LinkModel
+ if err := r.db.WithContext(ctx).First(&model, "id = ?", id).Error; err != nil {
+ return apiservice.Link{}, mapErr(err)
+ }
+ return toLink(model), nil
+}
+
+func (r *LinkRepo) List(ctx context.Context, limit, offset int) ([]apiservice.Link, error) {
+ var models []LinkModel
+ if err := r.db.WithContext(ctx).
+ Order("created_at desc").
+ Limit(limit).
+ Offset(offset).
+ Find(&models).Error; err != nil {
+ return nil, err
+ }
+ out := make([]apiservice.Link, 0, len(models))
+ for _, m := range models {
+ out = append(out, toLink(m))
+ }
+ return out, nil
+}
+
+func (r *LinkRepo) Random(ctx context.Context, resource string) (apiservice.Link, error) {
+ var model LinkModel
+ q := r.db.WithContext(ctx).Model(&LinkModel{})
+ if resource != "" {
+ q = q.Where("resource = ?", resource)
+ }
+ if err := q.Order("random()").Limit(1).Take(&model).Error; err != nil {
+ return apiservice.Link{}, mapErr(err)
+ }
+ return toLink(model), nil
+}
+
+func (r *LinkRepo) Update(ctx context.Context, id string, input apiservice.LinkUpdateInput) (apiservice.Link, error) {
+ updates := map[string]any{}
+ if input.URL != nil {
+ updates["url"] = *input.URL
+ }
+ if input.Resource != nil {
+ updates["resource"] = *input.Resource
+ }
+ if len(updates) > 0 {
+ res := r.db.WithContext(ctx).
+ Model(&LinkModel{}).
+ Where("id = ?", id).
+ Updates(updates)
+ if res.Error != nil {
+ return apiservice.Link{}, res.Error
+ }
+ if res.RowsAffected == 0 {
+ return apiservice.Link{}, apiservice.ErrNotFound
+ }
+ }
+ return r.GetByID(ctx, id)
+}
+
+func (r *LinkRepo) Delete(ctx context.Context, id string) error {
+ res := r.db.WithContext(ctx).Delete(&LinkModel{}, "id = ?", id)
+ if res.Error != nil {
+ return res.Error
+ }
+ if res.RowsAffected == 0 {
+ return apiservice.ErrNotFound
+ }
+ return nil
+}
+
+func (r *LinkRepo) MarkViewed(ctx context.Context, id string) (apiservice.Link, error) {
+ now := time.Now()
+ res := r.db.WithContext(ctx).
+ Model(&LinkModel{}).
+ Where("id = ?", id).
+ Updates(map[string]any{
+ "views": gorm.Expr("views + 1"),
+ "viewed_at": &now,
+ })
+ if res.Error != nil {
+ return apiservice.Link{}, res.Error
+ }
+ if res.RowsAffected == 0 {
+ return apiservice.Link{}, apiservice.ErrNotFound
+ }
+ return r.GetByID(ctx, id)
+}
+
+func (r *LinkRepo) GetViewStats(ctx context.Context, days int) ([]apiservice.ViewStats, error) {
+ if days <= 0 {
+ days = 53
+ }
+ if days > 365 {
+ days = 365
+ }
+
+ type resultRow struct {
+ Date string `gorm:"column:date"`
+ Count int64 `gorm:"column:count"`
+ }
+ var results []resultRow
+ startDate := time.Now().AddDate(0, 0, -days+1).Truncate(24 * time.Hour)
+ err := r.db.WithContext(ctx).
+ Model(&LinkModel{}).
+ Select("DATE(viewed_at)::text as date, COUNT(*)::bigint as count").
+ Where("viewed_at IS NOT NULL").
+ Where("viewed_at >= ?", startDate).
+ Group("DATE(viewed_at)").
+ Order("date ASC").
+ Scan(&results).Error
+
+ if err != nil {
+ return nil, err
+ }
+
+ statsMap := make(map[string]int64)
+ for _, r := range results {
+ statsMap[r.Date] = r.Count
+ }
+
+ var maxCount int64
+ for _, count := range statsMap {
+ if count > maxCount {
+ maxCount = count
+ }
+ }
+
+ now := time.Now()
+ stats := make([]apiservice.ViewStats, 0, days)
+ for i := days - 1; i >= 0; i-- {
+ date := now.AddDate(0, 0, -i)
+ dateStr := date.Format("2006-01-02")
+
+ count := statsMap[dateStr]
+ level := 0
+ if maxCount > 0 {
+ ratio := float64(count) / float64(maxCount)
+ if ratio > 0.8 {
+ level = 4
+ } else if ratio > 0.6 {
+ level = 3
+ } else if ratio > 0.4 {
+ level = 2
+ } else if ratio > 0.2 {
+ level = 1
+ }
+ }
+
+ stats = append(stats, apiservice.ViewStats{
+ Date: dateStr,
+ Count: count,
+ Level: level,
+ })
+ }
+
+ return stats, nil
+}
+
+func mapErr(err error) error {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return apiservice.ErrNotFound
+ }
+ return err
+}
+
+func toLink(m LinkModel) apiservice.Link {
+ return apiservice.Link{
+ ID: m.ID,
+ URL: m.URL,
+ Resource: m.Resource,
+ Views: m.Views,
+ ViewedAt: m.ViewedAt,
+ CreatedAt: m.CreatedAt,
+ UpdatedAt: m.UpdatedAt,
+ }
+}
+
+
+
package http
+
+import (
+ "net/http"
+ "time"
+
+ "github.com/gorilla/mux"
+ "github.com/justinas/alice"
+
+ apiservice "github.com/danilovid/linkkeeper/internal/api-service"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+ "github.com/rs/cors"
+)
+
+type Server struct {
+ uc apiservice.LinkService
+ router *mux.Router
+ handler http.Handler
+}
+
+func NewServer(uc apiservice.LinkService) *Server {
+ r := mux.NewRouter()
+ s := &Server{
+ uc: uc,
+ router: r,
+ }
+ s.routes()
+ return s
+}
+
+func (s *Server) Handler() http.Handler {
+ return s.handler
+}
+
+func (s *Server) routes() {
+ s.router.StrictSlash(true)
+
+ corsOpts := cors.Options{
+ AllowedOrigins: []string{"*"},
+ AllowedMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
+ AllowedHeaders: []string{"Origin", "Accept", "Content-Type", "X-Requested-With", "Authorization", "X-Auth-Key"},
+ }
+
+ s.handler = alice.New(
+ requestLogger,
+ cors.New(corsOpts).Handler,
+ ).Then(s.router)
+
+ s.router.HandleFunc("/health", Health).Methods(http.MethodGet)
+
+ api := s.router.PathPrefix("/api/v1").Subrouter()
+ api.HandleFunc("/links", s.Create()).Methods(http.MethodPost)
+ api.HandleFunc("/links", s.List()).Methods(http.MethodGet)
+ api.HandleFunc("/links/random", s.Random()).Methods(http.MethodGet)
+ api.HandleFunc("/links/{id}", s.Get()).Methods(http.MethodGet)
+ api.HandleFunc("/links/{id}", s.Update()).Methods(http.MethodPatch)
+ api.HandleFunc("/links/{id}", s.Delete()).Methods(http.MethodDelete)
+ api.HandleFunc("/links/{id}/viewed", s.MarkViewed()).Methods(http.MethodPost)
+ api.HandleFunc("/stats/views", s.GetViewStats()).Methods(http.MethodGet)
+}
+
+func requestLogger(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ start := time.Now()
+ next.ServeHTTP(w, r)
+ logger.L().Info().
+ Str("method", r.Method).
+ Str("path", r.URL.Path).
+ Dur("duration", time.Since(start)).
+ Msg("request")
+ })
+}
+
+
+
package http
+
+import (
+ "encoding/json"
+ "errors"
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/gorilla/mux"
+
+ apiservice "github.com/danilovid/linkkeeper/internal/api-service"
+)
+
+type createLinkRequest struct {
+ URL string `json:"url"`
+ Resource string `json:"resource"`
+}
+
+type updateLinkRequest struct {
+ URL *string `json:"url"`
+ Resource *string `json:"resource"`
+}
+
+type linkResponse struct {
+ ID string `json:"id"`
+ URL string `json:"url"`
+ Resource string `json:"resource,omitempty"`
+ Views int64 `json:"views"`
+ ViewedAt *time.Time `json:"viewed_at,omitempty"`
+ CreatedAt time.Time `json:"created_at"`
+ UpdatedAt time.Time `json:"updated_at"`
+}
+
+func Health(w http.ResponseWriter, _ *http.Request) {
+ w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) Create() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ var req createLinkRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad json", http.StatusBadRequest)
+ return
+ }
+ req.URL = strings.TrimSpace(req.URL)
+ req.Resource = strings.TrimSpace(req.Resource)
+ input := apiservice.LinkCreateInput{
+ URL: req.URL,
+ Resource: req.Resource,
+ }
+ link, err := s.uc.Create(r.Context(), input)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusCreated, toLinkResponse(link))
+ }
+}
+
+func (s *Server) Get() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ id := mux.Vars(r)["id"]
+ link, err := s.uc.GetByID(r.Context(), id)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, toLinkResponse(link))
+ }
+}
+
+func (s *Server) List() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ limit := parseIntDefault(r.URL.Query().Get("limit"), 50)
+ offset := parseIntDefault(r.URL.Query().Get("offset"), 0)
+ if limit > 200 {
+ limit = 200
+ }
+ links, err := s.uc.List(r.Context(), limit, offset)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ resp := make([]linkResponse, 0, len(links))
+ for _, link := range links {
+ resp = append(resp, toLinkResponse(link))
+ }
+ writeJSON(w, http.StatusOK, resp)
+ }
+}
+
+func (s *Server) Random() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ resource := strings.TrimSpace(r.URL.Query().Get("resource"))
+ link, err := s.uc.Random(r.Context(), resource)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, toLinkResponse(link))
+ }
+}
+
+func (s *Server) Update() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ id := mux.Vars(r)["id"]
+ var req updateLinkRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad json", http.StatusBadRequest)
+ return
+ }
+ if req.URL != nil {
+ trimmed := strings.TrimSpace(*req.URL)
+ req.URL = &trimmed
+ }
+ if req.Resource != nil {
+ trimmed := strings.TrimSpace(*req.Resource)
+ req.Resource = &trimmed
+ }
+ input := apiservice.LinkUpdateInput{
+ URL: req.URL,
+ Resource: req.Resource,
+ }
+ link, err := s.uc.Update(r.Context(), id, input)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, toLinkResponse(link))
+ }
+}
+
+func (s *Server) Delete() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ id := mux.Vars(r)["id"]
+ if err := s.uc.Delete(r.Context(), id); err != nil {
+ writeError(w, err)
+ return
+ }
+ w.WriteHeader(http.StatusNoContent)
+ }
+}
+
+func (s *Server) MarkViewed() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ id := mux.Vars(r)["id"]
+ link, err := s.uc.MarkViewed(r.Context(), id)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, toLinkResponse(link))
+ }
+}
+
+func (s *Server) GetViewStats() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ days := parseIntDefault(r.URL.Query().Get("days"), 53)
+ if days > 365 {
+ days = 365
+ }
+ stats, err := s.uc.GetViewStats(r.Context(), days)
+ if err != nil {
+ writeError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, stats)
+ }
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(status)
+ _ = json.NewEncoder(w).Encode(v)
+}
+
+func writeError(w http.ResponseWriter, err error) {
+ switch {
+ case errors.Is(err, apiservice.ErrNotFound):
+ http.Error(w, "not found", http.StatusNotFound)
+ case errors.Is(err, apiservice.ErrInvalidInput):
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ default:
+ http.Error(w, "internal error", http.StatusInternalServerError)
+ }
+}
+
+func toLinkResponse(link apiservice.Link) linkResponse {
+ return linkResponse{
+ ID: link.ID,
+ URL: link.URL,
+ Resource: link.Resource,
+ Views: link.Views,
+ ViewedAt: link.ViewedAt,
+ CreatedAt: link.CreatedAt,
+ UpdatedAt: link.UpdatedAt,
+ }
+}
+
+func parseIntDefault(raw string, def int) int {
+ if raw == "" {
+ return def
+ }
+ parsed, err := strconv.Atoi(raw)
+ if err != nil {
+ return def
+ }
+ return parsed
+}
+
+
+
package usecase
+
+import (
+ "context"
+ "fmt"
+
+ apiservice "github.com/danilovid/linkkeeper/internal/api-service"
+)
+
+type LinkService struct {
+ repo apiservice.LinkRepository
+}
+
+func NewLinkService(repo apiservice.LinkRepository) *LinkService {
+ return &LinkService{repo: repo}
+}
+
+func (s *LinkService) Create(ctx context.Context, input apiservice.LinkCreateInput) (apiservice.Link, error) {
+ if err := validateCreate(input); err != nil {
+ return apiservice.Link{}, err
+ }
+ return s.repo.Create(ctx, input)
+}
+
+func (s *LinkService) GetByID(ctx context.Context, id string) (apiservice.Link, error) {
+ return s.repo.GetByID(ctx, id)
+}
+
+func (s *LinkService) List(ctx context.Context, limit, offset int) ([]apiservice.Link, error) {
+ return s.repo.List(ctx, limit, offset)
+}
+
+func (s *LinkService) Random(ctx context.Context, resource string) (apiservice.Link, error) {
+ return s.repo.Random(ctx, resource)
+}
+
+func (s *LinkService) Update(ctx context.Context, id string, input apiservice.LinkUpdateInput) (apiservice.Link, error) {
+ if err := validateUpdate(input); err != nil {
+ return apiservice.Link{}, err
+ }
+ return s.repo.Update(ctx, id, input)
+}
+
+func (s *LinkService) Delete(ctx context.Context, id string) error {
+ return s.repo.Delete(ctx, id)
+}
+
+func (s *LinkService) MarkViewed(ctx context.Context, id string) (apiservice.Link, error) {
+ return s.repo.MarkViewed(ctx, id)
+}
+
+func (s *LinkService) GetViewStats(ctx context.Context, days int) ([]apiservice.ViewStats, error) {
+ if days <= 0 {
+ days = 53
+ }
+ return s.repo.GetViewStats(ctx, days)
+}
+
+func validateCreate(input apiservice.LinkCreateInput) error {
+ if input.URL == "" {
+ return fmt.Errorf("%w: url is required", apiservice.ErrInvalidInput)
+ }
+ return nil
+}
+
+func validateUpdate(input apiservice.LinkUpdateInput) error {
+ if input.URL == nil && input.Resource == nil {
+ return fmt.Errorf("%w: no fields to update", apiservice.ErrInvalidInput)
+ }
+ if input.URL != nil && *input.URL == "" {
+ return fmt.Errorf("%w: url is required", apiservice.ErrInvalidInput)
+ }
+ return nil
+}
+
+
+
package api
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+type Client struct {
+ baseURL string
+ http *http.Client
+}
+
+type Link struct {
+ ID string `json:"id"`
+ URL string `json:"url"`
+ Resource string `json:"resource"`
+}
+
+func NewClient(baseURL string, timeout time.Duration) *Client {
+ return &Client{
+ baseURL: strings.TrimRight(baseURL, "/"),
+ http: &http.Client{Timeout: timeout},
+ }
+}
+
+func (c *Client) CreateLink(ctx context.Context, url string) (string, error) {
+ payload, err := json.Marshal(map[string]string{"url": url})
+ if err != nil {
+ return "", err
+ }
+ req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/links", bytes.NewReader(payload))
+ if err != nil {
+ return "", err
+ }
+ req.Header.Set("Content-Type", "application/json")
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode >= 300 {
+ return "", fmt.Errorf("api status: %s", resp.Status)
+ }
+ var out struct {
+ ID string `json:"id"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+ return "", err
+ }
+ return out.ID, nil
+}
+
+func (c *Client) MarkViewed(ctx context.Context, id string) error {
+ req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/links/"+id+"/viewed", http.NoBody)
+ if err != nil {
+ return err
+ }
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode >= 300 {
+ return fmt.Errorf("api status: %s", resp.Status)
+ }
+ return nil
+}
+
+func (c *Client) RandomLink(ctx context.Context, resource string) (Link, error) {
+ requestURL := c.baseURL + "/api/v1/links/random"
+ if resource != "" {
+ requestURL += "?resource=" + url.QueryEscape(resource)
+ }
+ req, err := http.NewRequestWithContext(ctx, "GET", requestURL, http.NoBody)
+ if err != nil {
+ return Link{}, err
+ }
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return Link{}, err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode >= 300 {
+ return Link{}, fmt.Errorf("api status: %s", resp.Status)
+ }
+ var out Link
+ if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+ return Link{}, err
+ }
+ return out, nil
+}
+
+
+
package bot
+
+import (
+ "errors"
+ "strings"
+ "time"
+)
+
+type Config struct {
+ Token string
+ APIBaseURL string
+ UserServiceURL string
+ Timeout time.Duration
+}
+
+func (c *Config) Validate() error {
+ if strings.TrimSpace(c.Token) == "" {
+ return errors.New("missing TELEGRAM_TOKEN")
+ }
+ if strings.TrimSpace(c.APIBaseURL) == "" {
+ return errors.New("missing API_BASE_URL")
+ }
+ if strings.TrimSpace(c.UserServiceURL) == "" {
+ return errors.New("missing USER_SERVICE_URL")
+ }
+ if c.Timeout <= 0 {
+ c.Timeout = 10 * time.Second
+ }
+ return nil
+}
+
+
+
package bot
+
+import (
+ "context"
+ "strings"
+
+ "github.com/danilovid/linkkeeper/internal/bot-service/api"
+ "github.com/danilovid/linkkeeper/internal/bot-service/user"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+ tb "gopkg.in/telebot.v4"
+ "gopkg.in/telebot.v4/middleware"
+)
+
+type Wrapper struct {
+ bot *tb.Bot
+ config *Config
+ api *api.Client
+ userService *user.Client
+}
+
+var (
+ menu = &tb.ReplyMarkup{ResizeKeyboard: true}
+
+ btnSave = menu.Text("💾 Save link")
+ btnViewed = menu.Text("✅ Mark viewed")
+ btnRandom = menu.Text("🎲 Random")
+ btnRandomArticle = menu.Text("📰 Random article")
+ btnRandomVideo = menu.Text("🎬 Random video")
+)
+
+func NewWrapper(config *Config) (*Wrapper, error) {
+ if err := config.Validate(); err != nil {
+ return nil, err
+ }
+
+ settings := tb.Settings{
+ Token: config.Token,
+ Poller: &tb.LongPoller{Timeout: config.Timeout},
+ }
+
+ b, err := tb.NewBot(settings)
+ if err != nil {
+ return nil, err
+ }
+
+ b.Use(middleware.Logger())
+ b.Use(middleware.AutoRespond())
+
+ w := &Wrapper{
+ bot: b,
+ config: config,
+ api: api.NewClient(config.APIBaseURL, config.Timeout),
+ userService: user.NewClient(config.UserServiceURL, config.Timeout),
+ }
+ w.prepare()
+ return w, nil
+}
+
+func (w *Wrapper) Start() error {
+ w.bot.Start()
+ return nil
+}
+
+func (w *Wrapper) prepare() {
+ menu.Reply(
+ menu.Row(btnSave, btnViewed),
+ menu.Row(btnRandom),
+ menu.Row(btnRandomArticle, btnRandomVideo),
+ )
+
+ w.bot.Handle("/start", func(c tb.Context) error {
+ sender := c.Sender()
+ if sender != nil {
+ ctx := context.Background()
+ _, err := w.userService.GetOrCreateUser(
+ ctx,
+ sender.ID,
+ sender.Username,
+ sender.FirstName,
+ sender.LastName,
+ )
+ if err != nil {
+ logger.L().Error().Err(err).Int64("telegram_id", sender.ID).Msg("failed to get or create user")
+ } else {
+ logger.L().Info().Int64("telegram_id", sender.ID).Str("username", sender.Username).Msg("user registered or retrieved")
+ }
+ }
+ return c.Send("Welcome! Choose an action:", menu)
+ })
+
+ w.bot.Handle("/save", func(c tb.Context) error {
+ url := strings.TrimSpace(c.Message().Payload)
+ if url == "" {
+ return c.Send("usage: /save <url>")
+ }
+ ctx := context.Background()
+ id, err := w.api.CreateLink(ctx, url)
+ if err != nil {
+ logger.L().Error().Err(err).Str("url", url).Msg("create link failed")
+ return c.Send("failed to save link")
+ }
+ return c.Send("saved ✅ id: " + id)
+ })
+
+ w.bot.Handle("/viewed", func(c tb.Context) error {
+ id := strings.TrimSpace(c.Message().Payload)
+ if id == "" {
+ return c.Send("usage: /viewed <id>")
+ }
+ ctx := context.Background()
+ if err := w.api.MarkViewed(ctx, id); err != nil {
+ logger.L().Error().Err(err).Str("id", id).Msg("mark viewed failed")
+ return c.Send("failed to mark viewed")
+ }
+ return c.Send("marked viewed ✅")
+ })
+
+ w.bot.Handle("/random", func(c tb.Context) error {
+ resource := strings.TrimSpace(c.Message().Payload)
+ ctx := context.Background()
+ link, err := w.api.RandomLink(ctx, resource)
+ if err != nil {
+ logger.L().Error().Err(err).Str("resource", resource).Msg("random link failed")
+ return c.Send("failed to get random link")
+ }
+ if link.URL == "" {
+ return c.Send("no links found")
+ }
+ msg := "random ✅\n" + link.URL + "\nID: " + link.ID
+ if link.Resource != "" {
+ msg += "\nResource: " + link.Resource
+ }
+ return c.Send(msg, menu)
+ })
+
+ w.bot.Handle(&btnSave, func(c tb.Context) error {
+ return c.Send("Send link: /save <url>", menu)
+ })
+
+ w.bot.Handle(&btnViewed, func(c tb.Context) error {
+ return c.Send("Send id: /viewed <id>", menu)
+ })
+
+ w.bot.Handle(&btnRandom, func(c tb.Context) error {
+ ctx := context.Background()
+ link, err := w.api.RandomLink(ctx, "")
+ if err != nil {
+ logger.L().Error().Err(err).Msg("random link failed")
+ return c.Send("failed to get random link", menu)
+ }
+ if link.URL == "" {
+ return c.Send("no links found", menu)
+ }
+ msg := "random ✅\n" + link.URL + "\nID: " + link.ID
+ if link.Resource != "" {
+ msg += "\nResource: " + link.Resource
+ }
+ return c.Send(msg, menu)
+ })
+
+ w.bot.Handle(&btnRandomArticle, func(c tb.Context) error {
+ ctx := context.Background()
+ link, err := w.api.RandomLink(ctx, "article")
+ if err != nil {
+ logger.L().Error().Err(err).Msg("random article failed")
+ return c.Send("failed to get random article", menu)
+ }
+ if link.URL == "" {
+ return c.Send("no articles found", menu)
+ }
+ msg := "random ✅\n" + link.URL + "\nID: " + link.ID + "\nResource: article"
+ return c.Send(msg, menu)
+ })
+
+ w.bot.Handle(&btnRandomVideo, func(c tb.Context) error {
+ ctx := context.Background()
+ link, err := w.api.RandomLink(ctx, "video")
+ if err != nil {
+ logger.L().Error().Err(err).Msg("random video failed")
+ return c.Send("failed to get random video", menu)
+ }
+ if link.URL == "" {
+ return c.Send("no videos found", menu)
+ }
+ msg := "random ✅\n" + link.URL + "\nID: " + link.ID + "\nResource: video"
+ return c.Send(msg, menu)
+ })
+
+ w.bot.Handle(tb.OnText, func(c tb.Context) error {
+ text := strings.TrimSpace(c.Text())
+ if text == "" {
+ return nil
+ }
+ if strings.HasPrefix(text, "/") {
+ return c.Send("unknown command, try /save, /viewed, /random", menu)
+ }
+ return c.Send("commands: /save <url>, /viewed <id>, /random [resource]", menu)
+ })
+
+ w.bot.Handle(tb.OnPhoto, func(c tb.Context) error {
+ return c.Send("commands: /save <url>, /viewed <id>, /random [resource]", menu)
+ })
+
+ // reserved for future middleware
+}
+
+
+
package user
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "strings"
+ "time"
+)
+
+type Client struct {
+ baseURL string
+ http *http.Client
+}
+
+type User struct {
+ ID string `json:"id"`
+ TelegramID int64 `json:"telegram_id"`
+ Username string `json:"username,omitempty"`
+ FirstName string `json:"first_name,omitempty"`
+ LastName string `json:"last_name,omitempty"`
+ CreatedAt string `json:"created_at"`
+ UpdatedAt string `json:"updated_at"`
+}
+
+type CreateUserRequest struct {
+ TelegramID int64 `json:"telegram_id"`
+ Username string `json:"username,omitempty"`
+ FirstName string `json:"first_name,omitempty"`
+ LastName string `json:"last_name,omitempty"`
+}
+
+type ExistsResponse struct {
+ Exists bool `json:"exists"`
+}
+
+func NewClient(baseURL string, timeout time.Duration) *Client {
+ return &Client{
+ baseURL: strings.TrimRight(baseURL, "/"),
+ http: &http.Client{Timeout: timeout},
+ }
+}
+
+func (c *Client) GetOrCreateUser(ctx context.Context, telegramID int64, username, firstName, lastName string) (*User, error) {
+ reqData := CreateUserRequest{
+ TelegramID: telegramID,
+ Username: username,
+ FirstName: firstName,
+ LastName: lastName,
+ }
+
+ payload, err := json.Marshal(reqData)
+ if err != nil {
+ return nil, err
+ }
+
+ req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/users", bytes.NewReader(payload))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode >= 300 {
+ return nil, fmt.Errorf("api status: %s", resp.Status)
+ }
+
+ var user User
+ if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+ return nil, err
+ }
+
+ return &user, nil
+}
+
+func (c *Client) GetUserByTelegramID(ctx context.Context, telegramID int64) (*User, error) {
+ url := fmt.Sprintf("%s/api/v1/users/telegram/%d", c.baseURL, telegramID)
+
+ req, err := http.NewRequestWithContext(ctx, "GET", url, http.NoBody)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode >= 300 {
+ return nil, fmt.Errorf("api status: %s", resp.Status)
+ }
+
+ var user User
+ if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+ return nil, err
+ }
+
+ return &user, nil
+}
+
+func (c *Client) UserExists(ctx context.Context, telegramID int64) (bool, error) {
+ url := fmt.Sprintf("%s/api/v1/users/telegram/%d/exists", c.baseURL, telegramID)
+
+ req, err := http.NewRequestWithContext(ctx, "GET", url, http.NoBody)
+ if err != nil {
+ return false, err
+ }
+
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return false, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode >= 300 {
+ return false, fmt.Errorf("api status: %s", resp.Status)
+ }
+
+ var result ExistsResponse
+ if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+ return false, err
+ }
+
+ return result.Exists, nil
+}
+
+
+
package userservice
+
+import (
+ "time"
+
+ "github.com/google/uuid"
+ "gorm.io/gorm"
+)
+
+type UserModel struct {
+ ID uuid.UUID `gorm:"type:char(36);primary_key" json:"id"`
+ TelegramID int64 `gorm:"uniqueIndex;not null" json:"telegram_id"`
+ Username string `gorm:"type:varchar(255)" json:"username,omitempty"`
+ FirstName string `gorm:"type:varchar(255)" json:"first_name,omitempty"`
+ LastName string `gorm:"type:varchar(255)" json:"last_name,omitempty"`
+ CreatedAt time.Time `json:"created_at"`
+ UpdatedAt time.Time `json:"updated_at"`
+}
+
+func (UserModel) TableName() string {
+ return "users"
+}
+
+func (u *UserModel) BeforeCreate(tx *gorm.DB) error {
+ if u.ID == uuid.Nil {
+ u.ID = uuid.New()
+ }
+ return nil
+}
+
+
+
package repository
+
+import (
+ "errors"
+
+ "github.com/google/uuid"
+ "gorm.io/gorm"
+
+ userservice "github.com/danilovid/linkkeeper/internal/user-service"
+)
+
+type userRepo struct {
+ db *gorm.DB
+}
+
+func NewUserRepo(db *gorm.DB) userservice.Repository {
+ return &userRepo{db: db}
+}
+
+func (r *userRepo) Create(user *userservice.UserModel) error {
+ return r.db.Create(user).Error
+}
+
+func (r *userRepo) GetByID(id uuid.UUID) (*userservice.UserModel, error) {
+ var user userservice.UserModel
+ err := r.db.Where("id = ?", id).First(&user).Error
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, errors.New("user not found")
+ }
+ return nil, err
+ }
+ return &user, nil
+}
+
+func (r *userRepo) GetByTelegramID(telegramID int64) (*userservice.UserModel, error) {
+ var user userservice.UserModel
+ err := r.db.Where("telegram_id = ?", telegramID).First(&user).Error
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, errors.New("user not found")
+ }
+ return nil, err
+ }
+ return &user, nil
+}
+
+func (r *userRepo) Update(user *userservice.UserModel) error {
+ return r.db.Save(user).Error
+}
+
+func (r *userRepo) Exists(telegramID int64) (bool, error) {
+ var count int64
+ err := r.db.Model(&userservice.UserModel{}).Where("telegram_id = ?", telegramID).Count(&count).Error
+ if err != nil {
+ return false, err
+ }
+ return count > 0, nil
+}
+
+
+
package http
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+
+ "github.com/google/uuid"
+ "github.com/gorilla/mux"
+
+ userservice "github.com/danilovid/linkkeeper/internal/user-service"
+ "github.com/danilovid/linkkeeper/pkg/logger"
+)
+
+type Server struct {
+ uc userservice.Usecase
+}
+
+func NewServer(uc userservice.Usecase) *Server {
+ return &Server{uc: uc}
+}
+
+func (s *Server) Handler() http.Handler {
+ return s.routes()
+}
+
+type CreateUserRequest struct {
+ TelegramID int64 `json:"telegram_id"`
+ Username string `json:"username,omitempty"`
+ FirstName string `json:"first_name,omitempty"`
+ LastName string `json:"last_name,omitempty"`
+}
+
+type UserResponse struct {
+ ID string `json:"id"`
+ TelegramID int64 `json:"telegram_id"`
+ Username string `json:"username,omitempty"`
+ FirstName string `json:"first_name,omitempty"`
+ LastName string `json:"last_name,omitempty"`
+ CreatedAt string `json:"created_at"`
+ UpdatedAt string `json:"updated_at"`
+}
+
+type ExistsResponse struct {
+ Exists bool `json:"exists"`
+}
+
+func (s *Server) GetOrCreateUser(w http.ResponseWriter, r *http.Request) {
+ var req CreateUserRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ logger.L().Error().Err(err).Msg("failed to decode request")
+ http.Error(w, "invalid request body", http.StatusBadRequest)
+ return
+ }
+
+ if req.TelegramID == 0 {
+ http.Error(w, "telegram_id is required", http.StatusBadRequest)
+ return
+ }
+
+ user, err := s.uc.GetOrCreateUser(req.TelegramID, req.Username, req.FirstName, req.LastName)
+ if err != nil {
+ logger.L().Error().Err(err).Msg("failed to get or create user")
+ http.Error(w, "internal server error", http.StatusInternalServerError)
+ return
+ }
+
+ resp := UserResponse{
+ ID: user.ID.String(),
+ TelegramID: user.TelegramID,
+ Username: user.Username,
+ FirstName: user.FirstName,
+ LastName: user.LastName,
+ CreatedAt: user.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ UpdatedAt: user.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ if err := json.NewEncoder(w).Encode(resp); err != nil {
+ logger.L().Error().Err(err).Msg("failed to encode response")
+ }
+}
+
+func (s *Server) GetUserByID(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+ idStr := vars["id"]
+
+ id, err := uuid.Parse(idStr)
+ if err != nil {
+ http.Error(w, "invalid user id", http.StatusBadRequest)
+ return
+ }
+
+ user, err := s.uc.GetUserByID(id)
+ if err != nil {
+ logger.L().Error().Err(err).Msg("failed to get user")
+ http.Error(w, "user not found", http.StatusNotFound)
+ return
+ }
+
+ resp := UserResponse{
+ ID: user.ID.String(),
+ TelegramID: user.TelegramID,
+ Username: user.Username,
+ FirstName: user.FirstName,
+ LastName: user.LastName,
+ CreatedAt: user.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ UpdatedAt: user.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ if err := json.NewEncoder(w).Encode(resp); err != nil {
+ logger.L().Error().Err(err).Msg("failed to encode response")
+ }
+}
+
+func (s *Server) GetUserByTelegramID(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+ telegramID := vars["telegram_id"]
+
+ var id int64
+ if _, err := fmt.Sscanf(telegramID, "%d", &id); err != nil {
+ http.Error(w, "invalid telegram_id", http.StatusBadRequest)
+ return
+ }
+
+ user, err := s.uc.GetUserByTelegramID(id)
+ if err != nil {
+ logger.L().Error().Err(err).Msg("failed to get user by telegram id")
+ http.Error(w, "user not found", http.StatusNotFound)
+ return
+ }
+
+ resp := UserResponse{
+ ID: user.ID.String(),
+ TelegramID: user.TelegramID,
+ Username: user.Username,
+ FirstName: user.FirstName,
+ LastName: user.LastName,
+ CreatedAt: user.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ UpdatedAt: user.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ if err := json.NewEncoder(w).Encode(resp); err != nil {
+ logger.L().Error().Err(err).Msg("failed to encode response")
+ }
+}
+
+func (s *Server) CheckUserExists(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+ telegramID := vars["telegram_id"]
+
+ var id int64
+ if _, err := fmt.Sscanf(telegramID, "%d", &id); err != nil {
+ http.Error(w, "invalid telegram_id", http.StatusBadRequest)
+ return
+ }
+
+ exists, err := s.uc.UserExists(id)
+ if err != nil {
+ logger.L().Error().Err(err).Msg("failed to check user existence")
+ http.Error(w, "internal server error", http.StatusInternalServerError)
+ return
+ }
+
+ resp := ExistsResponse{Exists: exists}
+ w.Header().Set("Content-Type", "application/json")
+ if err := json.NewEncoder(w).Encode(resp); err != nil {
+ logger.L().Error().Err(err).Msg("failed to encode response")
+ }
+}
+
+
+
package http
+
+import (
+ "net/http"
+
+ "github.com/gorilla/mux"
+ "github.com/justinas/alice"
+ "github.com/rs/cors"
+
+ "github.com/danilovid/linkkeeper/pkg/logger"
+)
+
+func (s *Server) routes() http.Handler {
+ r := mux.NewRouter()
+
+ middleware := alice.New(
+ logRequest,
+ cors.New(cors.Options{
+ AllowedOrigins: []string{"*"},
+ AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+ AllowedHeaders: []string{"*"},
+ AllowCredentials: true,
+ }).Handler,
+ )
+
+ api := r.PathPrefix("/api/v1").Subrouter()
+
+ api.HandleFunc("/users", s.GetOrCreateUser).Methods("POST")
+ api.HandleFunc("/users/{id}", s.GetUserByID).Methods("GET")
+ api.HandleFunc("/users/telegram/{telegram_id}", s.GetUserByTelegramID).Methods("GET")
+ api.HandleFunc("/users/telegram/{telegram_id}/exists", s.CheckUserExists).Methods("GET")
+
+ r.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ if _, err := w.Write([]byte("OK")); err != nil {
+ logger.L().Error().Err(err).Msg("failed to write health response")
+ }
+ }).Methods("GET")
+
+ return middleware.Then(r)
+}
+
+func logRequest(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ logger.L().Info().
+ Str("method", r.Method).
+ Str("path", r.URL.Path).
+ Msg("request")
+ next.ServeHTTP(w, r)
+ })
+}
+
+
+
package usecase
+
+import (
+ "github.com/google/uuid"
+
+ userservice "github.com/danilovid/linkkeeper/internal/user-service"
+)
+
+type userUsecase struct {
+ repo userservice.Repository
+}
+
+func NewUserService(repo userservice.Repository) userservice.Usecase {
+ return &userUsecase{repo: repo}
+}
+
+func (u *userUsecase) CreateUser(telegramID int64, username, firstName, lastName string) (*userservice.UserModel, error) {
+ user := &userservice.UserModel{
+ TelegramID: telegramID,
+ Username: username,
+ FirstName: firstName,
+ LastName: lastName,
+ }
+
+ if err := u.repo.Create(user); err != nil {
+ return nil, err
+ }
+
+ return user, nil
+}
+
+func (u *userUsecase) GetUserByID(id uuid.UUID) (*userservice.UserModel, error) {
+ return u.repo.GetByID(id)
+}
+
+func (u *userUsecase) GetUserByTelegramID(telegramID int64) (*userservice.UserModel, error) {
+ return u.repo.GetByTelegramID(telegramID)
+}
+
+func (u *userUsecase) GetOrCreateUser(telegramID int64, username, firstName, lastName string) (*userservice.UserModel, error) {
+ user, err := u.repo.GetByTelegramID(telegramID)
+ if err == nil {
+ return user, nil
+ }
+
+ return u.CreateUser(telegramID, username, firstName, lastName)
+}
+
+func (u *userUsecase) UserExists(telegramID int64) (bool, error) {
+ return u.repo.Exists(telegramID)
+}
+
+
+
package config
+
+import (
+ "flag"
+ "os"
+)
+
+// Config represents system configuration.
+type Config struct {
+ Env string // runtime environment
+ HTTPAddr string // address "[host]:port" for HTTP server
+ PostgresDSN string // Postgres DSN
+}
+
+// New reads config from environment/flags and returns pointer to a new Config.
+func New() *Config {
+ c := &Config{}
+
+ flag.StringVar(&c.Env, "env", lookupEnvString("ENV", "dev"), "Set runtime environment.")
+ flag.StringVar(&c.HTTPAddr, "httpAddr", lookupEnvString("HTTP_ADDR", ":8080"), `Address in form of "[host]:port" that HTTP server should be listening on.`)
+ flag.StringVar(
+ &c.PostgresDSN,
+ "postgresDsn",
+ lookupEnvString("POSTGRES_DSN", "postgres://postgres:postgres@localhost:5432/linkkeeper?sslmode=disable"),
+ "PostgreSQL DSN.",
+ )
+
+ flag.Parse()
+
+ return c
+}
+
+func lookupEnvString(k, def string) string {
+ if v := os.Getenv(k); v != "" {
+ return v
+ }
+ return def
+}
+
+
+
package postgresql
+
+import (
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+
+ "gorm.io/driver/postgres"
+ "gorm.io/gorm"
+
+ "github.com/danilovid/linkkeeper/pkg/logger"
+)
+
+func New(dsn string, models ...any) *gorm.DB {
+ db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
+ if err != nil {
+ logger.L().Fatal().Err(err).Msg("open database")
+ }
+ if len(models) > 0 {
+ if err := db.AutoMigrate(models...); err != nil {
+ logger.L().Fatal().Err(err).Msg("auto migrate")
+ }
+ }
+ if err := applyMigrations(db, migrationsDir()); err != nil {
+ logger.L().Fatal().Err(err).Msg("apply migrations")
+ }
+ return db
+}
+
+func migrationsDir() string {
+ if v := os.Getenv("MIGRATIONS_DIR"); v != "" {
+ return v
+ }
+ return "migrations"
+}
+
+func applyMigrations(db *gorm.DB, dir string) error {
+ if err := db.Exec(`
+ CREATE TABLE IF NOT EXISTS schema_migrations (
+ version text PRIMARY KEY,
+ applied_at timestamptz NOT NULL DEFAULT now()
+ )
+ `).Error; err != nil {
+ return err
+ }
+
+ entries, err := os.ReadDir(dir)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return nil
+ }
+ return err
+ }
+
+ var files []string
+ for _, entry := range entries {
+ if entry.IsDir() {
+ continue
+ }
+ if strings.HasSuffix(entry.Name(), ".sql") {
+ files = append(files, entry.Name())
+ }
+ }
+ sort.Strings(files)
+
+ for _, name := range files {
+ var exists int
+ if err := db.Raw(`SELECT 1 FROM schema_migrations WHERE version = ?`, name).Scan(&exists).Error; err != nil {
+ return err
+ }
+ if exists == 1 {
+ continue
+ }
+
+ path := filepath.Join(dir, name)
+ content, err := os.ReadFile(path)
+ if err != nil {
+ return err
+ }
+ if err := db.Exec(string(content)).Error; err != nil {
+ return err
+ }
+ if err := db.Exec(`INSERT INTO schema_migrations (version) VALUES (?)`, name).Error; err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+
+
package httpclient
+
+import (
+ "crypto/tls"
+ "net/http"
+ "time"
+)
+
+const (
+ readTimeout = 5 * time.Second
+ writeTimeout = 5 * time.Second
+)
+
+func New(httpAddr string, handler http.Handler, tlsConfig *tls.Config) *http.Server {
+ return &http.Server{
+ ReadTimeout: readTimeout,
+ WriteTimeout: writeTimeout,
+ Addr: httpAddr,
+ Handler: handler,
+ TLSConfig: tlsConfig,
+ }
+}
+
+
+
package logger
+
+import (
+ "os"
+ "time"
+
+ "github.com/rs/zerolog"
+ "github.com/rs/zerolog/log"
+)
+
+func Init() {
+ zerolog.TimeFieldFormat = time.RFC3339Nano
+ writer := zerolog.ConsoleWriter{
+ Out: os.Stdout,
+ TimeFormat: time.RFC3339Nano,
+ }
+ log.Logger = log.Output(writer)
+}
+
+func L() *zerolog.Logger {
+ l := log.Logger
+ return &l
+}
+
+
+