refactor: привести кодовую базу в соответствие с канонами bible

- 400 → 422 для всех ошибок валидации входных данных (handlers: export, quote, sync, vendor_spec, partnumber_books, pricelist)
- SQL-запросы вынесены из handlers в localdb (partnumber_books, pricelist, support_bundle); ValidateMariaDBConnection перенесён в internal/db/validate.go
- List-ответы унифицированы: ключ items, поля total_count/page/per_page/total_pages (component, pricelist, partnumber_books); шаблоны обновлены
- Молчаливые ошибки заменены на slog.Warn/Error (support_bundle, vendor_spec, component, configuration, local_configuration, localdb)
- N+1 запросы устранены: batch-запросы в export.go и vendor_workspace_import.go
- fmt.Println → slog в cmd/ (qfs, migrate, migrate_ops_projects, migrate_project_updated_at)
- Заголовки recovery/verify добавлены во все 28 SQL-миграций
- Добавлены bible-local/runtime-flows.md и bible-local/decisions/
- Обновлён субмодуль bible до v0.2.0-13

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

internal/db/validate.go

@@ -0,0 +1,60 @@
+package db
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	gormmysql "gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+var errPermissionProbeRollback = errors.New("permission probe rollback")
+
+// ValidateMariaDBConnection opens a one-off connection using dsn, pings, checks
+// the required lot table exists, and probes write access to qt_client_schema_state.
+// Returns (lot row count, canWrite, error).
+func ValidateMariaDBConnection(dsn string) (int64, bool, error) {
+	db, err := gorm.Open(gormmysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		return 0, false, fmt.Errorf("open MariaDB connection: %w", err)
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return 0, false, fmt.Errorf("get database handle: %w", err)
+	}
+	defer sqlDB.Close()
+
+	if err := sqlDB.Ping(); err != nil {
+		return 0, false, fmt.Errorf("ping MariaDB: %w", err)
+	}
+
+	var lotCount int64
+	if err := db.Table("lot").Count(&lotCount).Error; err != nil {
+		return 0, false, fmt.Errorf("check required table lot: %w", err)
+	}
+
+	return lotCount, testSyncWritePermission(db), nil
+}
+
+func testSyncWritePermission(db *gorm.DB) bool {
+	sentinel := fmt.Sprintf("quoteforge-permission-check-%d", time.Now().UnixNano())
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Exec(`
+			INSERT INTO qt_client_schema_state (username, hostname, last_checked_at, updated_at)
+			VALUES (?, ?, NOW(), NOW())
+			ON DUPLICATE KEY UPDATE
+				last_checked_at = VALUES(last_checked_at),
+				updated_at = VALUES(updated_at)
+		`, sentinel, "setup-check").Error; err != nil {
+			return err
+		}
+		return errPermissionProbeRollback
+	})
+
+	return errors.Is(err, errPermissionProbeRollback)
+}

internal/handlers/component.go

@@ -64,11 +64,16 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		}
 	}
 
+	totalPages := int((total + int64(perPage) - 1) / int64(perPage))
+	if totalPages < 1 {
+		totalPages = 1
+	}
 	c.JSON(http.StatusOK, &services.ComponentListResult{
-		Components: components,
-		Total:      total,
+		Items:      components,
+		TotalCount: total,
 		Page:       page,
 		PerPage:    perPage,
+		TotalPages: totalPages,
 	})
 }
 

internal/handlers/export.go

@@ -60,7 +60,7 @@ type ProjectExportOptionsRequest struct {
 func (h *ExportHandler) ExportCSV(c *gin.Context) {
 	var req ExportRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -68,7 +68,7 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 
 	// Validate before streaming (can return JSON error)
 	if len(data.Configs) == 0 || len(data.Configs[0].Items) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "no items to export"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "no items to export"})
 		return
 	}
 
@@ -160,7 +160,7 @@ func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
 
 	// Validate before streaming (can return JSON error)
 	if len(data.Configs) == 0 || len(data.Configs[0].Items) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "no items to export"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "no items to export"})
 		return
 	}
 
@@ -206,7 +206,7 @@ func (h *ExportHandler) ExportProjectCSV(c *gin.Context) {
 	}
 
 	if len(result.Configs) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "no configurations to export"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "no configurations to export"})
 		return
 	}
 
@@ -228,7 +228,7 @@ func (h *ExportHandler) ExportConfigPricingCSV(c *gin.Context) {
 
 	var req ProjectExportOptionsRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -285,7 +285,7 @@ func (h *ExportHandler) ExportProjectPricingCSV(c *gin.Context) {
 
 	var req ProjectExportOptionsRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -301,7 +301,7 @@ func (h *ExportHandler) ExportProjectPricingCSV(c *gin.Context) {
 		return
 	}
 	if len(result.Configs) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "no configurations to export"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "no configurations to export"})
 		return
 	}
 

internal/handlers/export_test.go

@@ -128,8 +128,8 @@ func TestExportCSV_InvalidRequest(t *testing.T) {
 	handler.ExportCSV(c)
 
 	// Should return 400 Bad Request
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("Expected status 400, got %d", w.Code)
+	if w.Code != http.StatusUnprocessableEntity {
+		t.Errorf("Expected status 422, got %d", w.Code)
 	}
 
 	// Should return JSON error
@@ -162,8 +162,8 @@ func TestExportCSV_EmptyItems(t *testing.T) {
 	handler.ExportCSV(c)
 
 	// Should return 400 Bad Request (validation error from gin binding)
-	if w.Code != http.StatusBadRequest {
-		t.Logf("Status code: %d (expected 400 for empty items)", w.Code)
+	if w.Code != http.StatusUnprocessableEntity {
+		t.Logf("Status code: %d (expected 422 for empty items)", w.Code)
 	}
 }
 
@@ -294,8 +294,8 @@ func TestExportConfigCSV_EmptyItems(t *testing.T) {
 	handler.ExportConfigCSV(c)
 
 	// Should return 400 Bad Request
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("Expected status 400, got %d", w.Code)
+	if w.Code != http.StatusUnprocessableEntity {
+		t.Errorf("Expected status 422, got %d", w.Code)
 	}
 
 	// Should return JSON error

internal/handlers/partnumber_books.go

@@ -51,8 +51,11 @@ func (h *PartnumberBooksHandler) List(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"books": summaries,
-		"total": len(summaries),
+		"items":       summaries,
+		"total_count": len(summaries),
+		"page":        1,
+		"per_page":    len(summaries),
+		"total_pages": 1,
 	})
 }
 
@@ -62,7 +65,7 @@ func (h *PartnumberBooksHandler) GetItems(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 64)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid book ID"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "invalid book ID"})
 		return
 	}
 
@@ -77,9 +80,8 @@ func (h *PartnumberBooksHandler) GetItems(c *gin.Context) {
 		perPage = 100
 	}
 
-	// Find local book by server_id
-	var book localdb.LocalPartnumberBook
-	if err := h.localDB.DB().Where("server_id = ?", id).First(&book).Error; err != nil {
+	book, err := h.localDB.GetLocalPartnumberBookByServerID(uint(id))
+	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "partnumber book not found"})
 		return
 	}
@@ -90,15 +92,20 @@ func (h *PartnumberBooksHandler) GetItems(c *gin.Context) {
 		return
 	}
 
+	totalPages := int((total + int64(perPage) - 1) / int64(perPage))
+	if totalPages < 1 {
+		totalPages = 1
+	}
 	c.JSON(http.StatusOK, gin.H{
 		"book_id":     book.ServerID,
 		"version":     book.Version,
 		"is_active":   book.IsActive,
 		"partnumbers": book.PartnumbersJSON,
 		"items":       items,
-		"total":       total,
+		"total_count": total,
 		"page":        page,
 		"per_page":    perPage,
+		"total_pages": totalPages,
 		"search":      search,
 		"book_total":  bookRepo.CountBookItems(book.ID),
 		"lot_count":   bookRepo.CountDistinctLots(book.ID),

internal/handlers/pricelist.go

@@ -106,11 +106,16 @@ func (h *PricelistHandler) List(c *gin.Context) {
 		})
 	}
 
+	totalPages := (total + perPage - 1) / perPage
+	if totalPages < 1 {
+		totalPages = 1
+	}
 	c.JSON(http.StatusOK, gin.H{
-		"pricelists": summaries,
-		"total":      total,
-		"page":       page,
-		"per_page":   perPage,
+		"items":       summaries,
+		"total_count": total,
+		"page":        page,
+		"per_page":    perPage,
+		"total_pages": totalPages,
 	})
 }
 
@@ -119,7 +124,7 @@ func (h *PricelistHandler) Get(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "invalid pricelist ID"})
 		return
 	}
 
@@ -146,7 +151,7 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "invalid pricelist ID"})
 		return
 	}
 
@@ -165,40 +170,21 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 	if perPage < 1 {
 		perPage = 50
 	}
-	var items []localdb.LocalPricelistItem
-	dbq := h.localDB.DB().Model(&localdb.LocalPricelistItem{}).Where("pricelist_id = ?", localPL.ID)
-	if strings.TrimSpace(search) != "" {
-		dbq = dbq.Where("lot_name LIKE ?", "%"+strings.TrimSpace(search)+"%")
-	}
-	var total int64
-	if err := dbq.Count(&total).Error; err != nil {
-		RespondError(c, http.StatusInternalServerError, "internal server error", err)
-		return
-	}
-	offset := (page - 1) * perPage
 
-	if err := dbq.Order("lot_name").Offset(offset).Limit(perPage).Find(&items).Error; err != nil {
+	items, total, err := h.localDB.GetLocalPricelistItemsPage(localPL.ID, strings.TrimSpace(search), page, perPage)
+	if err != nil {
 		RespondError(c, http.StatusInternalServerError, "internal server error", err)
 		return
 	}
+
 	lotNames := make([]string, len(items))
 	for i, item := range items {
 		lotNames[i] = item.LotName
 	}
-	type compRow struct {
-		LotName        string
-		LotDescription string
-	}
-	var comps []compRow
-	if len(lotNames) > 0 {
-		h.localDB.DB().Table("local_components").
-			Select("lot_name, lot_description").
-			Where("lot_name IN ?", lotNames).
-			Scan(&comps)
-	}
-	descMap := make(map[string]string, len(comps))
-	for _, c := range comps {
-		descMap[c.LotName] = c.LotDescription
+	descMap, err := h.localDB.GetLocalComponentDescriptionsByLotNames(lotNames)
+	if err != nil {
+		RespondError(c, http.StatusInternalServerError, "internal server error", err)
+		return
 	}
 
 	resultItems := make([]gin.H, 0, len(items))
@@ -217,12 +203,14 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 		})
 	}
 
+	totalPages := int((total + int64(perPage) - 1) / int64(perPage))
 	c.JSON(http.StatusOK, gin.H{
-		"source":   localPL.Source,
-		"items":    resultItems,
-		"total":    total,
-		"page":     page,
-		"per_page": perPage,
+		"source":      localPL.Source,
+		"items":       resultItems,
+		"total_count": total,
+		"page":        page,
+		"per_page":    perPage,
+		"total_pages": totalPages,
 	})
 }
 
@@ -230,7 +218,7 @@ func (h *PricelistHandler) GetLotNames(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "invalid pricelist ID"})
 		return
 	}
 

internal/handlers/pricelist_test.go

@@ -141,21 +141,21 @@ func TestPricelistList_ActiveOnlyExcludesPricelistsWithoutItems(t *testing.T) {
 	}
 
 	var resp struct {
-		Pricelists []struct {
+		Items []struct {
 			ID uint `json:"id"`
-		} `json:"pricelists"`
-		Total int `json:"total"`
+		} `json:"items"`
+		TotalCount int `json:"total_count"`
 	}
 	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
 		t.Fatalf("unmarshal response: %v", err)
 	}
-	if resp.Total != 1 {
-		t.Fatalf("expected total=1, got %d", resp.Total)
+	if resp.TotalCount != 1 {
+		t.Fatalf("expected total=1, got %d", resp.TotalCount)
 	}
-	if len(resp.Pricelists) != 1 {
-		t.Fatalf("expected 1 pricelist, got %d", len(resp.Pricelists))
+	if len(resp.Items) != 1 {
+		t.Fatalf("expected 1 pricelist, got %d", len(resp.Items))
 	}
-	if resp.Pricelists[0].ID != 10 {
-		t.Fatalf("expected pricelist id=10, got %d", resp.Pricelists[0].ID)
+	if resp.Items[0].ID != 10 {
+		t.Fatalf("expected pricelist id=10, got %d", resp.Items[0].ID)
 	}
 }

internal/handlers/quote.go

@@ -18,13 +18,13 @@ func NewQuoteHandler(quoteService *services.QuoteService) *QuoteHandler {
 func (h *QuoteHandler) Validate(c *gin.Context) {
 	var req services.QuoteRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
 	result, err := h.quoteService.ValidateAndCalculate(&req)
 	if err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -34,13 +34,13 @@ func (h *QuoteHandler) Validate(c *gin.Context) {
 func (h *QuoteHandler) Calculate(c *gin.Context) {
 	var req services.QuoteRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
 	result, err := h.quoteService.ValidateAndCalculate(&req)
 	if err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -53,13 +53,13 @@ func (h *QuoteHandler) Calculate(c *gin.Context) {
 func (h *QuoteHandler) PriceLevels(c *gin.Context) {
 	var req services.PriceLevelsRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
 	result, err := h.quoteService.CalculatePriceLevels(&req)
 	if err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 

internal/handlers/setup.go

@@ -1,7 +1,6 @@
 package handlers
 
 import (
-	"errors"
 	"fmt"
 	"html/template"
 	"log/slog"
@@ -15,9 +14,6 @@ import (
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"github.com/gin-gonic/gin"
 	mysqlDriver "github.com/go-sql-driver/mysql"
-	gormmysql "gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
 )
 
 type SetupHandler struct {
@@ -27,8 +23,6 @@ type SetupHandler struct {
 	restartSig chan struct{}
 }
 
-var errPermissionProbeRollback = errors.New("permission probe rollback")
-
 func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, _ string, restartSig chan struct{}) (*SetupHandler, error) {
 	funcMap := template.FuncMap{
 		"sub": func(a, b int) int { return a - b },
@@ -93,7 +87,7 @@ func (h *SetupHandler) TestConnection(c *gin.Context) {
 	}
 
 	dsn := buildMySQLDSN(host, port, database, user, password, 5*time.Second)
-	lotCount, canWrite, err := validateMariaDBConnection(dsn)
+	lotCount, canWrite, err := db.ValidateMariaDBConnection(dsn)
 	if err != nil {
 		_ = c.Error(err)
 		c.JSON(http.StatusOK, gin.H{
@@ -135,7 +129,7 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 
 	// Test connection first
 	dsn := buildMySQLDSN(host, port, database, user, password, 5*time.Second)
-	if _, _, err := validateMariaDBConnection(dsn); err != nil {
+	if _, _, err := db.ValidateMariaDBConnection(dsn); err != nil {
 		_ = c.Error(err)
 		c.JSON(http.StatusBadRequest, gin.H{
 			"success": false,
@@ -214,46 +208,3 @@ func buildMySQLDSN(host string, port int, database, user, password string, timeo
 	return cfg.FormatDSN()
 }
 
-func validateMariaDBConnection(dsn string) (int64, bool, error) {
-	db, err := gorm.Open(gormmysql.Open(dsn), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		return 0, false, fmt.Errorf("open MariaDB connection: %w", err)
-	}
-
-	sqlDB, err := db.DB()
-	if err != nil {
-		return 0, false, fmt.Errorf("get database handle: %w", err)
-	}
-	defer sqlDB.Close()
-
-	if err := sqlDB.Ping(); err != nil {
-		return 0, false, fmt.Errorf("ping MariaDB: %w", err)
-	}
-
-	var lotCount int64
-	if err := db.Table("lot").Count(&lotCount).Error; err != nil {
-		return 0, false, fmt.Errorf("check required table lot: %w", err)
-	}
-
-	return lotCount, testSyncWritePermission(db), nil
-}
-
-func testSyncWritePermission(db *gorm.DB) bool {
-	sentinel := fmt.Sprintf("quoteforge-permission-check-%d", time.Now().UnixNano())
-	err := db.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Exec(`
-			INSERT INTO qt_client_schema_state (username, hostname, last_checked_at, updated_at)
-			VALUES (?, ?, NOW(), NOW())
-			ON DUPLICATE KEY UPDATE
-				last_checked_at = VALUES(last_checked_at),
-				updated_at = VALUES(updated_at)
-		`, sentinel, "setup-check").Error; err != nil {
-			return err
-		}
-		return errPermissionProbeRollback
-	})
-
-	return errors.Is(err, errPermissionProbeRollback)
-}

internal/handlers/support_bundle.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net"
 	"net/http"
 	"os"
@@ -39,7 +40,10 @@ func NewSupportBundleHandler(local *localdb.LocalDB, connMgr *db.ConnectionManag
 // GET /api/support-bundle
 func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 	now := time.Now().UTC()
-	hostname, _ := os.Hostname()
+	hostname, err := os.Hostname()
+	if err != nil {
+		slog.Warn("support bundle: could not get hostname", "err", err)
+	}
 
 	c.Header("Content-Type", "application/zip")
 	c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="qfs-bundle-%s.zip"`, now.Format("20060102-150405")))
@@ -153,8 +157,10 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 	}
 
 	// schema_migrations.json
-	var migrations []localdb.LocalSchemaMigration
-	_ = h.localDB.DB().Order("applied_at ASC").Find(&migrations).Error
+	migrations, err := h.localDB.GetSchemaMigrations()
+	if err != nil {
+		slog.Warn("support bundle: could not load schema migrations", "err", err)
+	}
 	writeJSON("schema_migrations.json", migrations)
 
 	// app.log (tail 5 MiB)
@@ -169,7 +175,9 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 				}
 				if _, err := f.Seek(offset, io.SeekStart); err == nil {
 					if w, err := zw.Create("app.log"); err == nil {
-						_, _ = io.Copy(w, f)
+						if _, err := io.Copy(w, f); err != nil {
+							slog.Warn("support bundle: error copying log file", "err", err)
+						}
 					}
 				}
 			}

internal/handlers/sync.go

@@ -739,7 +739,7 @@ func (h *SyncHandler) ReportPartnumberSeen(c *gin.Context) {
 		} `json:"items"`
 	}
 	if err := c.ShouldBindJSON(&body); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 

internal/handlers/vendor_spec.go

@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"errors"
+	"log/slog"
 	"net/http"
 	"strings"
 
@@ -65,7 +66,7 @@ func (h *VendorSpecHandler) PutVendorSpec(c *gin.Context) {
 		VendorSpec []localdb.VendorSpecItem `json:"vendor_spec"`
 	}
 	if err := c.ShouldBindJSON(&body); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -136,7 +137,7 @@ func (h *VendorSpecHandler) ResolveVendorSpec(c *gin.Context) {
 		VendorSpec []localdb.VendorSpecItem `json:"vendor_spec"`
 	}
 	if err := c.ShouldBindJSON(&body); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 
@@ -149,7 +150,11 @@ func (h *VendorSpecHandler) ResolveVendorSpec(c *gin.Context) {
 		return
 	}
 
-	book, _ := bookRepo.GetActiveBook()
+	book, err := bookRepo.GetActiveBook()
+	if err != nil {
+		slog.Warn("vendor spec resolve: no active partnumber book", "err", err)
+		book = nil
+	}
 	aggregated, err := services.AggregateLOTs(resolved, book, bookRepo)
 	if err != nil {
 		RespondError(c, http.StatusInternalServerError, "internal server error", err)
@@ -179,7 +184,7 @@ func (h *VendorSpecHandler) ApplyVendorSpec(c *gin.Context) {
 		} `json:"items"`
 	}
 	if err := c.ShouldBindJSON(&body); err != nil {
-		RespondError(c, http.StatusBadRequest, "invalid request", err)
+		RespondError(c, http.StatusUnprocessableEntity, "invalid request", err)
 		return
 	}
 

internal/localdb/localdb.go

@@ -497,7 +497,10 @@ func localReadOnlyCacheQuarantineTableName(tableName string, kind string) string
 // HasSettings returns true if connection settings exist
 func (l *LocalDB) HasSettings() bool {
 	var count int64
-	l.db.Model(&ConnectionSettings{}).Count(&count)
+	if err := l.db.Model(&ConnectionSettings{}).Count(&count).Error; err != nil {
+		slog.Error("localdb: HasSettings count failed", "err", err)
+		return false
+	}
 	return count > 0
 }
 
@@ -1044,14 +1047,18 @@ func (l *LocalDB) DeactivateConfiguration(uuid string) error {
 // CountConfigurations returns the number of local configurations
 func (l *LocalDB) CountConfigurations() int64 {
 	var count int64
-	l.db.Model(&LocalConfiguration{}).Count(&count)
+	if err := l.db.Model(&LocalConfiguration{}).Count(&count).Error; err != nil {
+		slog.Error("localdb: CountConfigurations failed", "err", err)
+	}
 	return count
 }
 
 // CountProjects returns the number of local projects
 func (l *LocalDB) CountProjects() int64 {
 	var count int64
-	l.db.Model(&LocalProject{}).Count(&count)
+	if err := l.db.Model(&LocalProject{}).Count(&count).Error; err != nil {
+		slog.Error("localdb: CountProjects failed", "err", err)
+	}
 	return count
 }
 
@@ -1819,3 +1826,62 @@ func (l *LocalDB) SetSyncGuardState(status, reasonCode, reasonText string, requi
 		}),
 	}).Create(state).Error
 }
+
+// GetLocalPartnumberBookByServerID returns a local partnumber book by its server-side ID.
+func (l *LocalDB) GetLocalPartnumberBookByServerID(serverID uint) (*LocalPartnumberBook, error) {
+	var book LocalPartnumberBook
+	if err := l.db.Where("server_id = ?", serverID).First(&book).Error; err != nil {
+		return nil, err
+	}
+	return &book, nil
+}
+
+// GetLocalPricelistItemsPage returns a paginated, searchable list of items for a pricelist.
+func (l *LocalDB) GetLocalPricelistItemsPage(pricelistID uint, search string, page, perPage int) ([]LocalPricelistItem, int64, error) {
+	dbq := l.db.Model(&LocalPricelistItem{}).Where("pricelist_id = ?", pricelistID)
+	if search != "" {
+		dbq = dbq.Where("lot_name LIKE ?", "%"+search+"%")
+	}
+	var total int64
+	if err := dbq.Count(&total).Error; err != nil {
+		return nil, 0, fmt.Errorf("count pricelist items: %w", err)
+	}
+	offset := (page - 1) * perPage
+	var items []LocalPricelistItem
+	if err := dbq.Order("lot_name").Offset(offset).Limit(perPage).Find(&items).Error; err != nil {
+		return nil, 0, fmt.Errorf("fetch pricelist items: %w", err)
+	}
+	return items, total, nil
+}
+
+// GetLocalComponentDescriptionsByLotNames returns a map of lot_name → lot_description for the given lots.
+func (l *LocalDB) GetLocalComponentDescriptionsByLotNames(lotNames []string) (map[string]string, error) {
+	if len(lotNames) == 0 {
+		return map[string]string{}, nil
+	}
+	type row struct {
+		LotName        string
+		LotDescription string
+	}
+	var rows []row
+	if err := l.db.Table("local_components").
+		Select("lot_name, lot_description").
+		Where("lot_name IN ?", lotNames).
+		Scan(&rows).Error; err != nil {
+		return nil, fmt.Errorf("fetch component descriptions: %w", err)
+	}
+	m := make(map[string]string, len(rows))
+	for _, r := range rows {
+		m[r.LotName] = r.LotDescription
+	}
+	return m, nil
+}
+
+// GetSchemaMigrations returns all applied local schema migrations ordered by applied_at.
+func (l *LocalDB) GetSchemaMigrations() ([]LocalSchemaMigration, error) {
+	var migrations []LocalSchemaMigration
+	if err := l.db.Order("applied_at ASC").Find(&migrations).Error; err != nil {
+		return nil, fmt.Errorf("fetch schema migrations: %w", err)
+	}
+	return migrations, nil
+}

internal/services/component.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"fmt"
+	"log/slog"
 	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -41,10 +42,11 @@ func ParsePartNumber(lotName string) (category, model string) {
 }
 
 type ComponentListResult struct {
-	Components []ComponentView `json:"components"`
-	Total      int64           `json:"total"`
+	Items      []ComponentView `json:"items"`
+	TotalCount int64           `json:"total_count"`
 	Page       int             `json:"page"`
 	PerPage    int             `json:"per_page"`
+	TotalPages int             `json:"total_pages"`
 }
 
 type ComponentView struct {
@@ -63,10 +65,11 @@ func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage
 	// Components should be loaded via /api/sync/components first
 	if s.componentRepo == nil {
 		return &ComponentListResult{
-			Components: []ComponentView{},
-			Total:      0,
+			Items:      []ComponentView{},
+			TotalCount: 0,
 			Page:       page,
 			PerPage:    perPage,
+			TotalPages: 1,
 		}, nil
 	}
 
@@ -107,11 +110,16 @@ func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage
 		views[i] = view
 	}
 
+	totalPages := int((total + int64(perPage) - 1) / int64(perPage))
+	if totalPages < 1 {
+		totalPages = 1
+	}
 	return &ComponentListResult{
-		Components: views,
-		Total:      total,
+		Items:      views,
+		TotalCount: total,
 		Page:       page,
 		PerPage:    perPage,
+		TotalPages: totalPages,
 	}, nil
 }
 
@@ -126,8 +134,10 @@ func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error)
 		return nil, err
 	}
 
-	// Track usage
-	_ = s.componentRepo.IncrementRequestCount(lotName)
+	// Track usage (best-effort)
+	if err := s.componentRepo.IncrementRequestCount(lotName); err != nil {
+		slog.Warn("component: could not increment request count", "lot", lotName, "err", err)
+	}
 
 	view := &ComponentView{
 		LotName:         c.LotName,

internal/services/configuration.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"errors"
+	"log/slog"
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -117,8 +118,10 @@ func (s *ConfigurationService) Create(ownerUsername string, req *CreateConfigReq
 		return nil, err
 	}
 
-	// Record usage stats
-	_ = s.quoteService.RecordUsage(req.Items)
+	// Record usage stats (best-effort)
+	if err := s.quoteService.RecordUsage(req.Items); err != nil {
+		slog.Warn("configuration: could not record usage stats", "err", err)
+	}
 
 	return config, nil
 }

internal/services/export.go

@@ -567,45 +567,52 @@ func (s *ExportService) resolvePricingTotals(cfg *models.Configuration, localCfg
 		}
 	}
 
+	estimatePrices := s.batchLookupPrices(estimateID, lots)
+	stockPrices := s.batchLookupPrices(warehouseID, lots)
+	competitorPrices := s.batchLookupPrices(competitorID, lots)
+
 	for _, lot := range lots {
 		level := pricingLevels{}
-		level.Estimate = s.lookupPricePointer(estimateID, lot)
-		level.Stock = s.lookupPricePointer(warehouseID, lot)
-		level.Competitor = s.lookupPricePointer(competitorID, lot)
+		if p, ok := estimatePrices[lot]; ok {
+			level.Estimate = floatPtr(p)
+		}
+		if p, ok := stockPrices[lot]; ok {
+			level.Stock = floatPtr(p)
+		}
+		if p, ok := competitorPrices[lot]; ok {
+			level.Competitor = floatPtr(p)
+		}
 		result[lot] = level
 	}
 	return result
 }
 
-func (s *ExportService) lookupPricePointer(serverPricelistID *uint, lotName string) *float64 {
-	if s.localDB == nil || serverPricelistID == nil || *serverPricelistID == 0 || strings.TrimSpace(lotName) == "" {
+// batchLookupPrices fetches prices for all lots from a pricelist in a single query.
+func (s *ExportService) batchLookupPrices(serverPricelistID *uint, lots []string) map[string]float64 {
+	if s.localDB == nil || serverPricelistID == nil || *serverPricelistID == 0 || len(lots) == 0 {
 		return nil
 	}
 	localPL, err := s.localDB.GetLocalPricelistByServerID(*serverPricelistID)
 	if err != nil {
 		return nil
 	}
-	price, err := s.localDB.GetLocalPriceForLot(localPL.ID, lotName)
-	if err != nil || price <= 0 {
+	prices, err := s.localDB.GetLocalPricesForLots(localPL.ID, lots)
+	if err != nil {
 		return nil
 	}
-	return floatPtr(price)
+	return prices
 }
 
 func (s *ExportService) resolveLotDescriptions(cfg *models.Configuration, localCfg *localdb.LocalConfiguration) map[string]string {
 	lots := collectPricingLots(cfg, localCfg, true)
-	result := make(map[string]string, len(lots))
-	if s.localDB == nil {
-		return result
+	if s.localDB == nil || len(lots) == 0 {
+		return map[string]string{}
 	}
-	for _, lot := range lots {
-		component, err := s.localDB.GetLocalComponent(lot)
-		if err != nil {
-			continue
-		}
-		result[lot] = component.LotDescription
+	descriptions, err := s.localDB.GetLocalComponentDescriptionsByLotNames(lots)
+	if err != nil {
+		return map[string]string{}
 	}
-	return result
+	return descriptions
 }
 
 func collectPricingLots(cfg *models.Configuration, localCfg *localdb.LocalConfiguration, includeBOM bool) []string {

internal/services/local_configuration.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"strings"
 	"time"
 
@@ -118,8 +119,10 @@ func (s *LocalConfigurationService) Create(ownerUsername string, req *CreateConf
 	}
 	cfg.Line = localCfg.Line
 
-	// Record usage stats
-	_ = s.quoteService.RecordUsage(req.Items)
+	// Record usage stats (best-effort)
+	if err := s.quoteService.RecordUsage(req.Items); err != nil {
+		slog.Warn("local configuration: could not record usage stats", "err", err)
+	}
 
 	return cfg, nil
 }
@@ -407,7 +410,9 @@ func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername str
 
 	// Refresh local pricelists when online.
 	if s.isOnline() {
-		_ = s.syncService.SyncPricelistsIfNeeded()
+		if err := s.syncService.SyncPricelistsIfNeeded(); err != nil {
+			slog.Warn("local configuration: background pricelist sync failed", "err", err)
+		}
 	}
 
 	// Use the pricelist stored in the config; fall back to latest if unavailable.
@@ -791,7 +796,9 @@ func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string, pricelistSe
 	}
 
 	if s.isOnline() {
-		_ = s.syncService.SyncPricelistsIfNeeded()
+		if err := s.syncService.SyncPricelistsIfNeeded(); err != nil {
+			slog.Warn("local configuration: background pricelist sync failed", "err", err)
+		}
 	}
 
 	// Resolve which pricelist to use:

internal/services/vendor_workspace_import.go

@@ -269,13 +269,17 @@ func aggregateVendorSpecToItems(spec localdb.VendorSpec, estimatePricelist *loca
 	}
 
 	sort.Strings(order)
+
+	var priceMap map[string]float64
+	if estimatePricelist != nil && local != nil && len(order) > 0 {
+		priceMap, _ = local.GetLocalPricesForLots(estimatePricelist.ID, order)
+	}
+
 	items := make(localdb.LocalConfigItems, 0, len(order))
 	for _, lotName := range order {
 		unitPrice := 0.0
-		if estimatePricelist != nil && local != nil {
-			if price, err := local.GetLocalPriceForLot(estimatePricelist.ID, lotName); err == nil && price > 0 {
-				unitPrice = price
-			}
+		if priceMap != nil {
+			unitPrice = priceMap[lotName]
 		}
 		items = append(items, localdb.LocalConfigItem{
 			LotName:   lotName,