type Core struct {
   userRepo     UserRepo
   sessionRepo  SessionRepo
  hashing      Hasher
  auth         Auth
}

// UserRepo interface for user data repository.
type UserRepo interface {
   // CreateUser adds to the new user in repository.
   // This method is also required to create a notifying hoard.
   // Errors: ErrEmailExist, ErrUsernameExist, unknown.
   CreateUser(context.Context, User, TaskNotification) (UserID, error)
   // UpdatePassword changes password.
   // Resets all codes to reset the password.
   // Errors: unknown.
   UpdatePassword(context.Context, UserID, []byte) error
   // UserByID returning user info by id.
   // Errors: ErrNotFound, unknown.
   UserByID(context.Context, UserID) (*User, error)
  // UserByEmail returning user info by email.
  // Errors: ErrNotFound, unknown.
  UserByEmail(context.Context, string) (*User, error)
  // UserByUsername returning user info by id.
  // Errors: ErrNotFound, unknown.
  UserByUsername(context.Context, string) (*User, error)
}

// SessionRepo interface for session data repository.
type SessionRepo interface {
   // SaveSession saves the new user Session in a database.
   // Errors: unknown.
   SaveSession(context.Context, UserID, TokenID, Origin) error
   // Session returns user Session.
   // Errors: ErrNotFound, unknown.
   SessionByTokenID(context.Context, TokenID) (*Session, error)
   // UserByAuthToken returning user info by authToken.
   // Errors: ErrNotFound, unknown.
   UserByTokenID(context.Context, TokenID) (*User, error)
   // DeleteSession removes user Session.
   // Errors: unknown.
   DeleteSession(context.Context, TokenID) error
}

// Hasher module responsible for working with passwords.
type Hasher interface {
   // Password returns the hashed version of the password.
   // Errors: unknown.
   Password(password string) ([]byte, error)
   // Compare compares two passwords for matches.
   Compare(hashedPassword []byte, password []byte) error
}
// Auth module is responsible for working with authorization tokens.
type Auth interface {
    // Token generates an authorization auth with a specified lifetime,
    // and can also use the UserID if necessary.
    // Errors: unknown.
    Token(expired time.Duration) (AuthToken, TokenID, error)
    // Parse and validates the auth and checks that it's expired.
    // Errors: ErrInvalidToken, ErrExpiredToken, unknown.
    Parse(token AuthToken) (TokenID, error)
}

// VerificationEmail for implemented UserApp.
func (a *Application) VerificationEmail(ctx context.Context, email string) error {
   _, err := a.userRepo.UserByEmail(ctx, email)
   switch {
   case errors.Is(err, ErrNotFound):
      return nil
   case err == nil:
      return ErrEmailExist
   default:
      return err
   }
}
// VerificationUsername for implemented UserApp.
func (a *Application) VerificationUsername(ctx context.Context, username string) error {
   _, err := a.userRepo.UserByUsername(ctx, username)
   switch {
   case errors.Is(err, ErrNotFound):
      return nil
   case err == nil:
      return ErrUsernameExist
   default:
      return err
   }
}

// CreateUser for implemented UserApp.
func (a *Application) CreateUser(ctx context.Context, email, username, password string, origin Origin) (*User, AuthToken, error) {
   passHash, err := a.password.Password(password)
   if err != nil {
      return nil, "", err
   }
   email = strings.ToLower(email)
   newUser := User{
      Email:    email,
      Name:     username,
      PassHash: passHash,
   }
   _, err = a.userRepo.CreateUser(ctx, newUser)
   if err != nil {
      return nil, "", err
   }
   return a.Login(ctx, email, password, origin)
}
// Login for implemented UserApp.
func (a *Application) Login(ctx context.Context, email, password string, origin Origin) (*User, AuthToken, error) {
  email = strings.ToLower(email)
  user, err := a.userRepo.UserByEmail(ctx, email)
  if err != nil {
    return nil, "", err
  }
  if err := a.password.Compare(user.PassHash, []byte(password)); err != nil {
    return nil, "", err
  }
  token, tokenID, err := a.auth.Token(TokenExpire)
  if err != nil {
    return nil, "", err
  }
  err = a.sessionRepo.SaveSession(ctx, user.ID, tokenID, origin)
  if err != nil {
    return nil, "", err
  }
  return user, token, nil
}

// Package hasher contains methods for hashing and comparing passwords.
package hasher
import (
   "errors"
   "github.com/zergslaw/boilerplate/internal/app"
   "golang.org/x/crypto/bcrypt"
)
type (
   // Hasher is an implements app.Hasher.
   // Responsible for working passwords, hashing and compare.
   Hasher struct {
      cost int
   }
)
// New creates and returns new app.Hasher.
func New(cost int) app.Hasher {
   return &Hasher{cost: cost}
}
// Hashing need for implements app.Hasher.
func (h *Hasher) Password(password string) ([]byte, error) {
   return bcrypt.GenerateFromPassword([]byte(password), h.cost)
}
// Compare need for implements app.Hasher.
func (h *Hasher) Compare(hashedPassword []byte, password []byte) error {
   err := bcrypt.CompareHashAndPassword(hashedPassword, password)
   switch {
   case errors.Is(err, bcrypt.ErrMismatchedHashAndPassword):
      return app.ErrNotValidPassword
   case err != nil:
      return err
   }
   return nil
}

var _ app.SessionRepo = &Repo{}
var _ app.UserRepo = &Repo{}
// Repo is an implements app.UserRepo.
// Responsible for working with database.
type Repo struct {
  db *sqlx.DB
}
// New creates and returns new app.UserRepo.
func New(repo *sqlx.DB) *Repo {
  return &Repo{db: repo}
}

// CreateUser need for implements app.UserRepo.
func (repo *Repo) CreateUser(ctx context.Context, newUser app.User, task app.TaskNotification) (userID app.UserID, err error) {
   const query = `INSERT INTO users (username, email, pass_hash) VALUES ($1, $2, $3) RETURNING id`
   hash := pgtype.Bytea{
      Bytes:  newUser.PassHash,
      Status: pgtype.Present,
   }
   err = repo.db.QueryRowxContext(ctx, query, newUser.Name, newUser.Email, hash).Scan(&userID)
   if err != nil {
      return 0, fmt.Errorf("create user: %w", err)
   }
   return userID, nil
}
// UserByUsername need for implements app.UserRepo.
func (repo *Repo) UserByUsername(ctx context.Context, username string) (user *app.User, err error) {
  const query = `SELECT * FROM users WHERE username = $1`
  u := &userDBFormat{}
  err = repo.db.GetContext(ctx, u, query, username)
  if err != nil {
    return nil, err
  }
  return u.toAppFormat(), nil
}

func (api *api) handler(w http.ResponseWriter, r *http.Request) {
  params := &arg{}
  err := json.NewDecoder(r.Body).Decode(params)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }
  origin := orifinFromReq(r)
  res, err := api.app.CreateUser(
    r.Context(),
    params.Email,
    params.Username,
    params.Password,
    request,
  )
  switch {
  case errors.Is(err, app.ErrNotFound):
    http.Error(w, app.ErrNotFound.Error(), http.StatusNotFound)
  case errors.Is(err, app.ErrChtoto):
    http.Error(w, app.ErrChtoto.Error(), http.StatusTeapot)
  case err == nil:
      json.NewEncoder(w).Encode(res)
  default:
    http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
  }
}

func (api *api) handler(w http.ResponseWriter, r *http.Request) {
  params := &arg{}
  err := json.NewDecoder(r.Body).Decode(params)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
  }
  rows, err := api.db.QueryContext(r.Context(), "sql query", params.Param)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }
  var arrayRes []val
  for rows.Next() {
    value := val{}
    err := rows.Scan(&value)
    if err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
    }
    arrayRes = append(arrayRes, value)
  }
  // ещё много кода для выполнения неких бизнес задач
  err = json.NewEncoder(w).Encode(arrayRes)
  w.WriteHeader(http.StatusOK)
}