feat(backend): 入库每行新建独立产品发独立序列号(product 加生产日期/批次列)

入库 Create/Update 改为对每条明细新建独立 product（createIndependentProduct，
nextProductCode 自增 + uk_shop_code 唯一约束兜底），回填 product_id；不再按名称复用。
product 表加 production_date/batch_no。向后兼容：保留明细/库存快照列。

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YZ4DskSRKsSiheQonFtQvx

.gitea/workflows/backup.yml

@@ -1,37 +1,35 @@
 name: DB Backup
 
 on:
-  # 定时备份已暂停（保留手动触发）。恢复时取消下面 schedule 的注释即可。
-  # schedule:
-  #   - cron: '0 18 * * *'  # UTC 18:00 = 北京时间 02:00
+  # 每日定时备份（北京时间 02:00）。手动触发亦可。
+  schedule:
+    - cron: '0 18 * * *'  # UTC 18:00 = 北京时间 02:00
   workflow_dispatch:
 
+concurrency:
+  group: db-backup
+  cancel-in-progress: false
+
 jobs:
   backup:
-    runs-on: ubuntu-latest
+    runs-on: mac
     steps:
-      - name: Setup SSH
-        run: |
-          mkdir -p ~/.ssh
-          printf '%s' "${{ secrets.EC2_SSH_KEY }}" > ~/.ssh/ec2.pem
-          chmod 600 ~/.ssh/ec2.pem
-          ssh-keyscan -H ${{ secrets.EC2_HOST }} >> ~/.ssh/known_hosts
+      - uses: actions/checkout@v4
 
-      - name: Dump MySQL to NAS
+      - name: Dump MySQL to local backup dir
         env:
+          EC2_SSH_KEY: ${{ secrets.EC2_SSH_KEY }}
           EC2_HOST: ${{ secrets.EC2_HOST }}
           EC2_USER: ${{ secrets.EC2_USER }}
-          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
-        run: |
-          BACKUP_DIR=/volume1/docker/backups/jiu-db
-          mkdir -p $BACKUP_DIR
-          FILENAME="jiu_db_$(date +%Y%m%d_%H%M%S).sql.gz"
-          ssh -i ~/.ssh/ec2.pem ${EC2_USER}@${EC2_HOST} \
-            "docker exec jiu_mysql mysqldump -uroot -p${DB_PASSWORD} jiu_db" \
-            | gzip > ${BACKUP_DIR}/${FILENAME}
-          find $BACKUP_DIR -name "*.sql.gz" -mtime +30 -delete
-          echo "Saved: ${BACKUP_DIR}/${FILENAME}"
+        run: sh scripts/ci/backup-db.sh
 
-      - name: Cleanup SSH key
+      - name: Notify (Telegram)
         if: always()
-        run: rm -f ~/.ssh/ec2.pem
+        env:
+          TELEGRAM_TOKEN: ${{ secrets.TELEGRAM_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          if [ "${{ job.status }}" = "success" ]; then ICON="✅"; LABEL="数据库备份成功"; else ICON="❌"; LABEL="数据库备份失败"; fi
+          curl -f -X POST "https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage" \
+            -d "chat_id=${TELEGRAM_CHAT_ID}" \
+            --data-urlencode "text=${ICON} 岩美 ${LABEL}" > /dev/null || true

CHANGELOG-server.md

@@ -5,6 +5,16 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.69] - 2026-06-21
+
+### 改进
+- 入库录入改为「每行一个独立产品」：每条明细新建独立商品、发独立序列号（同名同规格录多次也各自独立），不再复用已有商品编号，符合"每个货品一个唯一编号"的管理方式
+
+## [1.0.68] - 2026-06-21
+
+### 修复
+- 根治商品编码可能重复的问题：自动编码改为按现有最大序号递增生成（不再复用已删除商品占用过的编号、并发下也不会撞号），并在数据库层为「同门店 + 编码」加唯一约束，从此重复编码无法静默产生
+
 ## [1.0.67] - 2026-06-20
 
 ### 修复

backend/internal/handler/product.go

@@ -62,6 +62,65 @@ func (h *ProductHandler) List(c *gin.Context) {
 	})
 }
 
+// nextProductCode 生成该门店下一个自动商品编码（P001、P002…）。
+// 取现有 P 开头编码的最大数字序号 +1，**含软删行**（deleted_at 非空也计入，不复用已删商品占用过的号）。
+// 不加行锁——并发下两请求可能算出同号，由 uk_shop_code 唯一约束 + 调用方 ErrDuplicatedKey 重试兜底。
+// 用 GORM 表达式（非 MySQL 方言 SQL），sqlite 单测也能跑。
+func nextProductCode(tx *gorm.DB, shopID uint64) (string, error) {
+	var codes []string
+	if err := tx.Model(&model.Product{}).
+		Where("shop_id = ? AND code LIKE 'P%'", shopID).
+		Pluck("code", &codes).Error; err != nil {
+		return "", err
+	}
+	maxN := 0
+	for _, c := range codes {
+		if len(c) < 2 {
+			continue
+		}
+		if n, err := strconv.Atoi(c[1:]); err == nil && n > maxN {
+			maxN = n
+		}
+	}
+	return fmt.Sprintf("P%03d", maxN+1), nil
+}
+
+// createIndependentProduct 为入库明细新建一个独立产品（特有产品/序列号），返回新 product。
+// "入库每行 = 一个特有产品"模型:每条明细建一个独立 product、发新序列号,不按名称复用。
+// 含 nextProductCode 自增 + 撞 uk_shop_code 唯一约束时重试。必须在事务内调用。
+func createIndependentProduct(tx *gorm.DB, shopID uint64, name, series, spec, batchNo string, prodDate *model.Date, price float64) (model.Product, error) {
+	namePinyin, nameInitials := util.ToPinyin(name)
+	var prod model.Product
+	var err error
+	for attempt := 0; attempt < 5; attempt++ {
+		code, e := nextProductCode(tx, shopID)
+		if e != nil {
+			return model.Product{}, e
+		}
+		prod = model.Product{
+			TenantBase:     model.TenantBase{ShopID: shopID},
+			PublicID:       uuid.New().String(),
+			Code:           code,
+			Name:           name,
+			Series:         series,
+			Spec:           spec,
+			BatchNo:        batchNo,
+			ProductionDate: prodDate,
+			PurchasePrice:  price,
+			NamePinyin:     namePinyin,
+			NameInitials:   nameInitials,
+		}
+		prod.ID = 0
+		if err = tx.Create(&prod).Error; err == nil || !errors.Is(err, gorm.ErrDuplicatedKey) {
+			break
+		}
+	}
+	if err != nil {
+		return model.Product{}, err
+	}
+	return prod, nil
+}
+
 // Create POST /api/v1/products
 func (h *ProductHandler) Create(c *gin.Context) {
 	shopID := middleware.GetShopID(c)
@@ -74,31 +133,24 @@ func (h *ProductHandler) Create(c *gin.Context) {
 	product.PublicID = uuid.New().String()
 	product.NamePinyin, product.NameInitials = util.ToPinyin(product.Name)
 
-	// Auto-generate product code if not provided (e.g. P001, P002)
-	// Retry up to 5 times on duplicate key to handle concurrent creates
-	if product.Code == "" {
-		var count int64
-		h.db.Model(&model.Product{}).
-			Where("shop_id = ? AND deleted_at IS NULL", shopID).
-			Count(&count)
-		product.Code = fmt.Sprintf("P%03d", count+1)
-	}
-
+	// 未显式指定编码时自动生成（事务内 max+1）；撞 uk_shop_code 唯一约束则重算下一号重试（应对并发）。
+	autoCode := product.Code == ""
 	var createErr error
 	for attempt := 0; attempt < 5; attempt++ {
-		if createErr = h.db.Create(&product).Error; createErr == nil {
+		createErr = h.db.Transaction(func(tx *gorm.DB) error {
+			if autoCode {
+				code, err := nextProductCode(tx, shopID)
+				if err != nil {
+					return err
+				}
+				product.Code = code
+			}
+			product.ID = 0
+			return tx.Create(&product).Error
+		})
+		if createErr == nil || !autoCode || !errors.Is(createErr, gorm.ErrDuplicatedKey) {
 			break
 		}
-		if !errors.Is(createErr, gorm.ErrDuplicatedKey) {
-			break
-		}
-		// Duplicate code: try next slot
-		var count int64
-		h.db.Model(&model.Product{}).
-			Where("shop_id = ? AND deleted_at IS NULL", shopID).
-			Count(&count)
-		product.ID = 0
-		product.Code = fmt.Sprintf("P%03d", count+int64(attempt)+2)
 	}
 	if createErr != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": createErr.Error()})
@@ -256,25 +308,37 @@ func (h *ProductHandler) FindOrCreate(c *gin.Context) {
 		return
 	}
 
-	var count int64
-	h.db.Model(&model.Product{}).Where("shop_id = ? AND deleted_at IS NULL", shopID).Count(&count)
 	namePinyin, nameInitials := util.ToPinyin(req.Name)
-	product = model.Product{
-		TenantBase:       model.TenantBase{ShopID: shopID},
-		PublicID:         uuid.New().String(),
-		Name:             req.Name,
-		Series:           req.Series,
-		Spec:             req.Spec,
-		Code:             fmt.Sprintf("P%03d", count+1),
-		NamePinyin:       namePinyin,
-		NameInitials:     nameInitials,
-		OriginID:         req.OriginID,
-		ShelfLifeID:      req.ShelfLifeID,
-		StorageID:        req.StorageID,
-		DescriptionDocID: req.DescriptionDocID,
+	// 事务内 max+1 生成编码；撞 uk_shop_code 唯一约束则重算下一号重试（应对并发）。
+	var createErr error
+	for attempt := 0; attempt < 5; attempt++ {
+		createErr = h.db.Transaction(func(tx *gorm.DB) error {
+			code, err := nextProductCode(tx, shopID)
+			if err != nil {
+				return err
+			}
+			product = model.Product{
+				TenantBase:       model.TenantBase{ShopID: shopID},
+				PublicID:         uuid.New().String(),
+				Name:             req.Name,
+				Series:           req.Series,
+				Spec:             req.Spec,
+				Code:             code,
+				NamePinyin:       namePinyin,
+				NameInitials:     nameInitials,
+				OriginID:         req.OriginID,
+				ShelfLifeID:      req.ShelfLifeID,
+				StorageID:        req.StorageID,
+				DescriptionDocID: req.DescriptionDocID,
+			}
+			return tx.Create(&product).Error
+		})
+		if createErr == nil || !errors.Is(createErr, gorm.ErrDuplicatedKey) {
+			break
+		}
 	}
-	if createErr := h.db.Create(&product).Error; createErr != nil {
-		// Race condition: try to find the record created by another request
+	if createErr != nil {
+		// Race condition: 并发可能已按同 name/series/spec 建好，回查返回既有
 		if h.db.Where("shop_id = ? AND name = ? AND series = ? AND spec = ? AND deleted_at IS NULL",
 			shopID, req.Name, req.Series, req.Spec).First(&product).Error == nil {
 			util.RespondSuccess(c, product)

backend/internal/handler/product_test.go

@@ -2,13 +2,16 @@ package handler
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
 
+	"github.com/wangjia/jiu/backend/internal/model"
 	"github.com/wangjia/jiu/backend/testutil"
 )
 
@@ -199,3 +202,67 @@ func TestProductHandler_Create_ShopIDFromToken(t *testing.T) {
 	dataBytes, _ := json.Marshal(data)
 	_ = dataBytes
 }
+
+// 自动编码按最大序号递增：P001 → P002 → P003。
+func TestProductHandler_AutoCode_Increment(t *testing.T) {
+	db := testutil.SetupTestDB()
+	shop := testutil.CreateTestShop(db, "AC001")
+	user := testutil.CreateTestUser(db, shop.ID, "admin", "pass", "admin")
+	token := getAuthToken(user.ID, shop.ID, "admin")
+	r := setupProtectedRouter(db)
+
+	var codes []string
+	for i := 0; i < 3; i++ {
+		w := makeRequest(r, "POST", "/api/v1/products", token, map[string]interface{}{
+			"name": fmt.Sprintf("AutoP %d", i), "unit": "个",
+		})
+		require.Equal(t, http.StatusCreated, w.Code)
+		data := parseResponse(w)["data"].(map[string]interface{})
+		codes = append(codes, data["code"].(string))
+	}
+	assert.Equal(t, []string{"P001", "P002", "P003"}, codes)
+}
+
+// 软删商品后，新建不复用被删的号（旧 count+1 逻辑会复用 → 重复，此为根因修复回归测试）。
+func TestProductHandler_AutoCode_NoReuseAfterSoftDelete(t *testing.T) {
+	db := testutil.SetupTestDB()
+	shop := testutil.CreateTestShop(db, "AC002")
+	user := testutil.CreateTestUser(db, shop.ID, "admin", "pass", "admin")
+	token := getAuthToken(user.ID, shop.ID, "admin")
+	r := setupProtectedRouter(db)
+
+	var lastID uint64
+	for i := 0; i < 3; i++ { // P001 P002 P003
+		w := makeRequest(r, "POST", "/api/v1/products", token, map[string]interface{}{
+			"name": fmt.Sprintf("NR %d", i), "unit": "个",
+		})
+		require.Equal(t, http.StatusCreated, w.Code)
+		lastID = extractID(w)
+	}
+	// 软删 P003
+	w := makeRequest(r, "DELETE", fmt.Sprintf("/api/v1/products/%d", lastID), token, nil)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	// 再建 → 必须是 P004，不能复用已软删的 P003
+	w = makeRequest(r, "POST", "/api/v1/products", token, map[string]interface{}{
+		"name": "NR new", "unit": "个",
+	})
+	require.Equal(t, http.StatusCreated, w.Code)
+	data := parseResponse(w)["data"].(map[string]interface{})
+	assert.Equal(t, "P004", data["code"])
+}
+
+// (shop_id, code) 唯一约束生效，且重复被翻译成 gorm.ErrDuplicatedKey（Create/FindOrCreate 重试的前提）。
+func TestProductHandler_UniqueShopCode(t *testing.T) {
+	db := testutil.SetupTestDB()
+	shop := testutil.CreateTestShop(db, "UQ001")
+	require.NoError(t, db.Exec("CREATE UNIQUE INDEX uk_shop_code ON products(shop_id, code)").Error)
+
+	p1 := model.Product{TenantBase: model.TenantBase{ShopID: shop.ID}, Name: "A", Code: "P001"}
+	require.NoError(t, db.Create(&p1).Error)
+
+	p2 := model.Product{TenantBase: model.TenantBase{ShopID: shop.ID}, Name: "B", Code: "P001"}
+	err := db.Create(&p2).Error
+	require.Error(t, err)
+	assert.True(t, errors.Is(err, gorm.ErrDuplicatedKey))
+}

backend/internal/handler/stock_in.go

@@ -106,19 +106,28 @@ func (h *StockInHandler) Create(c *gin.Context) {
 	}
 	req.OrderNo = orderNo
 
-	// 计算总金额；自动生成批次号
-	var total float64
-	for i := range req.Items {
-		req.Items[i].ShopID = shopID
-		req.Items[i].TotalPrice = req.Items[i].Quantity * req.Items[i].UnitPrice
-		total += req.Items[i].TotalPrice
-		if req.Items[i].BatchNo == "" {
-			req.Items[i].BatchNo = fmt.Sprintf("%s-%02d", req.OrderNo, i+1)
+	// 事务内：每条明细新建一个独立产品（特有产品/序列号，不按名称复用），回填 product_id，再建单。
+	err = h.db.Transaction(func(tx *gorm.DB) error {
+		var total float64
+		for i := range req.Items {
+			it := &req.Items[i]
+			it.ShopID = shopID
+			if it.BatchNo == "" {
+				it.BatchNo = fmt.Sprintf("%s-%02d", req.OrderNo, i+1)
+			}
+			prod, e := createIndependentProduct(tx, shopID, it.ProductName, it.Series, it.Spec, it.BatchNo, it.ProductionDate, it.UnitPrice)
+			if e != nil {
+				return e
+			}
+			it.ProductID = prod.ID
+			it.ProductCode = prod.Code // 保留快照,兼容现有查询(瘦身阶段再去)
+			it.TotalPrice = it.Quantity * it.UnitPrice
+			total += it.TotalPrice
 		}
-	}
-	req.TotalAmount = total
-
-	if err := h.db.Create(&req).Error; err != nil {
+		req.TotalAmount = total
+		return tx.Create(&req).Error
+	})
+	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
@@ -148,13 +157,20 @@ func (h *StockInHandler) Update(c *gin.Context) {
 		}
 		var total float64
 		for i := range req.Items {
-			req.Items[i].ShopID = shopID
-			req.Items[i].OrderID = order.ID
-			req.Items[i].TotalPrice = req.Items[i].Quantity * req.Items[i].UnitPrice
-			total += req.Items[i].TotalPrice
-			if req.Items[i].BatchNo == "" {
-				req.Items[i].BatchNo = fmt.Sprintf("%s-%02d", order.OrderNo, i+1)
+			it := &req.Items[i]
+			it.ShopID = shopID
+			it.OrderID = order.ID
+			if it.BatchNo == "" {
+				it.BatchNo = fmt.Sprintf("%s-%02d", order.OrderNo, i+1)
 			}
+			// 编辑草稿:旧明细已删,每条按新模型重建独立产品（旧草稿 product 无库存,暂留待后续清理）
+			prod, e := createIndependentProduct(tx, shopID, it.ProductName, it.Series, it.Spec, it.BatchNo, it.ProductionDate, it.UnitPrice)
+			if e != nil {
+				return e
+			}
+			it.ProductID = prod.ID
+			it.ProductCode = prod.Code
+			it.TotalPrice = it.Quantity * it.UnitPrice
 		}
 		updates := map[string]interface{}{
 			"warehouse_id": req.WarehouseID,

backend/internal/handler/stock_in_test.go

@@ -28,9 +28,11 @@ func TestStockInHandler_FullFlow(t *testing.T) {
 		"order_date":   time.Now().Format(time.RFC3339),
 		"items": []map[string]interface{}{
 			{
-				"product_id": product.ID,
-				"quantity":   10.0,
-				"unit_price": 5.0,
+				"product_name": "Test Beer",
+				"series":       "普通",
+				"spec":         "500ml",
+				"quantity":     10.0,
+				"unit_price":   5.0,
 			},
 		},
 	})
@@ -57,15 +59,17 @@ func TestStockInHandler_FullFlow(t *testing.T) {
 	w = makeRequest(r, "PUT", fmt.Sprintf("/api/v1/stock-in/orders/%d/approve", orderID), token, nil)
 	require.Equal(t, http.StatusOK, w.Code)
 
-	// 5. 验证库存变化
+	// 5. 验证库存变化：入库为明细新建了独立产品，库存指向它（不是预设的 product）
 	var inv model.Inventory
-	db.Where("shop_id = ? AND warehouse_id = ? AND product_id = ?",
-		shop.ID, warehouse.ID, product.ID).First(&inv)
+	db.Where("shop_id = ? AND warehouse_id = ?",
+		shop.ID, warehouse.ID).First(&inv)
 	assert.Equal(t, float64(10), inv.Quantity)
+	assert.NotZero(t, inv.ProductID)
+	assert.NotEqual(t, product.ID, inv.ProductID)
 
 	// 6. 验证库存流水
 	var logs []model.InventoryLog
-	db.Where("shop_id = ? AND product_id = ?", shop.ID, product.ID).Find(&logs)
+	db.Where("shop_id = ? AND product_id = ?", shop.ID, inv.ProductID).Find(&logs)
 	require.Len(t, logs, 1)
 	assert.Equal(t, "in", logs[0].Direction)
 	assert.Equal(t, float64(10), logs[0].Quantity)

backend/internal/model/product.go

@@ -10,6 +10,8 @@ type ProductCategory struct {
 type Product struct {
 	TenantBase
 	PublicID      string  `gorm:"size:36;uniqueIndex" json:"public_id"`
+	// Code 商品编码：同店内唯一。(shop_id, code) 联合唯一索引 uk_shop_code 由 autoMigrate 显式建（见 main.go），
+	// 不在此用 tag 声明——ShopID 在共用 TenantBase 上，tag 只能建单列索引会破坏多租户隔离。
 	Code          string  `gorm:"size:50" json:"code"`
 	Barcode       string  `gorm:"size:100" json:"barcode"`
 	Name          string  `gorm:"size:200;not null" json:"name"`
@@ -20,6 +22,9 @@ type Product struct {
 	Brand         string  `gorm:"size:100" json:"brand"`
 	PurchasePrice float64 `gorm:"type:decimal(12,2)" json:"purchase_price"`
 	SalePrice     float64 `gorm:"type:decimal(12,2)" json:"sale_price"`
+	// 特有产品的批次属性：每个 product = 一个特有产品/序列号，生产日期/批次归此（单一来源）
+	ProductionDate *Date  `gorm:"type:date" json:"production_date"`
+	BatchNo        string `gorm:"size:50" json:"batch_no"`
 	MinStock      int     `gorm:"default:0" json:"min_stock"`
 	Description   string  `gorm:"type:text" json:"description"`
 	CustomFields    JSON    `gorm:"type:json" json:"custom_fields,omitempty"`

backend/main.go

@@ -87,7 +87,8 @@ func initDB() *gorm.DB {
 	}
 
 	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
-		Logger: logger.Default.LogMode(logLevel),
+		Logger:         logger.Default.LogMode(logLevel),
+		TranslateError: true, // 把 MySQL 1062 翻译成 gorm.ErrDuplicatedKey，供编码撞唯一约束时重试
 	})
 	if err != nil {
 		log.Fatalf("failed to connect database: %v", err)
@@ -136,5 +137,12 @@ func autoMigrate(db *gorm.DB) {
 	if err != nil {
 		log.Fatalf("auto migrate failed: %v", err)
 	}
+	// products(shop_id, code) 联合唯一索引：ShopID 在共用 TenantBase 上无法用 struct tag 表达，
+	// 故在此幂等显式建（保证同店内商品编码唯一，DB 层兜底防止重复编码静默落库）。
+	if !db.Migrator().HasIndex(&model.Product{}, "uk_shop_code") {
+		if err := db.Exec("CREATE UNIQUE INDEX uk_shop_code ON products (shop_id, code)").Error; err != nil {
+			log.Fatalf("create unique index uk_shop_code failed: %v", err)
+		}
+	}
 	log.Println("AutoMigrate completed")
 }

backend/testutil/setup.go

@@ -46,7 +46,8 @@ func SetupTestDB() *gorm.DB {
 	InitConfig()
 
 	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
+		Logger:         logger.Default.LogMode(logger.Silent),
+		TranslateError: true,
 	})
 	if err != nil {
 		panic(fmt.Sprintf("failed to open sqlite: %v", err))
@@ -187,6 +188,8 @@ func SetupTestDB() *gorm.DB {
 			brand TEXT,
 			purchase_price REAL,
 			sale_price REAL,
+			production_date DATETIME,
+			batch_no TEXT,
 			min_stock INTEGER DEFAULT 0,
 			description TEXT,
 			custom_fields TEXT,

scripts/ci/backup-db.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# backup-db.sh — dump the production MySQL (jiu_db) from EC2 and keep a gzip
+# snapshot on the mac (host) runner's local disk (~/jiu-db-backups), retaining
+# the last 30 days. The DB password is read on EC2 from production.env's
+# DATABASE_DSN, so no DB-password secret is needed.
+#
+# Requires env (same as deploy-server): EC2_SSH_KEY, EC2_HOST, EC2_USER.
+set -euo pipefail
+
+# shellcheck source=scripts/ci/lib-forgejo.sh
+. "$(dirname "$0")/lib-forgejo.sh"
+
+BACKUP_DIR="${HOME}/jiu-db-backups"
+mkdir -p "${BACKUP_DIR}"
+FILENAME="jiu_db_$(date +%Y%m%d_%H%M%S).sql.gz"
+DEST="${BACKUP_DIR}/${FILENAME}"
+
+setup_ssh
+trap teardown_ssh EXIT
+
+echo "==> backup-db: dumping jiu_db from ${EC2_HOST}"
+# On EC2: parse the DSN password from production.env, then mysqldump the
+# container to stdout; stream back over ssh and gzip locally. The heredoc is
+# single-quoted, so it runs verbatim on EC2 (no local expansion). ${SSH} carries
+# no -t, keeping stdout a clean dump stream.
+${SSH} "${EC2_USER}@${EC2_HOST}" 'bash -s' <<'ENDSSH' | gzip > "${DEST}"
+set -euo pipefail
+PW=$(python3 -c 'import re;e=open("/opt/jiu/config/production.env").read();d=re.search(r"DATABASE_DSN=(.*)",e).group(1).strip().strip(chr(34)).strip(chr(39));print(re.match(r"[^:]+:([^@]+)@",d).group(1))')
+exec docker exec -e MYSQL_PWD="${PW}" jiu_mysql mysqldump -uroot --single-transaction --no-tablespaces jiu_db
+ENDSSH
+
+# Integrity + sanity + retention.
+gzip -t "${DEST}"
+SIZE=$(stat -f%z "${DEST}" 2>/dev/null || stat -c%s "${DEST}")
+if [ "${SIZE}" -lt 100000 ]; then
+  echo "==> backup-db: dump suspiciously small (${SIZE} bytes), aborting" >&2
+  rm -f "${DEST}"
+  exit 1
+fi
+find "${BACKUP_DIR}" -name '*.sql.gz' -mtime +30 -delete
+echo "==> backup-db: saved ${DEST} (${SIZE} bytes)"