fix: remove EndpointCount from CollectionEntity

- Remove EndpointCount field from core CollectionEntity
- Use simple GetCollections query without JOIN
- Add GetEndpointCountsByCollections query
- Update itemMapper to fetch counts only for display

Author: maniac-en

db/queries/collections.sql

@@ -7,16 +7,8 @@ ORDER BY created_at DESC
 LIMIT ? OFFSET ?;
 
 -- name: GetCollections :many
-SELECT
-    c.id,
-    c.name,
-    c.created_at,
-    c.updated_at,
-    COUNT(e.id) AS endpoint_count
-FROM collections c
-LEFT JOIN endpoints e ON e.collection_id = c.id
-GROUP BY c.id, c.name, c.created_at, c.updated_at
-ORDER BY c.created_at DESC;
+SELECT * FROM collections
+ORDER BY created_at DESC;
 
 -- name: CountCollections :one
 SELECT COUNT(*) FROM collections;

db/queries/endpoints.sql

@@ -31,6 +31,11 @@ LIMIT ? OFFSET ?;
 SELECT COUNT(*) FROM endpoints
 WHERE collection_id = ?;
 
+-- name: GetEndpointCountsByCollections :many
+SELECT collection_id, COUNT(*) as count
+FROM endpoints
+GROUP BY collection_id;
+
 -- name: UpdateEndpointName :one
 UPDATE endpoints
 SET

internal/backend/collections/manager.go

@@ -96,23 +96,17 @@ func (c *CollectionsManager) Delete(ctx context.Context, id int64) error {
 }
 
 func (c *CollectionsManager) List(ctx context.Context) ([]CollectionEntity, error) {
-	log.Debug("listing all collections without pagination")
 	collections, err := c.DB.GetCollections(ctx)
-	collectionsEntity := []CollectionEntity{}
-	for _, collection := range collections {
-		collectionsEntity = append(collectionsEntity, CollectionEntity{Collection: database.Collection{
-			ID:        collection.ID,
-			Name:      collection.Name,
-			CreatedAt: collection.CreatedAt,
-			UpdatedAt: collection.UpdatedAt,
-		},
-			EndpointCount: int(collection.EndpointCount),
-		})
-	}
 	if err != nil {
 		return nil, err
 	}
-	return collectionsEntity, nil
+	
+	entities := make([]CollectionEntity, len(collections))
+	for i, collection := range collections {
+		entities[i] = CollectionEntity{Collection: collection}
+	}
+	
+	return entities, nil
 }
 
 func (c *CollectionsManager) ListPaginated(ctx context.Context, limit, offset int) (*PaginatedCollections, error) {

internal/backend/collections/models.go

@@ -9,7 +9,6 @@ import (
 
 type CollectionEntity struct {
 	database.Collection
-	EndpointCount int
 }
 
 func (c CollectionEntity) GetID() int64 {
@@ -20,9 +19,6 @@ func (c CollectionEntity) GetName() string {
 	return c.Name
 }
 
-func (c CollectionEntity) GetEnpointCount() int {
-	return c.EndpointCount
-}
 
 func (c CollectionEntity) GetCreatedAt() time.Time {
 	return crud.ParseTimestamp(c.CreatedAt)

internal/backend/database/collections.sql.go

@@ -256,3 +256,12 @@ func (e *EndpointsManager) UpdateEndpoint(ctx context.Context, id int64, data En
 	log.Info("updated endpoint", "id", endpoint.ID, "name", endpoint.Name)
 	return EndpointEntity{Endpoint: endpoint}, nil
 }
+
+func (e *EndpointsManager) GetCountsByCollections(ctx context.Context) ([]database.GetEndpointCountsByCollectionsRow, error) {
+	counts, err := e.DB.GetEndpointCountsByCollections(ctx)
+	if err != nil {
+		log.Error("failed to get endpoint counts", "error", err)
+		return nil, err
+	}
+	return counts, nil
+}

internal/backend/database/endpoints.sql.go

@@ -149,7 +149,7 @@ func NewAppModel(ctx *Context) AppModel {
 		keys:        appKeybinds,
 	}
 	model.Views = map[ViewName]views.ViewInterface{
-		Collections: views.NewCollectionsView(model.ctx.Collections, 1),
+		Collections: views.NewCollectionsView(model.ctx.Collections, model.ctx.Endpoints, 1),
 		Endpoints:   views.NewEndpointsView(model.ctx.Endpoints, 2),
 	}
 	return model

internal/backend/endpoints/manager.go

@@ -10,19 +10,21 @@ import (
 	"github.com/charmbracelet/bubbles/list"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/maniac-en/req/internal/backend/collections"
+	"github.com/maniac-en/req/internal/backend/endpoints"
 	optionsProvider "github.com/maniac-en/req/internal/tui/components/OptionsProvider"
 	"github.com/maniac-en/req/internal/tui/keybinds"
 	"github.com/maniac-en/req/internal/tui/messages"
 )
 
 type CollectionsView struct {
-	width   int
-	height  int
-	list    optionsProvider.OptionsProvider[collections.CollectionEntity, string]
-	manager *collections.CollectionsManager
-	help    help.Model
-	keys    *keybinds.ListKeyMap
-	order   int
+	width            int
+	height           int
+	list             optionsProvider.OptionsProvider[collections.CollectionEntity, string]
+	manager          *collections.CollectionsManager
+	endpointsManager *endpoints.EndpointsManager
+	help             help.Model
+	keys             *keybinds.ListKeyMap
+	order            int
 }
 
 func (c CollectionsView) Init() tea.Cmd {
@@ -85,33 +87,55 @@ func (c CollectionsView) OnBlur() {
 
 }
 
-func itemMapper(items []collections.CollectionEntity) []list.Item {
+func itemMapper(items []collections.CollectionEntity, endpointsManager *endpoints.EndpointsManager) []list.Item {
 	opts := make([]list.Item, len(items))
+	
+	counts, err := endpointsManager.GetCountsByCollections(context.Background())
+	if err != nil {
+		for i, item := range items {
+			opts[i] = optionsProvider.Option{
+				Name:    item.GetName(),
+				Subtext: "0 endpoints",
+				ID:      item.GetID(),
+			}
+		}
+		return opts
+	}
+	
+	countMap := make(map[int64]int)
+	for _, count := range counts {
+		countMap[count.CollectionID] = int(count.Count)
+	}
+	
 	for i, item := range items {
-		newOpt := optionsProvider.Option{
+		count := countMap[item.GetID()]
+		opts[i] = optionsProvider.Option{
 			Name:    item.GetName(),
-			Subtext: fmt.Sprintf("%d endpoints", item.GetEnpointCount()),
+			Subtext: fmt.Sprintf("%d endpoints", count),
 			ID:      item.GetID(),
 		}
-		opts[i] = newOpt
 	}
+	
 	return opts
 }
 
-func NewCollectionsView(collManager *collections.CollectionsManager, order int) *CollectionsView {
+func NewCollectionsView(collManager *collections.CollectionsManager, endpointsManager *endpoints.EndpointsManager, order int) *CollectionsView {
 	keybinds := keybinds.NewListKeyMap()
 	config := defaultListConfig[collections.CollectionEntity, string](keybinds)
 
 	config.GetItemsFunc = collManager.List
-	config.ItemMapper = itemMapper
+	config.ItemMapper = func(items []collections.CollectionEntity) []list.Item {
+		return itemMapper(items, endpointsManager)
+	}
 	config.AdditionalKeymaps = keybinds
 	config.Source = "collections"
 
 	return &CollectionsView{
-		list:    optionsProvider.NewOptionsProvider(config),
-		manager: collManager,
-		help:    help.New(),
-		keys:    keybinds,
-		order:   order,
+		list:             optionsProvider.NewOptionsProvider(config),
+		manager:          collManager,
+		endpointsManager: endpointsManager,
+		help:             help.New(),
+		keys:             keybinds,
+		order:            order,
 	}
 }