dev: initiate adjustment recording and trf to laying

feat: refactor module adjustment stock, etc.

See merge request mbugroup/lti-api!338

cmd/delete-adjustments/main.go

@@ -0,0 +1,442 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	"gorm.io/gorm"
+)
+
+type adjustmentRow struct {
+	ID                 uint      `gorm:"column:id"`
+	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
+	ProductID          uint      `gorm:"column:product_id"`
+	FunctionCode       string    `gorm:"column:function_code"`
+	TotalQty           float64   `gorm:"column:total_qty"`
+	UsageQty           float64   `gorm:"column:usage_qty"`
+	PendingQty         float64   `gorm:"column:pending_qty"`
+	StockLogIncrease   float64   `gorm:"column:stock_log_increase"`
+	StockLogDecrease   float64   `gorm:"column:stock_log_decrease"`
+	CreatedAt          time.Time `gorm:"column:created_at"`
+}
+
+type routeResolution struct {
+	FlagGroupCode string `gorm:"column:flag_group_code"`
+	Lane          string `gorm:"column:lane"`
+	FunctionCode  string `gorm:"column:function_code"`
+}
+
+func main() {
+	var (
+		idsRaw string
+		apply  bool
+	)
+
+	flag.StringVar(&idsRaw, "ids", "", "Comma-separated adjustment IDs (required), example: 1,2")
+	flag.BoolVar(&apply, "apply", false, "Apply delete. If false, run as dry-run")
+	flag.Parse()
+
+	ids, err := parseIDs(idsRaw)
+	if err != nil {
+		log.Fatalf("invalid --ids: %v", err)
+	}
+	if len(ids) == 0 {
+		log.Fatal("--ids is required")
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+
+	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
+	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
+	fifoSvc := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, nil)
+	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
+	if err := registerAdjustmentFIFO(fifoSvc); err != nil {
+		log.Fatalf("failed to register adjustment fifo config: %v", err)
+	}
+
+	adjustments, err := loadAdjustments(ctx, db, ids)
+	if err != nil {
+		log.Fatalf("failed to load adjustments: %v", err)
+	}
+	if len(adjustments) == 0 {
+		log.Fatal("no adjustments found for provided IDs")
+	}
+
+	sort.Slice(adjustments, func(i, j int) bool {
+		return adjustments[i].ID < adjustments[j].ID
+	})
+
+	fmt.Printf("Mode: %s\n", modeLabel(apply))
+	fmt.Printf("Adjustments loaded: %d\n\n", len(adjustments))
+
+	success := 0
+	failed := 0
+	skipped := 0
+
+	for _, adj := range adjustments {
+		if strings.TrimSpace(adj.FunctionCode) == "" {
+			fmt.Printf("SKIP adj=%d reason=function_code empty\n", adj.ID)
+			skipped++
+			continue
+		}
+
+		route, err := resolveRouteByFunctionCode(ctx, db, adj.ProductID, strings.ToUpper(strings.TrimSpace(adj.FunctionCode)))
+		if err != nil {
+			fmt.Printf("FAIL adj=%d error=resolve route: %v\n", adj.ID, err)
+			failed++
+			continue
+		}
+
+		switch route.Lane {
+		case "USABLE":
+			desiredQty := adj.UsageQty + adj.PendingQty
+			if desiredQty <= 0 && adj.StockLogDecrease > 0 {
+				desiredQty = adj.StockLogDecrease
+			}
+
+			activeAlloc, err := countActiveUsableAllocations(ctx, db, fifo.UsableKeyAdjustmentOut.String(), adj.ID)
+			if err != nil {
+				fmt.Printf("FAIL adj=%d error=count usable allocations: %v\n", adj.ID, err)
+				failed++
+				continue
+			}
+
+			fmt.Printf(
+				"PLAN adj=%d lane=USABLE function=%s usage=%.3f pending=%.3f active_alloc=%d action=reflow_to_zero+delete\n",
+				adj.ID,
+				route.FunctionCode,
+				adj.UsageQty,
+				adj.PendingQty,
+				activeAlloc,
+			)
+
+			if !apply {
+				skipped++
+				continue
+			}
+
+			err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+				reflowReq := commonSvc.FifoStockV2ReflowRequest{
+					FlagGroupCode:      route.FlagGroupCode,
+					ProductWarehouseID: adj.ProductWarehouseID,
+					Usable: commonSvc.FifoStockV2Ref{
+						ID:            adj.ID,
+						LegacyTypeKey: fifo.UsableKeyAdjustmentOut.String(),
+						FunctionCode:  route.FunctionCode,
+					},
+					DesiredQty:     0,
+					IdempotencyKey: fmt.Sprintf("delete-adjustment-usable-%d-%d", adj.ID, time.Now().UnixNano()),
+					Tx:             tx,
+				}
+				if _, err := fifoStockV2Svc.Reflow(ctx, reflowReq); err != nil {
+					return fmt.Errorf("reflow usable to zero: %w", err)
+				}
+
+				if err := hardDeleteUsableAllocations(ctx, tx, fifo.UsableKeyAdjustmentOut.String(), adj.ID); err != nil {
+					return err
+				}
+				if err := hardDeleteAdjustmentStockLogs(ctx, tx, adj.ID); err != nil {
+					return err
+				}
+				if err := hardDeleteAdjustment(ctx, tx, adj.ID); err != nil {
+					return err
+				}
+				return nil
+			})
+			if err != nil {
+				fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
+				failed++
+				continue
+			}
+
+			fmt.Printf("DONE adj=%d deleted\n", adj.ID)
+			success++
+
+		case "STOCKABLE":
+			removeQty := adj.TotalQty
+			if removeQty <= 0 && adj.StockLogIncrease > 0 {
+				removeQty = adj.StockLogIncrease
+			}
+
+			activeAlloc, err := countActiveStockableAllocations(ctx, db, fifo.StockableKeyAdjustmentIn.String(), adj.ID)
+			if err != nil {
+				fmt.Printf("FAIL adj=%d error=count stockable allocations: %v\n", adj.ID, err)
+				failed++
+				continue
+			}
+			if activeAlloc > 0 {
+				fmt.Printf(
+					"FAIL adj=%d reason=stockable still allocated active_alloc=%d action=delete blocked\n",
+					adj.ID,
+					activeAlloc,
+				)
+				failed++
+				continue
+			}
+
+			fmt.Printf(
+				"PLAN adj=%d lane=STOCKABLE function=%s total=%.3f remove_qty=%.3f action=reverse_stock+delete\n",
+				adj.ID,
+				route.FunctionCode,
+				adj.TotalQty,
+				removeQty,
+			)
+
+			if !apply {
+				skipped++
+				continue
+			}
+
+			err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+				if removeQty > 0 {
+					if err := fifoSvc.AdjustStockableQuantity(ctx, commonSvc.StockAdjustRequest{
+						StockableKey:       fifo.StockableKeyAdjustmentIn,
+						StockableID:        adj.ID,
+						ProductWarehouseID: adj.ProductWarehouseID,
+						Quantity:           -removeQty,
+						Tx:                 tx,
+					}); err != nil {
+						return fmt.Errorf("reverse stockable quantity: %w", err)
+					}
+				}
+
+				if err := hardDeleteStockableAllocations(ctx, tx, fifo.StockableKeyAdjustmentIn.String(), adj.ID); err != nil {
+					return err
+				}
+				if err := hardDeleteAdjustmentStockLogs(ctx, tx, adj.ID); err != nil {
+					return err
+				}
+				if err := hardDeleteAdjustment(ctx, tx, adj.ID); err != nil {
+					return err
+				}
+				return nil
+			})
+			if err != nil {
+				fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
+				failed++
+				continue
+			}
+
+			fmt.Printf("DONE adj=%d deleted\n", adj.ID)
+			success++
+
+		default:
+			fmt.Printf("SKIP adj=%d reason=unsupported lane=%s\n", adj.ID, route.Lane)
+			skipped++
+		}
+	}
+
+	fmt.Println()
+	fmt.Printf("Summary: success=%d failed=%d skipped=%d\n", success, failed, skipped)
+	if failed > 0 {
+		os.Exit(1)
+	}
+}
+
+func registerAdjustmentFIFO(fifoSvc commonSvc.FifoService) error {
+	if err := fifoSvc.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyAdjustmentIn,
+		Table: "adjustment_stocks",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil && !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+		return err
+	}
+
+	if err := fifoSvc.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyAdjustmentOut,
+		Table: "adjustment_stocks",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil && !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+		return err
+	}
+	return nil
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY-RUN"
+}
+
+func parseIDs(raw string) ([]uint, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, nil
+	}
+
+	parts := strings.Split(raw, ",")
+	out := make([]uint, 0, len(parts))
+	seen := map[uint]struct{}{}
+
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		v, err := strconv.ParseUint(part, 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("invalid id %q", part)
+		}
+		if v == 0 {
+			return nil, fmt.Errorf("id must be > 0: %q", part)
+		}
+		id := uint(v)
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, id)
+	}
+	return out, nil
+}
+
+func loadAdjustments(ctx context.Context, db *gorm.DB, ids []uint) ([]adjustmentRow, error) {
+	var rows []adjustmentRow
+	err := db.WithContext(ctx).
+		Table("adjustment_stocks a").
+		Select(`
+			a.id,
+			a.product_warehouse_id,
+			pw.product_id,
+			a.function_code,
+			COALESCE(a.total_qty, 0) AS total_qty,
+			COALESCE(a.usage_qty, 0) AS usage_qty,
+			COALESCE(a.pending_qty, 0) AS pending_qty,
+			COALESCE((
+				SELECT sl.increase
+				FROM stock_logs sl
+				WHERE sl.loggable_type = 'ADJUSTMENT'
+					AND sl.loggable_id = a.id
+				ORDER BY sl.id DESC
+				LIMIT 1
+			), 0) AS stock_log_increase,
+			COALESCE((
+				SELECT sl.decrease
+				FROM stock_logs sl
+				WHERE sl.loggable_type = 'ADJUSTMENT'
+					AND sl.loggable_id = a.id
+				ORDER BY sl.id DESC
+				LIMIT 1
+			), 0) AS stock_log_decrease,
+			a.created_at
+		`).
+		Joins("JOIN product_warehouses pw ON pw.id = a.product_warehouse_id").
+		Where("a.id IN ?", ids).
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func resolveRouteByFunctionCode(ctx context.Context, db *gorm.DB, productID uint, functionCode string) (*routeResolution, error) {
+	var rows []routeResolution
+	err := db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules rr").
+		Select("rr.flag_group_code, rr.lane, rr.function_code").
+		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
+		Where("rr.is_active = TRUE").
+		Where("rr.function_code = ?", functionCode).
+		Where(`
+			EXISTS (
+				SELECT 1
+				FROM flags f
+				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
+				WHERE f.flagable_type = ?
+					AND f.flagable_id = ?
+					AND fm.flag_group_code = rr.flag_group_code
+			)
+		`, entity.FlagableTypeProduct, productID).
+		Order("CASE WHEN rr.source_table = 'adjustment_stocks' THEN 0 ELSE 1 END ASC").
+		Order("rr.id ASC").
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("no route found for product_id=%d function_code=%s", productID, functionCode)
+	}
+
+	selected := rows[0]
+	for _, row := range rows {
+		if row.Lane != selected.Lane {
+			return nil, fmt.Errorf("ambiguous lane for product_id=%d function_code=%s", productID, functionCode)
+		}
+	}
+	selected.FunctionCode = functionCode
+	return &selected, nil
+}
+
+func countActiveUsableAllocations(ctx context.Context, db *gorm.DB, usableType string, usableID uint) (int64, error) {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Where("usable_type = ? AND usable_id = ?", usableType, usableID).
+		Where("status = ?", entity.StockAllocationStatusActive).
+		Count(&count).Error
+	return count, err
+}
+
+func countActiveStockableAllocations(ctx context.Context, db *gorm.DB, stockableType string, stockableID uint) (int64, error) {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Where("stockable_type = ? AND stockable_id = ?", stockableType, stockableID).
+		Where("status = ?", entity.StockAllocationStatusActive).
+		Count(&count).Error
+	return count, err
+}
+
+func hardDeleteUsableAllocations(ctx context.Context, tx *gorm.DB, usableType string, usableID uint) error {
+	return tx.WithContext(ctx).
+		Exec("DELETE FROM stock_allocations WHERE usable_type = ? AND usable_id = ?", usableType, usableID).
+		Error
+}
+
+func hardDeleteStockableAllocations(ctx context.Context, tx *gorm.DB, stockableType string, stockableID uint) error {
+	return tx.WithContext(ctx).
+		Exec("DELETE FROM stock_allocations WHERE stockable_type = ? AND stockable_id = ?", stockableType, stockableID).
+		Error
+}
+
+func hardDeleteAdjustmentStockLogs(ctx context.Context, tx *gorm.DB, adjustmentID uint) error {
+	return tx.WithContext(ctx).
+		Exec("DELETE FROM stock_logs WHERE loggable_type = ? AND loggable_id = ?", "ADJUSTMENT", adjustmentID).
+		Error
+}
+
+func hardDeleteAdjustment(ctx context.Context, tx *gorm.DB, adjustmentID uint) error {
+	return tx.WithContext(ctx).
+		Exec("DELETE FROM adjustment_stocks WHERE id = ?", adjustmentID).
+		Error
+}

cmd/reflow-adjustments/main.go

@@ -0,0 +1,343 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	"gorm.io/gorm"
+)
+
+type adjustmentRow struct {
+	ID                 uint      `gorm:"column:id"`
+	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
+	ProductID          uint      `gorm:"column:product_id"`
+	FunctionCode       string    `gorm:"column:function_code"`
+	UsageQty           float64   `gorm:"column:usage_qty"`
+	PendingQty         float64   `gorm:"column:pending_qty"`
+	StockLogIncrease   float64   `gorm:"column:stock_log_increase"`
+	StockLogDecrease   float64   `gorm:"column:stock_log_decrease"`
+	CreatedAt          time.Time `gorm:"column:created_at"`
+}
+
+type routeResolution struct {
+	FlagGroupCode string `gorm:"column:flag_group_code"`
+	Lane          string `gorm:"column:lane"`
+	FunctionCode  string `gorm:"column:function_code"`
+	SourceTable   string `gorm:"column:source_table"`
+	LegacyTypeKey string `gorm:"column:legacy_type_key"`
+}
+
+func main() {
+	var (
+		idsRaw                 string
+		apply                  bool
+		asOfCreatedAt          bool
+		compensateMissingAlloc bool
+	)
+
+	flag.StringVar(&idsRaw, "ids", "", "Comma-separated adjustment IDs (required), example: 1,2")
+	flag.BoolVar(&apply, "apply", false, "Apply changes. If false, run as dry-run")
+	flag.BoolVar(&asOfCreatedAt, "as-of-created-at", true, "Use adjustment created_at as reflow AsOf boundary")
+	flag.BoolVar(&compensateMissingAlloc, "compensate-missing-alloc", true, "When active allocations are missing and usage_qty > 0, temporarily add back usage_qty before reflow")
+	flag.Parse()
+
+	ids, err := parseIDs(idsRaw)
+	if err != nil {
+		log.Fatalf("invalid --ids: %v", err)
+	}
+	if len(ids) == 0 {
+		log.Fatal("--ids is required")
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
+
+	adjustments, err := loadAdjustments(ctx, db, ids)
+	if err != nil {
+		log.Fatalf("failed to load adjustments: %v", err)
+	}
+	if len(adjustments) == 0 {
+		log.Fatal("no adjustments found for provided IDs")
+	}
+
+	sort.Slice(adjustments, func(i, j int) bool {
+		return adjustments[i].ID < adjustments[j].ID
+	})
+
+	fmt.Printf("Mode: %s\n", modeLabel(apply))
+	fmt.Printf("Adjustments loaded: %d\n\n", len(adjustments))
+
+	success := 0
+	failed := 0
+	skipped := 0
+
+	for _, adj := range adjustments {
+		if strings.TrimSpace(adj.FunctionCode) == "" {
+			fmt.Printf("SKIP adj=%d reason=function_code empty\n", adj.ID)
+			skipped++
+			continue
+		}
+
+		route, err := resolveRouteByFunctionCode(ctx, db, adj.ProductID, strings.ToUpper(strings.TrimSpace(adj.FunctionCode)))
+		if err != nil {
+			fmt.Printf("FAIL adj=%d error=resolve route: %v\n", adj.ID, err)
+			failed++
+			continue
+		}
+		if route.Lane != "USABLE" {
+			fmt.Printf("SKIP adj=%d reason=lane=%s (not USABLE)\n", adj.ID, route.Lane)
+			skipped++
+			continue
+		}
+
+		desiredQty := adj.UsageQty + adj.PendingQty
+		desiredQtySource := "usage+pending"
+		if desiredQty <= 0 && adj.StockLogDecrease > 0 {
+			desiredQty = adj.StockLogDecrease
+			desiredQtySource = "stock_log.decrease"
+		}
+		if desiredQty <= 0 {
+			fmt.Printf(
+				"SKIP adj=%d reason=no usable qty (usage=%.3f pending=%.3f stock_log.decrease=%.3f)\n",
+				adj.ID,
+				adj.UsageQty,
+				adj.PendingQty,
+				adj.StockLogDecrease,
+			)
+			skipped++
+			continue
+		}
+
+		usableType := fifo.UsableKeyAdjustmentOut.String()
+		if route.SourceTable == "adjustment_stocks" && strings.TrimSpace(route.LegacyTypeKey) != "" {
+			usableType = strings.TrimSpace(route.LegacyTypeKey)
+		}
+
+		activeAllocationCount, err := countActiveAllocations(ctx, db, usableType, adj.ID)
+		if err != nil {
+			fmt.Printf("FAIL adj=%d error=count allocations: %v\n", adj.ID, err)
+			failed++
+			continue
+		}
+
+		compensateQty := adj.UsageQty
+		if compensateQty <= 0 && desiredQtySource == "stock_log.decrease" {
+			compensateQty = adj.StockLogDecrease
+		}
+		shouldCompensate := compensateMissingAlloc && activeAllocationCount == 0 && compensateQty > 0
+
+		reflowReq := commonSvc.FifoStockV2ReflowRequest{
+			FlagGroupCode:      route.FlagGroupCode,
+			ProductWarehouseID: adj.ProductWarehouseID,
+			Usable: commonSvc.FifoStockV2Ref{
+				ID:            adj.ID,
+				LegacyTypeKey: usableType,
+				FunctionCode:  route.FunctionCode,
+			},
+			DesiredQty:     desiredQty,
+			IdempotencyKey: fmt.Sprintf("manual-adjustment-reflow-%d-%d", adj.ID, time.Now().UnixNano()),
+		}
+		if asOfCreatedAt {
+			asOf := adj.CreatedAt
+			reflowReq.AsOf = &asOf
+		}
+
+		fmt.Printf(
+			"PLAN adj=%d pw=%d product=%d function=%s group=%s desired=%.3f source=%s active_alloc=%d compensate=%t\n",
+			adj.ID,
+			adj.ProductWarehouseID,
+			adj.ProductID,
+			route.FunctionCode,
+			route.FlagGroupCode,
+			desiredQty,
+			desiredQtySource,
+			activeAllocationCount,
+			shouldCompensate,
+		)
+
+		if !apply {
+			skipped++
+			continue
+		}
+
+		err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+			if shouldCompensate {
+				if err := tx.Table("product_warehouses").
+					Where("id = ?", adj.ProductWarehouseID).
+					Update("qty", gorm.Expr("COALESCE(qty,0) + ?", compensateQty)).Error; err != nil {
+					return fmt.Errorf("compensate product_warehouse qty: %w", err)
+				}
+			}
+
+			reflowReq.Tx = tx
+			res, err := fifoStockV2Svc.Reflow(ctx, reflowReq)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf(
+				"DONE adj=%d rollback=%.3f allocate=%.3f pending=%.3f\n",
+				adj.ID,
+				res.Rollback.ReleasedQty,
+				res.Allocate.AllocatedQty,
+				res.Allocate.PendingQty,
+			)
+			return nil
+		})
+		if err != nil {
+			fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
+			failed++
+			continue
+		}
+
+		success++
+	}
+
+	fmt.Println()
+	fmt.Printf("Summary: success=%d failed=%d skipped=%d\n", success, failed, skipped)
+	if failed > 0 {
+		os.Exit(1)
+	}
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY-RUN"
+}
+
+func parseIDs(raw string) ([]uint, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, nil
+	}
+	parts := strings.Split(raw, ",")
+	ids := make([]uint, 0, len(parts))
+	seen := map[uint]struct{}{}
+
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		value, err := strconv.ParseUint(part, 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("invalid id %q", part)
+		}
+		if value == 0 {
+			return nil, fmt.Errorf("id must be > 0: %q", part)
+		}
+		id := uint(value)
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		ids = append(ids, id)
+	}
+
+	return ids, nil
+}
+
+func loadAdjustments(ctx context.Context, db *gorm.DB, ids []uint) ([]adjustmentRow, error) {
+	var rows []adjustmentRow
+	err := db.WithContext(ctx).
+		Table("adjustment_stocks a").
+		Select(`
+				a.id,
+				a.product_warehouse_id,
+				pw.product_id,
+				a.function_code,
+				COALESCE(a.usage_qty, 0) AS usage_qty,
+				COALESCE(a.pending_qty, 0) AS pending_qty,
+				COALESCE((
+					SELECT sl.increase
+					FROM stock_logs sl
+					WHERE sl.loggable_type = 'ADJUSTMENT'
+						AND sl.loggable_id = a.id
+					ORDER BY sl.id DESC
+					LIMIT 1
+				), 0) AS stock_log_increase,
+				COALESCE((
+					SELECT sl.decrease
+					FROM stock_logs sl
+					WHERE sl.loggable_type = 'ADJUSTMENT'
+						AND sl.loggable_id = a.id
+					ORDER BY sl.id DESC
+					LIMIT 1
+				), 0) AS stock_log_decrease,
+				a.created_at
+			`).
+		Joins("JOIN product_warehouses pw ON pw.id = a.product_warehouse_id").
+		Where("a.id IN ?", ids).
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func resolveRouteByFunctionCode(ctx context.Context, db *gorm.DB, productID uint, functionCode string) (*routeResolution, error) {
+	var rows []routeResolution
+	err := db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules rr").
+		Select("rr.flag_group_code, rr.lane, rr.function_code, rr.source_table, rr.legacy_type_key").
+		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
+		Where("rr.is_active = TRUE").
+		Where("rr.function_code = ?", functionCode).
+		Where(`
+			EXISTS (
+				SELECT 1
+				FROM flags f
+				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
+				WHERE f.flagable_type = ?
+					AND f.flagable_id = ?
+					AND fm.flag_group_code = rr.flag_group_code
+			)
+		`, entity.FlagableTypeProduct, productID).
+		Order("CASE WHEN rr.source_table = 'adjustment_stocks' THEN 0 ELSE 1 END ASC").
+		Order("rr.id ASC").
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("no route found for product_id=%d function_code=%s", productID, functionCode)
+	}
+
+	selected := rows[0]
+	for _, row := range rows {
+		if row.Lane != selected.Lane {
+			return nil, fmt.Errorf("ambiguous lane for product_id=%d function_code=%s", productID, functionCode)
+		}
+	}
+
+	selected.FunctionCode = functionCode
+	return &selected, nil
+}
+
+func countActiveAllocations(ctx context.Context, db *gorm.DB, usableType string, usableID uint) (int64, error) {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Where("usable_type = ? AND usable_id = ?", usableType, usableID).
+		Where("status = ?", entity.StockAllocationStatusActive).
+		Count(&count).Error
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}

internal/common/repository/common.hpp.repository.go

@@ -297,6 +297,9 @@ func (r *HppRepositoryImpl) GetTransferSourceSummary(ctx context.Context, projec
 		Table("laying_transfer_targets AS ltt").
 		Select("lt.from_project_flock_id AS project_flock_id, COALESCE(SUM(ltt.total_qty), 0) AS total_qty").
 		Joins("JOIN laying_transfers AS lt ON lt.id = ltt.laying_transfer_id").
+		Where("lt.deleted_at IS NULL").
+		Where("ltt.deleted_at IS NULL").
+		Where("lt.executed_at IS NOT NULL").
 		Where("ltt.target_project_flock_kandang_id = ?", projectFlockKandangId).
 		Group("lt.from_project_flock_id").
 		Scan(&summary).Error

internal/common/service/common.fifo_stock_v2.service.go

@@ -0,0 +1,41 @@
+package service
+
+import (
+	"github.com/sirupsen/logrus"
+	fifoStockV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
+	"gorm.io/gorm"
+)
+
+type FifoStockV2Service = fifoStockV2.Service
+
+type FifoStockV2Lane = fifoStockV2.Lane
+
+type FifoStockV2Ref = fifoStockV2.Ref
+
+type FifoStockV2GatherRequest = fifoStockV2.GatherRequest
+
+type FifoStockV2GatherRow = fifoStockV2.GatherRow
+
+type FifoStockV2AllocateRequest = fifoStockV2.AllocateRequest
+
+type FifoStockV2AllocateResult = fifoStockV2.AllocateResult
+
+type FifoStockV2AllocationDetail = fifoStockV2.AllocationDetail
+
+type FifoStockV2RollbackRequest = fifoStockV2.RollbackRequest
+
+type FifoStockV2RollbackResult = fifoStockV2.RollbackResult
+
+type FifoStockV2ReflowRequest = fifoStockV2.ReflowRequest
+
+type FifoStockV2ReflowResult = fifoStockV2.ReflowResult
+
+type FifoStockV2RecalculateRequest = fifoStockV2.RecalculateRequest
+
+type FifoStockV2RecalculateResult = fifoStockV2.RecalculateResult
+
+type FifoStockV2WarehouseDrift = fifoStockV2.WarehouseDrift
+
+func NewFifoStockV2Service(db *gorm.DB, logger *logrus.Logger) FifoStockV2Service {
+	return fifoStockV2.NewService(db, logger)
+}

internal/common/service/fifo_stock_v2/RFC.md

@@ -0,0 +1,58 @@
+# RFC Ringkas: FIFO Stock V2
+
+## Tujuan
+`fifo_stock_v2` adalah engine FIFO baru berbasis konfigurasi `Flag Group + Jalur` yang berjalan paralel dengan v1 tanpa memutus kompatibilitas `stock_allocations`, HPP, dan closing/reporting existing.
+
+## Prinsip
+- V1 tidak dihapus, V2 jalan paralel.
+- Semua operasi transactional.
+- FIFO sorting deterministic lintas tabel.
+- Default over-consume `ALLOW` (pending), exception dapat `BLOCK`.
+- Reflow idempotent.
+- Recalculate bisa memperbaiki drift `product_warehouses.qty`.
+
+## Komponen
+- `fifo_stock_v2_flag_groups`: master grouping flag produk.
+- `fifo_stock_v2_flag_members`: pemetaan flag -> group.
+- `fifo_stock_v2_traits`: trait sort per `table:date_column` (+ optional join date source).
+- `fifo_stock_v2_route_rules`: rule per `flag_group + lane + function + table`.
+- `fifo_stock_v2_overconsume_rules`: policy pending/over-consume.
+- `fifo_stock_v2_operation_log`: idempotency + audit operasi.
+- `fifo_stock_v2_reflow_runs` + checkpoints + shadow allocations: bulk reflow resumable/observable.
+
+## API Service
+- `Gather`: union cross-table berdasarkan route rules + trait sorting.
+- `Allocate`: alokasi lot FIFO ke usable.
+- `Rollback`: batalkan alokasi aktif.
+- `Reflow`: rollback penuh lalu allocate ulang (idempotent).
+- `Recalculate`: rekonsiliasi qty warehouse dari ledger FIFO.
+
+## Deterministic Sorting
+Urutan gather:
+1. `sort_at ASC` (dari trait `date_column`)
+2. `sort_priority ASC`
+3. `source_table ASC`
+4. `source_id ASC`
+
+Fallback waktu: `1970-01-01 00:00:00+00` bila tanggal null.
+
+## Compat Strategy
+- Tetap menulis ke `stock_allocations` dengan tambahan metadata:
+  - `engine_version` (`v1`/`v2`)
+  - `flag_group_code`
+  - `function_code`
+  - `idempotency_key`
+- Query lama yang bergantung `stockable_type/usable_type` tetap berjalan.
+
+## Migration Strategy
+1. Deploy schema + seed v2.
+2. Aktifkan shadow-run comparator v1 vs v2.
+3. Canary cutover per flag group.
+4. Full cutover jika parity aman.
+5. Jalankan bulk reflow existing data.
+
+## Acceptance Criteria Singkat
+- Parity mismatch terkendali pada aggregate + detail alokasi.
+- Tidak ada regression closing/HPP.
+- Drift qty warehouse turun signifikan pasca reflow.
+- Rollback via feature flag memungkinkan kembali ke v1.

internal/common/service/fifo_stock_v2/allocate.go

@@ -0,0 +1,660 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type allocationRow struct {
+	ID                 uint      `gorm:"column:id"`
+	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
+	StockableType      string    `gorm:"column:stockable_type"`
+	StockableID        uint      `gorm:"column:stockable_id"`
+	UsableType         string    `gorm:"column:usable_type"`
+	UsableID           uint      `gorm:"column:usable_id"`
+	Qty                float64   `gorm:"column:qty"`
+	Status             string    `gorm:"column:status"`
+	CreatedAt          time.Time `gorm:"column:created_at"`
+}
+
+type usableQtySnapshot struct {
+	Usage   float64 `gorm:"column:usage_qty"`
+	Pending float64 `gorm:"column:pending_qty"`
+}
+
+func (s *fifoStockV2Service) Allocate(ctx context.Context, req AllocateRequest) (*AllocateResult, error) {
+	if err := s.validateAllocateRequest(req); err != nil {
+		return nil, err
+	}
+
+	result := &AllocateResult{}
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		if err := s.ensureStockAllocationColumns(tx); err != nil {
+			return err
+		}
+		if err := s.lockShard(tx, req.FlagGroupCode, req.ProductWarehouseID); err != nil {
+			return err
+		}
+
+		hash := requestHash(map[string]any{
+			"flag_group_code":      req.FlagGroupCode,
+			"product_warehouse_id": req.ProductWarehouseID,
+			"usable_type":          req.Usable.LegacyTypeKey,
+			"usable_id":            req.Usable.ID,
+			"need_qty":             req.NeedQty,
+			"as_of":                req.AsOf,
+			"allow_over_consume":   req.AllowOverConsume,
+		})
+		logRow, reused, err := s.beginOperation(
+			tx,
+			OperationAllocate,
+			req.IdempotencyKey,
+			hash,
+			req.ProductWarehouseID,
+			req.FlagGroupCode,
+			req.Usable.LegacyTypeKey,
+			req.Usable.ID,
+		)
+		if err != nil {
+			return err
+		}
+		if reused {
+			if len(logRow.ResultPayload) == 0 {
+				return fmt.Errorf("idempotent allocate has empty payload")
+			}
+			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
+				return err
+			}
+			return nil
+		}
+		if logRow != nil {
+			defer func() {
+				if err != nil {
+					s.failOperation(tx, logRow, err)
+				}
+			}()
+		}
+
+		allocated, allocErr := s.allocateInternal(ctx, tx, req)
+		if allocErr != nil {
+			err = allocErr
+			return allocErr
+		}
+		*result = *allocated
+
+		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
+			err = finishErr
+			return finishErr
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *fifoStockV2Service) allocateInternal(ctx context.Context, tx *gorm.DB, req AllocateRequest) (*AllocateResult, error) {
+	usableRule, err := s.loadRouteRuleByLegacyType(ctx, tx, LaneUsable, req.FlagGroupCode, req.Usable.LegacyTypeKey)
+	if err != nil {
+		return nil, err
+	}
+
+	allowOverConsume := usableRule.AllowPendingDefault
+	if req.AllowOverConsume != nil {
+		allowOverConsume = *req.AllowOverConsume
+	} else {
+		allowOverConsume, err = s.resolveOverConsume(tx, req.FlagGroupCode, req.Usable.FunctionCode, LaneUsable, allowOverConsume)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	gatherRows, err := s.gatherRows(ctx, tx, GatherRequest{
+		FlagGroupCode:      req.FlagGroupCode,
+		Lane:               LaneStockable,
+		ProductWarehouseID: req.ProductWarehouseID,
+		AsOf:               req.AsOf,
+		Limit:              s.defaultGatherLimit,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	stockableRuleMap, err := s.loadStockableRuleMap(ctx, tx, req.FlagGroupCode)
+	if err != nil {
+		return nil, err
+	}
+
+	now := time.Now()
+	remaining := req.NeedQty
+	result := &AllocateResult{Details: make([]AllocationDetail, 0)}
+
+	for _, lot := range gatherRows {
+		if remaining <= 0 {
+			break
+		}
+		if lot.AvailableQuantity <= 0 {
+			continue
+		}
+		portion := math.Min(remaining, lot.AvailableQuantity)
+		if nearlyZero(portion) {
+			continue
+		}
+
+		allocationInsert := map[string]any{
+			"product_warehouse_id": req.ProductWarehouseID,
+			"stockable_type":       lot.Ref.LegacyTypeKey,
+			"stockable_id":         lot.Ref.ID,
+			"usable_type":          req.Usable.LegacyTypeKey,
+			"usable_id":            req.Usable.ID,
+			"qty":                  portion,
+			"status":               activeAllocationStatus(),
+			"created_at":           now,
+			"updated_at":           now,
+			"engine_version":       "v2",
+			"flag_group_code":      req.FlagGroupCode,
+			"function_code":        req.Usable.FunctionCode,
+		}
+		if strings.TrimSpace(req.IdempotencyKey) != "" {
+			allocationInsert["idempotency_key"] = req.IdempotencyKey
+		}
+		if err := tx.Table("stock_allocations").Create(allocationInsert).Error; err != nil {
+			return nil, err
+		}
+
+		rule, ok := stockableRuleMap[lot.Ref.LegacyTypeKey]
+		if !ok {
+			return nil, fmt.Errorf("missing stockable route rule for type %s", lot.Ref.LegacyTypeKey)
+		}
+		if err := s.adjustStockableUsedQuantity(tx, rule, lot.Ref.ID, portion); err != nil {
+			return nil, err
+		}
+
+		result.Details = append(result.Details, AllocationDetail{
+			StockableType: lot.Ref.LegacyTypeKey,
+			StockableID:   lot.Ref.ID,
+			Qty:           portion,
+			SortAt:        lot.SortAt,
+		})
+
+		remaining -= portion
+		result.AllocatedQty += portion
+	}
+
+	if remaining > 0 {
+		if !allowOverConsume {
+			return nil, fmt.Errorf("%w: requested %.3f, allocated %.3f", ErrInsufficientStock, req.NeedQty, result.AllocatedQty)
+		}
+		result.PendingQty = remaining
+	}
+
+	if err := s.applyUsableDeltas(tx, *usableRule, req.Usable.ID, result.AllocatedQty, result.PendingQty); err != nil {
+		return nil, err
+	}
+	if err := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, -result.AllocatedQty); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (s *fifoStockV2Service) Rollback(ctx context.Context, req RollbackRequest) (*RollbackResult, error) {
+	if err := s.validateRollbackRequest(req); err != nil {
+		return nil, err
+	}
+
+	result := &RollbackResult{}
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		if err := s.ensureStockAllocationColumns(tx); err != nil {
+			return err
+		}
+
+		flagGroupCode, err := s.resolveRollbackFlagGroup(ctx, tx, req)
+		if err != nil {
+			return err
+		}
+		if err := s.lockShard(tx, flagGroupCode, req.ProductWarehouseID); err != nil {
+			return err
+		}
+
+		hash := requestHash(map[string]any{
+			"product_warehouse_id": req.ProductWarehouseID,
+			"usable_type":          req.Usable.LegacyTypeKey,
+			"usable_id":            req.Usable.ID,
+			"release_qty":          req.ReleaseQty,
+			"reason":               req.Reason,
+			"flag_group_code":      flagGroupCode,
+		})
+		logRow, reused, beginErr := s.beginOperation(
+			tx,
+			OperationRollback,
+			req.IdempotencyKey,
+			hash,
+			req.ProductWarehouseID,
+			flagGroupCode,
+			req.Usable.LegacyTypeKey,
+			req.Usable.ID,
+		)
+		if beginErr != nil {
+			return beginErr
+		}
+		if reused {
+			if len(logRow.ResultPayload) == 0 {
+				return fmt.Errorf("idempotent rollback has empty payload")
+			}
+			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
+				return err
+			}
+			return nil
+		}
+		if logRow != nil {
+			defer func() {
+				if err != nil {
+					s.failOperation(tx, logRow, err)
+				}
+			}()
+		}
+
+		rolled, rollbackErr := s.rollbackInternal(ctx, tx, req, flagGroupCode)
+		if rollbackErr != nil {
+			err = rollbackErr
+			return rollbackErr
+		}
+		*result = *rolled
+
+		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
+			err = finishErr
+			return finishErr
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *fifoStockV2Service) rollbackInternal(
+	ctx context.Context,
+	tx *gorm.DB,
+	req RollbackRequest,
+	flagGroupCode string,
+) (*RollbackResult, error) {
+	usableRule, err := s.loadRouteRuleByLegacyType(ctx, tx, LaneUsable, flagGroupCode, req.Usable.LegacyTypeKey)
+	if err != nil {
+		return nil, err
+	}
+
+	allocations, err := s.loadActiveAllocations(tx, req.Usable.LegacyTypeKey, req.Usable.ID, req.ProductWarehouseID)
+	if err != nil {
+		return nil, err
+	}
+	if len(allocations) == 0 {
+		if req.ReleaseQty == nil {
+			if err := s.resetUsableQuantities(tx, *usableRule, req.Usable.ID); err != nil {
+				return nil, err
+			}
+		}
+		return &RollbackResult{}, nil
+	}
+
+	stockableRuleMap, err := s.loadStockableRuleMap(ctx, tx, flagGroupCode)
+	if err != nil {
+		return nil, err
+	}
+
+	target := 0.0
+	for _, alloc := range allocations {
+		target += alloc.Qty
+	}
+	if req.ReleaseQty != nil {
+		if *req.ReleaseQty < 0 {
+			return nil, fmt.Errorf("%w: release qty must be >= 0", ErrInvalidRequest)
+		}
+		target = *req.ReleaseQty
+	}
+	if nearlyZero(target) {
+		return &RollbackResult{}, nil
+	}
+
+	result := &RollbackResult{Details: make([]AllocationDetail, 0)}
+	now := time.Now()
+	remaining := target
+
+	for _, alloc := range allocations {
+		if remaining <= 0 {
+			break
+		}
+		portion := math.Min(remaining, alloc.Qty)
+		if nearlyZero(portion) {
+			continue
+		}
+
+		if nearlyZero(alloc.Qty - portion) {
+			updates := map[string]any{
+				"status":      releasedAllocationStatus(),
+				"released_at": now,
+				"updated_at":  now,
+			}
+			if strings.TrimSpace(req.Reason) != "" {
+				updates["note"] = req.Reason
+			}
+			if err := tx.Table("stock_allocations").Where("id = ?", alloc.ID).Updates(updates).Error; err != nil {
+				return nil, err
+			}
+		} else {
+			if err := tx.Table("stock_allocations").
+				Where("id = ?", alloc.ID).
+				Updates(map[string]any{
+					"qty":        alloc.Qty - portion,
+					"updated_at": now,
+				}).Error; err != nil {
+				return nil, err
+			}
+		}
+
+		stockableRule, ok := stockableRuleMap[alloc.StockableType]
+		if !ok {
+			return nil, fmt.Errorf("missing stockable route rule for type %s", alloc.StockableType)
+		}
+		if err := s.adjustStockableUsedQuantity(tx, stockableRule, alloc.StockableID, -portion); err != nil {
+			return nil, err
+		}
+
+		result.ReleasedQty += portion
+		remaining -= portion
+		result.Details = append(result.Details, AllocationDetail{
+			StockableType: alloc.StockableType,
+			StockableID:   alloc.StockableID,
+			Qty:           portion,
+			SortAt:        alloc.CreatedAt,
+		})
+	}
+
+	if req.ReleaseQty != nil && remaining > 1e-6 {
+		return nil, fmt.Errorf("unable to release %.3f; only %.3f allocation exists", target, result.ReleasedQty)
+	}
+
+	if req.ReleaseQty == nil {
+		if err := s.resetUsableQuantities(tx, *usableRule, req.Usable.ID); err != nil {
+			return nil, err
+		}
+	} else {
+		if err := s.applyUsableDeltas(tx, *usableRule, req.Usable.ID, -result.ReleasedQty, 0); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, result.ReleasedQty); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (s *fifoStockV2Service) Reflow(ctx context.Context, req ReflowRequest) (*ReflowResult, error) {
+	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 || req.Usable.ID == 0 || strings.TrimSpace(req.Usable.LegacyTypeKey) == "" {
+		return nil, fmt.Errorf("%w: invalid reflow request", ErrInvalidRequest)
+	}
+	if req.DesiredQty < 0 {
+		return nil, fmt.Errorf("%w: desired qty must be >= 0", ErrInvalidRequest)
+	}
+
+	result := &ReflowResult{}
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		if err := s.ensureStockAllocationColumns(tx); err != nil {
+			return err
+		}
+		if err := s.lockShard(tx, req.FlagGroupCode, req.ProductWarehouseID); err != nil {
+			return err
+		}
+
+		hash := requestHash(map[string]any{
+			"flag_group_code":      req.FlagGroupCode,
+			"product_warehouse_id": req.ProductWarehouseID,
+			"usable_type":          req.Usable.LegacyTypeKey,
+			"usable_id":            req.Usable.ID,
+			"desired_qty":          req.DesiredQty,
+			"as_of":                req.AsOf,
+			"allow_over_consume":   req.AllowOverConsume,
+		})
+		logRow, reused, err := s.beginOperation(
+			tx,
+			OperationReflow,
+			req.IdempotencyKey,
+			hash,
+			req.ProductWarehouseID,
+			req.FlagGroupCode,
+			req.Usable.LegacyTypeKey,
+			req.Usable.ID,
+		)
+		if err != nil {
+			return err
+		}
+		if reused {
+			if len(logRow.ResultPayload) == 0 {
+				return fmt.Errorf("idempotent reflow has empty payload")
+			}
+			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
+				return err
+			}
+			return nil
+		}
+		if logRow != nil {
+			defer func() {
+				if err != nil {
+					s.failOperation(tx, logRow, err)
+				}
+			}()
+		}
+
+		rollbackRes, rollbackErr := s.rollbackInternal(ctx, tx, RollbackRequest{
+			ProductWarehouseID: req.ProductWarehouseID,
+			Usable:             req.Usable,
+			ReleaseQty:         nil,
+			Reason:             "reflow reset",
+		}, req.FlagGroupCode)
+		if rollbackErr != nil {
+			err = rollbackErr
+			return rollbackErr
+		}
+		result.Rollback = *rollbackRes
+
+		if req.DesiredQty > 0 {
+			allocateRes, allocateErr := s.allocateInternal(ctx, tx, AllocateRequest{
+				FlagGroupCode:      req.FlagGroupCode,
+				ProductWarehouseID: req.ProductWarehouseID,
+				Usable:             req.Usable,
+				NeedQty:            req.DesiredQty,
+				AllowOverConsume:   req.AllowOverConsume,
+				AsOf:               req.AsOf,
+			})
+			if allocateErr != nil {
+				err = allocateErr
+				return allocateErr
+			}
+			result.Allocate = *allocateRes
+		}
+
+		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
+			err = finishErr
+			return finishErr
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *fifoStockV2Service) loadActiveAllocations(
+	tx *gorm.DB,
+	usableType string,
+	usableID uint,
+	productWarehouseID uint,
+) ([]allocationRow, error) {
+	query := tx.Table("stock_allocations").
+		Select("id, product_warehouse_id, stockable_type, stockable_id, usable_type, usable_id, qty, status, created_at").
+		Where("usable_type = ? AND usable_id = ? AND status = ?", usableType, usableID, activeAllocationStatus())
+	if productWarehouseID > 0 {
+		query = query.Where("product_warehouse_id = ?", productWarehouseID)
+	}
+	query = query.Order("created_at DESC, id DESC")
+
+	var rows []allocationRow
+	if err := query.Find(&rows).Error; err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func (s *fifoStockV2Service) loadStockableRuleMap(ctx context.Context, tx *gorm.DB, flagGroupCode string) (map[string]routeRule, error) {
+	rules, err := s.loadRouteRules(ctx, tx, flagGroupCode, LaneStockable)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]routeRule, len(rules))
+	for _, rule := range rules {
+		m[rule.LegacyTypeKey] = rule
+	}
+	return m, nil
+}
+
+func (s *fifoStockV2Service) adjustStockableUsedQuantity(tx *gorm.DB, rule routeRule, sourceID uint, delta float64) error {
+	if nearlyZero(delta) || sourceID == 0 {
+		return nil
+	}
+	if rule.UsedQuantityCol == nil || strings.TrimSpace(*rule.UsedQuantityCol) == "" {
+		return nil
+	}
+
+	usedCol, _ := mustSafeIdentifier(*rule.UsedQuantityCol)
+	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
+	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
+
+	expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", usedCol)
+	return tx.Table(sourceTable).
+		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
+		Update(usedCol, gorm.Expr(expr, delta)).Error
+}
+
+func (s *fifoStockV2Service) applyUsableDeltas(tx *gorm.DB, rule routeRule, sourceID uint, usageDelta, pendingDelta float64) error {
+	if sourceID == 0 || (nearlyZero(usageDelta) && nearlyZero(pendingDelta)) {
+		return nil
+	}
+	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
+	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
+	usageCol, _ := mustSafeIdentifier(rule.QuantityCol)
+
+	updates := map[string]any{}
+	if !nearlyZero(usageDelta) {
+		expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", usageCol)
+		updates[usageCol] = gorm.Expr(expr, usageDelta)
+	}
+	if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" && !nearlyZero(pendingDelta) {
+		pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
+		expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", pendingCol)
+		updates[pendingCol] = gorm.Expr(expr, pendingDelta)
+	}
+	if len(updates) == 0 {
+		return nil
+	}
+
+	return tx.Table(sourceTable).
+		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
+		Updates(updates).Error
+}
+
+func (s *fifoStockV2Service) resetUsableQuantities(tx *gorm.DB, rule routeRule, sourceID uint) error {
+	if sourceID == 0 {
+		return nil
+	}
+	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
+	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
+	usageCol, _ := mustSafeIdentifier(rule.QuantityCol)
+
+	updates := map[string]any{usageCol: 0}
+	if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" {
+		pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
+		updates[pendingCol] = 0
+	}
+
+	return tx.Table(sourceTable).
+		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
+		Updates(updates).Error
+}
+
+func (s *fifoStockV2Service) resolveRollbackFlagGroup(ctx context.Context, tx *gorm.DB, req RollbackRequest) (string, error) {
+	type row struct {
+		FlagGroupCode string `gorm:"column:flag_group_code"`
+	}
+	var latest row
+	err := tx.WithContext(ctx).
+		Table("stock_allocations").
+		Select("flag_group_code").
+		Where("usable_type = ? AND usable_id = ?", req.Usable.LegacyTypeKey, req.Usable.ID).
+		Where("engine_version = 'v2'").
+		Where("flag_group_code IS NOT NULL AND flag_group_code <> ''").
+		Order("id DESC").
+		Limit(1).
+		Take(&latest).Error
+	if err == nil && strings.TrimSpace(latest.FlagGroupCode) != "" {
+		return latest.FlagGroupCode, nil
+	}
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return "", err
+	}
+
+	var rules []routeRule
+	err = tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Where("is_active = TRUE").
+		Where("lane = ?", string(LaneUsable)).
+		Where("legacy_type_key = ?", req.Usable.LegacyTypeKey).
+		Find(&rules).Error
+	if err != nil {
+		return "", err
+	}
+	if len(rules) == 0 {
+		return "", fmt.Errorf("cannot resolve flag group for usable type %s", req.Usable.LegacyTypeKey)
+	}
+	if len(rules) > 1 {
+		return "", fmt.Errorf("ambiguous rollback flag group for usable type %s", req.Usable.LegacyTypeKey)
+	}
+	return rules[0].FlagGroupCode, nil
+}
+
+func (s *fifoStockV2Service) validateAllocateRequest(req AllocateRequest) error {
+	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 {
+		return fmt.Errorf("%w: missing flag group or product warehouse", ErrInvalidRequest)
+	}
+	if req.Usable.ID == 0 || strings.TrimSpace(req.Usable.LegacyTypeKey) == "" {
+		return fmt.Errorf("%w: usable id and type are required", ErrInvalidRequest)
+	}
+	if req.NeedQty < 0 {
+		return fmt.Errorf("%w: need qty must be >= 0", ErrInvalidRequest)
+	}
+	return nil
+}
+
+func (s *fifoStockV2Service) validateRollbackRequest(req RollbackRequest) error {
+	if req.ProductWarehouseID == 0 {
+		return fmt.Errorf("%w: product warehouse is required", ErrInvalidRequest)
+	}
+	if req.Usable.ID == 0 || strings.TrimSpace(req.Usable.LegacyTypeKey) == "" {
+		return fmt.Errorf("%w: usable id and type are required", ErrInvalidRequest)
+	}
+	if req.ReleaseQty != nil && *req.ReleaseQty < 0 {
+		return fmt.Errorf("%w: release qty must be >= 0", ErrInvalidRequest)
+	}
+	return nil
+}

internal/common/service/fifo_stock_v2/config.go

@@ -0,0 +1,170 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"gorm.io/gorm"
+)
+
+type routeRule struct {
+	ID                  uint    `gorm:"column:id"`
+	FlagGroupCode       string  `gorm:"column:flag_group_code"`
+	Lane                string  `gorm:"column:lane"`
+	FunctionCode        string  `gorm:"column:function_code"`
+	SourceTable         string  `gorm:"column:source_table"`
+	SourceIDColumn      string  `gorm:"column:source_id_column"`
+	ProductWarehouseCol string  `gorm:"column:product_warehouse_col"`
+	QuantityCol         string  `gorm:"column:quantity_col"`
+	UsedQuantityCol     *string `gorm:"column:used_quantity_col"`
+	PendingQuantityCol  *string `gorm:"column:pending_quantity_col"`
+	ScopeSQL            *string `gorm:"column:scope_sql"`
+	LegacyTypeKey       string  `gorm:"column:legacy_type_key"`
+	AllowPendingDefault bool    `gorm:"column:allow_pending_default"`
+}
+
+type traitRule struct {
+	ID                 uint    `gorm:"column:id"`
+	SourceTable        string  `gorm:"column:source_table"`
+	Lane               string  `gorm:"column:lane"`
+	DateTable          *string `gorm:"column:date_table"`
+	DateJoinLeftCol    *string `gorm:"column:date_join_left_col"`
+	DateJoinRightCol   *string `gorm:"column:date_join_right_col"`
+	DateColumn         string  `gorm:"column:date_column"`
+	FallbackDateColumn *string `gorm:"column:fallback_date_column"`
+	SortPriority       int     `gorm:"column:sort_priority"`
+	IDColumn           string  `gorm:"column:id_column"`
+}
+
+func (s *fifoStockV2Service) loadRouteRules(ctx context.Context, tx *gorm.DB, flagGroupCode string, lane Lane) ([]routeRule, error) {
+	var rules []routeRule
+	err := tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Where("is_active = TRUE").
+		Where("flag_group_code = ?", flagGroupCode).
+		Where("lane = ?", string(lane)).
+		Order("id ASC").
+		Find(&rules).Error
+	if err != nil {
+		return nil, err
+	}
+	for _, rule := range rules {
+		if err := validateRouteRule(rule); err != nil {
+			return nil, err
+		}
+	}
+	return rules, nil
+}
+
+func (s *fifoStockV2Service) loadRouteRuleByLegacyType(
+	ctx context.Context,
+	tx *gorm.DB,
+	lane Lane,
+	flagGroupCode string,
+	legacyTypeKey string,
+) (*routeRule, error) {
+	var rule routeRule
+	err := tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Where("is_active = TRUE").
+		Where("lane = ?", string(lane)).
+		Where("flag_group_code = ?", flagGroupCode).
+		Where("legacy_type_key = ?", legacyTypeKey).
+		Order("id ASC").
+		Limit(1).
+		Take(&rule).Error
+	if err != nil {
+		return nil, err
+	}
+	if err := validateRouteRule(rule); err != nil {
+		return nil, err
+	}
+	return &rule, nil
+}
+
+func (s *fifoStockV2Service) loadTraitMap(
+	ctx context.Context,
+	tx *gorm.DB,
+	lane Lane,
+	sourceTables []string,
+) (map[string]traitRule, error) {
+	if len(sourceTables) == 0 {
+		return map[string]traitRule{}, nil
+	}
+
+	var traits []traitRule
+	err := tx.WithContext(ctx).
+		Table("fifo_stock_v2_traits").
+		Where("is_active = TRUE").
+		Where("lane = ?", string(lane)).
+		Where("source_table IN ?", sourceTables).
+		Find(&traits).Error
+	if err != nil {
+		return nil, err
+	}
+
+	out := make(map[string]traitRule, len(traits))
+	for _, tr := range traits {
+		if err := validateTraitRule(tr); err != nil {
+			return nil, err
+		}
+		out[tr.SourceTable] = tr
+	}
+	return out, nil
+}
+
+func validateRouteRule(rule routeRule) error {
+	fields := []string{rule.SourceTable, rule.SourceIDColumn, rule.ProductWarehouseCol, rule.QuantityCol}
+	for _, value := range fields {
+		if _, err := mustSafeIdentifier(value); err != nil {
+			return err
+		}
+	}
+	if rule.UsedQuantityCol != nil {
+		if _, err := mustSafeIdentifier(*rule.UsedQuantityCol); err != nil {
+			return err
+		}
+	}
+	if rule.PendingQuantityCol != nil {
+		if _, err := mustSafeIdentifier(*rule.PendingQuantityCol); err != nil {
+			return err
+		}
+	}
+	if strings.TrimSpace(rule.LegacyTypeKey) == "" {
+		return fmt.Errorf("route rule has empty legacy type key")
+	}
+	return nil
+}
+
+func validateTraitRule(rule traitRule) error {
+	if _, err := mustSafeIdentifier(rule.SourceTable); err != nil {
+		return err
+	}
+	if _, err := mustSafeIdentifier(rule.DateColumn); err != nil {
+		return err
+	}
+	if _, err := mustSafeIdentifier(rule.IDColumn); err != nil {
+		return err
+	}
+	if rule.DateTable != nil {
+		if _, err := mustSafeIdentifier(*rule.DateTable); err != nil {
+			return err
+		}
+		if rule.DateJoinLeftCol == nil || rule.DateJoinRightCol == nil {
+			return fmt.Errorf("trait %s requires date join columns", rule.SourceTable)
+		}
+		if _, err := mustSafeIdentifier(*rule.DateJoinLeftCol); err != nil {
+			return err
+		}
+		if _, err := mustSafeIdentifier(*rule.DateJoinRightCol); err != nil {
+			return err
+		}
+	}
+	if rule.FallbackDateColumn != nil {
+		if _, err := mustSafeIdentifier(*rule.FallbackDateColumn); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/common/service/fifo_stock_v2/errors.go

@@ -0,0 +1,8 @@
+package fifo_stock_v2
+
+import "errors"
+
+var (
+	ErrInvalidRequest    = errors.New("invalid fifo stock v2 request")
+	ErrInsufficientStock = errors.New("insufficient stock")
+)

internal/common/service/fifo_stock_v2/gather.go

@@ -0,0 +1,268 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+type gatherSQLRow struct {
+	SourceTable        string    `gorm:"column:source_table"`
+	LegacyTypeKey      string    `gorm:"column:legacy_type_key"`
+	FunctionCode       string    `gorm:"column:function_code"`
+	SourceID           uint      `gorm:"column:source_id"`
+	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
+	SortAt             time.Time `gorm:"column:sort_at"`
+	SortPriority       int       `gorm:"column:sort_priority"`
+	Quantity           float64   `gorm:"column:quantity"`
+	UsedQuantity       float64   `gorm:"column:used_quantity"`
+	PendingQuantity    float64   `gorm:"column:pending_quantity"`
+	AvailableQuantity  float64   `gorm:"column:available_quantity"`
+}
+
+func (s *fifoStockV2Service) Gather(ctx context.Context, req GatherRequest) ([]GatherRow, error) {
+	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 {
+		return nil, fmt.Errorf("%w: flag group and product warehouse are required", ErrInvalidRequest)
+	}
+	if req.Lane != LaneStockable && req.Lane != LaneUsable {
+		return nil, fmt.Errorf("%w: unsupported lane %q", ErrInvalidRequest, req.Lane)
+	}
+
+	var out []GatherRow
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		rows, err := s.gatherRows(ctx, tx, req)
+		if err != nil {
+			return err
+		}
+		out = rows
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (s *fifoStockV2Service) gatherRows(ctx context.Context, tx *gorm.DB, req GatherRequest) ([]GatherRow, error) {
+	rules, err := s.loadRouteRules(ctx, tx, req.FlagGroupCode, req.Lane)
+	if err != nil {
+		return nil, err
+	}
+	if len(rules) == 0 {
+		return []GatherRow{}, nil
+	}
+
+	tables := make([]string, 0, len(rules))
+	for _, rule := range rules {
+		tables = append(tables, rule.SourceTable)
+	}
+
+	traits, err := s.loadTraitMap(ctx, tx, req.Lane, tables)
+	if err != nil {
+		return nil, err
+	}
+
+	subqueries := make([]string, 0, len(rules))
+	args := make([]any, 0, len(rules)*10)
+
+	for _, rule := range rules {
+		trait, ok := traits[rule.SourceTable]
+		if !ok {
+			return nil, fmt.Errorf("missing trait for table %s lane %s", rule.SourceTable, req.Lane)
+		}
+		subSQL, subArgs, err := s.buildGatherSubquery(rule, trait, req)
+		if err != nil {
+			return nil, err
+		}
+		subqueries = append(subqueries, subSQL)
+		args = append(args, subArgs...)
+	}
+
+	if len(subqueries) == 0 {
+		return []GatherRow{}, nil
+	}
+
+	limit := req.Limit
+	if limit <= 0 {
+		limit = s.defaultGatherLimit
+	}
+	if limit <= 0 {
+		limit = 1000
+	}
+
+	query := "SELECT * FROM (" + strings.Join(subqueries, " UNION ALL ") + ") AS g"
+	if req.AfterSortAt != nil {
+		query += `
+			 WHERE
+			 	(g.sort_at > ?)
+			 	OR (g.sort_at = ? AND g.source_table > ?)
+			 	OR (g.sort_at = ? AND g.source_table = ? AND g.source_id > ?)
+		`
+		args = append(args,
+			*req.AfterSortAt,
+			*req.AfterSortAt, req.AfterSourceTable,
+			*req.AfterSortAt, req.AfterSourceTable, req.AfterSourceID,
+		)
+	}
+	query += " ORDER BY g.sort_at ASC, g.sort_priority ASC, g.source_table ASC, g.source_id ASC LIMIT ?"
+	args = append(args, limit)
+
+	var rows []gatherSQLRow
+	if err := tx.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	out := make([]GatherRow, 0, len(rows))
+	for _, row := range rows {
+		out = append(out, GatherRow{
+			Ref: Ref{
+				Table:         row.SourceTable,
+				ID:            row.SourceID,
+				LegacyTypeKey: row.LegacyTypeKey,
+				FunctionCode:  row.FunctionCode,
+			},
+			FlagGroupCode:      req.FlagGroupCode,
+			ProductWarehouseID: row.ProductWarehouseID,
+			SortAt:             row.SortAt,
+			SortPriority:       row.SortPriority,
+			Quantity:           row.Quantity,
+			UsedQuantity:       row.UsedQuantity,
+			PendingQuantity:    row.PendingQuantity,
+			AvailableQuantity:  row.AvailableQuantity,
+			SourceTable:        row.SourceTable,
+			SourceID:           row.SourceID,
+		})
+	}
+
+	return out, nil
+}
+
+func (s *fifoStockV2Service) buildGatherSubquery(rule routeRule, trait traitRule, req GatherRequest) (string, []any, error) {
+	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
+	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
+	productWarehouseCol, _ := mustSafeIdentifier(rule.ProductWarehouseCol)
+	quantityCol, _ := mustSafeIdentifier(rule.QuantityCol)
+
+	baseQtyExpr := fmt.Sprintf("COALESCE(src.%s,0)::numeric", quantityCol)
+	usedExpr := "0::numeric"
+	pendingExpr := "0::numeric"
+	availableExpr := baseQtyExpr
+	extraArgs := make([]any, 0, 1)
+
+	if req.Lane == LaneStockable {
+		if rule.UsedQuantityCol != nil && strings.TrimSpace(*rule.UsedQuantityCol) != "" {
+			usedCol, _ := mustSafeIdentifier(*rule.UsedQuantityCol)
+			usedExpr = fmt.Sprintf("COALESCE(src.%s,0)::numeric", usedCol)
+		} else {
+			usedExpr = fmt.Sprintf(
+				"(SELECT COALESCE(SUM(sa.qty),0)::numeric FROM stock_allocations sa WHERE sa.stockable_type = ? AND sa.stockable_id = src.%s AND sa.status = '%s')",
+				sourceIDCol,
+				activeAllocationStatus(),
+			)
+			extraArgs = append(extraArgs, rule.LegacyTypeKey)
+		}
+		availableExpr = fmt.Sprintf("(%s - %s)", baseQtyExpr, usedExpr)
+	} else {
+		if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" {
+			pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
+			pendingExpr = fmt.Sprintf("COALESCE(src.%s,0)::numeric", pendingCol)
+		}
+		availableExpr = baseQtyExpr
+	}
+
+	sortExpr, joinClause, err := buildSortExpr(trait)
+	if err != nil {
+		return "", nil, err
+	}
+
+	whereParts := []string{
+		fmt.Sprintf("src.%s = ?", productWarehouseCol),
+		fmt.Sprintf(`EXISTS (
+			SELECT 1
+			FROM product_warehouses pw
+			JOIN flags f ON f.flagable_type = ? AND f.flagable_id = pw.product_id
+			JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
+			WHERE pw.id = src.%s AND fm.flag_group_code = ?
+		)`, productWarehouseCol),
+	}
+
+	if req.Lane == LaneStockable {
+		whereParts = append(whereParts, fmt.Sprintf("%s > 0", availableExpr))
+	}
+
+	if req.AsOf != nil {
+		whereParts = append(whereParts, fmt.Sprintf("%s <= ?", sortExpr))
+	}
+
+	if rule.ScopeSQL != nil && strings.TrimSpace(*rule.ScopeSQL) != "" {
+		whereParts = append(whereParts, fmt.Sprintf("(%s)", normalizeScopeSQL(*rule.ScopeSQL)))
+	}
+
+	subquery := fmt.Sprintf(`
+		SELECT
+			?::text AS source_table,
+			?::text AS legacy_type_key,
+			?::text AS function_code,
+			src.%s AS source_id,
+			src.%s AS product_warehouse_id,
+			%s AS sort_at,
+			?::int AS sort_priority,
+			%s AS quantity,
+			%s AS used_quantity,
+			%s AS pending_quantity,
+			%s AS available_quantity
+		FROM %s src
+		%s
+		WHERE %s
+	`, sourceIDCol, productWarehouseCol, sortExpr, baseQtyExpr, usedExpr, pendingExpr, availableExpr, sourceTable, joinClause, strings.Join(whereParts, " AND "))
+
+	args := []any{
+		rule.SourceTable,
+		rule.LegacyTypeKey,
+		rule.FunctionCode,
+		trait.SortPriority,
+	}
+	args = append(args, extraArgs...)
+	args = append(args,
+		req.ProductWarehouseID,
+		entity.FlagableTypeProduct,
+		req.FlagGroupCode,
+	)
+
+	if req.AsOf != nil {
+		args = append(args, *req.AsOf)
+	}
+
+	return subquery, args, nil
+}
+
+func buildSortExpr(trait traitRule) (string, string, error) {
+	dateCol, _ := mustSafeIdentifier(trait.DateColumn)
+	idCol, _ := mustSafeIdentifier(trait.IDColumn)
+	_ = idCol
+
+	joinClause := ""
+	sortBase := fmt.Sprintf("src.%s", dateCol)
+	if trait.DateTable != nil && strings.TrimSpace(*trait.DateTable) != "" {
+		dateTable, _ := mustSafeIdentifier(*trait.DateTable)
+		if trait.DateJoinLeftCol == nil || trait.DateJoinRightCol == nil {
+			return "", "", fmt.Errorf("trait %s requires date join columns", trait.SourceTable)
+		}
+		leftCol, _ := mustSafeIdentifier(*trait.DateJoinLeftCol)
+		rightCol, _ := mustSafeIdentifier(*trait.DateJoinRightCol)
+		joinClause = fmt.Sprintf("LEFT JOIN %s dt ON src.%s = dt.%s", dateTable, leftCol, rightCol)
+		sortBase = fmt.Sprintf("dt.%s", dateCol)
+	}
+
+	if trait.FallbackDateColumn != nil && strings.TrimSpace(*trait.FallbackDateColumn) != "" {
+		fallbackCol, _ := mustSafeIdentifier(*trait.FallbackDateColumn)
+		sortBase = fmt.Sprintf("COALESCE(%s, src.%s)", sortBase, fallbackCol)
+	}
+
+	sortExpr := fmt.Sprintf("COALESCE(%s, '1970-01-01 00:00:00+00'::timestamptz)", sortBase)
+	return sortExpr, joinClause, nil
+}

internal/common/service/fifo_stock_v2/recalculate.go

@@ -0,0 +1,177 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+func (s *fifoStockV2Service) Recalculate(ctx context.Context, req RecalculateRequest) (*RecalculateResult, error) {
+	result := &RecalculateResult{Drifts: make([]WarehouseDrift, 0)}
+
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		hash := requestHash(map[string]any{
+			"product_warehouse_ids": req.ProductWarehouseIDs,
+			"flag_group_codes":      req.FlagGroupCodes,
+			"as_of":                 req.AsOf,
+			"fix_drift":             req.FixDrift,
+		})
+		logRow, reused, err := s.beginOperation(
+			tx,
+			OperationRecalculate,
+			req.IdempotencyKey,
+			hash,
+			0,
+			"RECALCULATE",
+			"",
+			0,
+		)
+		if err != nil {
+			return err
+		}
+		if reused {
+			if len(logRow.ResultPayload) == 0 {
+				return fmt.Errorf("idempotent recalculate has empty payload")
+			}
+			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
+				return err
+			}
+			return nil
+		}
+		if logRow != nil {
+			defer func() {
+				if err != nil {
+					s.failOperation(tx, logRow, err)
+				}
+			}()
+		}
+
+		warehouseIDs, err := s.resolveRecalculateWarehouseIDs(ctx, tx, req.ProductWarehouseIDs)
+		if err != nil {
+			return err
+		}
+		groupCodes, err := s.resolveRecalculateGroupCodes(ctx, tx, req.FlagGroupCodes)
+		if err != nil {
+			return err
+		}
+
+		for _, warehouseID := range warehouseIDs {
+			expected := 0.0
+			for _, flagGroup := range groupCodes {
+				available, calcErr := s.calculateWarehouseAvailableForGroup(ctx, tx, warehouseID, flagGroup, req.AsOf)
+				if calcErr != nil {
+					return calcErr
+				}
+				expected += available
+			}
+
+			actual, actualErr := s.loadWarehouseQty(ctx, tx, warehouseID)
+			if actualErr != nil {
+				return actualErr
+			}
+
+			delta := expected - actual
+			result.Checked++
+			if math.Abs(delta) < 1e-6 {
+				continue
+			}
+
+			drift := WarehouseDrift{
+				ProductWarehouseID: warehouseID,
+				ExpectedQty:        expected,
+				ActualQty:          actual,
+				Delta:              delta,
+			}
+			result.Drifts = append(result.Drifts, drift)
+
+			if req.FixDrift {
+				if err := s.adjustProductWarehouseQty(tx, warehouseID, delta); err != nil {
+					return err
+				}
+				result.Fixed++
+			}
+		}
+
+		if err := s.finishOperation(tx, logRow, result); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *fifoStockV2Service) resolveRecalculateWarehouseIDs(ctx context.Context, tx *gorm.DB, provided []uint) ([]uint, error) {
+	if len(provided) > 0 {
+		return provided, nil
+	}
+	var ids []uint
+	err := tx.WithContext(ctx).Table("product_warehouses").Select("id").Order("id ASC").Scan(&ids).Error
+	if err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+func (s *fifoStockV2Service) resolveRecalculateGroupCodes(ctx context.Context, tx *gorm.DB, provided []string) ([]string, error) {
+	if len(provided) > 0 {
+		return provided, nil
+	}
+	var groups []string
+	err := tx.WithContext(ctx).
+		Table("fifo_stock_v2_flag_groups").
+		Select("code").
+		Where("is_active = TRUE").
+		Order("priority ASC, code ASC").
+		Scan(&groups).Error
+	if err != nil {
+		return nil, err
+	}
+	return groups, nil
+}
+
+func (s *fifoStockV2Service) calculateWarehouseAvailableForGroup(
+	ctx context.Context,
+	tx *gorm.DB,
+	warehouseID uint,
+	flagGroupCode string,
+	asOf *time.Time,
+) (float64, error) {
+	rows, err := s.gatherRows(ctx, tx, GatherRequest{
+		FlagGroupCode:      flagGroupCode,
+		Lane:               LaneStockable,
+		ProductWarehouseID: warehouseID,
+		AsOf:               asOf,
+		Limit:              50000,
+	})
+	if err != nil {
+		return 0, err
+	}
+	total := 0.0
+	for _, row := range rows {
+		total += row.AvailableQuantity
+	}
+	return total, nil
+}
+
+func (s *fifoStockV2Service) loadWarehouseQty(ctx context.Context, tx *gorm.DB, warehouseID uint) (float64, error) {
+	type row struct {
+		Qty float64 `gorm:"column:qty"`
+	}
+	var out row
+	err := tx.WithContext(ctx).
+		Table("product_warehouses").
+		Select("COALESCE(qty,0) AS qty").
+		Where("id = ?", warehouseID).
+		Take(&out).Error
+	if err != nil {
+		return 0, err
+	}
+	return out.Qty, nil
+}

internal/common/service/fifo_stock_v2/scope_sql.go

@@ -0,0 +1,100 @@
+package fifo_stock_v2
+
+import "strings"
+
+func normalizeScopeSQL(scopeSQL string) string {
+	scopeSQL = strings.TrimSpace(scopeSQL)
+	if scopeSQL == "" {
+		return scopeSQL
+	}
+
+	var out strings.Builder
+	out.Grow(len(scopeSQL) + 16)
+
+	inSingleQuote := false
+	inDoubleQuote := false
+
+	for i := 0; i < len(scopeSQL); {
+		ch := scopeSQL[i]
+
+		if inSingleQuote {
+			out.WriteByte(ch)
+			i++
+			if ch == '\'' {
+				if i < len(scopeSQL) && scopeSQL[i] == '\'' {
+					out.WriteByte(scopeSQL[i])
+					i++
+				} else {
+					inSingleQuote = false
+				}
+			}
+			continue
+		}
+
+		if inDoubleQuote {
+			out.WriteByte(ch)
+			i++
+			if ch == '"' {
+				inDoubleQuote = false
+			}
+			continue
+		}
+
+		if ch == '\'' {
+			inSingleQuote = true
+			out.WriteByte(ch)
+			i++
+			continue
+		}
+
+		if ch == '"' {
+			inDoubleQuote = true
+			out.WriteByte(ch)
+			i++
+			continue
+		}
+
+		if isIdentifierStart(ch) {
+			start := i
+			i++
+			for i < len(scopeSQL) && isIdentifierPart(scopeSQL[i]) {
+				i++
+			}
+
+			token := scopeSQL[start:i]
+			if strings.EqualFold(token, "deleted_at") && !hasAliasQualifier(scopeSQL, start) {
+				out.WriteString("src.deleted_at")
+			} else {
+				out.WriteString(token)
+			}
+			continue
+		}
+
+		out.WriteByte(ch)
+		i++
+	}
+
+	return out.String()
+}
+
+func hasAliasQualifier(scopeSQL string, tokenStart int) bool {
+	for i := tokenStart - 1; i >= 0; i-- {
+		switch scopeSQL[i] {
+		case ' ', '\t', '\n', '\r':
+			continue
+		case '.':
+			return true
+		default:
+			return false
+		}
+	}
+	return false
+}
+
+func isIdentifierStart(ch byte) bool {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'
+}
+
+func isIdentifierPart(ch byte) bool {
+	return isIdentifierStart(ch) || (ch >= '0' && ch <= '9')
+}

internal/common/service/fifo_stock_v2/service.go

@@ -0,0 +1,265 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash/fnv"
+	"math"
+	"regexp"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+var identifierPattern = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
+
+type fifoStockV2Service struct {
+	db                 *gorm.DB
+	logger             *logrus.Logger
+	defaultGatherLimit int
+}
+
+func NewService(db *gorm.DB, logger *logrus.Logger) Service {
+	if logger == nil {
+		logger = logrus.StandardLogger()
+	}
+
+	return &fifoStockV2Service{
+		db:                 db,
+		logger:             logger,
+		defaultGatherLimit: 1000,
+	}
+}
+
+func (s *fifoStockV2Service) withTransaction(
+	ctx context.Context,
+	tx *gorm.DB,
+	fn func(*gorm.DB) error,
+) error {
+	if tx != nil {
+		return fn(tx.WithContext(ctx))
+	}
+	return s.db.WithContext(ctx).Transaction(func(inner *gorm.DB) error {
+		return fn(inner)
+	})
+}
+
+func isSafeIdentifier(v string) bool {
+	return identifierPattern.MatchString(strings.TrimSpace(v))
+}
+
+func mustSafeIdentifier(v string) (string, error) {
+	v = strings.TrimSpace(v)
+	if !isSafeIdentifier(v) {
+		return "", fmt.Errorf("unsafe identifier: %s", v)
+	}
+	return v, nil
+}
+
+func requestHash(v any) string {
+	payload, _ := json.Marshal(v)
+	sum := sha256.Sum256(payload)
+	return hex.EncodeToString(sum[:])
+}
+
+func shardLockKey(flagGroupCode string, productWarehouseID uint) int64 {
+	h := fnv.New64a()
+	_, _ = h.Write([]byte(strings.TrimSpace(strings.ToUpper(flagGroupCode))))
+	_, _ = h.Write([]byte("|"))
+	_, _ = h.Write([]byte(fmt.Sprintf("%d", productWarehouseID)))
+	return int64(h.Sum64())
+}
+
+func (s *fifoStockV2Service) lockShard(tx *gorm.DB, flagGroupCode string, productWarehouseID uint) error {
+	if strings.TrimSpace(flagGroupCode) == "" || productWarehouseID == 0 {
+		return fmt.Errorf("lock shard requires flag group and product warehouse")
+	}
+	return tx.Exec("SELECT pg_advisory_xact_lock(?)", shardLockKey(flagGroupCode, productWarehouseID)).Error
+}
+
+type operationLogRow struct {
+	ID            uint            `gorm:"column:id"`
+	Status        string          `gorm:"column:status"`
+	RequestHash   string          `gorm:"column:request_hash"`
+	ResultPayload json.RawMessage `gorm:"column:result_payload"`
+}
+
+func (s *fifoStockV2Service) beginOperation(
+	tx *gorm.DB,
+	op Operation,
+	idempotencyKey string,
+	requestHashValue string,
+	productWarehouseID uint,
+	flagGroupCode string,
+	usableType string,
+	usableID uint,
+) (*operationLogRow, bool, error) {
+	if strings.TrimSpace(idempotencyKey) == "" {
+		return nil, false, nil
+	}
+
+	inserted := operationLogRow{}
+	insertSQL := `
+		INSERT INTO fifo_stock_v2_operation_log
+			(idempotency_key, operation, product_warehouse_id, flag_group_code, usable_type, usable_id, request_hash, status, created_at)
+		VALUES (?, ?, ?, ?, NULLIF(?, ''), NULLIF(?, 0), ?, 'RUNNING', NOW())
+		ON CONFLICT (idempotency_key, operation) DO NOTHING
+		RETURNING id, status, request_hash
+	`
+	if err := tx.Raw(insertSQL,
+		idempotencyKey,
+		string(op),
+		productWarehouseID,
+		flagGroupCode,
+		usableType,
+		usableID,
+		requestHashValue,
+	).Scan(&inserted).Error; err != nil {
+		return nil, false, err
+	}
+	if inserted.ID != 0 {
+		return &inserted, false, nil
+	}
+
+	existing := operationLogRow{}
+	if err := tx.Table("fifo_stock_v2_operation_log").
+		Select("id, status, request_hash, result_payload").
+		Where("idempotency_key = ? AND operation = ?", idempotencyKey, string(op)).
+		Take(&existing).Error; err != nil {
+		return nil, false, err
+	}
+
+	if existing.RequestHash != requestHashValue {
+		return nil, false, fmt.Errorf("idempotency key %s reused with different payload", idempotencyKey)
+	}
+
+	switch strings.ToUpper(existing.Status) {
+	case "DONE":
+		return &existing, true, nil
+	case "RUNNING":
+		return nil, false, fmt.Errorf("operation %s with idempotency key %s is still running", op, idempotencyKey)
+	case "FAILED":
+		if err := tx.Table("fifo_stock_v2_operation_log").
+			Where("id = ?", existing.ID).
+			Updates(map[string]any{
+				"status":      "RUNNING",
+				"error_text":  nil,
+				"finished_at": nil,
+			}).Error; err != nil {
+			return nil, false, err
+		}
+		existing.Status = "RUNNING"
+		return &existing, false, nil
+	default:
+		return nil, false, fmt.Errorf("unknown operation status: %s", existing.Status)
+	}
+}
+
+func (s *fifoStockV2Service) finishOperation(tx *gorm.DB, logRow *operationLogRow, payload any) error {
+	if logRow == nil || logRow.ID == 0 {
+		return nil
+	}
+
+	encoded, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	return tx.Table("fifo_stock_v2_operation_log").
+		Where("id = ?", logRow.ID).
+		Updates(map[string]any{
+			"status":         "DONE",
+			"result_payload": encoded,
+			"finished_at":    gorm.Expr("NOW()"),
+		}).Error
+}
+
+func (s *fifoStockV2Service) failOperation(tx *gorm.DB, logRow *operationLogRow, failure error) {
+	if logRow == nil || logRow.ID == 0 || failure == nil {
+		return
+	}
+	_ = tx.Table("fifo_stock_v2_operation_log").
+		Where("id = ?", logRow.ID).
+		Updates(map[string]any{
+			"status":      "FAILED",
+			"error_text":  failure.Error(),
+			"finished_at": gorm.Expr("NOW()"),
+		}).Error
+}
+
+func (s *fifoStockV2Service) resolveOverConsume(
+	tx *gorm.DB,
+	flagGroupCode string,
+	functionCode string,
+	lane Lane,
+	defaultValue bool,
+) (bool, error) {
+	type row struct {
+		Allow bool `gorm:"column:allow_overconsume"`
+	}
+	selected := row{}
+	err := tx.Table("fifo_stock_v2_overconsume_rules").
+		Select("allow_overconsume").
+		Where("is_active = TRUE").
+		Where("lane = ?", string(lane)).
+		Where("(flag_group_code IS NULL OR flag_group_code = ?)", flagGroupCode).
+		Where("(function_code IS NULL OR function_code = ?)", functionCode).
+		Order("CASE WHEN flag_group_code IS NULL THEN 1 ELSE 0 END ASC").
+		Order("CASE WHEN function_code IS NULL THEN 1 ELSE 0 END ASC").
+		Order("priority ASC, id ASC").
+		Limit(1).
+		Take(&selected).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return defaultValue, nil
+		}
+		return false, err
+	}
+	return selected.Allow, nil
+}
+
+func (s *fifoStockV2Service) adjustProductWarehouseQty(tx *gorm.DB, productWarehouseID uint, delta float64) error {
+	if productWarehouseID == 0 || delta == 0 {
+		return nil
+	}
+	return tx.Table("product_warehouses").
+		Where("id = ?", productWarehouseID).
+		Update("qty", gorm.Expr("COALESCE(qty,0) + ?", delta)).Error
+}
+
+func nearlyZero(v float64) bool {
+	return math.Abs(v) < 1e-6
+}
+
+func (s *fifoStockV2Service) ensureStockAllocationColumns(tx *gorm.DB) error {
+	checkCols := []string{"engine_version", "flag_group_code", "function_code", "idempotency_key"}
+	for _, col := range checkCols {
+		var count int64
+		err := tx.Raw(`
+			SELECT COUNT(1)
+			FROM information_schema.columns
+			WHERE table_schema = 'public' AND table_name = 'stock_allocations' AND column_name = ?
+		`, col).Scan(&count).Error
+		if err != nil {
+			return err
+		}
+		if count == 0 {
+			return fmt.Errorf("stock_allocations.%s does not exist, run fifo_stock_v2 migration first", col)
+		}
+	}
+	return nil
+}
+
+func activeAllocationStatus() string {
+	return entity.StockAllocationStatusActive
+}
+
+func releasedAllocationStatus() string {
+	return entity.StockAllocationStatusReleased
+}

internal/common/service/fifo_stock_v2/types.go

@@ -0,0 +1,142 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type Lane string
+
+const (
+	LaneStockable Lane = "STOCKABLE"
+	LaneUsable    Lane = "USABLE"
+)
+
+type Operation string
+
+const (
+	OperationAllocate    Operation = "ALLOCATE"
+	OperationRollback    Operation = "ROLLBACK"
+	OperationReflow      Operation = "REFLOW"
+	OperationRecalculate Operation = "RECALCULATE"
+)
+
+type Ref struct {
+	Table         string
+	ID            uint
+	LegacyTypeKey string
+	FunctionCode  string
+}
+
+type GatherRequest struct {
+	FlagGroupCode      string
+	Lane               Lane
+	ProductWarehouseID uint
+	AsOf               *time.Time
+	Limit              int
+	AfterSortAt        *time.Time
+	AfterSourceTable   string
+	AfterSourceID      uint
+	ForUpdate          bool
+	Tx                 *gorm.DB
+}
+
+type GatherRow struct {
+	Ref                Ref
+	FlagGroupCode      string
+	ProductWarehouseID uint
+	SortAt             time.Time
+	SortPriority       int
+	Quantity           float64
+	UsedQuantity       float64
+	PendingQuantity    float64
+	AvailableQuantity  float64
+	SourceTable        string
+	SourceID           uint
+}
+
+type AllocateRequest struct {
+	FlagGroupCode      string
+	ProductWarehouseID uint
+	Usable             Ref
+	NeedQty            float64
+	AllowOverConsume   *bool
+	IdempotencyKey     string
+	AsOf               *time.Time
+	Tx                 *gorm.DB
+}
+
+type AllocationDetail struct {
+	StockableType string
+	StockableID   uint
+	Qty           float64
+	SortAt        time.Time
+}
+
+type AllocateResult struct {
+	AllocatedQty float64
+	PendingQty   float64
+	Details      []AllocationDetail
+}
+
+type RollbackRequest struct {
+	ProductWarehouseID uint
+	Usable             Ref
+	ReleaseQty         *float64
+	Reason             string
+	IdempotencyKey     string
+	Tx                 *gorm.DB
+}
+
+type RollbackResult struct {
+	ReleasedQty float64
+	Details     []AllocationDetail
+}
+
+type ReflowRequest struct {
+	FlagGroupCode      string
+	ProductWarehouseID uint
+	Usable             Ref
+	DesiredQty         float64
+	AllowOverConsume   *bool
+	IdempotencyKey     string
+	AsOf               *time.Time
+	Tx                 *gorm.DB
+}
+
+type ReflowResult struct {
+	Rollback RollbackResult
+	Allocate AllocateResult
+}
+
+type RecalculateRequest struct {
+	ProductWarehouseIDs []uint
+	FlagGroupCodes      []string
+	AsOf                *time.Time
+	FixDrift            bool
+	IdempotencyKey      string
+	Tx                  *gorm.DB
+}
+
+type WarehouseDrift struct {
+	ProductWarehouseID uint
+	ExpectedQty        float64
+	ActualQty          float64
+	Delta              float64
+}
+
+type RecalculateResult struct {
+	Checked int
+	Fixed   int
+	Drifts  []WarehouseDrift
+}
+
+type Service interface {
+	Gather(ctx context.Context, req GatherRequest) ([]GatherRow, error)
+	Allocate(ctx context.Context, req AllocateRequest) (*AllocateResult, error)
+	Rollback(ctx context.Context, req RollbackRequest) (*RollbackResult, error)
+	Reflow(ctx context.Context, req ReflowRequest) (*ReflowResult, error)
+	Recalculate(ctx context.Context, req RecalculateRequest) (*RecalculateResult, error)
+}

internal/config/config.go

@@ -22,60 +22,61 @@ type SSOClientConfig struct {
 }
 
 var (
-	IsProd                  bool
-	AppHost                 string
-	Version                 string
-	LogLevel                string
-	AppPort                 int
-	DBHost                  string
-	DBUser                  string
-	DBPassword              string
-	DBName                  string
-	DBPort                  int
-	DBSSLMode               string
-	DBSSLRootCert           string
-	DBSSLCert               string
-	DBSSLKey                string
-	JWTSecret               string
-	JWTAccessExp            int
-	JWTRefreshExp           int
-	JWTResetPasswordExp     int
-	JWTVerifyEmailExp       int
-	RedisURL                string
-	CORSAllowOrigins        []string
-	CORSAllowMethods        []string
-	CORSAllowHeaders        []string
-	CORSExposeHeaders       []string
-	CORSAllowCredentials    bool
-	CORSMaxAge              int
-	SSOIssuer               string
-	SSOJWKSURL              string
-	SSOAllowedAudiences     []string
-	SSOAuthorizeURL         string
-	SSOTokenURL             string
-	SSOGetMeURL             string
-	SSOPortalURL            string
-	SSOClients              map[string]SSOClientConfig
-	SSOAccessCookieName     string
-	SSORefreshCookieName    string
-	SSOCookieDomain         string
-	SSOCookieSecure         bool
-	SSOCookieSameSite       string
-	SSOAccessTokenMaxBytes  int
-	SSOTokenBlacklistPrefix string
-	SSOPKCETTL              time.Duration
-	SSOUserSyncDrift        time.Duration
-	SSOUserSyncNonceTTL     time.Duration
-	SSOUserSyncMaxBodyBytes int
-	S3Endpoint              string
-	S3Region                string
-	S3Bucket                string
-	S3AccessKey             string
-	S3SecretKey             string
-	S3ForcePathStyle        bool
-	S3PublicBaseURL         string
-	S3EnvPrefix             string
-	S3DocumentKeyPrefix     string
+	IsProd                         bool
+	AppHost                        string
+	Version                        string
+	LogLevel                       string
+	AppPort                        int
+	DBHost                         string
+	DBUser                         string
+	DBPassword                     string
+	DBName                         string
+	DBPort                         int
+	DBSSLMode                      string
+	DBSSLRootCert                  string
+	DBSSLCert                      string
+	DBSSLKey                       string
+	JWTSecret                      string
+	JWTAccessExp                   int
+	JWTRefreshExp                  int
+	JWTResetPasswordExp            int
+	JWTVerifyEmailExp              int
+	RedisURL                       string
+	CORSAllowOrigins               []string
+	CORSAllowMethods               []string
+	CORSAllowHeaders               []string
+	CORSExposeHeaders              []string
+	CORSAllowCredentials           bool
+	CORSMaxAge                     int
+	SSOIssuer                      string
+	SSOJWKSURL                     string
+	SSOAllowedAudiences            []string
+	SSOAuthorizeURL                string
+	SSOTokenURL                    string
+	SSOGetMeURL                    string
+	SSOPortalURL                   string
+	SSOClients                     map[string]SSOClientConfig
+	SSOAccessCookieName            string
+	SSORefreshCookieName           string
+	SSOCookieDomain                string
+	SSOCookieSecure                bool
+	SSOCookieSameSite              string
+	SSOAccessTokenMaxBytes         int
+	SSOTokenBlacklistPrefix        string
+	SSOPKCETTL                     time.Duration
+	SSOUserSyncDrift               time.Duration
+	SSOUserSyncNonceTTL            time.Duration
+	SSOUserSyncMaxBodyBytes        int
+	S3Endpoint                     string
+	S3Region                       string
+	S3Bucket                       string
+	S3AccessKey                    string
+	S3SecretKey                    string
+	S3ForcePathStyle               bool
+	S3PublicBaseURL                string
+	S3EnvPrefix                    string
+	S3DocumentKeyPrefix            string
+	TransferToLayingGrowingMaxWeek int
 )
 
 func init() {
@@ -117,6 +118,11 @@ func init() {
 	// Redis
 	RedisURL = viper.GetString("REDIS_URL")
 
+	TransferToLayingGrowingMaxWeek = viper.GetInt("TRANSFER_TO_LAYING_GROWING_MAX_WEEK")
+	if TransferToLayingGrowingMaxWeek <= 0 {
+		TransferToLayingGrowingMaxWeek = 19
+	}
+
 	// Object storage
 	S3Endpoint = strings.TrimSpace(viper.GetString("S3_ENDPOINT"))
 	S3Region = strings.TrimSpace(viper.GetString("S3_REGION"))

internal/database/migrations/20260218090000_create_fifo_stock_v2_core.down.sql

@@ -0,0 +1,24 @@
+BEGIN;
+
+DROP INDEX IF EXISTS idx_stock_allocations_idempotency;
+DROP INDEX IF EXISTS idx_stock_allocations_flag_group;
+DROP INDEX IF EXISTS idx_stock_allocations_engine_version;
+
+ALTER TABLE stock_allocations
+    DROP COLUMN IF EXISTS idempotency_key,
+    DROP COLUMN IF EXISTS reflow_run_id,
+    DROP COLUMN IF EXISTS function_code,
+    DROP COLUMN IF EXISTS flag_group_code,
+    DROP COLUMN IF EXISTS engine_version;
+
+DROP TABLE IF EXISTS fifo_stock_v2_shadow_allocations;
+DROP TABLE IF EXISTS fifo_stock_v2_reflow_checkpoints;
+DROP TABLE IF EXISTS fifo_stock_v2_reflow_runs;
+DROP TABLE IF EXISTS fifo_stock_v2_operation_log;
+DROP TABLE IF EXISTS fifo_stock_v2_overconsume_rules;
+DROP TABLE IF EXISTS fifo_stock_v2_route_rules;
+DROP TABLE IF EXISTS fifo_stock_v2_traits;
+DROP TABLE IF EXISTS fifo_stock_v2_flag_members;
+DROP TABLE IF EXISTS fifo_stock_v2_flag_groups;
+
+COMMIT;

internal/database/migrations/20260218090000_create_fifo_stock_v2_core.up.sql

@@ -0,0 +1,151 @@
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_groups (
+    code VARCHAR(64) PRIMARY KEY,
+    name VARCHAR(128) NOT NULL,
+    priority INT NOT NULL DEFAULT 100,
+    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_members (
+    flag_name VARCHAR(64) PRIMARY KEY,
+    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
+    priority INT NOT NULL DEFAULT 100,
+    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_traits (
+    id BIGSERIAL PRIMARY KEY,
+    source_table VARCHAR(64) NOT NULL,
+    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
+    date_table VARCHAR(64) NULL,
+    date_join_left_col VARCHAR(64) NULL,
+    date_join_right_col VARCHAR(64) NULL,
+    date_column VARCHAR(64) NOT NULL,
+    fallback_date_column VARCHAR(64) NULL,
+    sort_priority INT NOT NULL DEFAULT 100,
+    id_column VARCHAR(64) NOT NULL DEFAULT 'id',
+    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+    UNIQUE (source_table, lane)
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_route_rules (
+    id BIGSERIAL PRIMARY KEY,
+    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
+    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
+    function_code VARCHAR(64) NOT NULL,
+    source_table VARCHAR(64) NOT NULL,
+    source_id_column VARCHAR(64) NOT NULL DEFAULT 'id',
+    product_warehouse_col VARCHAR(64) NOT NULL,
+    quantity_col VARCHAR(64) NOT NULL,
+    used_quantity_col VARCHAR(64) NULL,
+    pending_quantity_col VARCHAR(64) NULL,
+    scope_sql TEXT NULL,
+    legacy_type_key VARCHAR(100) NOT NULL,
+    allow_pending_default BOOLEAN NOT NULL DEFAULT TRUE,
+    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (flag_group_code, lane, function_code, source_table)
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_overconsume_rules (
+    id BIGSERIAL PRIMARY KEY,
+    flag_group_code VARCHAR(64) NULL REFERENCES fifo_stock_v2_flag_groups(code),
+    function_code VARCHAR(64) NULL,
+    lane VARCHAR(16) NOT NULL DEFAULT 'USABLE' CHECK (lane IN ('STOCKABLE', 'USABLE')),
+    allow_overconsume BOOLEAN NOT NULL,
+    priority INT NOT NULL DEFAULT 100,
+    reason TEXT NULL,
+    is_active BOOLEAN NOT NULL DEFAULT TRUE
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_operation_log (
+    id BIGSERIAL PRIMARY KEY,
+    idempotency_key VARCHAR(128) NOT NULL,
+    operation VARCHAR(16) NOT NULL CHECK (operation IN ('ALLOCATE', 'ROLLBACK', 'REFLOW', 'RECALCULATE')),
+    product_warehouse_id BIGINT NOT NULL,
+    flag_group_code VARCHAR(64) NOT NULL,
+    usable_type VARCHAR(100) NULL,
+    usable_id BIGINT NULL,
+    request_hash VARCHAR(64) NOT NULL,
+    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'DONE', 'FAILED')),
+    result_payload JSONB NULL,
+    error_text TEXT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    finished_at TIMESTAMPTZ NULL,
+    UNIQUE (idempotency_key, operation)
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_runs (
+    id BIGSERIAL PRIMARY KEY,
+    mode VARCHAR(16) NOT NULL CHECK (mode IN ('DRY_RUN', 'APPLY')),
+    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'PAUSED', 'DONE', 'FAILED', 'CANCELLED')),
+    as_of TIMESTAMPTZ NULL,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    finished_at TIMESTAMPTZ NULL,
+    total_shards INT NOT NULL DEFAULT 0,
+    processed_shards INT NOT NULL DEFAULT 0,
+    processed_rows BIGINT NOT NULL DEFAULT 0,
+    mismatch_rows BIGINT NOT NULL DEFAULT 0,
+    created_by BIGINT NULL,
+    note TEXT NULL
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_checkpoints (
+    id BIGSERIAL PRIMARY KEY,
+    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
+    flag_group_code VARCHAR(64) NOT NULL,
+    product_warehouse_id BIGINT NOT NULL,
+    last_sort_at TIMESTAMPTZ NULL,
+    last_source_table VARCHAR(64) NULL,
+    last_source_id BIGINT NULL,
+    status VARCHAR(16) NOT NULL CHECK (status IN ('PENDING', 'RUNNING', 'DONE', 'FAILED')) DEFAULT 'PENDING',
+    retry_count INT NOT NULL DEFAULT 0,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (run_id, flag_group_code, product_warehouse_id)
+);
+
+CREATE TABLE IF NOT EXISTS fifo_stock_v2_shadow_allocations (
+    id BIGSERIAL PRIMARY KEY,
+    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
+    product_warehouse_id BIGINT NOT NULL,
+    stockable_type VARCHAR(100) NOT NULL,
+    stockable_id BIGINT NOT NULL,
+    usable_type VARCHAR(100) NOT NULL,
+    usable_id BIGINT NOT NULL,
+    qty NUMERIC(15,3) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
+    sort_at TIMESTAMPTZ NULL,
+    source_table VARCHAR(64) NULL,
+    source_id BIGINT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_usable
+    ON fifo_stock_v2_shadow_allocations(run_id, usable_type, usable_id);
+
+CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_stockable
+    ON fifo_stock_v2_shadow_allocations(run_id, stockable_type, stockable_id);
+
+ALTER TABLE stock_allocations
+    ADD COLUMN IF NOT EXISTS engine_version VARCHAR(8) NOT NULL DEFAULT 'v1',
+    ADD COLUMN IF NOT EXISTS flag_group_code VARCHAR(64) NULL,
+    ADD COLUMN IF NOT EXISTS function_code VARCHAR(64) NULL,
+    ADD COLUMN IF NOT EXISTS reflow_run_id BIGINT NULL,
+    ADD COLUMN IF NOT EXISTS idempotency_key VARCHAR(128) NULL;
+
+CREATE INDEX IF NOT EXISTS idx_stock_allocations_engine_version
+    ON stock_allocations(engine_version);
+
+CREATE INDEX IF NOT EXISTS idx_stock_allocations_flag_group
+    ON stock_allocations(flag_group_code);
+
+CREATE INDEX IF NOT EXISTS idx_stock_allocations_idempotency
+    ON stock_allocations(idempotency_key);
+
+COMMIT;

internal/database/migrations/20260218090010_seed_fifo_stock_v2_config.down.sql

@@ -0,0 +1,36 @@
+BEGIN;
+
+DELETE FROM fifo_stock_v2_overconsume_rules
+WHERE reason IN (
+    'fifo_v2_default_allow',
+    'fifo_v2_exception_ayam_depletion_block',
+    'fifo_v2_exception_marketing_block',
+    'fifo_v2_exception_transfer_block',
+    'fifo_v2_exception_adjustment_block',
+    'fifo_v2_exception_transfer_laying_block'
+);
+
+DELETE FROM fifo_stock_v2_route_rules
+WHERE flag_group_code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
+
+DELETE FROM fifo_stock_v2_traits
+WHERE source_table IN (
+    'purchase_items',
+    'stock_transfer_details',
+    'laying_transfer_targets',
+    'laying_transfer_sources',
+    'adjustment_stocks',
+    'recording_stocks',
+    'recording_depletions',
+    'recording_eggs',
+    'marketing_delivery_products',
+    'project_chickins'
+);
+
+DELETE FROM fifo_stock_v2_flag_members
+WHERE flag_group_code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
+
+DELETE FROM fifo_stock_v2_flag_groups
+WHERE code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
+
+COMMIT;

internal/database/migrations/20260218090010_seed_fifo_stock_v2_config.up.sql

@@ -0,0 +1,248 @@
+BEGIN;
+
+INSERT INTO fifo_stock_v2_flag_groups(code, name, priority)
+VALUES
+    ('AYAM', 'AYAM', 10),
+    ('AFKIR_CULLING_MATI', 'AFKIR/CULLING/MATI', 20),
+    ('PAKAN', 'PAKAN', 30),
+    ('OVK', 'OVK', 40),
+    ('TELUR', 'TELUR', 50),
+    ('TELUR_GRADE', 'UTUH/PUTIH/RETAK/PECAH/PAPACAL/JUMBO', 60)
+ON CONFLICT (code) DO UPDATE
+SET
+    name = EXCLUDED.name,
+    priority = EXCLUDED.priority,
+    updated_at = NOW();
+
+INSERT INTO fifo_stock_v2_flag_members(flag_name, flag_group_code, priority)
+VALUES
+    ('DOC', 'AYAM', 10),
+    ('PULLET', 'AYAM', 20),
+    ('LAYER', 'AYAM', 30),
+
+    ('AYAM-AFKIR', 'AFKIR_CULLING_MATI', 10),
+    ('AYAM-CULLING', 'AFKIR_CULLING_MATI', 20),
+    ('AYAM-MATI', 'AFKIR_CULLING_MATI', 30),
+
+    ('PAKAN', 'PAKAN', 10),
+    ('PRE-STARTER', 'PAKAN', 20),
+    ('STARTER', 'PAKAN', 30),
+    ('FINISHER', 'PAKAN', 40),
+
+    ('OVK', 'OVK', 10),
+    ('OBAT', 'OVK', 20),
+    ('VITAMIN', 'OVK', 30),
+    ('KIMIA', 'OVK', 40),
+
+    ('TELUR', 'TELUR', 10),
+
+    ('TELUR-UTUH', 'TELUR_GRADE', 10),
+    ('TELUR-PUTIH', 'TELUR_GRADE', 20),
+    ('TELUR-RETAK', 'TELUR_GRADE', 30),
+    ('TELUR-PECAH', 'TELUR_GRADE', 40),
+    ('TELUR-PAPACAL', 'TELUR_GRADE', 50),
+    ('TELUR-JUMBO', 'TELUR_GRADE', 60)
+ON CONFLICT (flag_name) DO UPDATE
+SET
+    flag_group_code = EXCLUDED.flag_group_code,
+    priority = EXCLUDED.priority,
+    updated_at = NOW();
+
+INSERT INTO fifo_stock_v2_traits(
+    source_table,
+    lane,
+    date_table,
+    date_join_left_col,
+    date_join_right_col,
+    date_column,
+    fallback_date_column,
+    sort_priority,
+    id_column
+)
+VALUES
+    ('purchase_items', 'STOCKABLE', NULL, NULL, NULL, 'received_date', NULL, 10, 'id'),
+
+    ('stock_transfer_details', 'STOCKABLE', 'stock_transfers', 'stock_transfer_id', 'id', 'transfer_date', NULL, 20, 'id'),
+    ('stock_transfer_details', 'USABLE', 'stock_transfers', 'stock_transfer_id', 'id', 'transfer_date', NULL, 20, 'id'),
+
+    ('laying_transfer_targets', 'STOCKABLE', 'laying_transfers', 'laying_transfer_id', 'id', 'transfer_date', NULL, 25, 'id'),
+    ('laying_transfer_sources', 'USABLE', 'laying_transfers', 'laying_transfer_id', 'id', 'transfer_date', NULL, 25, 'id'),
+
+    ('adjustment_stocks', 'STOCKABLE', NULL, NULL, NULL, 'created_at', NULL, 30, 'id'),
+    ('adjustment_stocks', 'USABLE', NULL, NULL, NULL, 'created_at', NULL, 30, 'id'),
+
+    ('recording_stocks', 'USABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
+    ('recording_depletions', 'USABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
+    ('recording_depletions', 'STOCKABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
+
+    ('recording_eggs', 'STOCKABLE', 'recordings', 'recording_id', 'id', 'record_datetime', 'created_at', 40, 'id'),
+
+    ('marketing_delivery_products', 'USABLE', NULL, NULL, NULL, 'delivery_date', 'created_at', 45, 'id'),
+
+    ('project_chickins', 'USABLE', NULL, NULL, NULL, 'chick_in_date', 'created_at', 50, 'id')
+ON CONFLICT (source_table, lane) DO UPDATE
+SET
+    date_table = EXCLUDED.date_table,
+    date_join_left_col = EXCLUDED.date_join_left_col,
+    date_join_right_col = EXCLUDED.date_join_right_col,
+    date_column = EXCLUDED.date_column,
+    fallback_date_column = EXCLUDED.fallback_date_column,
+    sort_priority = EXCLUDED.sort_priority,
+    id_column = EXCLUDED.id_column,
+    is_active = TRUE;
+
+INSERT INTO fifo_stock_v2_route_rules(
+    flag_group_code,
+    lane,
+    function_code,
+    source_table,
+    source_id_column,
+    product_warehouse_col,
+    quantity_col,
+    used_quantity_col,
+    pending_quantity_col,
+    scope_sql,
+    legacy_type_key,
+    allow_pending_default,
+    is_active
+)
+VALUES
+    -- AYAM STOCKABLE
+    ('AYAM', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('AYAM', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('AYAM', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
+    ('AYAM', 'STOCKABLE', 'TRANSFER_TO_LAYING_IN', 'laying_transfer_targets', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'TRANSFERTOLAYING_IN', TRUE, TRUE),
+
+    -- AYAM USABLE
+    ('AYAM', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('AYAM', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('AYAM', 'USABLE', 'CHICKIN_OUT', 'project_chickins', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_usage_qty', 'deleted_at IS NULL', 'PROJECT_CHICKIN', TRUE, TRUE),
+    ('AYAM', 'USABLE', 'RECORDING_DEPLETION_OUT', 'recording_depletions', 'id', 'source_product_warehouse_id', 'qty', NULL, 'pending_qty', NULL, 'RECORDING_DEPLETION', TRUE, TRUE),
+    ('AYAM', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
+    ('AYAM', 'USABLE', 'TRANSFER_TO_LAYING_OUT', 'laying_transfer_sources', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_usage_qty', 'deleted_at IS NULL', 'TRANSFERTOLAYING_OUT', TRUE, TRUE),
+
+    -- AFKIR/CULLING/MATI STOCKABLE
+    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'RECORDING_DEPLETION_IN', 'recording_depletions', 'id', 'product_warehouse_id', 'qty', NULL, NULL, NULL, 'RECORDING_DEPLETION', TRUE, TRUE),
+
+    -- AFKIR/CULLING/MATI USABLE
+    ('AFKIR_CULLING_MATI', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('AFKIR_CULLING_MATI', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('AFKIR_CULLING_MATI', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
+
+    -- PAKAN STOCKABLE
+    ('PAKAN', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('PAKAN', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('PAKAN', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
+
+    -- PAKAN USABLE
+    ('PAKAN', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('PAKAN', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('PAKAN', 'USABLE', 'RECORDING_STOCK_OUT', 'recording_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'RECORDING_STOCK', TRUE, TRUE),
+    ('PAKAN', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
+
+    -- OVK STOCKABLE
+    ('OVK', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('OVK', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('OVK', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
+
+    -- OVK USABLE
+    ('OVK', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('OVK', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('OVK', 'USABLE', 'RECORDING_STOCK_OUT', 'recording_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'RECORDING_STOCK', TRUE, TRUE),
+    ('OVK', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
+
+    -- TELUR STOCKABLE
+    ('TELUR', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('TELUR', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('TELUR', 'STOCKABLE', 'RECORDING_EGG_IN', 'recording_eggs', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'RECORDING_EGG', TRUE, TRUE),
+
+    -- TELUR USABLE
+    ('TELUR', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('TELUR', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('TELUR', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
+
+    -- TELUR_GRADE STOCKABLE
+    ('TELUR_GRADE', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
+    ('TELUR_GRADE', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
+    ('TELUR_GRADE', 'STOCKABLE', 'RECORDING_EGG_IN', 'recording_eggs', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'RECORDING_EGG', TRUE, TRUE),
+
+    -- TELUR_GRADE USABLE
+    ('TELUR_GRADE', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
+    ('TELUR_GRADE', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
+    ('TELUR_GRADE', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE)
+ON CONFLICT (flag_group_code, lane, function_code, source_table) DO UPDATE
+SET
+    source_id_column = EXCLUDED.source_id_column,
+    product_warehouse_col = EXCLUDED.product_warehouse_col,
+    quantity_col = EXCLUDED.quantity_col,
+    used_quantity_col = EXCLUDED.used_quantity_col,
+    pending_quantity_col = EXCLUDED.pending_quantity_col,
+    scope_sql = EXCLUDED.scope_sql,
+    legacy_type_key = EXCLUDED.legacy_type_key,
+    allow_pending_default = EXCLUDED.allow_pending_default,
+    is_active = EXCLUDED.is_active,
+    updated_at = NOW();
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT NULL, NULL, 'USABLE', TRUE, 999, 'fifo_v2_default_allow', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code IS NULL
+      AND function_code IS NULL
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_default_allow'
+);
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT 'AYAM', 'RECORDING_DEPLETION_OUT', 'USABLE', FALSE, 10, 'fifo_v2_exception_ayam_depletion_block', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code = 'AYAM'
+      AND function_code = 'RECORDING_DEPLETION_OUT'
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_exception_ayam_depletion_block'
+);
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT NULL, 'MARKETING_OUT', 'USABLE', FALSE, 20, 'fifo_v2_exception_marketing_block', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code IS NULL
+      AND function_code = 'MARKETING_OUT'
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_exception_marketing_block'
+);
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT NULL, 'STOCK_TRANSFER_OUT', 'USABLE', FALSE, 30, 'fifo_v2_exception_transfer_block', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code IS NULL
+      AND function_code = 'STOCK_TRANSFER_OUT'
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_exception_transfer_block'
+);
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT NULL, 'ADJUSTMENT_OUT', 'USABLE', FALSE, 40, 'fifo_v2_exception_adjustment_block', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code IS NULL
+      AND function_code = 'ADJUSTMENT_OUT'
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_exception_adjustment_block'
+);
+
+INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
+SELECT NULL, 'TRANSFER_TO_LAYING_OUT', 'USABLE', FALSE, 50, 'fifo_v2_exception_transfer_laying_block', TRUE
+WHERE NOT EXISTS (
+    SELECT 1 FROM fifo_stock_v2_overconsume_rules
+    WHERE flag_group_code IS NULL
+      AND function_code = 'TRANSFER_TO_LAYING_OUT'
+      AND lane = 'USABLE'
+      AND reason = 'fifo_v2_exception_transfer_laying_block'
+);
+
+COMMIT;

internal/database/migrations/20260225073024_adjustment_stocks_add_fifo_v2_columns.down.sql

@@ -0,0 +1,12 @@
+BEGIN;
+
+DROP INDEX IF EXISTS idx_adjustment_stocks_function_code;
+DROP INDEX IF EXISTS idx_adjustment_stocks_transaction_type;
+
+ALTER TABLE adjustment_stocks
+    DROP COLUMN IF EXISTS grand_total,
+    DROP COLUMN IF EXISTS price,
+    DROP COLUMN IF EXISTS function_code,
+    DROP COLUMN IF EXISTS transaction_type;
+
+COMMIT;

internal/database/migrations/20260225073024_adjustment_stocks_add_fifo_v2_columns.up.sql

@@ -0,0 +1,23 @@
+BEGIN;
+
+ALTER TABLE adjustment_stocks
+    ADD COLUMN IF NOT EXISTS transaction_type VARCHAR(100) NOT NULL DEFAULT 'LEGACY',
+    ADD COLUMN IF NOT EXISTS function_code VARCHAR(64),
+    ADD COLUMN IF NOT EXISTS price NUMERIC(15, 3) NOT NULL DEFAULT 0,
+    ADD COLUMN IF NOT EXISTS grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+UPDATE adjustment_stocks
+SET function_code = CASE
+    WHEN COALESCE(total_qty, 0) > 0 THEN 'ADJUSTMENT_IN'
+    WHEN COALESCE(usage_qty, 0) > 0 THEN 'ADJUSTMENT_OUT'
+    ELSE 'ADJUSTMENT_IN'
+END
+WHERE function_code IS NULL OR function_code = '';
+
+CREATE INDEX IF NOT EXISTS idx_adjustment_stocks_transaction_type
+    ON adjustment_stocks(transaction_type);
+
+CREATE INDEX IF NOT EXISTS idx_adjustment_stocks_function_code
+    ON adjustment_stocks(function_code);
+
+COMMIT;

internal/database/migrations/20260227130000_add_deferred_execution_to_laying_transfers.down.sql

@@ -0,0 +1,11 @@
+DROP INDEX IF EXISTS idx_laying_transfers_executed_by;
+DROP INDEX IF EXISTS idx_laying_transfers_executed_at;
+DROP INDEX IF EXISTS idx_laying_transfers_effective_move_date;
+
+ALTER TABLE laying_transfers
+    DROP CONSTRAINT IF EXISTS fk_laying_transfers_executed_by;
+
+ALTER TABLE laying_transfers
+    DROP COLUMN IF EXISTS executed_by,
+    DROP COLUMN IF EXISTS executed_at,
+    DROP COLUMN IF EXISTS effective_move_date;

internal/database/migrations/20260227130000_add_deferred_execution_to_laying_transfers.up.sql

@@ -0,0 +1,46 @@
+ALTER TABLE laying_transfers
+    ADD COLUMN IF NOT EXISTS effective_move_date DATE,
+    ADD COLUMN IF NOT EXISTS executed_at TIMESTAMPTZ,
+    ADD COLUMN IF NOT EXISTS executed_by BIGINT;
+
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'users')
+        AND NOT EXISTS (
+            SELECT 1
+            FROM pg_constraint
+            WHERE conname = 'fk_laying_transfers_executed_by'
+        ) THEN
+        ALTER TABLE laying_transfers
+            ADD CONSTRAINT fk_laying_transfers_executed_by
+            FOREIGN KEY (executed_by)
+            REFERENCES users(id)
+            ON DELETE SET NULL
+            ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_laying_transfers_effective_move_date
+    ON laying_transfers(effective_move_date);
+
+CREATE INDEX IF NOT EXISTS idx_laying_transfers_executed_at
+    ON laying_transfers(executed_at);
+
+CREATE INDEX IF NOT EXISTS idx_laying_transfers_executed_by
+    ON laying_transfers(executed_by);
+
+-- Backfill historical approved transfers. Before deferred execution,
+-- approved transfers were executed immediately during approval.
+UPDATE laying_transfers lt
+SET
+    effective_move_date = COALESCE(lt.effective_move_date, lt.transfer_date),
+    executed_at = COALESCE(lt.executed_at, lt.updated_at),
+    executed_by = COALESCE(lt.executed_by, lt.created_by)
+WHERE (
+    SELECT a.action
+    FROM approvals a
+    WHERE a.approvable_type = 'TRANSFER_TO_LAYINGS'
+      AND a.approvable_id = lt.id
+    ORDER BY a.id DESC
+    LIMIT 1
+) = 'APPROVED';

internal/entities/adjustment_stock.go

@@ -5,10 +5,14 @@ import "time"
 type AdjustmentStock struct {
 	Id                 uint      `gorm:"primaryKey"`
 	ProductWarehouseId uint      `gorm:"column:product_warehouse_id;not null"`
+	TransactionType    string    `gorm:"column:transaction_type;type:varchar(100);not null;default:LEGACY"`
+	FunctionCode       string    `gorm:"column:function_code;type:varchar(64)"`
 	TotalQty           float64   `gorm:"column:total_qty;default:0"`
 	TotalUsed          float64   `gorm:"column:total_used;default:0"`
 	UsageQty           float64   `gorm:"column:usage_qty;default:0"`
 	PendingQty         float64   `gorm:"column:pending_qty;default:0"`
+	Price              float64   `gorm:"column:price;type:numeric(15,3);default:0"`
+	GrandTotal         float64   `gorm:"column:grand_total;type:numeric(15,3);default:0"`
 	CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime"`
 	UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime"`
 	AdjNumber          string    `gorm:"column:adj_number;uniqueIndex;not null"`

internal/entities/laying_transfer.go

@@ -12,16 +12,20 @@ type LayingTransfer struct {
 	FromProjectFlockId uint           `gorm:"not null"`
 	ToProjectFlockId   uint           `gorm:"not null"`
 	TransferDate       time.Time      `gorm:"type:date;not null"`
+	EffectiveMoveDate  *time.Time     `gorm:"type:date"`
+	ExecutedAt         *time.Time     `gorm:"type:timestamptz"`
+	ExecutedBy         *uint          `gorm:"index"`
 	Notes              string         `gorm:"type:text"`
 	CreatedBy          uint           `gorm:"not null"`
 	CreatedAt          time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt          time.Time      `gorm:"autoUpdateTime"`
 	DeletedAt          gorm.DeletedAt `gorm:"index"`
 
-	FromProjectFlock    *ProjectFlock          `gorm:"foreignKey:FromProjectFlockId;references:Id"`
-	ToProjectFlock      *ProjectFlock          `gorm:"foreignKey:ToProjectFlockId;references:Id"`
-	CreatedUser         *User                  `gorm:"foreignKey:CreatedBy;references:Id"`
-	Sources             []LayingTransferSource `gorm:"foreignKey:LayingTransferId;constraint:OnDelete:CASCADE"`
-	Targets             []LayingTransferTarget `gorm:"foreignKey:LayingTransferId;constraint:OnDelete:CASCADE"`
-	LatestApproval      *Approval              `gorm:"-" json:"-"`
+	FromProjectFlock *ProjectFlock          `gorm:"foreignKey:FromProjectFlockId;references:Id"`
+	ToProjectFlock   *ProjectFlock          `gorm:"foreignKey:ToProjectFlockId;references:Id"`
+	CreatedUser      *User                  `gorm:"foreignKey:CreatedBy;references:Id"`
+	ExecutedUser     *User                  `gorm:"foreignKey:ExecutedBy;references:Id"`
+	Sources          []LayingTransferSource `gorm:"foreignKey:LayingTransferId;constraint:OnDelete:CASCADE"`
+	Targets          []LayingTransferTarget `gorm:"foreignKey:LayingTransferId;constraint:OnDelete:CASCADE"`
+	LatestApproval   *Approval              `gorm:"-" json:"-"`
 }

internal/modules/constants/repositories/constant.repository.go

@@ -12,7 +12,7 @@ import (
 )
 
 type ConstantRepository interface {
-	GetConstants() map[string]interface{}
+	GetConstants() (map[string]interface{}, error)
 }
 
 type ConstantRepositoryImpl struct {
@@ -25,7 +25,7 @@ func NewConstantRepository(db *gorm.DB) ConstantRepository {
 	}
 }
 
-func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
+func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error) {
 	flagList := make([]string, 0)
 	for f := range utils.AllFlagTypes() {
 		flagList = append(flagList, string(f))
@@ -75,6 +75,8 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 		})
 	}
 
+	adjustmentSubtypesByType := utils.AdjustmentTransactionSubtypesByTypeForFrontend()
+
 	return map[string]interface{}{
 		"flags": flagList,
 		"warehouse_types": []string{
@@ -94,6 +96,9 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 			"BISNIS",
 			"INDIVIDUAL",
 		},
+		"adjustment": map[string]interface{}{
+			"transaction_subtypes": adjustmentSubtypesByType,
+		},
 		"approval_workflows": approvalWorkflows,
-	}
+	}, nil
 }

internal/modules/constants/services/constant.service.go

@@ -22,5 +22,5 @@ func NewConstantService(repo repository.ConstantRepository, validate *validator.
 }
 
 func (s constantService) GetAll(c *fiber.Ctx) (map[string]interface{}, error) {
-	return s.Repository.GetConstants(), nil
+	return s.Repository.GetConstants()
 }

internal/modules/inventory/adjustments/controllers/adjustment.controller.go

@@ -47,11 +47,13 @@ func (u *AdjustmentController) Adjustment(c *fiber.Ctx) error {
 
 func (u *AdjustmentController) AdjustmentHistory(c *fiber.Ctx) error {
 	query := &validation.Query{
-		Page:            c.QueryInt("page", 1),
-		Limit:           c.QueryInt("limit", 10),
-		ProductID:       uint(c.QueryInt("product_id", 0)),
-		WarehouseID:     uint(c.QueryInt("warehouse_id", 0)),
-		TransactionType: c.Query("transaction_type", ""),
+		Page:               c.QueryInt("page", 1),
+		Limit:              c.QueryInt("limit", 10),
+		ProductID:          uint(c.QueryInt("product_id", 0)),
+		WarehouseID:        uint(c.QueryInt("warehouse_id", 0)),
+		TransactionType:    c.Query("transaction_type", ""),
+		TransactionSubtype: c.Query("transaction_subtype", ""),
+		FunctionCode:       c.Query("function_code", ""),
 	}
 
 	result, totalResults, err := u.AdjustmentService.AdjustmentHistory(c, query)

internal/modules/inventory/adjustments/dto/adjustment.dto.go

@@ -17,27 +17,49 @@ type ProductRelationDTO struct {
 	ProductCategory *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
 }
 
-type WarehouseRelationDTO struct {
+type LocationRelationDTO struct {
 	Id   uint   `json:"id"`
 	Name string `json:"name"`
 }
 
+type ProjectFlockRelationDTO struct {
+	Id        uint   `json:"id"`
+	FlockName string `json:"flock_name"`
+	Period    int    `json:"period"`
+}
+
+type WarehouseRelationDTO struct {
+	Id       uint                 `json:"id"`
+	Name     string               `json:"name"`
+	Location *LocationRelationDTO `json:"location,omitempty"`
+}
+
 type ProductWarehouseDTO struct {
-	Id          uint                  `json:"id"`
-	ProductId   uint                  `json:"product_id"`
-	WarehouseId uint                  `json:"warehouse_id"`
-	Quantity    float64               `json:"quantity"`
-	Product     *ProductRelationDTO   `json:"product,omitempty"`
-	Warehouse   *WarehouseRelationDTO `json:"warehouse,omitempty"`
+	Id           uint                     `json:"id"`
+	ProductId    uint                     `json:"product_id"`
+	WarehouseId  uint                     `json:"warehouse_id"`
+	Quantity     float64                  `json:"quantity"`
+	Product      *ProductRelationDTO      `json:"product,omitempty"`
+	Warehouse    *WarehouseRelationDTO    `json:"warehouse,omitempty"`
+	ProjectFlock *ProjectFlockRelationDTO `json:"project_flock,omitempty"`
 }
 
 type AdjustmentRelationDTO struct {
-	Id                 uint                 `json:"id"`
-	Increase           float64              `json:"increase"`
-	Decrease           float64              `json:"decrease"`
-	Note               string               `json:"note,omitempty"`
-	ProductWarehouseId uint                 `json:"product_warehouse_id"`
-	ProductWarehouse   *ProductWarehouseDTO `json:"product_warehouse,omitempty"`
+	Id                 uint                     `json:"id"`
+	AdjNumber          string                   `json:"adj_number"`
+	TransactionType    string                   `json:"transaction_type"`
+	TransactionSubtype string                   `json:"transaction_subtype"`
+	FunctionCode       string                   `json:"function_code"`
+	Qty                float64                  `json:"qty"`
+	Price              float64                  `json:"price"`
+	GrandTotal         float64                  `json:"grand_total"`
+	Increase           float64                  `json:"increase"`
+	Decrease           float64                  `json:"decrease"`
+	Notes              string                   `json:"notes,omitempty"`
+	Location           *LocationRelationDTO     `json:"location,omitempty"`
+	ProjectFlock       *ProjectFlockRelationDTO `json:"project_flock,omitempty"`
+	ProductWarehouseId uint                     `json:"product_warehouse_id"`
+	ProductWarehouse   *ProductWarehouseDTO     `json:"product_warehouse,omitempty"`
 }
 
 type AdjustmentListDTO struct {
@@ -81,31 +103,80 @@ func ToWarehouseRelationDTO(e *entity.Warehouse) *WarehouseRelationDTO {
 		return nil
 	}
 	return &WarehouseRelationDTO{
+		Id:       e.Id,
+		Name:     e.Name,
+		Location: ToLocationRelationDTO(e.Location),
+	}
+}
+
+func ToLocationRelationDTO(e *entity.Location) *LocationRelationDTO {
+	if e == nil {
+		return nil
+	}
+	return &LocationRelationDTO{
 		Id:   e.Id,
 		Name: e.Name,
 	}
 }
 
+func ToProjectFlockRelationDTO(e *entity.ProjectFlockKandang) *ProjectFlockRelationDTO {
+	if e == nil || e.ProjectFlock.Id == 0 {
+		return nil
+	}
+	return &ProjectFlockRelationDTO{
+		Id:        e.ProjectFlock.Id,
+		FlockName: e.ProjectFlock.FlockName,
+		Period:    e.Period,
+	}
+}
+
 func ToProductWarehouseDTO(e *entity.ProductWarehouse) *ProductWarehouseDTO {
 	if e == nil {
 		return nil
 	}
 	return &ProductWarehouseDTO{
-		Id:          e.Id,
-		ProductId:   e.ProductId,
-		WarehouseId: e.WarehouseId,
-		Quantity:    e.Quantity,
-		Product:     ToProductRelationDTO(&e.Product),
-		Warehouse:   ToWarehouseRelationDTO(&e.Warehouse),
+		Id:           e.Id,
+		ProductId:    e.ProductId,
+		WarehouseId:  e.WarehouseId,
+		Quantity:     e.Quantity,
+		Product:      ToProductRelationDTO(&e.Product),
+		Warehouse:    ToWarehouseRelationDTO(&e.Warehouse),
+		ProjectFlock: ToProjectFlockRelationDTO(e.ProjectFlockKandang),
 	}
 }
 
 func ToAdjustmentRelationDTO(e *entity.AdjustmentStock) AdjustmentRelationDTO {
+	note := ""
+	if e.StockLog != nil {
+		note = e.StockLog.Notes
+	}
+
+	qty := e.TotalQty
+	if qty <= 0 {
+		qty = e.UsageQty + e.PendingQty
+	}
+
+	var location *LocationRelationDTO
+	var projectFlock *ProjectFlockRelationDTO
+	if e.ProductWarehouse != nil {
+		location = ToLocationRelationDTO(e.ProductWarehouse.Warehouse.Location)
+		projectFlock = ToProjectFlockRelationDTO(e.ProductWarehouse.ProjectFlockKandang)
+	}
+
 	return AdjustmentRelationDTO{
 		Id:                 e.Id,
-		Note:               "",
+		AdjNumber:          e.AdjNumber,
+		TransactionType:    e.TransactionType,
+		TransactionSubtype: e.FunctionCode,
+		FunctionCode:       e.FunctionCode,
+		Qty:                qty,
+		Price:              e.Price,
+		GrandTotal:         e.GrandTotal,
 		Increase:           e.TotalQty,
 		Decrease:           e.UsageQty,
+		Notes:              note,
+		Location:           location,
+		ProjectFlock:       projectFlock,
 		ProductWarehouseId: e.ProductWarehouseId,
 		ProductWarehouse:   ToProductWarehouseDTO(e.ProductWarehouse),
 	}

internal/modules/inventory/adjustments/module.go

@@ -34,6 +34,7 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
 
 	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	err := fifoService.RegisterStockable(fifo.StockableConfig{
 		Key:   fifo.StockableKeyAdjustmentIn,
@@ -74,6 +75,7 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 		productWarehouseRepo,
 		adjustmentStockRepo,
 		fifoService,
+		fifoStockV2Service,
 		validate,
 		projectFlockKandangRepo,
 	)

internal/modules/inventory/adjustments/repositories/adjustment_stock.repository.go

@@ -2,6 +2,7 @@ package repositories
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -14,11 +15,35 @@ import (
 type AdjustmentStockRepository interface {
 	CreateOne(ctx context.Context, data *entity.AdjustmentStock, modifier func(*gorm.DB) *gorm.DB) error
 	GetByID(ctx context.Context, id uint, modifier func(*gorm.DB) *gorm.DB) (*entity.AdjustmentStock, error)
+	FindKandangIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (uint, error)
+	FindRoutesByFunctionCode(ctx context.Context, productID uint, functionCode string) ([]AdjustmentRouteResolution, error)
+	FindOverconsumeRule(ctx context.Context, lane, flagGroupCode, functionCode string) (*bool, error)
+	FindHistory(ctx context.Context, filter AdjustmentHistoryFilter, modifier func(*gorm.DB) *gorm.DB) ([]*entity.AdjustmentStock, int64, error)
 	WithTx(tx *gorm.DB) AdjustmentStockRepository
 	DB() *gorm.DB
 	GenerateSequentialNumber(ctx context.Context, prefix string) (string, error)
 }
 
+type AdjustmentRouteResolution struct {
+	FlagGroupCode       string `gorm:"column:flag_group_code"`
+	Lane                string `gorm:"column:lane"`
+	FunctionCode        string `gorm:"column:function_code"`
+	SourceTable         string `gorm:"column:source_table"`
+	LegacyTypeKey       string `gorm:"column:legacy_type_key"`
+	AllowPendingDefault bool   `gorm:"column:allow_pending_default"`
+}
+
+type AdjustmentHistoryFilter struct {
+	ProductID       uint
+	WarehouseID     uint
+	TransactionType string
+	FunctionCode    string
+	ScopeRestrict   bool
+	ScopeIDs        []uint
+	Offset          int
+	Limit           int
+}
+
 type adjustmentStockRepositoryImpl struct {
 	db *gorm.DB
 }
@@ -48,6 +73,151 @@ func (r *adjustmentStockRepositoryImpl) GetByID(ctx context.Context, id uint, mo
 	return &record, nil
 }
 
+func (r *adjustmentStockRepositoryImpl) FindKandangIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (uint, error) {
+	type pfkRow struct {
+		KandangID uint `gorm:"column:kandang_id"`
+	}
+
+	var pfk pfkRow
+	err := r.db.WithContext(ctx).
+		Table("project_flock_kandangs pfk").
+		Select("pfk.kandang_id").
+		Where("pfk.id = ?", projectFlockKandangID).
+		Where("pfk.closed_at IS NULL").
+		Take(&pfk).Error
+	if err != nil {
+		return 0, err
+	}
+	return pfk.KandangID, nil
+}
+
+func (r *adjustmentStockRepositoryImpl) FindRoutesByFunctionCode(
+	ctx context.Context,
+	productID uint,
+	functionCode string,
+) ([]AdjustmentRouteResolution, error) {
+	var rows []AdjustmentRouteResolution
+	err := r.db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules rr").
+		Select("rr.flag_group_code, rr.lane, rr.function_code, rr.source_table, rr.legacy_type_key, rr.allow_pending_default").
+		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
+		Where("rr.is_active = TRUE").
+		Where("rr.function_code = ?", functionCode).
+		Where(`
+			EXISTS (
+				SELECT 1
+				FROM flags f
+				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
+				WHERE f.flagable_type = ?
+				  AND f.flagable_id = ?
+				  AND fm.flag_group_code = rr.flag_group_code
+			)
+		`, entity.FlagableTypeProduct, productID).
+		Order("CASE WHEN rr.source_table = 'adjustment_stocks' THEN 0 ELSE 1 END ASC").
+		Order("rr.id ASC").
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func (r *adjustmentStockRepositoryImpl) FindOverconsumeRule(
+	ctx context.Context,
+	lane string,
+	flagGroupCode string,
+	functionCode string,
+) (*bool, error) {
+	type selectedRow struct {
+		AllowOverconsume bool `gorm:"column:allow_overconsume"`
+	}
+
+	var selected selectedRow
+	err := r.db.WithContext(ctx).
+		Table("fifo_stock_v2_overconsume_rules").
+		Select("allow_overconsume").
+		Where("is_active = TRUE").
+		Where("lane = ?", lane).
+		Where("(flag_group_code IS NULL OR flag_group_code = ?)", flagGroupCode).
+		Where("(function_code IS NULL OR function_code = ?)", functionCode).
+		Order("CASE WHEN flag_group_code IS NULL THEN 1 ELSE 0 END ASC").
+		Order("CASE WHEN function_code IS NULL THEN 1 ELSE 0 END ASC").
+		Order("priority ASC, id ASC").
+		Limit(1).
+		Take(&selected).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &selected.AllowOverconsume, nil
+}
+
+func (r *adjustmentStockRepositoryImpl) FindHistory(
+	ctx context.Context,
+	filter AdjustmentHistoryFilter,
+	modifier func(*gorm.DB) *gorm.DB,
+) ([]*entity.AdjustmentStock, int64, error) {
+	q := r.db.WithContext(ctx).Model(&entity.AdjustmentStock{}).
+		Preload("ProductWarehouse").
+		Preload("ProductWarehouse.Product").
+		Preload("ProductWarehouse.Warehouse").
+		Preload("ProductWarehouse.Warehouse.Location").
+		Preload("ProductWarehouse.ProjectFlockKandang").
+		Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
+		Preload("StockLog.CreatedUser")
+
+	if modifier != nil {
+		q = modifier(q)
+	}
+
+	if filter.ScopeRestrict {
+		q = q.Joins("JOIN product_warehouses pw_scope ON pw_scope.id = adjustment_stocks.product_warehouse_id").
+			Joins("JOIN warehouses w_scope ON w_scope.id = pw_scope.warehouse_id")
+		if len(filter.ScopeIDs) == 0 {
+			q = q.Where("1 = 0")
+		} else {
+			q = q.Where("w_scope.location_id IN ?", filter.ScopeIDs)
+		}
+	}
+
+	if filter.ProductID > 0 || filter.WarehouseID > 0 {
+		q = q.Joins("JOIN product_warehouses pw_filter ON pw_filter.id = adjustment_stocks.product_warehouse_id")
+		if filter.ProductID > 0 {
+			q = q.Where("pw_filter.product_id = ?", filter.ProductID)
+		}
+		if filter.WarehouseID > 0 {
+			q = q.Where("pw_filter.warehouse_id = ?", filter.WarehouseID)
+		}
+	}
+
+	if strings.TrimSpace(filter.TransactionType) != "" {
+		q = q.Where("UPPER(adjustment_stocks.transaction_type) = ?", strings.ToUpper(strings.TrimSpace(filter.TransactionType)))
+	}
+
+	if strings.TrimSpace(filter.FunctionCode) != "" {
+		q = q.Where("adjustment_stocks.function_code = ?", strings.ToUpper(strings.TrimSpace(filter.FunctionCode)))
+	}
+
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	var rows []entity.AdjustmentStock
+	if err := q.Offset(filter.Offset).Limit(filter.Limit).Order("created_at DESC").Find(&rows).Error; err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*entity.AdjustmentStock, len(rows))
+	for i := range rows {
+		result[i] = &rows[i]
+	}
+	return result, total, nil
+}
+
 func (r *adjustmentStockRepositoryImpl) WithTx(tx *gorm.DB) AdjustmentStockRepository {
 	return &adjustmentStockRepositoryImpl{db: tx}
 }

internal/modules/inventory/adjustments/services/adjustment.service.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"strings"
 
 	"github.com/go-playground/validator/v10"
@@ -40,8 +41,14 @@ type adjustmentService struct {
 	ProjectFlockKandangRepo   projectFlockKandangRepo.ProjectFlockKandangRepository
 	AdjustmentStockRepository adjustmentStockRepo.AdjustmentStockRepository
 	FifoSvc                   common.FifoService
+	FifoStockV2Svc            common.FifoStockV2Service
 }
 
+const (
+	adjustmentLaneStockable = "STOCKABLE"
+	adjustmentLaneUsable    = "USABLE"
+)
+
 func NewAdjustmentService(
 	productRepo productRepo.ProductRepository,
 	stockLogsRepo stockLogsRepo.StockLogRepository,
@@ -49,6 +56,7 @@ func NewAdjustmentService(
 	productWarehouseRepo ProductWarehouse.ProductWarehouseRepository,
 	adjustmentStockRepo adjustmentStockRepo.AdjustmentStockRepository,
 	fifoSvc common.FifoService,
+	fifoStockV2Svc common.FifoStockV2Service,
 	validate *validator.Validate,
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
 ) AdjustmentService {
@@ -62,6 +70,7 @@ func NewAdjustmentService(
 		ProjectFlockKandangRepo:   projectFlockKandangRepo,
 		AdjustmentStockRepository: adjustmentStockRepo,
 		FifoSvc:                   fifoSvc,
+		FifoStockV2Svc:            fifoStockV2Svc,
 	}
 }
 
@@ -70,6 +79,9 @@ func (s *adjustmentService) withRelations(db *gorm.DB) *gorm.DB {
 		Preload("ProductWarehouse").
 		Preload("ProductWarehouse.Product").
 		Preload("ProductWarehouse.Warehouse").
+		Preload("ProductWarehouse.Warehouse.Location").
+		Preload("ProductWarehouse.ProjectFlockKandang").
+		Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
 		Preload("StockLog.CreatedUser")
 }
 
@@ -94,47 +106,93 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err
 	}
+
+	productID := req.ProductID
+	if productID == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Product is required")
+	}
+
+	qty := req.Qty
+	if qty <= 0 {
+		qty = req.Quantity
+	}
+	if qty <= 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
+	}
+
+	functionCode := strings.ToUpper(strings.TrimSpace(req.TransactionSubtype))
+	if functionCode == "" {
+		functionCode = strings.ToUpper(strings.TrimSpace(req.TransactionSubType))
+	}
+	if functionCode == "" {
+		functionCode = strings.ToUpper(strings.TrimSpace(req.FunctionCode))
+	}
+	if functionCode == "" {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype is required")
+	}
+	if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) {
+		functionCode = string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut)
+	}
+
+	warehouseID, err := s.resolveWarehouseID(c.Context(), req)
+	if err != nil {
+		return nil, err
+	}
+
+	note := strings.TrimSpace(req.Notes)
+	if note == "" {
+		note = strings.TrimSpace(req.Note)
+	}
+	grandTotal := math.Round((qty*req.Price)*1000) / 1000
+
 	ctx := c.Context()
 	actorID, err := m.ActorIDFromContext(c)
 	if err != nil {
 		return nil, err
 	}
-	if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), uint(req.WarehouseID)); err != nil {
+	if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), warehouseID); err != nil {
 		return nil, err
 	}
-	if err := common.EnsureRelations(c.Context(),
-		common.RelationCheck{Name: "Product", ID: &req.ProductID, Exists: s.ProductRepo.IdExists},
-		common.RelationCheck{Name: "Warehouse", ID: &req.WarehouseID, Exists: s.WarehouseRepo.IdExists},
+	if err := common.EnsureRelations(ctx,
+		common.RelationCheck{Name: "Product", ID: &productID, Exists: s.ProductRepo.IdExists},
+		common.RelationCheck{Name: "Warehouse", ID: &warehouseID, Exists: s.WarehouseRepo.IdExists},
 	); err != nil {
 		return nil, err
 	}
 
-	if req.Quantity <= 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
+	routeMeta, err := s.resolveRouteByFunctionCode(ctx, productID, functionCode)
+	if err != nil {
+		return nil, err
 	}
 
-	transactionType := strings.ToUpper(req.TransactionType)
-	if transactionType != string(utils.StockLogTransactionTypeIncrease) && transactionType != string(utils.StockLogTransactionTypeDecrease) {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid transaction type")
+	transactionType := utils.ResolveAdjustmentTransactionType(routeMeta.FunctionCode)
+
+	allowPending := false
+	if routeMeta.Lane == adjustmentLaneUsable {
+		allowPending, err = s.resolveOverconsumePolicy(ctx, routeMeta)
+		if err != nil {
+			s.Log.Errorf("Failed to resolve overconsume rule: %+v", err)
+			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve FIFO policy")
+		}
 	}
 
 	var createdAdjustmentStockId uint
 
 	var projectFlockKandangID *uint
-	pfkID, err := s.getActiveProjectFlockKandangID(ctx, uint(req.WarehouseID))
+	pfkID, err := s.getActiveProjectFlockKandangID(ctx, warehouseID)
 	if err == nil && pfkID > 0 {
 		projectFlockKandangID = &pfkID
 	}
 
-	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
+	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, productID, warehouseID, projectFlockKandangID)
 	if err != nil {
 		if !errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to get product warehouse")
 		}
 
 		newPW := &entity.ProductWarehouse{
-			ProductId:             uint(req.ProductID),
-			WarehouseId:           uint(req.WarehouseID),
+			ProductId:             productID,
+			WarehouseId:           warehouseID,
 			Quantity:              0,
 			ProjectFlockKandangId: projectFlockKandangID,
 		}
@@ -153,96 +211,115 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 		return nil, err
 	}
 	err = s.StockLogsRepository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		productWarehouseRepoTX := ProductWarehouse.NewProductWarehouseRepository(tx)
+		stockLogRepoTX := stockLogsRepo.NewStockLogRepository(tx)
+		adjustmentStockRepoTX := s.AdjustmentStockRepository.WithTx(tx)
 
-		productWarehouse, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
+		productWarehouse, err := productWarehouseRepoTX.FindByProductWarehouseAndPfk(ctx, productID, warehouseID, projectFlockKandangID)
 		if err != nil {
 			s.Log.Errorf("Failed to get product warehouse: %+v", err)
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get product warehouse")
 		}
 
-		newLog := &entity.StockLog{
-			LoggableType:       string(utils.StockLogTypeAdjustment),
-			LoggableId:         0,
-			Notes:              req.Note,
-			ProductWarehouseId: productWarehouse.Id,
-			CreatedBy:          actorID,
-		}
-
-		stockLogs, err := s.StockLogsRepository.GetByProductWarehouse(ctx, productWarehouse.Id, 1)
-		if err != nil {
-			s.Log.Errorf("Failed to get stock logs: %+v", err)
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-		}
-
-		if len(stockLogs) > 0 {
-			latestStockLog := stockLogs[0]
-			newLog.Stock = latestStockLog.Stock
-		} else {
-			newLog.Stock = 0
-		}
-
-		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
-			newLog.Increase = req.Quantity
-			newLog.Stock += newLog.Increase
-		} else {
-			if productWarehouse.Quantity < req.Quantity {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk pengurangan. Stok saat ini: %.2f, Jumlah yang akan dikurangi: %.2f", productWarehouse.Quantity, req.Quantity))
-			}
-			newLog.Decrease = req.Quantity
-			newLog.Stock -= newLog.Decrease
-		}
-
-		if err := s.StockLogsRepository.WithTx(tx).CreateOne(ctx, newLog, nil); err != nil {
-
-			return err
-		}
-
 		adjustmentStock := &entity.AdjustmentStock{
 			ProductWarehouseId: productWarehouse.Id,
+			TransactionType:    transactionType,
+			FunctionCode:       routeMeta.FunctionCode,
+			Price:              req.Price,
+			GrandTotal:         grandTotal,
 		}
-		code, err := s.AdjustmentStockRepository.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
+		code, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
 		if err != nil {
 			return err
 		}
 		adjustmentStock.AdjNumber = code
-		if err := s.AdjustmentStockRepository.WithTx(tx).CreateOne(ctx, adjustmentStock, nil); err != nil {
-
+		if err := adjustmentStockRepoTX.CreateOne(ctx, adjustmentStock, nil); err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create adjustment stock record")
 		}
 
-		newLog.LoggableType = string(utils.StockLogTypeAdjustment)
-		newLog.LoggableId = adjustmentStock.Id
-		if err := s.StockLogsRepository.WithTx(tx).UpdateOne(ctx, newLog.Id, newLog, nil); err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to link stock log")
-		}
+		var increaseQty float64
+		var decreaseQty float64
 
-		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
-
-			note := fmt.Sprintf("Stock Adjustment IN #%d", newLog.Id)
-			_, err := s.FifoSvc.Replenish(ctx, common.StockReplenishRequest{
+		switch routeMeta.Lane {
+		case adjustmentLaneStockable:
+			fifoNote := fmt.Sprintf("Stock Adjustment %s #%s", routeMeta.FunctionCode, adjustmentStock.AdjNumber)
+			result, err := s.FifoSvc.Replenish(ctx, common.StockReplenishRequest{
 				StockableKey:       fifo.StockableKeyAdjustmentIn,
 				StockableID:        adjustmentStock.Id,
-				ProductWarehouseID: uint(productWarehouse.Id),
-				Quantity:           req.Quantity,
-				Note:               &note,
+				ProductWarehouseID: productWarehouse.Id,
+				Quantity:           qty,
+				Note:               &fifoNote,
 				Tx:                 tx,
 			})
 			if err != nil {
 				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock via FIFO: %v", err))
 			}
+			increaseQty = result.AddedQuantity
+		case adjustmentLaneUsable:
+			if s.FifoStockV2Svc != nil {
+				usableLegacyTypeKey := fifo.UsableKeyAdjustmentOut.String()
+				if routeMeta.SourceTable == "adjustment_stocks" && strings.TrimSpace(routeMeta.LegacyTypeKey) != "" {
+					usableLegacyTypeKey = strings.TrimSpace(routeMeta.LegacyTypeKey)
+				}
 
-		} else {
-			_, err := s.FifoSvc.Consume(ctx, common.StockConsumeRequest{
-				UsableKey:          fifo.UsableKeyAdjustmentOut,
-				UsableID:           adjustmentStock.Id,
-				ProductWarehouseID: uint(productWarehouse.Id),
-				Quantity:           req.Quantity,
-				AllowPending:       false,
-				Tx:                 tx,
-			})
-			if err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO: %v", err))
+				reflowResult, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
+					FlagGroupCode:      routeMeta.FlagGroupCode,
+					ProductWarehouseID: productWarehouse.Id,
+					Usable: common.FifoStockV2Ref{
+						ID:            adjustmentStock.Id,
+						LegacyTypeKey: usableLegacyTypeKey,
+						FunctionCode:  routeMeta.FunctionCode,
+					},
+					DesiredQty:       qty,
+					AllowOverConsume: &allowPending,
+					Tx:               tx,
+				})
+				if err != nil {
+					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO v2: %v", err))
+				}
+				decreaseQty = reflowResult.Allocate.AllocatedQty
+			} else {
+				result, err := s.FifoSvc.Consume(ctx, common.StockConsumeRequest{
+					UsableKey:          fifo.UsableKeyAdjustmentOut,
+					UsableID:           adjustmentStock.Id,
+					ProductWarehouseID: productWarehouse.Id,
+					Quantity:           qty,
+					AllowPending:       allowPending,
+					Tx:                 tx,
+				})
+				if err != nil {
+					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO: %v", err))
+				}
+				decreaseQty = result.UsageQuantity
 			}
+		default:
+			return fiber.NewError(fiber.StatusBadRequest, "Unsupported transaction subtype lane")
+		}
+
+		stockLogs, err := stockLogRepoTX.GetByProductWarehouse(ctx, productWarehouse.Id, 1)
+		if err != nil {
+			s.Log.Errorf("Failed to get stock logs: %+v", err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+		}
+
+		currentStock := 0.0
+		if len(stockLogs) > 0 {
+			currentStock = stockLogs[0].Stock
+		}
+
+		newLog := &entity.StockLog{
+			LoggableType:       string(utils.StockLogTypeAdjustment),
+			LoggableId:         adjustmentStock.Id,
+			Notes:              note,
+			ProductWarehouseId: productWarehouse.Id,
+			CreatedBy:          actorID,
+			Increase:           increaseQty,
+			Decrease:           decreaseQty,
+			Stock:              currentStock + increaseQty - decreaseQty,
+		}
+
+		if err := stockLogRepoTX.CreateOne(ctx, newLog, nil); err != nil {
+			return err
 		}
 
 		createdAdjustmentStockId = adjustmentStock.Id
@@ -261,6 +338,91 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 	return s.GetOne(c, createdAdjustmentStockId)
 }
 
+func (s *adjustmentService) resolveWarehouseID(ctx context.Context, req *validation.Create) (uint, error) {
+	if req == nil {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "Invalid request")
+	}
+
+	if req.WarehouseID > 0 {
+		return req.WarehouseID, nil
+	}
+
+	if req.ProjectFlockKandangID != nil && *req.ProjectFlockKandangID > 0 {
+		kandangID, err := s.AdjustmentStockRepository.FindKandangIDByProjectFlockKandangID(ctx, *req.ProjectFlockKandangID)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return 0, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id tidak valid atau tidak aktif")
+			}
+			return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate project_flock_kandang_id context")
+		}
+
+		warehouse, err := s.WarehouseRepo.GetLatestByKandangID(ctx, kandangID)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return 0, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Warehouse untuk project_flock_kandang_id %d tidak ditemukan", *req.ProjectFlockKandangID))
+			}
+			return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve warehouse by project_flock_kandang_id")
+		}
+		return warehouse.Id, nil
+	}
+
+	return 0, fiber.NewError(fiber.StatusBadRequest, "warehouse_id atau project_flock_kandang_id wajib diisi")
+}
+
+func (s *adjustmentService) resolveRouteByFunctionCode(
+	ctx context.Context,
+	productID uint,
+	functionCode string,
+) (*adjustmentStockRepo.AdjustmentRouteResolution, error) {
+	rows, err := s.AdjustmentStockRepository.FindRoutesByFunctionCode(ctx, productID, functionCode)
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype tidak kompatibel dengan konfigurasi FIFO v2 produk")
+	}
+
+	selected := rows[0]
+	for _, row := range rows {
+		if row.Lane != selected.Lane {
+			return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype ambigu: lane FIFO v2 lebih dari satu")
+		}
+	}
+
+	selected.FunctionCode = functionCode
+	switch selected.Lane {
+	case adjustmentLaneStockable, adjustmentLaneUsable:
+		return &selected, nil
+	default:
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype memiliki lane FIFO v2 yang tidak didukung")
+	}
+}
+
+func (s *adjustmentService) resolveOverconsumePolicy(
+	ctx context.Context,
+	route *adjustmentStockRepo.AdjustmentRouteResolution,
+) (bool, error) {
+	if route == nil {
+		return false, fmt.Errorf("route is required")
+	}
+
+	defaultValue := route.AllowPendingDefault
+	selected, err := s.AdjustmentStockRepository.FindOverconsumeRule(
+		ctx,
+		route.Lane,
+		route.FlagGroupCode,
+		route.FunctionCode,
+	)
+	if err != nil {
+		return false, err
+	}
+	if selected == nil {
+		return defaultValue, nil
+	}
+
+	return *selected, nil
+}
+
 func (s *adjustmentService) getActiveProjectFlockKandangID(ctx context.Context, warehouseID uint) (uint, error) {
 	warehouse, err := s.WarehouseRepo.GetByID(ctx, warehouseID, nil)
 	if err != nil {
@@ -291,6 +453,12 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 	if err := s.Validate.Struct(query); err != nil {
 		return nil, 0, err
 	}
+	if query.Page <= 0 {
+		query.Page = 1
+	}
+	if query.Limit <= 0 {
+		query.Limit = 10
+	}
 	offset := (query.Page - 1) * query.Limit
 
 	var isProductsExist bool
@@ -313,15 +481,6 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 		return nil, 0, fiber.NewError(fiber.StatusNotFound, "Product not found")
 	}
 
-	var adjustmentStocks []entity.AdjustmentStock
-	var total int64
-
-	q := s.AdjustmentStockRepository.DB().WithContext(c.Context()).Model(&entity.AdjustmentStock{}).
-		Preload("ProductWarehouse").
-		Preload("ProductWarehouse.Product").
-		Preload("ProductWarehouse.Warehouse").
-		Preload("StockLog.CreatedUser")
-
 	scope, scopeErr := m.ResolveLocationScope(c, s.AdjustmentStockRepository.DB())
 	if scopeErr != nil {
 		return nil, 0, scopeErr
@@ -330,42 +489,32 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 		if len(scope.IDs) == 0 {
 			return []*entity.AdjustmentStock{}, 0, nil
 		}
-		q = q.Joins("JOIN product_warehouses pw_scope ON pw_scope.id = adjustment_stocks.product_warehouse_id").
-			Joins("JOIN warehouses w_scope ON w_scope.id = pw_scope.warehouse_id")
-		q = m.ApplyScopeFilter(q, scope, "w_scope.location_id")
 	}
 
-	if query.ProductID > 0 {
-		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-			Where("product_warehouses.product_id = ?", query.ProductID)
+	functionCode := strings.ToUpper(strings.TrimSpace(query.TransactionSubtype))
+	if functionCode == "" {
+		functionCode = strings.ToUpper(strings.TrimSpace(query.FunctionCode))
 	}
+	transactionType := strings.ToUpper(strings.TrimSpace(query.TransactionType))
 
-	if query.WarehouseID > 0 {
-		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-			Where("product_warehouses.warehouse_id = ?", query.WarehouseID)
-	}
-
-	if query.TransactionType != "" {
-		q = q.Joins("JOIN stock_logs ON stock_logs.loggable_type = ? AND stock_logs.loggable_id = adjustment_stocks.id", "ADJUSTMENT").
-			Where("stock_logs.transaction_type = ?", strings.ToUpper(query.TransactionType))
-	}
-
-	if err = q.Count(&total).Error; err != nil {
-		s.Log.Errorf("Failed to get adjustments: %+v", err)
-		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to get adjustment history")
-	}
-
-	err = q.Offset(offset).Limit(query.Limit).Order("created_at DESC").Find(&adjustmentStocks).Error
-
+	adjustmentStocks, total, err := s.AdjustmentStockRepository.FindHistory(
+		c.Context(),
+		adjustmentStockRepo.AdjustmentHistoryFilter{
+			ProductID:       query.ProductID,
+			WarehouseID:     query.WarehouseID,
+			TransactionType: transactionType,
+			FunctionCode:    functionCode,
+			ScopeRestrict:   scope.Restrict,
+			ScopeIDs:        scope.IDs,
+			Offset:          offset,
+			Limit:           query.Limit,
+		},
+		nil,
+	)
 	if err != nil {
 		s.Log.Errorf("Failed to get adjustments: %+v", err)
 		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to get adjustment history")
 	}
 
-	result := make([]*entity.AdjustmentStock, len(adjustmentStocks))
-	for i := range adjustmentStocks {
-		result[i] = &adjustmentStocks[i]
-	}
-
-	return result, total, nil
+	return adjustmentStocks, total, nil
 }

internal/modules/inventory/adjustments/validations/adjustment.validation.go

@@ -1,17 +1,25 @@
 package validation
 
 type Create struct {
-	ProductID       uint    `json:"product_id" validate:"required"`
-	WarehouseID     uint    `json:"warehouse_id" validate:"required"`
-	TransactionType string  `json:"transaction_type" validate:"required,oneof=increase decrease"`
-	Quantity        float64 `json:"quantity" validate:"required,gt=0"`
-	Note            string  `json:"note" validate:"omitempty,max=255"`
+	ProjectFlockKandangID *uint   `json:"project_flock_kandang_id" validate:"omitempty,min=1"`
+	WarehouseID           uint    `json:"warehouse_id" validate:"omitempty,min=1"`
+	ProductID             uint    `json:"product_id" validate:"omitempty,min=1"`
+	TransactionSubtype    string  `json:"transaction_subtype" validate:"required_without=TransactionSubType,max=64"`
+	TransactionSubType    string  `json:"transaction_sub_type" validate:"required_without=TransactionSubtype,max=64"`
+	FunctionCode          string  `json:"function_code" validate:"omitempty,max=64"`
+	Qty                   float64 `json:"qty" validate:"omitempty,gt=0"`
+	Quantity              float64 `json:"quantity" validate:"omitempty,gt=0"`
+	Price                 float64 `json:"price" validate:"required,gte=0"`
+	Notes                 string  `json:"notes" validate:"omitempty,max=255"`
+	Note                  string  `json:"note" validate:"omitempty,max=255"`
 }
 
 type Query struct {
-	Page            int    `query:"page" validate:"omitempty,min=1"`
-	Limit           int    `query:"limit" validate:"omitempty,min=1,max=100"`
-	ProductID       uint   `query:"product_id" validate:"omitempty,min=0"`
-	WarehouseID     uint   `query:"warehouse_id" validate:"omitempty,min=0"`
-	TransactionType string `query:"transaction_type" validate:"omitempty,oneof=increase decrease"`
+	Page               int    `query:"page" validate:"omitempty,min=1"`
+	Limit              int    `query:"limit" validate:"omitempty,min=1,max=100"`
+	ProductID          uint   `query:"product_id" validate:"omitempty,min=0"`
+	WarehouseID        uint   `query:"warehouse_id" validate:"omitempty,min=0"`
+	TransactionType    string `query:"transaction_type" validate:"omitempty,max=100"`
+	TransactionSubtype string `query:"transaction_subtype" validate:"omitempty,max=64"`
+	FunctionCode       string `query:"function_code" validate:"omitempty,max=64"`
 }

internal/modules/inventory/transfers/module.go

@@ -52,7 +52,6 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		panic(err)
 	}
 
-
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
 	if err := approvalSvc.RegisterWorkflowSteps(utils.ApprovalWorkflowExpense, utils.ExpenseApprovalSteps); err != nil {
@@ -71,6 +70,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	)
 
 	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 	expenseBridge := sTransfer.NewTransferExpenseBridge(
 		db,
 		stockTransferRepo,
@@ -111,7 +111,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		panic(err)
 	}
 
-	transferService := sTransfer.NewTransferService(validate, stockTransferRepo, stockTransferDetailRepo, stockTransferDeliveryRepo, StockTransferDeliveryItemRepo, stockLogsRepo, productWarehouseRepo, supplierRepo, warehouseRepo, projectFlockKandangRepo, documentSvc, fifoService, expenseBridge)
+	transferService := sTransfer.NewTransferService(validate, stockTransferRepo, stockTransferDetailRepo, stockTransferDeliveryRepo, StockTransferDeliveryItemRepo, stockLogsRepo, productWarehouseRepo, supplierRepo, warehouseRepo, projectFlockKandangRepo, documentSvc, fifoService, fifoStockV2Service, expenseBridge)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	TransferRoutes(router, userService, transferService)

internal/modules/inventory/transfers/services/transfer.service.go

@@ -46,10 +46,11 @@ type transferService struct {
 	ProjectFlockKandangRepo       projectFlockKandangRepo.ProjectFlockKandangRepository
 	DocumentSvc                   commonSvc.DocumentService
 	FifoSvc                       commonSvc.FifoService
+	FifoStockV2Svc                commonSvc.FifoStockV2Service
 	ExpenseBridge                 TransferExpenseBridge
 }
 
-func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTransfer.StockTransferRepository, stockTransferDetailRepo rStockTransfer.StockTransferDetailRepository, stockTransferDeliveryRepo rStockTransfer.StockTransferDeliveryRepository, stockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository, stockLogsRepo rStockLogs.StockLogRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, supplierRepo rSupplier.SupplierRepository, warehouseRepo warehouseRepo.WarehouseRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoSvc commonSvc.FifoService, expenseBridge TransferExpenseBridge) TransferService {
+func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTransfer.StockTransferRepository, stockTransferDetailRepo rStockTransfer.StockTransferDetailRepository, stockTransferDeliveryRepo rStockTransfer.StockTransferDeliveryRepository, stockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository, stockLogsRepo rStockLogs.StockLogRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, supplierRepo rSupplier.SupplierRepository, warehouseRepo warehouseRepo.WarehouseRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoSvc commonSvc.FifoService, fifoStockV2Svc commonSvc.FifoStockV2Service, expenseBridge TransferExpenseBridge) TransferService {
 	return &transferService{
 		Log:                           utils.Log,
 		Validate:                      validate,
@@ -64,6 +65,7 @@ func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTr
 		ProjectFlockKandangRepo:       projectFlockKandangRepo,
 		DocumentSvc:                   documentSvc,
 		FifoSvc:                       fifoSvc,
+		FifoStockV2Svc:                fifoStockV2Svc,
 		ExpenseBridge:                 expenseBridge,
 	}
 }
@@ -442,26 +444,73 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			}
 		}
 
+		pakanProducts := map[uint]bool{}
+		if s.FifoStockV2Svc != nil && len(req.Products) > 0 {
+			pakanProducts, err = s.resolvePakanProducts(c.Context(), tx, req.Products)
+			if err != nil {
+				return err
+			}
+		}
+
 		for _, product := range req.Products {
 			detail := detailMap[uint64(product.ProductID)]
 
-			consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-				UsableKey:          fifo.UsableKeyStockTransferOut,
-				UsableID:           uint(detail.Id),
-				ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
-				Quantity:           product.ProductQty,
-				AllowPending:       false,
-				Tx:                 tx,
-			})
-			if err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
+			outUsageQty := 0.0
+			outPendingQty := 0.0
+			useFifoV2 := s.FifoStockV2Svc != nil && pakanProducts[uint(product.ProductID)]
+			if useFifoV2 {
+				s.Log.Infof(
+					"[fifo-v2][transfer] use reflow movement=%s detail_id=%d product_id=%d source_pw=%d qty=%.3f",
+					entityTransfer.MovementNumber,
+					detail.Id,
+					product.ProductID,
+					*detail.SourceProductWarehouseID,
+					product.ProductQty,
+				)
+				reflowResult, err := s.FifoStockV2Svc.Reflow(c.Context(), commonSvc.FifoStockV2ReflowRequest{
+					FlagGroupCode:      "PAKAN",
+					ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
+					Usable: commonSvc.FifoStockV2Ref{
+						ID:            uint(detail.Id),
+						LegacyTypeKey: fifo.UsableKeyStockTransferOut.String(),
+						FunctionCode:  "STOCK_TRANSFER_OUT",
+					},
+					DesiredQty: product.ProductQty,
+					Tx:         tx,
+				})
+				if err != nil {
+					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
+				}
+				outUsageQty = reflowResult.Allocate.AllocatedQty
+				outPendingQty = reflowResult.Allocate.PendingQty
+				s.Log.Infof(
+					"[fifo-v2][transfer] reflow result movement=%s detail_id=%d usage=%.3f pending=%.3f",
+					entityTransfer.MovementNumber,
+					detail.Id,
+					outUsageQty,
+					outPendingQty,
+				)
+			} else {
+				consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
+					UsableKey:          fifo.UsableKeyStockTransferOut,
+					UsableID:           uint(detail.Id),
+					ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
+					Quantity:           product.ProductQty,
+					AllowPending:       false,
+					Tx:                 tx,
+				})
+				if err != nil {
+					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
+				}
+				outUsageQty = consumeResult.UsageQuantity
+				outPendingQty = consumeResult.PendingQuantity
 			}
 
 			if err := tx.Model(&entity.StockTransferDetail{}).
 				Where("id = ?", detail.Id).
 				Updates(map[string]interface{}{
-					"usage_qty":   consumeResult.UsageQuantity,
-					"pending_qty": consumeResult.PendingQuantity,
+					"usage_qty":   outUsageQty,
+					"pending_qty": outPendingQty,
 				}).Error; err != nil {
 				s.Log.Errorf("Failed to update tracking usage for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
@@ -493,6 +542,17 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			}
 
 			note := fmt.Sprintf("Transfer #%s", entityTransfer.MovementNumber)
+			inAddedQty := 0.0
+			if useFifoV2 {
+				s.Log.Infof(
+					"[fifo-v2][transfer] stock-in uses replenish path movement=%s detail_id=%d product_id=%d dest_pw=%d qty=%.3f",
+					entityTransfer.MovementNumber,
+					detail.Id,
+					product.ProductID,
+					*detail.DestProductWarehouseID,
+					product.ProductQty,
+				)
+			}
 			replenishResult, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
 				StockableKey:       fifo.StockableKeyStockTransferIn,
 				StockableID:        uint(detail.Id),
@@ -505,11 +565,12 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 				s.Log.Errorf("Failed to replenish stock for product_id=%d, pw_id=%d, qty=%.2f: %+v", product.ProductID, *detail.DestProductWarehouseID, product.ProductQty, err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal menambah stok gudang tujuan")
 			}
+			inAddedQty = replenishResult.AddedQuantity
 
 			if err := tx.Model(&entity.StockTransferDetail{}).
 				Where("id = ?", detail.Id).
 				Updates(map[string]interface{}{
-					"total_qty": replenishResult.AddedQuantity,
+					"total_qty": inAddedQty,
 				}).Error; err != nil {
 				s.Log.Errorf("Failed to update tracking total for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
@@ -596,6 +657,53 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 	return result, nil
 }
 
+func (s *transferService) resolvePakanProducts(
+	ctx context.Context,
+	tx *gorm.DB,
+	products []validation.TransferProduct,
+) (map[uint]bool, error) {
+	out := make(map[uint]bool, len(products))
+	if len(products) == 0 {
+		return out, nil
+	}
+
+	productIDs := make([]uint, 0, len(products))
+	seen := make(map[uint]struct{}, len(products))
+	for _, product := range products {
+		if product.ProductID == 0 {
+			continue
+		}
+		if _, ok := seen[product.ProductID]; ok {
+			continue
+		}
+		seen[product.ProductID] = struct{}{}
+		productIDs = append(productIDs, product.ProductID)
+	}
+	if len(productIDs) == 0 {
+		return out, nil
+	}
+
+	type row struct {
+		ProductID uint `gorm:"column:product_id"`
+	}
+	var rows []row
+	err := tx.WithContext(ctx).
+		Table("flags f").
+		Select("DISTINCT f.flagable_id AS product_id").
+		Where("f.flagable_type = ?", entity.FlagableTypeProduct).
+		Where("f.name IN ?", []string{"PAKAN", "PRE-STARTER", "STARTER", "FINISHER"}).
+		Where("f.flagable_id IN ?", productIDs).
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		out[row.ProductID] = true
+	}
+	return out, nil
+}
+
 func (s *transferService) notifyExpenseItemsDelivered(c *fiber.Ctx, transferID uint64, payloads []TransferExpenseReceivingPayload) error {
 	if s.ExpenseBridge == nil || transferID == 0 || len(payloads) == 0 {
 		return nil

internal/modules/production/recordings/module.go

@@ -24,6 +24,7 @@ import (
 	sProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
 	rRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	sRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
+	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/repositories"
 	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
@@ -48,6 +49,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	productRepo := rProduct.NewProductRepository(db)
 	chickinRepo := rChickin.NewChickinRepository(db)
 	chickinDetailRepo := rChickin.NewChickinDetailRepository(db)
+	transferLayingRepo := rTransferLaying.NewTransferLayingRepository(db)
 	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
 	stockLogRepo := rStockLogs.NewStockLogRepository(db)
 	productionStandardRepo := rProductionStandard.NewProductionStandardRepository(db)
@@ -184,6 +186,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		productionStandardService,
 		projectFlockService,
 		chickinService,
+		transferLayingRepo,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

internal/modules/production/recordings/services/recording.service.go

@@ -19,6 +19,7 @@ import (
 	sProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
 	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
+	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/repositories"
 	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
@@ -52,6 +53,7 @@ type recordingService struct {
 	ProductionStandardSvc      sProductionStandard.ProductionStandardService
 	ProjectFlockSvc            sProjectFlock.ProjectflockService
 	ChickinSvc                 sChickin.ChickinService
+	TransferLayingRepo         rTransferLaying.TransferLayingRepository
 	FifoSvc                    commonSvc.FifoService
 	StockLogRepo               rStockLogs.StockLogRepository
 }
@@ -68,6 +70,7 @@ func NewRecordingService(
 	productionStandardSvc sProductionStandard.ProductionStandardService,
 	projectFlockSvc sProjectFlock.ProjectflockService,
 	chickinSvc sChickin.ChickinService,
+	transferLayingRepo rTransferLaying.TransferLayingRepository,
 	validate *validator.Validate,
 ) RecordingService {
 	return &recordingService{
@@ -82,6 +85,7 @@ func NewRecordingService(
 		ProductionStandardSvc:      productionStandardSvc,
 		ProjectFlockSvc:            projectFlockSvc,
 		ChickinSvc:                 chickinSvc,
+		TransferLayingRepo:         transferLayingRepo,
 		FifoSvc:                    fifoSvc,
 		StockLogRepo:               stockLogRepo,
 	}
@@ -287,6 +291,10 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 	category := strings.ToUpper(pfk.ProjectFlock.Category)
 	isLaying := category == strings.ToUpper(string(utils.ProjectFlockCategoryLaying))
 
+	if err := s.enforceTransferRecordingRoute(ctx, pfk, recordTime); err != nil {
+		return nil, err
+	}
+
 	if err := s.ProjectFlockSvc.EnsureProjectFlockApproved(ctx, pfk.ProjectFlockId); err != nil {
 		return nil, err
 	}
@@ -897,6 +905,91 @@ func (s recordingService) DeleteOne(c *fiber.Ctx, id uint) error {
 	})
 }
 
+func (s *recordingService) enforceTransferRecordingRoute(
+	ctx context.Context,
+	pfk *entity.ProjectFlockKandang,
+	recordTime time.Time,
+) error {
+	if pfk == nil || pfk.Id == 0 || s.TransferLayingRepo == nil {
+		return nil
+	}
+
+	recordDate := normalizeDateOnlyUTC(recordTime)
+	category := strings.ToUpper(strings.TrimSpace(pfk.ProjectFlock.Category))
+
+	switch category {
+	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
+		transfer, err := s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx, pfk.Id)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil
+			}
+			s.Log.Errorf("Failed to resolve approved transfer by target kandang %d: %+v", pfk.Id, err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi transfer laying")
+		}
+
+		effectiveDate := effectiveTransferDate(transfer)
+		if effectiveDate.IsZero() {
+			return nil
+		}
+
+		if recordDate.Before(effectiveDate) {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Recording kandang laying hanya bisa dimulai pada %s. Sebelumnya gunakan kandang growing", effectiveDate.Format("2006-01-02")),
+			)
+		}
+
+		if transfer.ExecutedAt == nil || transfer.ExecutedAt.IsZero() {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Transfer laying %s sudah efektif pada %s tetapi belum dieksekusi. Eksekusi transfer terlebih dahulu", transfer.TransferNumber, effectiveDate.Format("2006-01-02")),
+			)
+		}
+
+	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
+		transfer, err := s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, pfk.Id)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil
+			}
+			s.Log.Errorf("Failed to resolve approved transfer by source kandang %d: %+v", pfk.Id, err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi transfer laying")
+		}
+
+		effectiveDate := effectiveTransferDate(transfer)
+		if effectiveDate.IsZero() {
+			return nil
+		}
+
+		if !recordDate.Before(effectiveDate) {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Recording kandang growing hanya diperbolehkan sampai %s. Gunakan kandang laying mulai %s", effectiveDate.AddDate(0, 0, -1).Format("2006-01-02"), effectiveDate.Format("2006-01-02")),
+			)
+		}
+	}
+
+	return nil
+}
+
+func effectiveTransferDate(transfer *entity.LayingTransfer) time.Time {
+	if transfer == nil {
+		return time.Time{}
+	}
+	if transfer.EffectiveMoveDate != nil && !transfer.EffectiveMoveDate.IsZero() {
+		return normalizeDateOnlyUTC(*transfer.EffectiveMoveDate)
+	}
+	if !transfer.TransferDate.IsZero() {
+		return normalizeDateOnlyUTC(transfer.TransferDate)
+	}
+	return time.Time{}
+}
+
+func normalizeDateOnlyUTC(value time.Time) time.Time {
+	return time.Date(value.UTC().Year(), value.UTC().Month(), value.UTC().Day(), 0, 0, 0, 0, time.UTC)
+}
+
 func (s *recordingService) ensureProductWarehousesExist(c *fiber.Ctx, stocks []validation.Stock, depletions []validation.Depletion, eggs []validation.Egg) error {
 	idSet := make(map[uint]struct{})
 

internal/modules/production/transfer_layings/controllers/transfer_laying.controller.go

@@ -186,6 +186,28 @@ func (u *TransferLayingController) Approval(c *fiber.Ctx) error {
 		})
 }
 
+func (u *TransferLayingController) Execute(c *fiber.Ctx) error {
+	param := c.Params("id")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	result, err := u.TransferLayingService.Execute(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Execute transfer laying successfully",
+			Data:    dto.ToTransferLayingDetailDTOWithSingleApproval(*result, result.LatestApproval),
+		})
+}
+
 func (u *TransferLayingController) GetAvailableQtyPerKandang(c *fiber.Ctx) error {
 	projectFlockID, err := strconv.ParseUint(c.Params("project_flock_id"), 10, 32)
 	if err != nil {

internal/modules/production/transfer_layings/dto/transfer_laying.dto.go

@@ -14,10 +14,12 @@ import (
 // === DTO Structs ===
 
 type TransferLayingRelationDTO struct {
-	Id             uint      `json:"id"`
-	TransferNumber string    `json:"transfer_number"`
-	TransferDate   time.Time `json:"transfer_date"`
-	Notes          string    `json:"notes"`
+	Id                uint       `json:"id"`
+	TransferNumber    string     `json:"transfer_number"`
+	TransferDate      time.Time  `json:"transfer_date"`
+	EffectiveMoveDate *time.Time `json:"effective_move_date,omitempty"`
+	ExecutedAt        *time.Time `json:"executed_at,omitempty"`
+	Notes             string     `json:"notes"`
 }
 
 type ProjectFlockKandangWithKandangDTO struct {
@@ -47,6 +49,8 @@ type TransferLayingListDTO struct {
 	ToProjectFlock   *projectFlockDTO.ProjectFlockRelationDTO `json:"to_project_flock,omitempty"`
 	CreatedBy        uint                                     `json:"created_by"`
 	CreatedUser      *userDTO.UserRelationDTO                 `json:"created_user,omitempty"`
+	ExecutedBy       *uint                                    `json:"executed_by,omitempty"`
+	ExecutedUser     *userDTO.UserRelationDTO                 `json:"executed_user,omitempty"`
 	CreatedAt        time.Time                                `json:"created_at"`
 	Approval         *approvalDTO.ApprovalRelationDTO         `json:"approval,omitempty"`
 }
@@ -88,10 +92,12 @@ type MaxTargetQtyForTransferDTO struct {
 
 func ToTransferLayingRelationDTO(e entity.LayingTransfer) TransferLayingRelationDTO {
 	return TransferLayingRelationDTO{
-		Id:             e.Id,
-		TransferNumber: e.TransferNumber,
-		TransferDate:   e.TransferDate,
-		Notes:          e.Notes,
+		Id:                e.Id,
+		TransferNumber:    e.TransferNumber,
+		TransferDate:      e.TransferDate,
+		EffectiveMoveDate: e.EffectiveMoveDate,
+		ExecutedAt:        e.ExecutedAt,
+		Notes:             e.Notes,
 	}
 }
 
@@ -190,6 +196,12 @@ func ToTransferLayingListDTO(e entity.LayingTransfer) TransferLayingListDTO {
 		createdUser = &mapped
 	}
 
+	var executedUser *userDTO.UserRelationDTO
+	if e.ExecutedUser != nil && e.ExecutedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(*e.ExecutedUser)
+		executedUser = &mapped
+	}
+
 	var approval *approvalDTO.ApprovalRelationDTO
 	if e.LatestApproval != nil {
 		mapped := approvalDTO.ToApprovalDTO(*e.LatestApproval)
@@ -219,6 +231,8 @@ func ToTransferLayingListDTO(e entity.LayingTransfer) TransferLayingListDTO {
 		ToProjectFlock:            toProjectFlock,
 		CreatedBy:                 e.CreatedBy,
 		CreatedUser:               createdUser,
+		ExecutedBy:                e.ExecutedBy,
+		ExecutedUser:              executedUser,
 		CreatedAt:                 e.CreatedAt,
 		Approval:                  approval,
 	}

internal/modules/production/transfer_layings/module.go

@@ -37,6 +37,7 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 
 	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
 	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	// daftarin jadi stockable
 	if err := fifoService.RegisterStockable(fifo.StockableConfig{
@@ -91,6 +92,7 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 		warehouseRepo,
 		approvalService,
 		fifoService,
+		fifoStockV2Service,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

internal/modules/production/transfer_layings/repositories/laying_transfer.repository.go

@@ -7,6 +7,7 @@ import (
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gorm.io/gorm"
 )
 
@@ -14,6 +15,8 @@ type TransferLayingRepository interface {
 	repository.BaseRepository[entity.LayingTransfer]
 	GetByTransferNumber(ctx context.Context, transferNumber string) (*entity.LayingTransfer, error)
 	IdExists(ctx context.Context, id uint) (bool, error)
+	GetLatestApprovedBySourceKandang(ctx context.Context, sourceProjectFlockKandangID uint) (*entity.LayingTransfer, error)
+	GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error)
 
 	// Tambah method baru untuk query dengan filter lengkap
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params *GetAllFilterParams) ([]entity.LayingTransfer, int64, error)
@@ -164,6 +167,7 @@ func (r *TransferLayingRepositoryImpl) GetAllWithFilters(ctx context.Context, of
 		Preload("FromProjectFlock").
 		Preload("ToProjectFlock").
 		Preload("CreatedUser").
+		Preload("ExecutedUser").
 		Preload("Sources").
 		Preload("Sources.SourceProjectFlockKandang").
 		Preload("Sources.SourceProjectFlockKandang.Kandang").
@@ -180,3 +184,57 @@ func (r *TransferLayingRepositoryImpl) GetAllWithFilters(ctx context.Context, of
 
 	return records, total, nil
 }
+
+func (r *TransferLayingRepositoryImpl) GetLatestApprovedBySourceKandang(ctx context.Context, sourceProjectFlockKandangID uint) (*entity.LayingTransfer, error) {
+	if sourceProjectFlockKandangID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	var transfer entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_sources lts ON lts.laying_transfer_id = laying_transfers.id AND lts.deleted_at IS NULL").
+		Where("lts.source_project_flock_kandang_id = ?", sourceProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.id DESC").
+		First(&transfer).Error
+	if err != nil {
+		return nil, err
+	}
+	return &transfer, nil
+}
+
+func (r *TransferLayingRepositoryImpl) GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error) {
+	if targetProjectFlockKandangID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	var transfer entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_targets ltt ON ltt.laying_transfer_id = laying_transfers.id AND ltt.deleted_at IS NULL").
+		Where("ltt.target_project_flock_kandang_id = ?", targetProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.id DESC").
+		First(&transfer).Error
+	if err != nil {
+		return nil, err
+	}
+	return &transfer, nil
+}

internal/modules/production/transfer_layings/route.go

@@ -27,6 +27,7 @@ func TransferLayingRoutes(v1 fiber.Router, u user.UserService, s transferLaying.
 	route.Patch("/:id", m.RequirePermissions(m.P_TransferToLaying_UpdateOne), ctrl.UpdateOne)
 	route.Delete("/:id", m.RequirePermissions(m.P_TransferToLaying_DeleteOne), ctrl.DeleteOne)
 	route.Post("/approvals", m.RequirePermissions(m.P_TransferToLaying_Approval), ctrl.Approval)
+	route.Post("/:id/execute", m.RequirePermissions(m.P_TransferToLaying_Approval), ctrl.Execute)
 	route.Get("/project-flocks/:project_flock_id/available-qty", m.RequirePermissions(m.P_TransferToLaying_GetAvailableQty), ctrl.GetAvailableQtyPerKandang)
 	route.Get("/project-flocks/:project_flock_id/max-target-qty", m.RequirePermissions(m.P_TransferToLaying_CreateOne), ctrl.GetMaxTargetQtyPerKandang)
 }

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -10,6 +10,7 @@ import (
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	rInventory "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
@@ -34,6 +35,7 @@ type TransferLayingService interface {
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.LayingTransfer, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.LayingTransfer, error)
+	Execute(ctx *fiber.Ctx, id uint) (*entity.LayingTransfer, error)
 	GetAvailableQtyPerKandang(ctx *fiber.Ctx, projectFlockID uint) (*entity.ProjectFlock, map[uint]float64, error)
 	GetMaxTargetQtyPerKandang(ctx *fiber.Ctx, projectFlockID uint) (map[uint]float64, error)
 }
@@ -52,8 +54,14 @@ type transferLayingService struct {
 	StockLogRepo               rStockLogs.StockLogRepository
 	ApprovalService            commonSvc.ApprovalService
 	FifoSvc                    commonSvc.FifoService
+	FifoStockV2Svc             commonSvc.FifoStockV2Service
 }
 
+const (
+	transferToLayingFlagGroupCode   = "AYAM"
+	transferToLayingOutFunctionCode = "TRANSFER_TO_LAYING_OUT"
+)
+
 func NewTransferLayingService(
 	repo repository.TransferLayingRepository,
 	layingTransferSourceRepo repository.LayingTransferSourceRepository,
@@ -65,6 +73,7 @@ func NewTransferLayingService(
 	warehouseRepo rWarehouse.WarehouseRepository,
 	approvalService commonSvc.ApprovalService,
 	fifoSvc commonSvc.FifoService,
+	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	validate *validator.Validate,
 ) TransferLayingService {
 	return &transferLayingService{
@@ -81,12 +90,14 @@ func NewTransferLayingService(
 		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
 		ApprovalService:            approvalService,
 		FifoSvc:                    fifoSvc,
+		FifoStockV2Svc:             fifoStockV2Svc,
 	}
 }
 
 func (s transferLayingService) withRelations(db *gorm.DB) *gorm.DB {
 	return db.
 		Preload("CreatedUser").
+		Preload("ExecutedUser").
 		Preload("FromProjectFlock").
 		Preload("ToProjectFlock").
 		Preload("Sources").
@@ -744,13 +755,10 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		repoTx := s.Repository.WithTx(dbTransaction)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
-		stockAllocationRepo := commonRepo.NewStockAllocationRepository(dbTransaction)
 		sourceRepoTx := repository.NewLayingTransferSourceRepository(dbTransaction)
-		targetRepoTx := repository.NewLayingTransferTargetRepository(dbTransaction)
-		stockLogRepoTx := rStockLogs.NewStockLogRepository(dbTransaction)
 
 		for _, approvableID := range approvableIDs {
-			transfer, err := repoTx.GetByID(c.Context(), approvableID, nil)
+			_, err := repoTx.GetByID(c.Context(), approvableID, nil)
 			if err != nil {
 				if errors.Is(err, gorm.ErrRecordNotFound) {
 					return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("TransferLaying %d not found", approvableID))
@@ -771,148 +779,21 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 			}
 
 			if action == entity.ApprovalActionApproved {
-
 				sources, err := sourceRepoTx.GetByLayingTransferId(c.Context(), approvableID)
 				if err != nil {
 					return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil sources transfer")
 				}
-
-				targets, err := targetRepoTx.GetByLayingTransferId(c.Context(), approvableID)
+				effectiveMoveDate, err := s.calculateEffectiveMoveDate(c.Context(), sources)
 				if err != nil {
-					return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil targets transfer")
+					return err
 				}
 
-				totalTargetQty := 0.0
-				for _, target := range targets {
-					totalTargetQty += target.TotalQty
-				}
-
-				totalSourceRequested := 0.0
-				for _, source := range sources {
-					totalSourceRequested += source.RequestedQty
-				}
-
-				for _, source := range sources {
-					if source.ProductWarehouseId == nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Source product warehouse tidak ditemukan untuk transfer %d", approvableID))
-					}
-
-					sourceShare := (source.RequestedQty / totalSourceRequested) * totalTargetQty
-
-					consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-						UsableKey:          fifo.UsableKeyTransferToLayingOut,
-						UsableID:           source.Id,
-						ProductWarehouseID: *source.ProductWarehouseId,
-						Quantity:           sourceShare,
-						AllowPending:       false,
-						Tx:                 dbTransaction,
-					})
-					if err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal consume FIFO stock: %v", err))
-					}
-
-					if err := sourceRepoTx.PatchOne(c.Context(), source.Id, map[string]interface{}{
-						"usage_qty":         source.UsageQty + consumeResult.UsageQuantity,
-						"pending_usage_qty": consumeResult.PendingQuantity,
-					}, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update source usage qty")
-					}
-
-					targetShares := distributeProportionalWithRounding(targets, totalTargetQty, sourceShare)
-
-					for i, target := range targets {
-						roundedQty := math.Round(targetShares[i])
-						if roundedQty <= 0 {
-							continue
-						}
-						mappingAllocation := &entity.StockAllocation{
-							StockableType:      fifo.UsableKeyTransferToLayingOut.String(),
-							StockableId:        source.Id,
-							UsableType:         fifo.StockableKeyTransferToLayingIn.String(),
-							UsableId:           target.Id,
-							ProductWarehouseId: *source.ProductWarehouseId,
-							Qty:                roundedQty,
-							Status:             entity.StockAllocationStatusActive,
-						}
-						if err := stockAllocationRepo.CreateOne(c.Context(), mappingAllocation, nil); err != nil {
-							return fiber.NewError(fiber.StatusInternalServerError, "Gagal create mapping allocation source→target")
-						}
-					}
-
-					stockLogDecrease := &entity.StockLog{
-						ProductWarehouseId: *source.ProductWarehouseId,
-						CreatedBy:          actorID,
-						Increase:           0,
-						Decrease:           sourceShare,
-						LoggableType:       string(utils.StockLogTypeTransferLaying),
-						LoggableId:         approvableID,
-						Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
-					}
-					stockLogs, err := stockLogRepoTx.GetByProductWarehouse(c.Context(), *source.ProductWarehouseId, 1)
-					if err != nil {
-						s.Log.Errorf("Failed to get stock logs: %+v", err)
-						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-					}
-					if len(stockLogs) > 0 {
-						latestStockLog := stockLogs[0]
-						stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
-					} else {
-						stockLogDecrease.Stock -= stockLogDecrease.Decrease
-					}
-
-					if err := stockLogRepoTx.CreateOne(c.Context(), stockLogDecrease, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
-					}
-				}
-
-				for _, target := range targets {
-					if target.ProductWarehouseId == nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", approvableID))
-					}
-
-					note := fmt.Sprintf("Transfer to Laying #%s", transfer.TransferNumber)
-					_, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
-						StockableKey:       fifo.StockableKeyTransferToLayingIn,
-						StockableID:        target.Id,
-						ProductWarehouseID: *target.ProductWarehouseId,
-						Quantity:           target.TotalQty,
-						Note:               &note,
-						Tx:                 dbTransaction,
-					})
-					if err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal replenish stock ke target warehouse: %v", err))
-					}
-
-					if err := targetRepoTx.PatchOne(c.Context(), target.Id, map[string]interface{}{
-						"total_qty": target.TotalQty,
-					}, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update target total qty")
-					}
-
-					stockLogIncrease := &entity.StockLog{
-						ProductWarehouseId: *target.ProductWarehouseId,
-						CreatedBy:          actorID,
-						Increase:           target.TotalQty,
-						Decrease:           0,
-						LoggableType:       string(utils.StockLogTypeTransferLaying),
-						LoggableId:         approvableID,
-						Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
-					}
-					stockLogs, err := stockLogRepoTx.GetByProductWarehouse(c.Context(), *target.ProductWarehouseId, 1)
-					if err != nil {
-						s.Log.Errorf("Failed to get stock logs: %+v", err)
-						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-					}
-					if len(stockLogs) > 0 {
-						latestStockLog := stockLogs[0]
-						stockLogIncrease.Stock = latestStockLog.Stock + stockLogIncrease.Increase
-					} else {
-						stockLogIncrease.Stock += stockLogIncrease.Increase
-					}
-
-					if err := stockLogRepoTx.CreateOne(c.Context(), stockLogIncrease, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
-					}
+				if err := repoTx.PatchOne(c.Context(), approvableID, map[string]any{
+					"effective_move_date": effectiveMoveDate,
+					"executed_at":         nil,
+					"executed_by":         nil,
+				}, nil); err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan tanggal efektif transfer laying")
 				}
 			}
 		}
@@ -939,6 +820,362 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 	return updated, nil
 }
 
+func (s transferLayingService) Execute(c *fiber.Ctx, id uint) (*entity.LayingTransfer, error) {
+	if err := m.EnsureLayingTransferAccess(c, s.Repository.DB(), id); err != nil {
+		return nil, err
+	}
+
+	actorID, err := m.ActorIDFromContext(c)
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+		repoTx := s.Repository.WithTx(dbTransaction)
+		sourceRepoTx := repository.NewLayingTransferSourceRepository(dbTransaction)
+		targetRepoTx := repository.NewLayingTransferTargetRepository(dbTransaction)
+		approvalRepoTx := commonRepo.NewApprovalRepository(dbTransaction)
+
+		transfer, err := repoTx.GetByID(c.Context(), id, nil)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "Transfer laying tidak ditemukan")
+			}
+			return err
+		}
+
+		if transfer.ExecutedAt != nil {
+			return nil
+		}
+
+		latestApproval, err := approvalRepoTx.LatestByTarget(c.Context(), string(utils.ApprovalWorkflowTransferToLaying), transfer.Id, nil)
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			return err
+		}
+		if latestApproval == nil || latestApproval.Action == nil || *latestApproval.Action != entity.ApprovalActionApproved {
+			return fiber.NewError(fiber.StatusBadRequest, "Transfer laying harus disetujui sebelum dieksekusi")
+		}
+
+		sources, err := sourceRepoTx.GetByLayingTransferId(c.Context(), transfer.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil sumber transfer laying")
+		}
+
+		targets, err := targetRepoTx.GetByLayingTransferId(c.Context(), transfer.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil target transfer laying")
+		}
+
+		if transfer.EffectiveMoveDate == nil || transfer.EffectiveMoveDate.IsZero() {
+			effectiveMoveDate, calcErr := s.calculateEffectiveMoveDate(c.Context(), sources)
+			if calcErr != nil {
+				return calcErr
+			}
+			if patchErr := repoTx.PatchOne(c.Context(), transfer.Id, map[string]any{
+				"effective_move_date": effectiveMoveDate,
+			}, nil); patchErr != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan tanggal efektif transfer laying")
+			}
+			transfer.EffectiveMoveDate = &effectiveMoveDate
+		}
+
+		effectiveMoveDate := normalizeDateOnlyUTC(*transfer.EffectiveMoveDate)
+		today := normalizeDateOnlyUTC(time.Now().UTC())
+		if today.Before(effectiveMoveDate) {
+			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Transfer laying baru bisa dieksekusi mulai tanggal %s", effectiveMoveDate.Format("2006-01-02")))
+		}
+
+		if err := s.executeApprovedTransferMovement(c.Context(), dbTransaction, transfer, actorID, sources, targets); err != nil {
+			return err
+		}
+
+		executedAt := time.Now().UTC()
+		if err := repoTx.PatchOne(c.Context(), transfer.Id, map[string]any{
+			"executed_at": executedAt,
+			"executed_by": actorID,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan status eksekusi transfer laying")
+		}
+
+		return nil
+	})
+	if err != nil {
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return nil, fiberErr
+		}
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengeksekusi transfer laying")
+	}
+
+	transfer, _, err := s.GetOne(c, id)
+	if err != nil {
+		return nil, err
+	}
+	return transfer, nil
+}
+
+func (s *transferLayingService) executeApprovedTransferMovement(
+	ctx context.Context,
+	tx *gorm.DB,
+	transfer *entity.LayingTransfer,
+	actorID uint,
+	sources []entity.LayingTransferSource,
+	targets []entity.LayingTransferTarget,
+) error {
+	if transfer == nil || transfer.Id == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying tidak valid")
+	}
+	if len(sources) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying belum memiliki sumber")
+	}
+	if len(targets) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying belum memiliki target")
+	}
+
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
+	sourceRepoTx := repository.NewLayingTransferSourceRepository(tx)
+	targetRepoTx := repository.NewLayingTransferTargetRepository(tx)
+	stockLogRepoTx := rStockLogs.NewStockLogRepository(tx)
+
+	totalTargetQty := 0.0
+	for _, target := range targets {
+		totalTargetQty += target.TotalQty
+	}
+	if totalTargetQty <= 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Total kuantitas target transfer laying harus lebih dari 0")
+	}
+
+	totalSourceRequested := 0.0
+	for _, source := range sources {
+		totalSourceRequested += source.RequestedQty
+	}
+	if totalSourceRequested <= 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Total kuantitas sumber transfer laying harus lebih dari 0")
+	}
+
+	for _, source := range sources {
+		if source.ProductWarehouseId == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Source product warehouse tidak ditemukan untuk transfer %d", transfer.Id))
+		}
+		if source.RequestedQty <= 0 {
+			continue
+		}
+
+		sourceShare := (source.RequestedQty / totalSourceRequested) * totalTargetQty
+		if sourceShare <= 0 {
+			continue
+		}
+
+		usageQty := 0.0
+		pendingQty := 0.0
+		if s.FifoStockV2Svc != nil {
+			allowPending := false
+			reflowResult, err := s.FifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
+				FlagGroupCode:      transferToLayingFlagGroupCode,
+				ProductWarehouseID: *source.ProductWarehouseId,
+				Usable: commonSvc.FifoStockV2Ref{
+					ID:            source.Id,
+					LegacyTypeKey: fifo.UsableKeyTransferToLayingOut.String(),
+					FunctionCode:  transferToLayingOutFunctionCode,
+				},
+				DesiredQty:       sourceShare,
+				AllowOverConsume: &allowPending,
+				Tx:               tx,
+			})
+			if err != nil {
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal consume FIFO v2 stock: %v", err))
+			}
+			usageQty = reflowResult.Allocate.AllocatedQty
+			pendingQty = reflowResult.Allocate.PendingQty
+		} else {
+			consumeResult, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
+				UsableKey:          fifo.UsableKeyTransferToLayingOut,
+				UsableID:           source.Id,
+				ProductWarehouseID: *source.ProductWarehouseId,
+				Quantity:           sourceShare,
+				AllowPending:       false,
+				Tx:                 tx,
+			})
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal consume FIFO stock: %v", err))
+			}
+			usageQty = consumeResult.UsageQuantity
+			pendingQty = consumeResult.PendingQuantity
+		}
+
+		if err := sourceRepoTx.PatchOne(ctx, source.Id, map[string]any{
+			"usage_qty":         source.UsageQty + usageQty,
+			"pending_usage_qty": pendingQty,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal update source usage qty")
+		}
+
+		if pendingQty > 0 || usageQty < sourceShare-1e-6 {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Stok sumber tidak mencukupi untuk mengeksekusi transfer laying %s", transfer.TransferNumber),
+			)
+		}
+
+		movedQty := sourceShare
+		targetShares := distributeProportionalWithRounding(targets, totalTargetQty, movedQty)
+		for i, target := range targets {
+			roundedQty := math.Round(targetShares[i])
+			if roundedQty <= 0 {
+				continue
+			}
+			mappingAllocation := &entity.StockAllocation{
+				StockableType:      fifo.UsableKeyTransferToLayingOut.String(),
+				StockableId:        source.Id,
+				UsableType:         fifo.StockableKeyTransferToLayingIn.String(),
+				UsableId:           target.Id,
+				ProductWarehouseId: *source.ProductWarehouseId,
+				Qty:                roundedQty,
+				Status:             entity.StockAllocationStatusActive,
+			}
+			if err := stockAllocationRepo.CreateOne(ctx, mappingAllocation, nil); err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal create mapping allocation source→target")
+			}
+		}
+
+		stockLogDecrease := &entity.StockLog{
+			ProductWarehouseId: *source.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Increase:           0,
+			Decrease:           movedQty,
+			LoggableType:       string(utils.StockLogTypeTransferLaying),
+			LoggableId:         transfer.Id,
+			Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
+		}
+		stockLogs, err := stockLogRepoTx.GetByProductWarehouse(ctx, *source.ProductWarehouseId, 1)
+		if err != nil {
+			s.Log.Errorf("Failed to get stock logs: %+v", err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+		}
+		if len(stockLogs) > 0 {
+			latestStockLog := stockLogs[0]
+			stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
+		} else {
+			stockLogDecrease.Stock -= stockLogDecrease.Decrease
+		}
+
+		if err := stockLogRepoTx.CreateOne(ctx, stockLogDecrease, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
+		}
+	}
+
+	for _, target := range targets {
+		if target.ProductWarehouseId == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", transfer.Id))
+		}
+
+		note := fmt.Sprintf("Transfer to Laying #%s", transfer.TransferNumber)
+		_, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
+			StockableKey:       fifo.StockableKeyTransferToLayingIn,
+			StockableID:        target.Id,
+			ProductWarehouseID: *target.ProductWarehouseId,
+			Quantity:           target.TotalQty,
+			Note:               &note,
+			Tx:                 tx,
+		})
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal replenish stock ke target warehouse: %v", err))
+		}
+
+		if err := targetRepoTx.PatchOne(ctx, target.Id, map[string]any{
+			"total_qty": target.TotalQty,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal update target total qty")
+		}
+
+		stockLogIncrease := &entity.StockLog{
+			ProductWarehouseId: *target.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Increase:           target.TotalQty,
+			Decrease:           0,
+			LoggableType:       string(utils.StockLogTypeTransferLaying),
+			LoggableId:         transfer.Id,
+			Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
+		}
+		stockLogs, err := stockLogRepoTx.GetByProductWarehouse(ctx, *target.ProductWarehouseId, 1)
+		if err != nil {
+			s.Log.Errorf("Failed to get stock logs: %+v", err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+		}
+		if len(stockLogs) > 0 {
+			latestStockLog := stockLogs[0]
+			stockLogIncrease.Stock = latestStockLog.Stock + stockLogIncrease.Increase
+		} else {
+			stockLogIncrease.Stock += stockLogIncrease.Increase
+		}
+
+		if err := stockLogRepoTx.CreateOne(ctx, stockLogIncrease, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
+		}
+	}
+
+	return nil
+}
+
+func (s *transferLayingService) calculateEffectiveMoveDate(ctx context.Context, sources []entity.LayingTransferSource) (time.Time, error) {
+	if len(sources) == 0 {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Sumber transfer laying tidak ditemukan")
+	}
+
+	maxGrowingWeek := config.TransferToLayingGrowingMaxWeek
+	if maxGrowingWeek <= 0 {
+		maxGrowingWeek = 19
+	}
+
+	var baselineChickInDate time.Time
+	for _, source := range sources {
+		chickInDate, err := s.resolveSourceChickInDate(ctx, source.SourceProjectFlockKandangId)
+		if err != nil {
+			return time.Time{}, err
+		}
+		if baselineChickInDate.IsZero() || chickInDate.Before(baselineChickInDate) {
+			baselineChickInDate = chickInDate
+		}
+	}
+
+	if baselineChickInDate.IsZero() {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Tanggal chick in sumber transfer laying tidak ditemukan")
+	}
+
+	effectiveMoveDate := baselineChickInDate.AddDate(0, 0, maxGrowingWeek*7)
+	return normalizeDateOnlyUTC(effectiveMoveDate), nil
+}
+
+func (s *transferLayingService) resolveSourceChickInDate(ctx context.Context, sourceProjectFlockKandangID uint) (time.Time, error) {
+	if sourceProjectFlockKandangID == 0 {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang sumber tidak valid")
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, sourceProjectFlockKandangID)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	var earliestChickInDate time.Time
+	for _, population := range populations {
+		if population.ProjectChickin == nil || population.ProjectChickin.ChickInDate.IsZero() {
+			continue
+		}
+		chickInDate := normalizeDateOnlyUTC(population.ProjectChickin.ChickInDate)
+		if earliestChickInDate.IsZero() || chickInDate.Before(earliestChickInDate) {
+			earliestChickInDate = chickInDate
+		}
+	}
+
+	if earliestChickInDate.IsZero() {
+		return time.Time{}, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Tanggal chick in untuk kandang sumber %d tidak ditemukan", sourceProjectFlockKandangID),
+		)
+	}
+
+	return earliestChickInDate, nil
+}
+
 func createApprovalTransferLaying(ctx context.Context, tx *gorm.DB, transferLayingID uint, actorID uint) error {
 	if transferLayingID == 0 || actorID == 0 {
 		return nil
@@ -1053,6 +1290,10 @@ func (s transferLayingService) GetMaxTargetQtyPerKandang(c *fiber.Ctx, projectFl
 	return kandangMaxTargetQty, nil
 }
 
+func normalizeDateOnlyUTC(value time.Time) time.Time {
+	return time.Date(value.UTC().Year(), value.UTC().Month(), value.UTC().Day(), 0, 0, 0, 0, time.UTC)
+}
+
 func distributeProportionalWithRounding(targets []entity.LayingTransferTarget, totalTargetQty, sourceShare float64) []float64 {
 	if len(targets) == 0 {
 		return []float64{}

internal/utils/constant.go

@@ -198,6 +198,136 @@ const (
 	TransactionTypeSaldoAwal TransactionType = "SALDO_AWAL"
 )
 
+type AdjustmentTransactionType string
+
+const (
+	AdjustmentTransactionTypePembelian AdjustmentTransactionType = "PEMBELIAN"
+	AdjustmentTransactionTypeRecording AdjustmentTransactionType = "RECORDING"
+	AdjustmentTransactionTypePenjualan AdjustmentTransactionType = "PENJUALAN"
+)
+
+type AdjustmentTransactionSubtype string
+
+const (
+	AdjustmentTransactionSubtypePurchaseIn            AdjustmentTransactionSubtype = "PURCHASE_IN"
+	AdjustmentTransactionSubtypeRecordingDepletionOut AdjustmentTransactionSubtype = "RECORDING_DEPLETION_OUT"
+	AdjustmentTransactionSubtypeMarketingOut          AdjustmentTransactionSubtype = "MARKETING_OUT"
+	AdjustmentTransactionSubtypeRecordingDepletionIn  AdjustmentTransactionSubtype = "RECORDING_DEPLETION_IN"
+	AdjustmentTransactionSubtypeRecordingStockOut     AdjustmentTransactionSubtype = "RECORDING_STOCK_OUT"
+	AdjustmentTransactionSubtypeRecordingEggIn        AdjustmentTransactionSubtype = "RECORDING_EGG_IN"
+)
+
+var adjustmentSubtypesByType = map[AdjustmentTransactionType][]string{
+	AdjustmentTransactionTypePembelian: {
+		string(AdjustmentTransactionSubtypePurchaseIn),
+	},
+	AdjustmentTransactionTypeRecording: {
+		string(AdjustmentTransactionSubtypeRecordingStockOut),
+		string(AdjustmentTransactionSubtypeRecordingDepletionOut),
+		string(AdjustmentTransactionSubtypeRecordingDepletionIn),
+		string(AdjustmentTransactionSubtypeRecordingEggIn),
+	},
+	AdjustmentTransactionTypePenjualan: {
+		string(AdjustmentTransactionSubtypeMarketingOut),
+	},
+}
+
+var hiddenAdjustmentSubtypesForFrontend = map[string]struct{}{
+	string(AdjustmentTransactionSubtypeRecordingDepletionIn): {},
+}
+
+var adjustmentSubtypeToType = func() map[string]AdjustmentTransactionType {
+	out := make(map[string]AdjustmentTransactionType)
+	for txType, subtypes := range adjustmentSubtypesByType {
+		for _, subtype := range subtypes {
+			code := strings.ToUpper(strings.TrimSpace(subtype))
+			if code == "" {
+				continue
+			}
+			out[code] = txType
+		}
+	}
+	return out
+}()
+
+func AdjustmentTransactionTypes() []string {
+	return []string{
+		string(AdjustmentTransactionTypePembelian),
+		string(AdjustmentTransactionTypeRecording),
+		string(AdjustmentTransactionTypePenjualan),
+	}
+}
+
+func AdjustmentTransactionSubtypesByType() map[string][]string {
+	out := make(map[string][]string, len(adjustmentSubtypesByType))
+	for _, txType := range []AdjustmentTransactionType{
+		AdjustmentTransactionTypePembelian,
+		AdjustmentTransactionTypeRecording,
+		AdjustmentTransactionTypePenjualan,
+	} {
+		src := adjustmentSubtypesByType[txType]
+		dup := make([]string, len(src))
+		copy(dup, src)
+		out[string(txType)] = dup
+	}
+	return out
+}
+
+func AdjustmentTransactionSubtypes() []string {
+	result := make([]string, 0)
+	for _, txType := range []AdjustmentTransactionType{
+		AdjustmentTransactionTypePembelian,
+		AdjustmentTransactionTypeRecording,
+		AdjustmentTransactionTypePenjualan,
+	} {
+		result = append(result, adjustmentSubtypesByType[txType]...)
+	}
+	return result
+}
+
+func AdjustmentTransactionSubtypesByTypeForFrontend() map[string][]string {
+	out := make(map[string][]string, len(adjustmentSubtypesByType))
+	for txType, subtypes := range AdjustmentTransactionSubtypesByType() {
+		filtered := make([]string, 0, len(subtypes))
+		for _, subtype := range subtypes {
+			if _, hidden := hiddenAdjustmentSubtypesForFrontend[subtype]; hidden {
+				continue
+			}
+			filtered = append(filtered, subtype)
+		}
+		out[txType] = filtered
+	}
+	return out
+}
+
+func AdjustmentTransactionSubtypesForFrontend() []string {
+	result := make([]string, 0)
+	for _, subtype := range AdjustmentTransactionSubtypes() {
+		if _, hidden := hiddenAdjustmentSubtypesForFrontend[subtype]; hidden {
+			continue
+		}
+		result = append(result, subtype)
+	}
+	return result
+}
+
+func ResolveAdjustmentTransactionType(functionCode string) string {
+	code := strings.ToUpper(strings.TrimSpace(functionCode))
+	if txType, ok := adjustmentSubtypeToType[code]; ok {
+		return string(txType)
+	}
+	switch {
+	case strings.HasPrefix(code, "PURCHASE_"):
+		return string(AdjustmentTransactionTypePembelian)
+	case strings.HasPrefix(code, "MARKETING_"):
+		return string(AdjustmentTransactionTypePenjualan)
+	case strings.HasPrefix(code, "RECORDING_"):
+		return string(AdjustmentTransactionTypeRecording)
+	default:
+		return ""
+	}
+}
+
 // -------------------------------------------------------------------
 // Payment Party
 // -------------------------------------------------------------------