updates

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

internal/database/migrations/sqlite/000001_init_schema.down.sql

@@ -1,4 +1,5 @@
 drop table if exists packages;
 drop table if exists modules;
 drop table if exists issues;
-drop table if exists comments;
+drop table if exists comments;
+drop table if exists handlers;

internal/database/migrations/sqlite/000001_init_schema.up.sql

@@ -15,11 +15,18 @@ create table if not exists issues (
     updated timestamp not null default current_timestamp
 );
 
+create table if not exists handlers (
+    id integer primary key autoincrement not null,
+    package integer not null,
+    name varchar,
+    coverage number default 0
+);
+
 create table if not exists packages (
     id integer primary key autoincrement not null,
     name varchar not null,
     url varchar not null,
-    desc varchar,
+    description varchar,
     modules integer default 0,
     issues integer default 0,
     comments integer default 0,

internal/handler/handler_list.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"context"
+	"net/http"
+
+	"git.unistack.org/unistack-org/pkgdash/internal/models"
+	pb "git.unistack.org/unistack-org/pkgdash/proto"
+	httpsrv "go.unistack.org/micro-server-http/v4"
+	"go.unistack.org/micro/v4/logger"
+)
+
+func (h *Handler) HandlerList(ctx context.Context, req *pb.HandlerListReq, rsp *pb.HandlerListRsp) error {
+	logger.Debug(ctx, "HandlerList handler start")
+
+	packages, err := h.store.HandlerList(ctx, req)
+	if err != nil {
+		logger.Errorf(ctx, "error db response: %v", err)
+		httpsrv.SetRspCode(ctx, http.StatusInternalServerError)
+		return httpsrv.SetError(NewInternalError(err))
+	}
+
+	for _, hdlr := range packages {
+		rsp.Handlers = append(rsp.Handlers, models.NewHandler(hdlr))
+	}
+	logger.Debug(ctx, "HandlerList handler stop")
+	return nil
+}

internal/models/models.go

@@ -8,20 +8,48 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
+type Handler struct {
+	ID       uint64          `db:"id"`
+	Package  uint64          `db:"package"`
+	Name     string          `db:"name"`
+	Coverage sql.NullFloat64 `db:"coverage"`
+}
+
+func NewHandler(hdlr *Handler) *pb.Handler {
+	if hdlr == nil {
+		return nil
+	}
+	rsp := &pb.Handler{
+		Id:      hdlr.ID,
+		Package: hdlr.Package,
+		Name:    hdlr.Name,
+	}
+	if hdlr.Coverage.Valid {
+		rsp.Coverage = hdlr.Coverage.Float64
+	}
+	return rsp
+}
+
 type Package struct {
-	LastCheck sql.NullTime `db:"last_check"`
-	Created   time.Time    `db:"created"`
-	Updated   time.Time    `db:"updated"`
-	Name      string       `db:"name"`
-	URL       string       `db:"url"`
-	Modules   uint64       `db:"modules"`
-	Issues    uint64       `db:"issues"`
-	Comments  uint64       `db:"comments"`
-	ID        uint64       `db:"id"`
-	Status    uint64       `db:"status"`
+	Created     time.Time       `db:"created"`
+	Updated     time.Time       `db:"updated"`
+	LastCheck   sql.NullTime    `db:"last_check"`
+	Type        string          `db:"type"`
+	Name        string          `db:"name"`
+	URL         string          `db:"url"`
+	Description sql.NullString  `db:"description"`
+	Coverage    sql.NullFloat64 `db:"coverage"`
+	Modules     uint64          `db:"modules"`
+	ID          uint64          `db:"id"`
+	Status      uint64          `db:"status"`
+	Comments    uint64          `db:"comments"`
+	Issues      uint64          `db:"issues"`
 }
 
 func NewPackage(pkg *Package) *pb.Package {
+	if pkg == nil {
+		return nil
+	}
 	rsp := &pb.Package{
 		Name:     pkg.Name,
 		Url:      pkg.URL,
@@ -31,10 +59,20 @@ func NewPackage(pkg *Package) *pb.Package {
 		Id:       pkg.ID,
 		Created:  timestamppb.New(pkg.Created),
 		Updated:  timestamppb.New(pkg.Updated),
+		Type:     pkg.Type,
+	}
+	if rsp.Type == "" {
+		rsp.Type = "package"
+	}
+	if pkg.Description.Valid {
+		rsp.Description = pkg.Description.String
 	}
 	if pkg.LastCheck.Valid {
 		rsp.LastCheck = timestamppb.New(pkg.LastCheck.Time)
 	}
+	if pkg.Coverage.Valid {
+		rsp.Coverage = pkg.Coverage.Float64
+	}
 	return rsp
 }
 
@@ -46,6 +84,9 @@ type Module struct {
 }
 
 func NewModule(mod *Module) *pb.Module {
+	if mod == nil {
+		return nil
+	}
 	rsp := &pb.Module{
 		Name:    mod.Name,
 		Version: mod.Version,
@@ -73,6 +114,9 @@ type Comment struct {
 }
 
 func NewComment(com *Comment) *pb.Comment {
+	if com == nil {
+		return nil
+	}
 	return &pb.Comment{
 		Id:      com.ID,
 		Comment: com.Comment,

internal/storage/sqlite/queries.go

@@ -1,6 +1,7 @@
 package sqlite
 
 const (
+	queryPackageModulesCount     = `update packages set modules = $2 where id = $1;`
 	queryPackagesModulesCreate   = `insert into packages_modules as pm (package, module) values ($1, $2) on conflict (package,module) do nothing;`
 	queryPackagesUpdateLastCheck = `update packages set last_check = CURRENT_TIMESTAMP where id = $1;`
 	queryPackagesModules         = `select modules.id, modules.name, modules.version from modules left join packages_modules on modules.id = packages_modules.module left join packages on packages.id = packages_modules.package where packages_modules.package = $1;`
@@ -13,5 +14,6 @@ const (
 	queryPackagesCreate          = `insert into packages as p (name, url) values ($1, $2) on conflict (url) do update set name = p.name returning *;`
 	queryModulesList             = `select id, name, version from modules;`
 	queryModulesCreate           = `insert into modules as m (name, version) values ($1, $2) on conflict (name,version) do update set last_check = CURRENT_TIMESTAMP returning *;`
-	queryCommentsList            = `select id, text, created, updated from comments;`
+	queryCommentsList            = `select id, text, created, updated from comments where package = $1;`
+	queryHandlersList            = `select id, name, coverage from handlers where package = $1;`
 )

internal/storage/sqlite/storage.go

@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"time"
 
@@ -48,6 +49,12 @@ func (s *Sqlite) PackageModulesCreate(ctx context.Context, pkg *models.Package,
 
 	}
 
+	_, err = tx.ExecContext(ctx, queryPackageModulesCount, pkg.ID, len(modules))
+	if err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+
 	if err = tx.Commit(); err != nil {
 		_ = tx.Rollback()
 		return err
@@ -69,6 +76,9 @@ func (s *Sqlite) PackageLookup(ctx context.Context, req *pb.PackageLookupReq) (*
 
 	err := s.db.GetContext(ctx, pkg, queryPackagesLookup, req.Id)
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
 		return nil, err
 	}
 
@@ -80,6 +90,9 @@ func (s *Sqlite) PackageList(ctx context.Context, req *pb.PackageListReq) ([]*mo
 
 	err := s.db.SelectContext(ctx, &packages, queryPackagesList)
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
 		return nil, err
 	}
 
@@ -91,6 +104,9 @@ func (s *Sqlite) PackageModules(ctx context.Context, req *pb.PackageModulesReq)
 
 	err := s.db.SelectContext(ctx, &modules, queryPackagesModules, req.Package)
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
 		return nil, err
 	}
 
@@ -201,6 +217,9 @@ func (s *Sqlite) ModuleList(ctx context.Context, req *pb.ModuleListReq) ([]*mode
 
 	err := s.db.SelectContext(ctx, &modules, queryModulesList)
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
 		return nil, err
 	}
 
@@ -210,10 +229,27 @@ func (s *Sqlite) ModuleList(ctx context.Context, req *pb.ModuleListReq) ([]*mode
 func (s *Sqlite) CommentList(ctx context.Context, req *pb.CommentListReq) ([]*models.Comment, error) {
 	var comments []*models.Comment
 
-	err := s.db.SelectContext(ctx, &comments, queryCommentsList, req.PackageId)
+	err := s.db.SelectContext(ctx, &comments, queryCommentsList, req.Package)
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
 		return nil, err
 	}
 
 	return comments, nil
 }
+
+func (s *Sqlite) HandlerList(ctx context.Context, req *pb.HandlerListReq) ([]*models.Handler, error) {
+	var handlers []*models.Handler
+
+	err := s.db.SelectContext(ctx, &handlers, queryHandlersList, req.Package)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return handlers, nil
+}

internal/storage/storage.go

@@ -23,6 +23,7 @@ type Storage interface {
 	ModulesProcess(ctx context.Context, td time.Duration) ([]*models.Module, error)
 	PackagesProcess(ctx context.Context, td time.Duration) ([]*models.Package, error)
 	PackageCreate(ctx context.Context, req *pb.PackageCreateReq) (*models.Package, error)
+	HandlerList(ctx context.Context, req *pb.HandlerListReq) ([]*models.Handler, error)
 	PackageList(ctx context.Context, req *pb.PackageListReq) ([]*models.Package, error)
 	PackageLookup(ctx context.Context, req *pb.PackageLookupReq) (*models.Package, error)
 	PackageUpdate(ctx context.Context, req *pb.PackageUpdateReq) (*models.Package, error)