Merge branch 'feat/BE/implement-new-trf' into 'dev/fifo-v2'

Fix transfer to laying delete and fix chikin delete with response recording

See merge request mbugroup/lti-api!366

.gitignore

@@ -9,11 +9,13 @@ main
 bin/
 *.exe
 *.out
-
+.air.toml
 Makefile
 docker-compose.local.yml
 docker-compose.yaml
+Dockerfile
 Dockerfile.local
+.gitlab-ci.yml
 # Go build cache
 .gocache/
 vendor
@@ -27,3 +29,4 @@ coverage/
 .vscode/
 .idea/
 *.swp
+.DS_Store

.gitlab-ci.yml

@@ -1,90 +1,35 @@
-stages:
-  - deploy
+workflow:
+  rules:
+    # MR pipeline
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+      when: always
 
-deploy-dev:
-  stage: deploy
-  image: alpine:3.20
-  variables:
-    DEPLOY_APP: "LTI-MBUGROUP"
-    # Opsional: kalau pakai submodule, ini bikin clone submodule pakai SSH juga
-    GIT_SUBMODULE_STRATEGY: recursive
-    GIT_DEPTH: "1"
+    # Push pipeline hanya untuk env branch
+    - if: '$CI_COMMIT_BRANCH == "development"'
+      when: always
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: always
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: always
 
-  before_script:
-    - echo "🧰 Installing dependencies..."
-    - apk update && apk add --no-cache openssh git curl bash
+    # Selain itu jangan buat pipeline
+    - when: never
 
-    # Setup SSH di runner
-    - mkdir -p ~/.ssh
-    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' > ~/.ssh/id_rsa
-    - chmod 600 ~/.ssh/id_rsa
-    - eval "$(ssh-agent -s)"
-    - ssh-add ~/.ssh/id_rsa
+include:
+  # khusus MR (notif)
+  - local: "ci/merge_request.yml"
+    rules:
+      - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
 
-    # Trust host keys (server + gitlab) biar SSH gak nanya interaktif
-    - ssh-keyscan -H "$SERVER_IP" >> ~/.ssh/known_hosts
-    - ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
+  # khusus push ke branch env
+  - local: "ci/development.yml"
+    rules:
+      - if: '$CI_COMMIT_BRANCH == "development"'
 
-  script:
-    - echo "🚀 Deploying latest code to $SERVER_USER@$SERVER_IP"
+  - local: "ci/staging.yml"
+    rules:
+      - if: '$CI_COMMIT_BRANCH == "staging"'
 
-    - >
-      if ssh -o StrictHostKeyChecking=no "$SERVER_USER@$SERVER_IP" "
-        set -e
-
-        cd /home/devops/docker/deployment/development/lti-api
-
-        # Pastikan remote origin SSH (antisipasi kalau pernah ke-set HTTPS)
-        git remote set-url origin git@gitlab.com:mbugroup/lti-api.git
-
-        # Pastikan server percaya gitlab.com juga (untuk git fetch via SSH)
-        mkdir -p ~/.ssh
-        ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
-
-        # Fetch/reset pakai SSH
-        GIT_SSH_COMMAND='ssh -o StrictHostKeyChecking=no' git fetch origin development
-        git reset --hard origin/development
-
-        docker compose restart dev-api-lti || docker compose up -d dev-api-lti
-      "; then
-        STATUS='success';
-      else
-        STATUS='failed';
-      fi;
-
-      RUN_URL="${CI_PROJECT_URL}/-/pipelines/${CI_PIPELINE_ID}";
-
-      if [ "$STATUS" = "success" ]; then
-        COLOR=3066993;
-        TITLE="✅ Deployment API Succeeded";
-        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` completed successfully.";
-      else
-        COLOR=15158332;
-        TITLE="❌ Deployment API Failed Gaes";
-        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` failed.";
-      fi;
-
-      echo "{
-        \"username\": \"CI Bot\",
-        \"embeds\": [{
-          \"title\": \"$TITLE\",
-          \"description\": \"$DESC\",
-          \"color\": $COLOR,
-          \"fields\": [
-            {\"name\": \"Repository\", \"value\": \"${CI_PROJECT_PATH}\", \"inline\": true},
-            {\"name\": \"Actor\", \"value\": \"${GITLAB_USER_LOGIN}\", \"inline\": true},
-            {\"name\": \"Commit\", \"value\": \"${CI_COMMIT_SHA}\", \"inline\": false},
-            {\"name\": \"Pipeline\", \"value\": \"[Open run](${RUN_URL})\", \"inline\": false}
-          ]
-        }]
-      }" > payload.json;
-
-      echo "📡 Sending notification to Discord...";
-      curl -sS -H "Content-Type: application/json" \
-        -d @payload.json "$DISCORD_WEBHOOK_URL";
-
-  only:
-    - development
-
-  environment:
-    name: development
+  - local: "ci/production.yml"
+    rules:
+      - if: '$CI_COMMIT_BRANCH == "production"'

Dockerfile

@@ -1,20 +1,38 @@
-FROM golang:1.23-alpine
+# =========================
+# Builder stage
+# =========================
+FROM golang:1.23-alpine AS builder
 
-# Install dependensi dasar
-RUN apk add --no-cache git curl bash build-base
+RUN apk add --no-cache git ca-certificates tzdata
+WORKDIR /app
 
-# Install Air (pakai repo baru air-verse)
-RUN go install github.com/air-verse/air@v1.52.3
-
-WORKDIR /lti-api
-
-# Cache dependencies
 COPY go.mod go.sum ./
 RUN go mod download
 
-# Copy source code
 COPY . .
 
+# Build API binary
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
+    go build -trimpath -ldflags="-s -w" -o lti-api ./cmd/api
+
+# Build SEED binary (pastikan cmd/seed ada)
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
+    go build -trimpath -ldflags="-s -w" -o lti-seed ./cmd/seed
+
+# =========================
+# Runtime stage
+# =========================
+FROM alpine:3.20
+
+RUN apk add --no-cache ca-certificates tzdata curl bash postgresql-client \
+  && adduser -D -H -u 10001 appuser
+
+WORKDIR /app
+
+COPY --from=builder /app/lti-api /app/lti-api
+COPY --from=builder /app/lti-seed /app/lti-seed
+
+USER appuser
 EXPOSE 8081
 
-CMD ["air", "-c", ".air.toml"]
+CMD ["/app/lti-api"]

README.md

@@ -110,4 +110,4 @@ IT Development PT Mitra Berlian Unggas Group
 
 ## 📃 License
 
-This project is private. All rights reserved.
+> This project is private. All rights reserved.

ci/development.yml

@@ -0,0 +1,91 @@
+stages:
+  - deploy
+
+deploy-dev:
+  stage: deploy
+  image: alpine:3.20
+
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "development"'
+      when: on_success
+    - when: never
+
+  variables:
+    DEPLOY_APP: "LTI-MBUGROUP"
+    GIT_SUBMODULE_STRATEGY: recursive
+    GIT_DEPTH: "1"
+
+  before_script:
+    - echo "🧰 Installing dependencies..."
+    - apk update && apk add --no-cache openssh git curl bash
+
+    # Setup SSH di runner
+    - mkdir -p ~/.ssh
+    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' > ~/.ssh/id_rsa
+    - chmod 600 ~/.ssh/id_rsa
+    - eval "$(ssh-agent -s)"
+    - ssh-add ~/.ssh/id_rsa
+
+    # Trust host keys (server + gitlab) biar SSH gak nanya interaktif
+    - ssh-keyscan -H "$SERVER_IP" >> ~/.ssh/known_hosts
+    - ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
+
+  script:
+    - echo "🚀 Deploying latest code to $SERVER_USER@$SERVER_IP"
+    - >
+      if ssh -o StrictHostKeyChecking=no "$SERVER_USER@$SERVER_IP" "
+        set -e
+
+        cd /home/devops/docker/deployment/development/lti-api
+
+        # Pastikan remote origin SSH (antisipasi kalau pernah ke-set HTTPS)
+        git remote set-url origin git@gitlab.com:mbugroup/lti-api.git
+
+        # Pastikan server percaya gitlab.com juga (untuk git fetch via SSH)
+        mkdir -p ~/.ssh
+        ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
+
+        # Fetch/reset pakai SSH
+        GIT_SSH_COMMAND='ssh -o StrictHostKeyChecking=no' git fetch origin development
+        git reset --hard origin/development
+
+        docker compose restart dev-api-lti || docker compose up -d dev-api-lti
+      "; then
+        STATUS='success';
+      else
+        STATUS='failed';
+      fi;
+
+      RUN_URL="${CI_PROJECT_URL}/-/pipelines/${CI_PIPELINE_ID}";
+
+      if [ "$STATUS" = "success" ]; then
+        COLOR=3066993;
+        TITLE="✅ Deployment API Succeeded";
+        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` completed successfully.";
+      else
+        COLOR=15158332;
+        TITLE="❌ Deployment API Failed Gaes";
+        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` failed.";
+      fi;
+
+      echo "{
+        \"username\": \"CI Bot\",
+        \"embeds\": [{
+          \"title\": \"$TITLE\",
+          \"description\": \"$DESC\",
+          \"color\": $COLOR,
+          \"fields\": [
+            {\"name\": \"Repository\", \"value\": \"${CI_PROJECT_PATH}\", \"inline\": true},
+            {\"name\": \"Actor\", \"value\": \"${GITLAB_USER_LOGIN}\", \"inline\": true},
+            {\"name\": \"Commit\", \"value\": \"${CI_COMMIT_SHA}\", \"inline\": false},
+            {\"name\": \"Pipeline\", \"value\": \"[Open run](${RUN_URL})\", \"inline\": false}
+          ]
+        }]
+      }" > payload.json;
+
+      echo "📡 Sending notification to Discord...";
+      curl -sS -H "Content-Type: application/json" \
+        -d @payload.json "$DISCORD_WEBHOOK_URL";
+
+  environment:
+    name: development

ci/merge_request.yml

@@ -0,0 +1,48 @@
+stages:
+  - notify
+
+notify_discord_on_mr_request_main_dev:
+  stage: notify
+  image: alpine:3.20
+  rules:
+    # hanya MR yang target ke main atau development
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && ($CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main" || $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "development")'
+      when: on_success
+    - when: never
+
+  script:
+    - apk add --no-cache curl jq coreutils
+    - |
+      TIME_HUMAN="$(date '+%d/%m/%y, %H.%M')"
+      TIME_ISO="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+      TITLE="${CI_MERGE_REQUEST_TITLE}"
+      IID="!${CI_MERGE_REQUEST_IID}"
+      USER_LINE="${GITLAB_USER_NAME} (${GITLAB_USER_LOGIN})"
+      PROJECT_PATH="${CI_PROJECT_PATH}"
+      USERNAME="${GITLAB_USER_LOGIN}"
+      MR_URL="${CI_PROJECT_URL}/-/merge_requests/${CI_MERGE_REQUEST_IID}"
+
+      DESC="$(printf "**%s**\n\n%s opened merge request %s %s\n%s" \
+        "$USERNAME" "$USER_LINE" "$IID" "$TITLE" "$TIME_HUMAN")"
+
+      payload=$(jq -n \
+        --arg desc "$DESC" \
+        --arg project "$PROJECT_PATH" \
+        --arg timeiso "$TIME_ISO" \
+        --arg mrurl "$MR_URL" \
+        '{
+          "username": "Mock-api - Merge Requests",
+          "embeds": [
+            {
+              "description": ($desc + "\n" + $mrurl),
+              "color": 15105570,
+              "footer": { "text": $project },
+              "timestamp": $timeiso
+            }
+          ]
+        }')
+
+      curl -sS -H "Content-Type: application/json" \
+        -d "$payload" \
+        "$DISCORD_WEBHOOK_URL"

ci/production.yml

@@ -0,0 +1,155 @@
+stages:
+  - build
+  - migrate
+  - deploy
+  - seed
+
+default:
+  tags:
+    - self-hosted-prod
+
+variables:
+  DOCKER_BUILDKIT: "1"
+
+  IMAGE_TAG: "production_${CI_COMMIT_SHORT_SHA}"
+  IMAGE_NAME: "${CI_REGISTRY_IMAGE}:${IMAGE_TAG}"
+  IMAGE_LATEST: "${CI_REGISTRY_IMAGE}:production_latest"
+
+  DEPLOY_DIR: "/opt/deploy/lti"
+  COMPOSE_FILE: "docker-compose.yaml"
+
+# =========================
+# BUILD (AUTO)
+# =========================
+build_production:
+  stage: build
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: on_success
+    - when: never
+  script: |
+    set -e
+    docker info
+
+    echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+
+    echo "✅ Build image: $IMAGE_NAME"
+    docker build -t "$IMAGE_NAME" -f Dockerfile .
+
+    echo "✅ Push image: $IMAGE_NAME"
+    docker push "$IMAGE_NAME"
+
+    echo "✅ Tag latest: $IMAGE_LATEST"
+    docker tag "$IMAGE_NAME" "$IMAGE_LATEST"
+    docker push "$IMAGE_LATEST"
+
+# =========================
+# MIGRATE (PRODUCTION)
+# =========================
+migrate_production:
+  stage: migrate
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: on_success
+    - when: never
+  needs:
+    - job: build_production
+      artifacts: false
+  script: |
+    set -e
+    echo "✅ Running migrations (production) ..."
+
+    cd "$DEPLOY_DIR"
+    test -f "$COMPOSE_FILE" || (echo "❌ $COMPOSE_FILE not found in $DEPLOY_DIR" && exit 1)
+    test -f .env || (echo "❌ .env not found in $DEPLOY_DIR" && exit 1)
+
+    set -a
+    . ./.env
+    set +a
+
+    test -n "$DB_HOST" || (echo "❌ DB_HOST empty" && exit 1)
+    test -n "$DB_PORT" || (echo "❌ DB_PORT empty" && exit 1)
+    test -n "$DB_USER" || (echo "❌ DB_USER empty" && exit 1)
+    test -n "$DB_PASSWORD" || (echo "❌ DB_PASSWORD empty" && exit 1)
+    test -n "$DB_NAME" || (echo "❌ DB_NAME empty" && exit 1)
+
+    export DATABASE_URL="postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?sslmode=${DB_SSLMODE:-disable}"
+    echo "✅ DATABASE_URL=$DATABASE_URL"
+
+    # NOTE: pastikan nama servicenya benar untuk production (ini sebelumnya masih stg-*)
+    docker compose -f "$COMPOSE_FILE" up -d stg-postgres-lti stg-redis-lti || true
+
+    COMPOSE_NETWORK_KEY="$(docker compose -f "$COMPOSE_FILE" config | awk '/networks:/ {getline; print $1}' | tr -d ':')"
+    NETWORK_NAME="$(docker network ls --format '{{.Name}}' | grep "_${COMPOSE_NETWORK_KEY}$" | head -n 1)"
+    test -n "$NETWORK_NAME" || (echo "❌ Cannot find docker network for compose ($COMPOSE_NETWORK_KEY)" && exit 1)
+
+    echo "✅ Checking migrations from repo..."
+    ls -lah "$CI_PROJECT_DIR/internal/database/migrations"
+
+    echo "✅ Running migrations via migrate/migrate container"
+    set +e
+    out=$(docker run --rm \
+      --network "$NETWORK_NAME" \
+      -v "$CI_PROJECT_DIR/internal/database/migrations:/migrations:ro" \
+      migrate/migrate:v4.15.2 \
+      -path=/migrations -database "$DATABASE_URL" up 2>&1)
+    code=$?
+    set -e
+
+    echo "$out"
+
+    if echo "$out" | grep -qi "no change"; then
+      echo "✅ No change (already up to date)"
+      exit 0
+    fi
+
+    if [ $code -ne 0 ]; then
+      echo "❌ Migration failed with exit code $code"
+      exit $code
+    fi
+
+    echo "✅ Migration applied successfully"
+
+# =========================
+# DEPLOY (AUTO)
+# =========================
+deploy_production:
+  stage: deploy
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: on_success
+    - when: never
+  needs:
+    - job: build_production
+      artifacts: false
+  script: |
+    set -e
+    docker info
+    echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+
+    cd "$DEPLOY_DIR"
+    test -f "$COMPOSE_FILE" || (echo "❌ $COMPOSE_FILE not found in $DEPLOY_DIR" && exit 1)
+    test -f .env || (echo "❌ .env not found in $DEPLOY_DIR" && exit 1)
+
+    docker compose -f "$COMPOSE_FILE" pull
+    docker compose -f "$COMPOSE_FILE" up -d --force-recreate
+    docker image prune -f
+
+# =========================
+# SEED (MANUAL)
+# =========================
+seed_production:
+  stage: seed
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: manual
+    - when: never
+  script: |
+    set -e
+    cd "$DEPLOY_DIR"
+    test -f .env || (echo "❌ .env not found" && exit 1)
+
+    echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+
+    docker compose --env-file .env pull seed
+    docker compose --env-file .env run --rm seed

ci/staging.yml

@@ -0,0 +1,164 @@
+stages:
+  - build
+  - migrate
+  - deploy
+  - seed
+
+default:
+  tags:
+    - self-hosted-stg
+
+variables:
+  DOCKER_BUILDKIT: "1"
+
+  IMAGE_TAG: "staging_${CI_COMMIT_SHORT_SHA}"
+  IMAGE_NAME: "${CI_REGISTRY_IMAGE}:${IMAGE_TAG}"
+  IMAGE_LATEST: "${CI_REGISTRY_IMAGE}:staging_latest"
+
+  DEPLOY_DIR: "/opt/deploy/stg-lti-api"
+  COMPOSE_FILE: "docker-compose.yaml"
+
+# =========================
+# BUILD (AUTO)
+# =========================
+build_staging:
+  stage: build
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: on_success
+    - when: never
+  script: |
+    set -e
+    docker info
+
+    echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+
+    echo "✅ Build image: $IMAGE_NAME"
+    docker build -t "$IMAGE_NAME" -f Dockerfile .
+
+    echo "✅ Push image: $IMAGE_NAME"
+    docker push "$IMAGE_NAME"
+
+    echo "✅ Tag latest: $IMAGE_LATEST"
+    docker tag "$IMAGE_NAME" "$IMAGE_LATEST"
+    docker push "$IMAGE_LATEST"
+
+# =========================
+# MIGRATE (AUTO)
+# =========================
+migrate_staging:
+  stage: migrate
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: on_success
+    - when: never
+  needs:
+    - job: build_staging
+      artifacts: false
+  script: |
+    set -e
+    echo "✅ Running migrations (staging) ..."
+
+    cd "$DEPLOY_DIR"
+    test -f "$COMPOSE_FILE" || (echo "❌ $COMPOSE_FILE not found in $DEPLOY_DIR" && exit 1)
+    test -f .env || (echo "❌ .env not found in $DEPLOY_DIR" && exit 1)
+
+    set -a
+    . ./.env
+    set +a
+
+    test -n "$DB_HOST" || (echo "❌ DB_HOST empty" && exit 1)
+    test -n "$DB_PORT" || (echo "❌ DB_PORT empty" && exit 1)
+    test -n "$DB_USER" || (echo "❌ DB_USER empty" && exit 1)
+    test -n "$DB_PASSWORD" || (echo "❌ DB_PASSWORD empty" && exit 1)
+    test -n "$DB_NAME" || (echo "❌ DB_NAME empty" && exit 1)
+
+    export DATABASE_URL="postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?sslmode=${DB_SSLMODE:-disable}"
+    echo "✅ DATABASE_URL=$DATABASE_URL"
+
+    echo "✅ Ensuring postgres & redis running ..."
+    docker compose -f "$COMPOSE_FILE" up -d stg-postgres-lti stg-redis-lti || true
+
+    COMPOSE_NETWORK_KEY="$(docker compose -f "$COMPOSE_FILE" config | awk '/networks:/ {getline; print $1}' | tr -d ':')"
+    echo "✅ Compose network key: $COMPOSE_NETWORK_KEY"
+
+    NETWORK_NAME="$(docker network ls --format '{{.Name}}' | grep "_${COMPOSE_NETWORK_KEY}$" | head -n 1)"
+    test -n "$NETWORK_NAME" || (echo "❌ Cannot find docker network for compose ($COMPOSE_NETWORK_KEY)" && exit 1)
+
+    echo "✅ Docker network detected: $NETWORK_NAME"
+
+    echo "✅ Checking migrations from repo..."
+    ls -lah "$CI_PROJECT_DIR/internal/database/migrations"
+
+    echo "✅ Running migrations via migrate/migrate container"
+    set +e
+    out=$(docker run --rm \
+      --network "$NETWORK_NAME" \
+      -v "$CI_PROJECT_DIR/internal/database/migrations:/migrations:ro" \
+      migrate/migrate:v4.15.2 \
+      -path=/migrations -database "$DATABASE_URL" up 2>&1)
+    code=$?
+    set -e
+
+    echo "$out"
+
+    if echo "$out" | grep -qi "no change"; then
+      echo "✅ No change (already up to date)"
+      exit 0
+    fi
+
+    if [ $code -ne 0 ]; then
+      echo "❌ Migration failed with exit code $code"
+      exit $code
+    fi
+
+    echo "✅ Migration applied successfully"
+
+# =========================
+# DEPLOY (AUTO)
+# =========================
+deploy_staging:
+  stage: deploy
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: on_success
+    - when: never
+  needs:
+    - job: migrate_staging
+      artifacts: false
+    - job: build_staging
+      artifacts: false
+  script: |
+    set -e
+    docker info
+    echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+
+    cd "$DEPLOY_DIR"
+    test -f "$COMPOSE_FILE" || (echo "❌ $COMPOSE_FILE not found in $DEPLOY_DIR" && exit 1)
+    test -f .env || (echo "❌ .env not found in $DEPLOY_DIR" && exit 1)
+
+    docker compose -f "$COMPOSE_FILE" pull
+    docker compose -f "$COMPOSE_FILE" up -d --force-recreate
+    docker image prune -f
+
+# =========================
+# SEED (MANUAL)
+# =========================
+seed_staging:
+  stage: seed
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: manual
+    - when: never
+  needs:
+    - job: deploy_staging
+      artifacts: false
+  allow_failure: false
+  script: |
+    set -e
+    cd "$DEPLOY_DIR"
+    test -f "$COMPOSE_FILE" || (echo "❌ $COMPOSE_FILE not found" && exit 1)
+    test -f .env || (echo "❌ .env not found" && exit 1)
+
+    docker compose -f "$COMPOSE_FILE" pull seed || true
+    docker compose -f "$COMPOSE_FILE" run --rm seed

cmd/api/main.go

@@ -14,8 +14,8 @@ import (
 	"gitlab.com/mbugroup/lti-api.git/internal/database"
 	"gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/sso/session"
+	sso "gitlab.com/mbugroup/lti-api.git/internal/modules/sso/verifier"
 	"gitlab.com/mbugroup/lti-api.git/internal/route"
-	"gitlab.com/mbugroup/lti-api.git/internal/sso"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 
 	"github.com/gofiber/fiber/v2"

cmd/delete-adjustments/main.go

@@ -0,0 +1,407 @@
+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"`
+	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)
+
+	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
+		}
+
+		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,
+					AsOf:               &adj.CreatedAt,
+					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=reflow_to_zero+delete\n",
+				adj.ID,
+				route.FunctionCode,
+				adj.TotalQty,
+				removeQty,
+			)
+
+			if !apply {
+				skipped++
+				continue
+			}
+
+			err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+				if err := tx.WithContext(ctx).
+					Table("adjustment_stocks").
+					Where("id = ?", adj.ID).
+					Updates(map[string]any{
+						"total_qty":  0,
+						"total_used": 0,
+					}).Error; err != nil {
+					return fmt.Errorf("set stockable qty to zero: %w", err)
+				}
+
+				reflowReq := commonSvc.FifoStockV2ReflowRequest{
+					FlagGroupCode:      route.FlagGroupCode,
+					ProductWarehouseID: adj.ProductWarehouseID,
+					AsOf:               &adj.CreatedAt,
+					IdempotencyKey:     fmt.Sprintf("delete-adjustment-stockable-%d-%d", adj.ID, time.Now().UnixNano()),
+					Tx:                 tx,
+				}
+				if _, err := fifoStockV2Svc.Reflow(ctx, reflowReq); err != nil {
+					return fmt.Errorf("reflow stockable to zero: %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 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).
+		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
+		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).
+		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
+		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 = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationPurposeConsume).
+		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 = ? AND allocation_purpose = ?", stockableType, stockableID, entity.StockAllocationPurposeConsume).
+		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,333 @@
+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
+		}
+
+		activeAllocationCount, err := countActiveAllocations(ctx, db, fifo.UsableKeyAdjustmentOut.String(), 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,
+			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).
+		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
+		Count(&count).Error
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}

cmd/reflow-project-flock-kandang/main.go

@@ -0,0 +1,648 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"sort"
+	"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 productWarehouseScopeRow struct {
+	ProductWarehouseID    uint  `gorm:"column:product_warehouse_id"`
+	ProductID             uint  `gorm:"column:product_id"`
+	WarehouseID           uint  `gorm:"column:warehouse_id"`
+	ProjectFlockKandangID *uint `gorm:"column:project_flock_kandang_id"`
+}
+
+type reflowTarget struct {
+	ProductWarehouseID    uint
+	ProductID             uint
+	WarehouseID           uint
+	ProjectFlockKandangID *uint
+	FlagGroupCode         string
+}
+
+func main() {
+	var (
+		projectFlockKandangID uint
+		apply                 bool
+		asOfRaw               string
+		includeShared         bool
+	)
+
+	flag.UintVar(&projectFlockKandangID, "project-flock-kandang-id", 0, "Project flock kandang ID (required)")
+	flag.BoolVar(&apply, "apply", false, "Apply reflow. If false, run as dry-run")
+	flag.StringVar(&asOfRaw, "as-of", "", "Optional AsOf boundary. Format: RFC3339 or YYYY-MM-DD")
+	flag.BoolVar(&includeShared, "include-shared", true, "Include product warehouses referenced by transactions in this PFK scope (including shared/non-bound product warehouses)")
+	flag.Parse()
+
+	if projectFlockKandangID == 0 {
+		log.Fatal("--project-flock-kandang-id is required")
+	}
+
+	asOf, err := parseAsOf(asOfRaw)
+	if err != nil {
+		log.Fatalf("invalid --as-of: %v", err)
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
+
+	exists, err := projectFlockKandangExists(ctx, db, projectFlockKandangID)
+	if err != nil {
+		log.Fatalf("failed to check project flock kandang: %v", err)
+	}
+	if !exists {
+		log.Fatalf("project_flock_kandang_id %d not found", projectFlockKandangID)
+	}
+
+	scopedPWs, err := loadScopedProductWarehouses(ctx, db, projectFlockKandangID, includeShared)
+	if err != nil {
+		log.Fatalf("failed to load scoped product warehouses: %v", err)
+	}
+	if len(scopedPWs) == 0 {
+		fmt.Printf("Mode: %s\n", modeLabel(apply))
+		fmt.Printf("Scope: project_flock_kandang_id=%d\n", projectFlockKandangID)
+		fmt.Println("No product warehouse found in scope")
+		return
+	}
+
+	targets := make([]reflowTarget, 0, len(scopedPWs))
+	skippedPW := 0
+	failedResolve := 0
+
+	for _, pw := range scopedPWs {
+		flagGroups, err := resolveFlagGroupsByProductWarehouse(ctx, db, pw.ProductWarehouseID)
+		if err != nil {
+			fmt.Printf("FAIL pw=%d error=resolve flag groups: %v\n", pw.ProductWarehouseID, err)
+			failedResolve++
+			continue
+		}
+		if len(flagGroups) == 0 {
+			fmt.Printf("SKIP pw=%d reason=no active fifo v2 route by product flag\n", pw.ProductWarehouseID)
+			skippedPW++
+			continue
+		}
+		for _, group := range flagGroups {
+			targets = append(targets, reflowTarget{
+				ProductWarehouseID:    pw.ProductWarehouseID,
+				ProductID:             pw.ProductID,
+				WarehouseID:           pw.WarehouseID,
+				ProjectFlockKandangID: pw.ProjectFlockKandangID,
+				FlagGroupCode:         group,
+			})
+		}
+	}
+
+	sort.Slice(targets, func(i, j int) bool {
+		if targets[i].ProductWarehouseID == targets[j].ProductWarehouseID {
+			return targets[i].FlagGroupCode < targets[j].FlagGroupCode
+		}
+		return targets[i].ProductWarehouseID < targets[j].ProductWarehouseID
+	})
+
+	fmt.Printf("Mode: %s\n", modeLabel(apply))
+	fmt.Printf("Scope: project_flock_kandang_id=%d include_shared=%t\n", projectFlockKandangID, includeShared)
+	if asOf != nil {
+		fmt.Printf("AsOf: %s\n", asOf.UTC().Format(time.RFC3339))
+	} else {
+		fmt.Println("AsOf: <nil> (full timeline)")
+	}
+	fmt.Printf("Product warehouses in scope: %d\n", len(scopedPWs))
+	fmt.Printf("Planned reflow targets: %d\n\n", len(targets))
+
+	for _, target := range targets {
+		fmt.Printf(
+			"PLAN pw=%d product=%d warehouse=%d pw_pfk=%s flag_group=%s\n",
+			target.ProductWarehouseID,
+			target.ProductID,
+			target.WarehouseID,
+			displayOptionalUint(target.ProjectFlockKandangID),
+			target.FlagGroupCode,
+		)
+	}
+
+	if !apply {
+		fmt.Println()
+		fmt.Printf("Summary: planned=%d skipped_pw=%d failed_resolve=%d applied=0 failed_apply=0\n", len(targets), skippedPW, failedResolve)
+		if failedResolve > 0 {
+			os.Exit(1)
+		}
+		return
+	}
+
+	successApply := 0
+	failedApply := 0
+	for idx, target := range targets {
+		req := commonSvc.FifoStockV2ReflowRequest{
+			FlagGroupCode:      target.FlagGroupCode,
+			ProductWarehouseID: target.ProductWarehouseID,
+			AsOf:               asOf,
+			IdempotencyKey: fmt.Sprintf(
+				"manual-pfk-reflow-%d-%d-%s-%d-%d",
+				projectFlockKandangID,
+				target.ProductWarehouseID,
+				strings.ToUpper(strings.TrimSpace(target.FlagGroupCode)),
+				time.Now().UnixNano(),
+				idx,
+			),
+		}
+
+		res, err := fifoStockV2Svc.Reflow(ctx, req)
+		if err != nil {
+			fmt.Printf("FAIL pw=%d flag_group=%s error=%v\n", target.ProductWarehouseID, target.FlagGroupCode, err)
+			failedApply++
+			continue
+		}
+
+		fmt.Printf(
+			"DONE pw=%d flag_group=%s rollback=%.3f allocate=%.3f pending=%.3f processed_usable=%d\n",
+			target.ProductWarehouseID,
+			target.FlagGroupCode,
+			res.Rollback.ReleasedQty,
+			res.Allocate.AllocatedQty,
+			res.Allocate.PendingQty,
+			res.ProcessedUsables,
+		)
+		successApply++
+	}
+
+	orphanPopulationRows := int64(0)
+	syncedPopulationQtyRows := int64(0)
+	syncedPopulationUsedRows := int64(0)
+	traceReleasedRows := int64(0)
+	traceInsertedRows := int64(0)
+	if rowsOrphan, rowsQty, rowsUsed, err := resyncProjectFlockPopulation(ctx, db, projectFlockKandangID); err != nil {
+		fmt.Printf("FAIL population_resync project_flock_kandang_id=%d error=%v\n", projectFlockKandangID, err)
+		failedApply++
+	} else {
+		orphanPopulationRows = rowsOrphan
+		syncedPopulationQtyRows = rowsQty
+		syncedPopulationUsedRows = rowsUsed
+		fmt.Printf(
+			"SYNC project_flock_populations orphan_marked=%d qty_synced=%d used_synced=%d\n",
+			orphanPopulationRows,
+			syncedPopulationQtyRows,
+			syncedPopulationUsedRows,
+		)
+	}
+
+	if released, inserted, err := resyncChickinTraceByProjectFlockKandang(ctx, db, fifoStockV2Svc, projectFlockKandangID); err != nil {
+		fmt.Printf("FAIL chickin_trace_resync project_flock_kandang_id=%d error=%v\n", projectFlockKandangID, err)
+		failedApply++
+	} else {
+		traceReleasedRows = released
+		traceInsertedRows = inserted
+		fmt.Printf(
+			"SYNC chickin_trace released=%d inserted=%d\n",
+			traceReleasedRows,
+			traceInsertedRows,
+		)
+	}
+
+	fmt.Println()
+	fmt.Printf(
+		"Summary: planned=%d skipped_pw=%d failed_resolve=%d applied=%d failed_apply=%d population_orphan=%d population_qty_synced=%d population_used_synced=%d trace_released=%d trace_inserted=%d\n",
+		len(targets),
+		skippedPW,
+		failedResolve,
+		successApply,
+		failedApply,
+		orphanPopulationRows,
+		syncedPopulationQtyRows,
+		syncedPopulationUsedRows,
+		traceReleasedRows,
+		traceInsertedRows,
+	)
+	if failedResolve > 0 || failedApply > 0 {
+		os.Exit(1)
+	}
+}
+
+func parseAsOf(raw string) (*time.Time, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, nil
+	}
+
+	layouts := []string{
+		time.RFC3339Nano,
+		time.RFC3339,
+		"2006-01-02 15:04:05",
+		"2006-01-02",
+	}
+
+	for _, layout := range layouts {
+		parsed, err := time.Parse(layout, raw)
+		if err != nil {
+			continue
+		}
+		if layout == "2006-01-02" {
+			endOfDay := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 23, 59, 59, int(time.Second-time.Nanosecond), time.UTC)
+			return &endOfDay, nil
+		}
+		asOf := parsed.UTC()
+		return &asOf, nil
+	}
+
+	return nil, fmt.Errorf("unsupported format %q", raw)
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY-RUN"
+}
+
+func displayOptionalUint(v *uint) string {
+	if v == nil {
+		return "NULL"
+	}
+	return fmt.Sprintf("%d", *v)
+}
+
+func projectFlockKandangExists(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (bool, error) {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("project_flock_kandangs").
+		Where("id = ?", projectFlockKandangID).
+		Count(&count).Error
+	if err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+func loadScopedProductWarehouses(ctx context.Context, db *gorm.DB, projectFlockKandangID uint, includeShared bool) ([]productWarehouseScopeRow, error) {
+	if !includeShared {
+		var rows []productWarehouseScopeRow
+		err := db.WithContext(ctx).
+			Table("product_warehouses").
+			Select("id AS product_warehouse_id, product_id, warehouse_id, project_flock_kandang_id").
+			Where("project_flock_kandang_id = ?", projectFlockKandangID).
+			Order("id ASC").
+			Scan(&rows).Error
+		if err != nil {
+			return nil, err
+		}
+		return rows, nil
+	}
+
+	query := `
+		WITH scoped_pw AS (
+			SELECT pw.id AS product_warehouse_id
+			FROM product_warehouses pw
+			WHERE pw.project_flock_kandang_id = ?
+
+			UNION
+			SELECT pc.product_warehouse_id
+			FROM project_chickins pc
+			WHERE pc.project_flock_kandang_id = ?
+				AND pc.deleted_at IS NULL
+
+			UNION
+			SELECT rs.product_warehouse_id
+			FROM recordings r
+			JOIN recording_stocks rs ON rs.recording_id = r.id
+			WHERE r.project_flock_kandangs_id = ?
+				AND r.deleted_at IS NULL
+
+			UNION
+			SELECT rd.product_warehouse_id
+			FROM recordings r
+			JOIN recording_depletions rd ON rd.recording_id = r.id
+			WHERE r.project_flock_kandangs_id = ?
+				AND r.deleted_at IS NULL
+
+			UNION
+			SELECT rd.source_product_warehouse_id
+			FROM recordings r
+			JOIN recording_depletions rd ON rd.recording_id = r.id
+			WHERE r.project_flock_kandangs_id = ?
+				AND r.deleted_at IS NULL
+				AND rd.source_product_warehouse_id IS NOT NULL
+
+			UNION
+			SELECT re.product_warehouse_id
+			FROM recordings r
+			JOIN recording_eggs re ON re.recording_id = r.id
+			WHERE r.project_flock_kandangs_id = ?
+				AND r.deleted_at IS NULL
+
+			UNION
+			SELECT lts.product_warehouse_id
+			FROM laying_transfer_sources lts
+			WHERE lts.source_project_flock_kandang_id = ?
+				AND lts.deleted_at IS NULL
+				AND lts.product_warehouse_id IS NOT NULL
+
+			UNION
+			SELECT ltt.product_warehouse_id
+			FROM laying_transfer_targets ltt
+			WHERE ltt.target_project_flock_kandang_id = ?
+				AND ltt.deleted_at IS NULL
+				AND ltt.product_warehouse_id IS NOT NULL
+
+			UNION
+			SELECT pi.product_warehouse_id
+			FROM purchase_items pi
+			WHERE pi.project_flock_kandang_id = ?
+				AND pi.product_warehouse_id IS NOT NULL
+		)
+		SELECT DISTINCT
+			pw.id AS product_warehouse_id,
+			pw.product_id,
+			pw.warehouse_id,
+			pw.project_flock_kandang_id
+		FROM scoped_pw s
+		JOIN product_warehouses pw ON pw.id = s.product_warehouse_id
+		ORDER BY pw.id ASC
+	`
+
+	var rows []productWarehouseScopeRow
+	err := db.WithContext(ctx).
+		Raw(
+			query,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+			projectFlockKandangID,
+		).
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func resolveFlagGroupsByProductWarehouse(ctx context.Context, db *gorm.DB, productWarehouseID uint) ([]string, error) {
+	var groups []string
+	err := db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules rr").
+		Select("DISTINCT rr.flag_group_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(`
+			EXISTS (
+				SELECT 1
+				FROM product_warehouses pw
+				JOIN flags f ON 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 = ?
+					AND f.flagable_type = ?
+					AND fm.flag_group_code = rr.flag_group_code
+			)
+		`, productWarehouseID, entity.FlagableTypeProduct).
+		Order("rr.flag_group_code ASC").
+		Scan(&groups).Error
+	if err != nil {
+		return nil, err
+	}
+	return groups, nil
+}
+
+func resyncProjectFlockPopulation(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (int64, int64, int64, error) {
+	if projectFlockKandangID == 0 {
+		return 0, 0, 0, nil
+	}
+
+	orphanResult := db.WithContext(ctx).Exec(`
+		UPDATE project_flock_populations pfp
+		SET deleted_at = NOW(),
+			updated_at = NOW()
+		FROM project_chickins pc
+		WHERE pfp.project_chickin_id = pc.id
+		  AND pc.project_flock_kandang_id = ?
+		  AND pc.deleted_at IS NOT NULL
+		  AND pfp.deleted_at IS NULL
+	`, projectFlockKandangID)
+	if orphanResult.Error != nil {
+		return 0, 0, 0, orphanResult.Error
+	}
+
+	qtyResult := db.WithContext(ctx).Exec(`
+		UPDATE project_flock_populations p
+		SET total_qty = GREATEST(COALESCE(pc.usage_qty, 0), 0),
+			updated_at = NOW()
+		FROM project_chickins pc
+		WHERE p.project_chickin_id = pc.id
+		  AND pc.project_flock_kandang_id = ?
+		  AND pc.deleted_at IS NULL
+		  AND p.deleted_at IS NULL
+	`, projectFlockKandangID)
+	if qtyResult.Error != nil {
+		return 0, 0, 0, qtyResult.Error
+	}
+
+	usedResult := db.WithContext(ctx).Exec(`
+		WITH scoped AS (
+			SELECT pfp.id, pfp.total_qty
+			FROM project_flock_populations pfp
+			JOIN project_chickins pc ON pc.id = pfp.project_chickin_id
+			WHERE pc.project_flock_kandang_id = ?
+			  AND pc.deleted_at IS NULL
+			  AND pfp.deleted_at IS NULL
+		),
+		alloc AS (
+			SELECT sa.stockable_id, SUM(sa.qty) AS used_qty
+			FROM stock_allocations sa
+			WHERE sa.stockable_type = 'PROJECT_FLOCK_POPULATION'
+			  AND sa.status = 'ACTIVE'
+				  AND sa.allocation_purpose = 'CONSUME'
+				GROUP BY sa.stockable_id
+			)
+		UPDATE project_flock_populations p
+		SET total_used_qty = LEAST(COALESCE(a.used_qty, 0), GREATEST(s.total_qty, 0)),
+			updated_at = NOW()
+		FROM scoped s
+		LEFT JOIN alloc a ON a.stockable_id = s.id
+		WHERE p.id = s.id
+	`, projectFlockKandangID)
+	if usedResult.Error != nil {
+		return 0, 0, 0, usedResult.Error
+	}
+
+	return orphanResult.RowsAffected, qtyResult.RowsAffected, usedResult.RowsAffected, nil
+}
+func resyncChickinTraceByProjectFlockKandang(
+	ctx context.Context,
+	db *gorm.DB,
+	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	projectFlockKandangID uint,
+) (int64, int64, error) {
+	if projectFlockKandangID == 0 {
+		return 0, 0, nil
+	}
+
+	var productWarehouseIDs []uint
+	if err := db.WithContext(ctx).
+		Table("project_chickins").
+		Distinct("product_warehouse_id").
+		Where("project_flock_kandang_id = ?", projectFlockKandangID).
+		Where("deleted_at IS NULL").
+		Order("product_warehouse_id ASC").
+		Pluck("product_warehouse_id", &productWarehouseIDs).Error; err != nil {
+		return 0, 0, err
+	}
+	if len(productWarehouseIDs) == 0 {
+		return 0, 0, nil
+	}
+
+	totalReleased := int64(0)
+	totalInserted := int64(0)
+
+	for _, productWarehouseID := range productWarehouseIDs {
+		var releasedRows int64
+		var insertedRows int64
+
+		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+			flagGroups, err := resolveFlagGroupsByProductWarehouse(ctx, tx, productWarehouseID)
+			if err != nil {
+				return err
+			}
+			if len(flagGroups) == 0 {
+				return nil
+			}
+			flagGroupCode := strings.TrimSpace(flagGroups[0])
+			if flagGroupCode == "" {
+				return nil
+			}
+
+			released := tx.WithContext(ctx).
+				Table("stock_allocations").
+				Where("product_warehouse_id = ?", productWarehouseID).
+				Where("usable_type = ?", fifo.UsableKeyProjectChickin.String()).
+				Where("allocation_purpose = ?", entity.StockAllocationPurposeTraceChickin).
+				Where("status = ?", entity.StockAllocationStatusActive).
+				Updates(map[string]any{
+					"status":      entity.StockAllocationStatusReleased,
+					"released_at": time.Now(),
+					"updated_at":  time.Now(),
+					"note":        "chickin_trace_reflow_reset",
+				})
+			if released.Error != nil {
+				return released.Error
+			}
+			releasedRows = released.RowsAffected
+
+			type chickinRow struct {
+				ID       uint      `gorm:"column:id"`
+				UsageQty float64   `gorm:"column:usage_qty"`
+				ChickIn  time.Time `gorm:"column:chick_in_date"`
+			}
+			chickins := make([]chickinRow, 0)
+			if err := tx.WithContext(ctx).
+				Table("project_chickins").
+				Select("id, usage_qty, chick_in_date").
+				Where("product_warehouse_id = ?", productWarehouseID).
+				Where("deleted_at IS NULL").
+				Where("usage_qty > 0").
+				Order("chick_in_date ASC, id ASC").
+				Scan(&chickins).Error; err != nil {
+				return err
+			}
+			if len(chickins) == 0 {
+				return nil
+			}
+
+			gatherRows, err := fifoStockV2Svc.Gather(ctx, commonSvc.FifoStockV2GatherRequest{
+				FlagGroupCode:      flagGroupCode,
+				Lane:               "STOCKABLE",
+				AllocationPurpose:  entity.StockAllocationPurposeTraceChickin,
+				IgnoreSourceUsed:   true,
+				ProductWarehouseID: productWarehouseID,
+				Limit:              50000,
+				Tx:                 tx,
+			})
+			if err != nil {
+				return err
+			}
+			if len(gatherRows) == 0 {
+				return nil
+			}
+
+			type lotKey struct {
+				StockableType string
+				StockableID   uint
+			}
+			remainingByLot := make(map[lotKey]float64, len(gatherRows))
+			for _, row := range gatherRows {
+				key := lotKey{StockableType: row.Ref.LegacyTypeKey, StockableID: row.Ref.ID}
+				remainingByLot[key] = row.AvailableQuantity
+			}
+
+			now := time.Now()
+			lotIndex := 0
+			for _, chickinRow := range chickins {
+				remaining := chickinRow.UsageQty
+				for remaining > 1e-6 && lotIndex < len(gatherRows) {
+					lot := gatherRows[lotIndex]
+					key := lotKey{StockableType: lot.Ref.LegacyTypeKey, StockableID: lot.Ref.ID}
+					available := remainingByLot[key]
+					if available <= 1e-6 {
+						lotIndex++
+						continue
+					}
+
+					portion := math.Min(remaining, available)
+					if portion <= 1e-6 {
+						lotIndex++
+						continue
+					}
+
+					insert := map[string]any{
+						"product_warehouse_id": productWarehouseID,
+						"stockable_type":       lot.Ref.LegacyTypeKey,
+						"stockable_id":         lot.Ref.ID,
+						"usable_type":          fifo.UsableKeyProjectChickin.String(),
+						"usable_id":            chickinRow.ID,
+						"qty":                  portion,
+						"status":               entity.StockAllocationStatusActive,
+						"allocation_purpose":   entity.StockAllocationPurposeTraceChickin,
+						"engine_version":       "v2",
+						"flag_group_code":      flagGroupCode,
+						"function_code":        "CHICKIN_TRACE",
+						"created_at":           now,
+						"updated_at":           now,
+					}
+					if err := tx.WithContext(ctx).Table("stock_allocations").Create(insert).Error; err != nil {
+						return err
+					}
+
+					insertedRows++
+					remaining -= portion
+					remainingByLot[key] = available - portion
+				}
+			}
+
+			return nil
+		})
+		if err != nil {
+			return totalReleased, totalInserted, err
+		}
+
+		totalReleased += releasedRows
+		totalInserted += insertedRows
+	}
+
+	return totalReleased, totalInserted, nil
+}

cmd/validate-chickin-trace/main.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"math"
+	"os"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	"gorm.io/gorm"
+)
+
+type mismatchRow struct {
+	ChickinID           uint    `gorm:"column:chickin_id"`
+	ProjectFlockKandang uint    `gorm:"column:project_flock_kandang_id"`
+	ProductWarehouseID  uint    `gorm:"column:product_warehouse_id"`
+	UsageQty            float64 `gorm:"column:usage_qty"`
+	TraceQty            float64 `gorm:"column:trace_qty"`
+}
+
+func main() {
+	var projectFlockKandangID uint
+	flag.UintVar(&projectFlockKandangID, "project-flock-kandang-id", 0, "Optional project flock kandang scope")
+	flag.Parse()
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+
+	rows, err := loadTraceMismatches(ctx, db, projectFlockKandangID)
+	if err != nil {
+		log.Fatalf("failed to load trace mismatches: %v", err)
+	}
+
+	activeConsumeRows, err := countActiveConsumeProjectChickin(ctx, db, projectFlockKandangID)
+	if err != nil {
+		log.Fatalf("failed to count active consume rows: %v", err)
+	}
+
+	fmt.Printf("Scope project_flock_kandang_id=%d\n", projectFlockKandangID)
+	fmt.Printf("Mismatched chickin trace rows: %d\n", len(rows))
+	fmt.Printf("Active PROJECT_CHICKIN consume rows: %d\n", activeConsumeRows)
+
+	if len(rows) > 0 {
+		for _, row := range rows {
+			fmt.Printf(
+				"MISMATCH chickin_id=%d pfk=%d pw=%d usage=%.3f trace=%.3f diff=%.3f\n",
+				row.ChickinID,
+				row.ProjectFlockKandang,
+				row.ProductWarehouseID,
+				row.UsageQty,
+				row.TraceQty,
+				row.TraceQty-row.UsageQty,
+			)
+		}
+	}
+
+	if len(rows) > 0 || activeConsumeRows > 0 {
+		os.Exit(1)
+	}
+}
+
+func loadTraceMismatches(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) ([]mismatchRow, error) {
+	query := db.WithContext(ctx).
+		Table("project_chickins pc").
+		Select(`
+			pc.id AS chickin_id,
+			pc.project_flock_kandang_id,
+			pc.product_warehouse_id,
+			COALESCE(pc.usage_qty, 0) AS usage_qty,
+			COALESCE(SUM(sa.qty), 0) AS trace_qty
+		`).
+		Joins(`
+			LEFT JOIN stock_allocations sa
+				ON sa.usable_type = ?
+				AND sa.usable_id = pc.id
+				AND sa.status = 'ACTIVE'
+				AND sa.allocation_purpose = 'TRACE_CHICKIN'
+		`, fifo.UsableKeyProjectChickin.String()).
+		Where("pc.deleted_at IS NULL").
+		Where("COALESCE(pc.usage_qty,0) > 0").
+		Group("pc.id, pc.project_flock_kandang_id, pc.product_warehouse_id, pc.usage_qty")
+
+	if projectFlockKandangID > 0 {
+		query = query.Where("pc.project_flock_kandang_id = ?", projectFlockKandangID)
+	}
+
+	rows := make([]mismatchRow, 0)
+	if err := query.Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	out := make([]mismatchRow, 0, len(rows))
+	for _, row := range rows {
+		if math.Abs(row.TraceQty-row.UsageQty) > 1e-3 {
+			out = append(out, row)
+		}
+	}
+	return out, nil
+}
+
+func countActiveConsumeProjectChickin(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (int64, error) {
+	q := db.WithContext(ctx).
+		Table("stock_allocations sa").
+		Joins("JOIN project_chickins pc ON pc.id = sa.usable_id").
+		Where("sa.usable_type = ?", fifo.UsableKeyProjectChickin.String()).
+		Where("sa.status = 'ACTIVE'").
+		Where("sa.allocation_purpose = 'CONSUME'")
+
+	if projectFlockKandangID > 0 {
+		q = q.Where("pc.project_flock_kandang_id = ?", projectFlockKandangID)
+	}
+
+	var count int64
+	if err := q.Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}

docker-compose.local.yml

@@ -1,77 +0,0 @@
-services:
-  postgresdb:
-    image: postgres:alpine
-    restart: always
-    ports:
-      - "${DB_PORT_HOST:-5542}:5432"
-    environment:
-      POSTGRES_USER: ${DB_USER:-postgres}
-      POSTGRES_PASSWORD: ${DB_PASSWORD:-postgres}
-      POSTGRES_DB: ${DB_NAME:-db_lti_erp}
-    volumes:
-      - dbdata:/var/lib/postgresql/data
-      - ./internal/database/init:/docker-entrypoint-initdb.d
-    networks: [go-network]
-    healthcheck:
-      test:
-        [
-          "CMD-SHELL",
-          "pg_isready -U ${DB_USER:-postgres} -d ${DB_NAME:-db_lti_erp}",
-        ]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-  redis:
-    image: redis:7-alpine
-    restart: unless-stopped
-    ports:
-      - "${REDIS_PORT_HOST:-6381}:6379"
-    healthcheck:
-      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
-      interval: 5s
-      timeout: 3s
-      retries: 10
-    networks: [go-network]
-
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile.local
-    image: cosmtrek/air:v1.52.3
-    working_dir: /lti-api
-    volumes:
-      - .:/lti-api
-      - ./internal/config/jwtRS256.key:/run/keys/jwtRS256.key
-      - ./internal/config/jwtRS256.key.pub:/run/keys/jwtRS256.key.pub
-    command: air -c .air.toml
-    env_file:
-      - .env
-    environment:
-      DB_HOST: postgresdb
-      DB_PORT: 5432
-      DB_USER: ${DB_USER:-postgres}
-      DB_PASSWORD: ${DB_PASSWORD:-postgres}
-      DB_NAME: ${DB_NAME:-db_lti_erp}
-      REDIS_URL: ${REDIS_URL:-redis://redis:6379/0}
-    ports:
-      - "${APP_PORT:-8081}:8081"
-    depends_on:
-      postgresdb:
-        condition: service_healthy
-    networks: [go-network]
-    healthcheck:
-      test: ["CMD-SHELL", "wget -qO- http://localhost:8081/healthz || exit 1"]
-      interval: 10s
-      timeout: 3s
-      retries: 10
-      start_period: 10s
-
-volumes:
-  dbdata:
-  go-mod-cache:
-  go-build-cache:
-
-networks:
-  go-network:
-    name: lti-api_go-network
-    driver: bridge

docker-compose.yaml

@@ -1,98 +0,0 @@
-services:
-  dev-api-lti:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: dev-api-lti
-    working_dir: /lti-api
-    command: ["/bin/sh", "scripts/entrypoint.sh"]
-    ports:
-      - "8081:8081"
-    env_file:
-      - .env
-    environment:
-      # override agar koneksi ke container internal
-      DB_HOST: dev-postgres-lti
-      DB_PORT: 5432
-      REDIS_URL: redis://dev-redis-lti:6379/0
-    volumes:
-      - .:/lti-api
-      - ./.air.toml:/lti-api/.air.toml:ro
-      - ./internal/config/jwtRS256.key:/run/keys/jwtRS256.key
-      - ./internal/config/jwtRS256.key.pub:/run/keys/jwtRS256.key.pub
-    depends_on:
-      - dev-postgres-lti
-      - dev-redis-lti
-    networks:
-      - lti-network
-    healthcheck:
-      test: ["CMD-SHELL", "wget -qO- http://localhost:8081/healthz || exit 1"]
-      interval: 10s
-      timeout: 3s
-      retries: 10
-      start_period: 10s
-    deploy:
-      resources:
-        limits:
-          cpus: "2.0"
-          memory: 2G
-        reservations:
-          cpus: "1.0"
-          memory: 512M
-
-  dev-postgres-lti:
-    image: postgres:15-alpine
-    container_name: dev-postgres-lti
-    restart: always
-    env_file:
-      - credential/.env.db
-    ports:
-      - "5433:5432"
-    volumes:
-      - dev-postgres-lti-data:/var/lib/postgresql/data
-      - ./credential:/docker-entrypoint-initdb.d:ro
-    networks:
-      - lti-network
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-postgres} -d ${DB_NAME:-db_lti_erp}"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-      start_period: 5s
-    deploy:
-      resources:
-        limits:
-          cpus: "1.0"
-          memory: 2G
-        reservations:
-          cpus: "0.5"
-          memory: 512M
-
-  dev-redis-lti:
-    image: redis:7-alpine
-    container_name: dev-redis-lti
-    restart: always
-    ports:
-      - "6380:6379"
-    networks:
-      - lti-network
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 10s
-      timeout: 3s
-      retries: 10
-    deploy:
-      resources:
-        limits:
-          cpus: "0.5"
-          memory: 512M
-        reservations:
-          cpus: "0.2"
-          memory: 256M
-
-networks:
-  lti-network:
-    driver: bridge
-
-volumes:
-  dev-postgres-lti-data:

go.mod

@@ -16,9 +16,11 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.2.1
 	github.com/google/uuid v1.6.0
 	github.com/jackc/pgconn v1.14.1
+	github.com/jackc/pgx/v5 v5.5.5
 	github.com/redis/go-redis/v9 v9.14.0
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/viper v1.19.0
+	github.com/xuri/excelize/v2 v2.9.0
 	golang.org/x/crypto v0.33.0
 	gorm.io/driver/postgres v1.5.9
 	gorm.io/gorm v1.25.11
@@ -59,7 +61,6 @@ require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgproto3/v2 v2.3.2 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.5.5 // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
@@ -71,9 +72,12 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/philhofer/fwd v1.1.2 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/richardlehane/mscfb v1.0.4 // indirect
+	github.com/richardlehane/msoleps v1.0.4 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/rogpeppe/go-internal v1.11.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
@@ -82,12 +86,15 @@ require (
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/stretchr/testify v1.11.1 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/tinylib/msgp v1.1.8 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasthttp v1.55.0 // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
+	github.com/xuri/efp v0.0.0-20240408161823-9ad904a10d6d // indirect
+	github.com/xuri/nfp v0.0.0-20240318013403-ab9948c2c4a7 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect

go.sum

@@ -182,6 +182,8 @@ github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6T
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw=
@@ -195,6 +197,11 @@ github.com/redis/go-redis/v9 v9.14.0/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM=
+github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7gK3DypaEsUk=
+github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
+github.com/richardlehane/msoleps v1.0.4 h1:WuESlvhX3gH2IHcd8UqyCuFY5yiq/GR/yqaSM/9/g00=
+github.com/richardlehane/msoleps v1.0.4/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
@@ -238,8 +245,9 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/tinylib/msgp v1.1.8 h1:FCXC1xanKO4I8plpHGH2P7koL/RzZs12l/+r7vakfm0=
@@ -252,6 +260,12 @@ github.com/valyala/fasthttp v1.55.0 h1:Zkefzgt6a7+bVKHnu/YaYSOPfNYNisSVBo/unVCf8
 github.com/valyala/fasthttp v1.55.0/go.mod h1:NkY9JtkrpPKmgwV3HTaS2HWaJss9RSIsRVfcxxoHiOM=
 github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
 github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
+github.com/xuri/efp v0.0.0-20240408161823-9ad904a10d6d h1:llb0neMWDQe87IzJLS4Ci7psK/lVsjIS2otl+1WyRyY=
+github.com/xuri/efp v0.0.0-20240408161823-9ad904a10d6d/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
+github.com/xuri/excelize/v2 v2.9.0 h1:1tgOaEq92IOEumR1/JfYS/eR0KHOCsRv/rYXXh6YJQE=
+github.com/xuri/excelize/v2 v2.9.0/go.mod h1:uqey4QBZ9gdMeWApPLdhm9x+9o2lq4iVmjiLfBS5hdE=
+github.com/xuri/nfp v0.0.0-20240318013403-ab9948c2c4a7 h1:hPVCafDV85blFTabnqKgNhDCkJX25eik94Si9cTER4A=
+github.com/xuri/nfp v0.0.0-20240318013403-ab9948c2c4a7/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -278,6 +292,8 @@ golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
 golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
+golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

internal/common/repository/common.base.repository.go

@@ -187,10 +187,11 @@ func (r *BaseRepositoryImpl[T]) PatchOne(
 	updates map[string]any,
 	modifier func(*gorm.DB) *gorm.DB,
 ) error {
-	q := r.db.WithContext(ctx).Model(new(T)).Where("id = ?", id)
+	q := r.db.WithContext(ctx)
 	if modifier != nil {
 		q = modifier(q)
 	}
+	q = q.Model(new(T)).Where("id = ?", id)
 
 	result := q.Updates(updates)
 	if result.Error != nil {

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

@@ -0,0 +1,313 @@
+package repository
+
+import (
+	"context"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	"gorm.io/gorm"
+)
+
+type HppCostRepository interface {
+	GetProjectFlockKandangIDs(ctx context.Context, projectFlockId uint) ([]uint, error)
+	GetDocCost(ctx context.Context, projectFlockKandangIDs []uint) (float64, error)
+	GetBudgetCostByProjectFlockId(ctx context.Context, projectFlockId uint) (float64, error)
+	GetExpedisionCost(ctx context.Context, projectFlockKandangIDs []uint) (float64, error)
+	GetFeedUsageCost(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, error)
+	GetOvkUsageCost(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, error)
+	GetTotalPopulation(ctx context.Context, projectFlockKandangIDs []uint) (float64, error)
+	GetPulletCost(ctx context.Context, projectFlockKandangId uint) (float64, error)
+	GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, float64, error)
+	GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, startDate *time.Time, endDate *time.Time) (float64, float64, error)
+	GetProjectFlockIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (uint, error)
+	GetTransferSourceSummary(ctx context.Context, projectFlockKandangId uint) (uint, float64, error)
+}
+
+type HppRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewHppCostRepository(db *gorm.DB) HppCostRepository {
+	return &HppRepositoryImpl{db: db}
+}
+
+func (r *HppRepositoryImpl) GetProjectFlockKandangIDs(ctx context.Context, projectFlockId uint) ([]uint, error) {
+	var ids []uint
+	err := r.db.WithContext(ctx).
+		Table("project_flock_kandangs").
+		Select("id").
+		Where("project_flock_id = ?", projectFlockId).
+		Scan(&ids).Error
+	if err != nil {
+		return nil, err
+	}
+
+	return ids, nil
+}
+
+func (r *HppRepositoryImpl) GetDocCost(ctx context.Context, projectFlockKandangIDs []uint) (float64, error) {
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("project_chickins AS pc").
+		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
+		Where("pc.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetBudgetCostByProjectFlockId(ctx context.Context, projectFlockId uint) (float64, error) {
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("project_budgets AS pb").
+		Select("COALESCE(SUM(pb.qty * pb.price), 0)").
+		Where("pb.project_flock_id = ?", projectFlockId).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetExpedisionCost(ctx context.Context, projectFlockKandangIDs []uint) (float64, error) {
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("expense_nonstocks AS en").
+		Select("COALESCE(SUM(er.qty * er.price), 0)").
+		Joins("JOIN expense_realizations AS er ON er.expense_nonstock_id = en.id").
+		Joins("JOIN flags AS f ON f.flagable_id = en.nonstock_id AND f.flagable_type = ?", entity.FlagableTypeNonstock).
+		Where("en.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
+		Where("f.name = ?", utils.FlagEkspedisi).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetFeedUsageCost(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, error) {
+	if date == nil {
+		now := time.Now()
+		date = &now
+	}
+
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("recordings AS r").
+		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Joins("JOIN recording_stocks AS rs ON rs.recording_id = r.id").
+		Joins("JOIN product_warehouses AS pw ON pw.id = rs.product_warehouse_id").
+		Joins("JOIN flags AS f ON f.flagable_id = pw.product_id AND f.flagable_type = ?", entity.FlagableTypeProduct).
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
+		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
+		Where("r.record_datetime <= ?", *date).
+		Where("f.name = ?", utils.FlagPakan).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetOvkUsageCost(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, error) {
+	if date == nil {
+		now := time.Now()
+		date = &now
+	}
+
+	flags := []utils.FlagType{
+		utils.FlagOVK,
+		utils.FlagObat,
+		utils.FlagVitamin,
+		utils.FlagKimia,
+	}
+
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("recordings AS r").
+		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Joins("JOIN recording_stocks AS rs ON rs.recording_id = r.id").
+		Joins("JOIN product_warehouses AS pw ON pw.id = rs.product_warehouse_id").
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
+		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
+		Where("r.record_datetime <= ?", *date).
+		Where("EXISTS (SELECT 1 FROM flags f WHERE f.flagable_id = pw.product_id AND f.flagable_type = ? AND f.name IN ?)", entity.FlagableTypeProduct, flags).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetTotalPopulation(ctx context.Context, projectFlockKandangIDs []uint) (float64, error) {
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("project_chickins AS pc").
+		Select("COALESCE(SUM(pc.usage_qty), 0)").
+		Where("pc.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetPulletCost(ctx context.Context, projectFlockKandangId uint) (float64, error) {
+	stockablePurchase := fifo.StockableKeyPurchaseItems.String()
+	stockableTransferIn := fifo.StockableKeyStockTransferIn.String()
+	usableProjectChickin := fifo.UsableKeyProjectChickin.String()
+
+	var total float64
+	err := r.db.WithContext(ctx).
+		Table("project_chickins AS pc").
+		Select(`
+			COALESCE(SUM(sa.qty * CASE
+				WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
+				WHEN sa.stockable_type = ? THEN COALESCE(tpi.price, 0)
+				ELSE 0
+			END), 0)`,
+			stockablePurchase, stockableTransferIn).
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.status = ? AND sa.allocation_purpose = ?", usableProjectChickin, entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id AND sa.stockable_type = ?", stockablePurchase).
+		Joins("LEFT JOIN stock_allocations AS tsa ON tsa.usable_type = ? AND tsa.usable_id = sa.stockable_id AND sa.stockable_type = ? AND tsa.stockable_type = ? AND tsa.status = ? AND tsa.allocation_purpose = ?", stockableTransferIn, stockableTransferIn, stockablePurchase, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		Joins("LEFT JOIN purchase_items AS tpi ON tpi.id = tsa.stockable_id").
+		Where("pc.project_flock_kandang_id = ?", projectFlockKandangId).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+func (r *HppRepositoryImpl) GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, float64, error) {
+	if date == nil {
+		now := time.Now()
+		date = &now
+	}
+
+	var totals struct {
+		TotalPieces   float64
+		TotalWeightKg float64
+	}
+	err := r.db.WithContext(ctx).
+		Table("recordings AS r").
+		Select("COALESCE(SUM(re.qty), 0) AS total_pieces, COALESCE(SUM(re.weight), 0)AS total_weight_kg").
+		Joins("JOIN recording_eggs AS re ON re.recording_id = r.id").
+		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
+		Where("r.record_datetime <= ?", *date).
+		Scan(&totals).Error
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return totals.TotalPieces, totals.TotalWeightKg, nil
+}
+
+func (r *HppRepositoryImpl) GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(
+	ctx context.Context,
+	projectFlockKandangIDs []uint,
+	startDate *time.Time,
+	endDate *time.Time,
+) (float64, float64, error) {
+
+	if endDate == nil {
+		now := time.Now()
+		endDate = &now
+	}
+
+	type subResult struct {
+		UsableID    uint
+		MdpUsageQty float64
+		MdpWeight   float64
+	}
+
+	subQuery := r.db.WithContext(ctx).
+		Table("recordings AS r").
+		Select(`
+			DISTINCT sa.usable_id,
+			mdp.usage_qty  AS mdp_usage_qty,
+			mdp.total_weight AS mdp_weight
+		`).
+		Joins("JOIN recording_eggs re ON re.recording_id = r.id").
+		Joins(
+			"JOIN stock_allocations sa ON sa.stockable_type = ? AND sa.stockable_id = re.id AND sa.usable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
+			fifo.StockableKeyRecordingEgg.String(),
+			fifo.UsableKeyMarketingDelivery.String(),
+			entity.StockAllocationStatusActive,
+			entity.StockAllocationPurposeConsume,
+		).
+		Joins("JOIN marketing_delivery_products mdp ON mdp.id = sa.usable_id").
+		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
+		Where("r.record_datetime <= ?", *endDate).
+		Where("mdp.delivery_date <= ?", *startDate)
+
+	var totals struct {
+		TotalPieces float64
+		TotalWeight float64
+	}
+
+	err := r.db.WithContext(ctx).
+		Table("(?) AS x", subQuery).
+		Select(`
+			COALESCE(SUM(x.mdp_usage_qty), 0)  AS total_pieces,
+			COALESCE(SUM(x.mdp_weight), 0)     AS total_weight
+		`).
+		Scan(&totals).Error
+
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return totals.TotalPieces, totals.TotalWeight, nil
+}
+
+func (r *HppRepositoryImpl) GetProjectFlockIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (uint, error) {
+	var projectFlockID uint
+	err := r.db.WithContext(ctx).
+		Table("project_flock_kandangs").
+		Select("project_flock_id").
+		Where("id = ?", projectFlockKandangId).
+		Scan(&projectFlockID).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return projectFlockID, nil
+}
+
+func (r *HppRepositoryImpl) GetTransferSourceSummary(ctx context.Context, projectFlockKandangId uint) (uint, float64, error) {
+	var summary struct {
+		ProjectFlockID uint
+		TotalQty       float64
+	}
+	err := r.db.WithContext(ctx).
+		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
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return summary.ProjectFlockID, summary.TotalQty, nil
+}

internal/common/repository/common.stock_allocation.repository.go

@@ -33,7 +33,7 @@ func (r *StockAllocationRepositoryImpl) FindActiveByUsable(
 	var allocations []entity.StockAllocation
 
 	q := r.DB().WithContext(ctx).
-		Where("usable_type = ? AND usable_id = ? AND status = ?", usableType, usableID, entity.StockAllocationStatusActive)
+		Where("usable_type = ? AND usable_id = ? AND status = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume)
 
 	if modifier != nil {
 		q = modifier(q)
@@ -70,7 +70,7 @@ func (r *StockAllocationRepositoryImpl) ReleaseByUsable(
 
 	q := baseDB.WithContext(ctx).
 		Model(&entity.StockAllocation{}).
-		Where("usable_type = ? AND usable_id = ? AND status = ?", usableType, usableID, entity.StockAllocationStatusActive)
+		Where("usable_type = ? AND usable_id = ? AND status = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume)
 
 	return q.Updates(updates).Error
 }

internal/common/service/common.approval.service.go

@@ -15,7 +15,7 @@ type ApprovalService interface {
 	WorkflowSteps(workflow approvalutils.ApprovalWorkflowKey) map[approvalutils.ApprovalStep]string
 	WorkflowStepName(workflow approvalutils.ApprovalWorkflowKey, step approvalutils.ApprovalStep) (string, bool)
 	CreateApproval(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, step approvalutils.ApprovalStep, action *entity.ApprovalAction, actorID uint, note *string) (*entity.Approval, error)
-	List(ctx context.Context, module string, approvableID *uint, page, limit int, search string) ([]entity.Approval, int64, error)
+	List(ctx context.Context, module string, approvableID *uint, page, limit int, search string, orderByDate string) ([]entity.Approval, int64, error)
 	ListByTarget(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, modifier func(*gorm.DB) *gorm.DB) ([]entity.Approval, error)
 	LatestByTarget(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, modifier func(*gorm.DB) *gorm.DB) (*entity.Approval, error)
 	LatestByTargets(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableIDs []uint, modifier func(*gorm.DB) *gorm.DB) (map[uint]*entity.Approval, error)
@@ -70,9 +70,14 @@ func (s *approvalService) List(
 	approvableID *uint,
 	page, limit int,
 	search string,
+	orderByDate string,
 ) ([]entity.Approval, int64, error) {
 	module = strings.TrimSpace(strings.ToUpper(module))
 	search = strings.TrimSpace(search)
+	orderByDate = strings.TrimSpace(strings.ToUpper(orderByDate))
+	if orderByDate != "ASC" && orderByDate != "DESC" {
+		orderByDate = "DESC"
+	}
 
 	if limit <= 0 {
 		limit = 10
@@ -90,7 +95,7 @@ func (s *approvalService) List(
 		func(db *gorm.DB) *gorm.DB {
 			query := db.
 				Where("approvable_type = ?", module).
-				Order("action_at DESC").
+				Order("action_at " + orderByDate).
 				Preload("ActionUser")
 
 			if approvableID != nil {

internal/common/service/common.document.service.go

@@ -6,8 +6,10 @@ import (
 	"fmt"
 	"mime"
 	"mime/multipart"
+	"net/url"
 	"path/filepath"
 	"strings"
+	"time"
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	"gitlab.com/mbugroup/lti-api.git/internal/config"
@@ -18,7 +20,7 @@ import (
 )
 
 const (
-	defaultDocumentPathLimit = 50
+	defaultDocumentPathLimit = 255
 	defaultDocumentKeyPrefix = "docs"
 	maxDocumentNameLength    = 50
 )
@@ -29,6 +31,7 @@ type DocumentService interface {
 	DeleteDocuments(ctx context.Context, ids []uint, removeFromStorage bool) error
 	DeleteByTarget(ctx context.Context, documentableType string, documentableID uint64, removeFromStorage bool) error
 	PublicURL(document entity.Document) string
+	PresignURL(ctx context.Context, document entity.Document, expires time.Duration) (string, error)
 }
 
 type DocumentUploadRequest struct {
@@ -293,6 +296,66 @@ func (s *documentService) PublicURL(document entity.Document) string {
 	return s.storage.URL(document.Path)
 }
 
+func (s *documentService) PresignURL(ctx context.Context, document entity.Document, expires time.Duration) (string, error) {
+	if s.storage == nil {
+		return "", errors.New("document storage not configured")
+	}
+	if strings.TrimSpace(document.Path) == "" {
+		return "", errors.New("document path is required")
+	}
+	return s.storage.PresignURL(ctx, document.Path, expires)
+}
+
+// ResolveDocumentURL normalizes a stored path or URL into a presigned URL.
+func ResolveDocumentURL(
+	ctx context.Context,
+	svc DocumentService,
+	rawPath string,
+	expires time.Duration,
+) (string, error) {
+	if svc == nil {
+		return "", nil
+	}
+
+	rawPath = strings.TrimSpace(rawPath)
+	if rawPath == "" {
+		return "", nil
+	}
+
+	key := rawPath
+	lower := strings.ToLower(rawPath)
+	if strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://") {
+		key = extractS3KeyFromURL(rawPath)
+		if key == "" {
+			return "", nil
+		}
+	}
+
+	return svc.PresignURL(ctx, entity.Document{Path: key}, expires)
+}
+
+func extractS3KeyFromURL(raw string) string {
+	parsed, err := url.Parse(strings.TrimSpace(raw))
+	if err != nil {
+		return ""
+	}
+	path := strings.TrimPrefix(parsed.Path, "/")
+	if path == "" {
+		return ""
+	}
+
+	host := strings.ToLower(strings.TrimSpace(parsed.Host))
+	if strings.HasPrefix(host, "s3.") || strings.HasPrefix(host, "s3-") {
+		parts := strings.SplitN(path, "/", 2)
+		if len(parts) == 2 {
+			return parts[1]
+		}
+		return ""
+	}
+
+	return path
+}
+
 func (s *documentService) generateObjectKey(ext string) (string, error) {
 	normalizedExt := strings.TrimSpace(ext)
 	if normalizedExt != "" && !strings.HasPrefix(normalizedExt, ".") {
@@ -300,13 +363,19 @@ func (s *documentService) generateObjectKey(ext string) (string, error) {
 	}
 
 	u := uuid.New().String()
-	key := fmt.Sprintf("%s/%s%s", strings.Trim(s.keyPrefix, "/"), u, normalizedExt)
-	if s.keyPrefix == "" {
-		key = fmt.Sprintf("%s%s", u, normalizedExt)
+	keyPrefix := strings.Trim(s.keyPrefix, "/")
+	key := fmt.Sprintf("%s%s", u, normalizedExt)
+	if keyPrefix != "" {
+		key = fmt.Sprintf("%s/%s%s", keyPrefix, u, normalizedExt)
 	}
 
 	if len(key) > s.maxPathLength {
-		key = fmt.Sprintf("%s%s", u, normalizedExt)
+		compact := strings.ReplaceAll(u, "-", "")
+		if keyPrefix != "" {
+			key = fmt.Sprintf("%s/%s%s", keyPrefix, compact, normalizedExt)
+		} else {
+			key = fmt.Sprintf("%s%s", compact, normalizedExt)
+		}
 	}
 
 	if len(key) > s.maxPathLength {

internal/common/service/common.document.storage.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	awsconfig "github.com/aws/aws-sdk-go-v2/config"
@@ -17,6 +18,7 @@ type DocumentStorage interface {
 	Upload(ctx context.Context, key string, body io.Reader, size int64, contentType string) (DocumentStorageUploadResult, error)
 	Delete(ctx context.Context, key string) error
 	URL(key string) string
+	PresignURL(ctx context.Context, key string, expires time.Duration) (string, error)
 }
 
 type DocumentStorageUploadResult struct {
@@ -37,6 +39,7 @@ type S3DocumentStorageConfig struct {
 
 type s3DocumentStorage struct {
 	client        *s3.Client
+	presignClient *s3.PresignClient
 	bucket        string
 	base          string
 }
@@ -86,6 +89,7 @@ func NewS3DocumentStorage(ctx context.Context, cfg S3DocumentStorageConfig) (Doc
 	client := s3.NewFromConfig(awsCfg, func(o *s3.Options) {
 		o.UsePathStyle = cfg.ForcePathStyle
 	})
+	presignClient := s3.NewPresignClient(client)
 
 	baseURL := strings.TrimSuffix(strings.TrimSpace(cfg.BaseURL), "/")
 	if baseURL == "" {
@@ -98,6 +102,7 @@ func NewS3DocumentStorage(ctx context.Context, cfg S3DocumentStorageConfig) (Doc
 
 	return &s3DocumentStorage{
 		client:        client,
+		presignClient: presignClient,
 		bucket:        bucket,
 		base:          baseURL,
 	}, nil
@@ -158,3 +163,23 @@ func (s *s3DocumentStorage) URL(key string) string {
 	}
 	return fmt.Sprintf("%s/%s", s.base, key)
 }
+
+func (s *s3DocumentStorage) PresignURL(ctx context.Context, key string, expires time.Duration) (string, error) {
+	key = strings.TrimPrefix(strings.TrimSpace(key), "/")
+	if key == "" {
+		return "", errors.New("storage key is required")
+	}
+	if expires <= 0 {
+		expires = 15 * time.Minute
+	}
+
+	out, err := s.presignClient.PresignGetObject(ctx, &s3.GetObjectInput{
+		Bucket: aws.String(s.bucket),
+		Key:    aws.String(key),
+	}, s3.WithPresignExpires(expires))
+	if err != nil {
+		return "", err
+	}
+
+	return out.URL, nil
+}

internal/common/service/common.fifo.service.go

@@ -25,6 +25,8 @@ type FifoService interface {
 	Replenish(ctx context.Context, req StockReplenishRequest) (*StockReplenishResult, error)
 	Consume(ctx context.Context, req StockConsumeRequest) (*StockConsumeResult, error)
 	ReleaseUsage(ctx context.Context, req StockReleaseRequest) error
+	AdjustStockableQuantity(ctx context.Context, req StockAdjustRequest) error
+	ResolvePending(ctx context.Context, req PendingResolveRequest) ([]PendingResolution, error)
 }
 
 type fifoService struct {
@@ -95,12 +97,26 @@ type StockReplenishRequest struct {
 	Tx                 *gorm.DB
 }
 
+type StockAdjustRequest struct {
+	StockableKey       fifo.StockableKey
+	StockableID        uint
+	ProductWarehouseID uint
+	Quantity           float64
+	Note               *string
+	Tx                 *gorm.DB
+}
+
 type PendingResolution struct {
 	UsableKey fifo.UsableKey
 	UsableID  uint
 	Quantity  float64
 }
 
+type PendingResolveRequest struct {
+	ProductWarehouseID uint
+	Tx                 *gorm.DB
+}
+
 type StockReplenishResult struct {
 	AddedQuantity    float64
 	PendingResolved  []PendingResolution
@@ -138,6 +154,38 @@ type StockReleaseRequest struct {
 	Tx        *gorm.DB
 }
 
+func (s *fifoService) AdjustStockableQuantity(ctx context.Context, req StockAdjustRequest) error {
+	if req.StockableID == 0 || strings.TrimSpace(req.StockableKey.String()) == "" {
+		return errors.New("stockable key and id are required")
+	}
+	if req.ProductWarehouseID == 0 {
+		return errors.New("product warehouse id is required")
+	}
+	if req.Quantity == 0 {
+		return nil
+	}
+	if req.Quantity > 0 {
+		return errors.New("quantity must be negative")
+	}
+
+	cfg, ok := fifo.Stockable(req.StockableKey)
+	if !ok {
+		return fmt.Errorf("stockable %q is not registered", req.StockableKey)
+	}
+
+	return s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		if err := s.incrementStockableQty(ctx, tx, cfg, req.StockableID, req.Quantity); err != nil {
+			return err
+		}
+
+		return s.productWarehouseRepo.AdjustQuantities(ctx, map[uint]float64{
+			req.ProductWarehouseID: req.Quantity,
+		}, func(db *gorm.DB) *gorm.DB {
+			return s.txOrDB(tx, db)
+		})
+	})
+}
+
 func (s *fifoService) Replenish(ctx context.Context, req StockReplenishRequest) (*StockReplenishResult, error) {
 	if req.StockableID == 0 || strings.TrimSpace(req.StockableKey.String()) == "" {
 		return nil, errors.New("stockable key and id are required")
@@ -185,6 +233,23 @@ func (s *fifoService) Replenish(ctx context.Context, req StockReplenishRequest)
 	return result, nil
 }
 
+func (s *fifoService) ResolvePending(ctx context.Context, req PendingResolveRequest) ([]PendingResolution, error) {
+	if req.ProductWarehouseID == 0 {
+		return nil, errors.New("product warehouse id is required")
+	}
+
+	var resolved []PendingResolution
+	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
+		var err error
+		resolved, err = s.resolvePendingForWarehouse(ctx, tx, req.ProductWarehouseID)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+	return resolved, nil
+}
+
 func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*StockConsumeResult, error) {
 	if req.UsableID == 0 || strings.TrimSpace(req.UsableKey.String()) == "" {
 		return nil, errors.New("usable key and id are required")
@@ -192,7 +257,6 @@ func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*St
 	if req.Quantity < 0 {
 		return nil, errors.New("quantity must be zero or greater")
 	}
-
 	cfg, ok := fifo.Usable(req.UsableKey)
 	if !ok {
 		return nil, fmt.Errorf("usable %q is not registered", req.UsableKey)
@@ -220,7 +284,6 @@ func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*St
 		currentPending := ctxRow.PendingQty
 		currentTotal := currentUsage + currentPending
 		delta := req.Quantity - currentTotal
-
 		var (
 			usageDelta     float64
 			pendingDelta   float64
@@ -230,7 +293,13 @@ func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*St
 
 		switch {
 		case delta > 0:
-			allocationRes, err := s.allocateFromStock(ctx, tx, productWarehouseID, req.UsableKey, req.UsableID, delta)
+
+			var excludedStockables []fifo.StockableKey
+			if cfg.ExcludedStockables != nil {
+				excludedStockables = cfg.ExcludedStockables
+			}
+
+			allocationRes, err := s.allocateFromStock(ctx, tx, productWarehouseID, req.UsableKey, req.UsableID, delta, excludedStockables)
 			if err != nil {
 				return err
 			}
@@ -263,7 +332,7 @@ func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*St
 			}
 
 			if reductionTarget > 0 {
-				released, err := s.releaseUsagePortion(ctx, tx, req.UsableKey, req.UsableID, reductionTarget)
+				released, err := s.releaseUsagePortion(ctx, tx, req.UsableKey, req.UsableID, reductionTarget, productWarehouseID)
 				if err != nil {
 					return err
 				}
@@ -285,7 +354,6 @@ func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*St
 		result.ReleasedQuantity = releasedAmount
 		result.UsageQuantity = currentUsage + usageDelta
 		result.PendingQuantity = currentPending + pendingDelta
-
 		return nil
 	})
 	if err != nil {
@@ -299,7 +367,6 @@ func (s *fifoService) ReleaseUsage(ctx context.Context, req StockReleaseRequest)
 	if req.UsableID == 0 || strings.TrimSpace(req.UsableKey.String()) == "" {
 		return errors.New("usable key and id are required")
 	}
-
 	return s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
 		cfg, ok := fifo.Usable(req.UsableKey)
 		if !ok {
@@ -310,10 +377,9 @@ func (s *fifoService) ReleaseUsage(ctx context.Context, req StockReleaseRequest)
 		if err != nil {
 			return err
 		}
-
 		var usageDelta, pendingDelta float64
 		if ctxRow.UsageQty > 0 {
-			if _, err := s.releaseUsagePortion(ctx, tx, req.UsableKey, req.UsableID, ctxRow.UsageQty); err != nil {
+			if _, err := s.releaseUsagePortion(ctx, tx, req.UsableKey, req.UsableID, ctxRow.UsageQty, ctxRow.ProductWarehouseID); err != nil {
 				return err
 			}
 			usageDelta -= ctxRow.UsageQty
@@ -415,8 +481,9 @@ func (s *fifoService) allocateFromStock(
 	usableKey fifo.UsableKey,
 	usableID uint,
 	requestQty float64,
+	excludedStockables []fifo.StockableKey,
 ) (*allocationOutcome, error) {
-	lots, err := s.fetchStockLots(ctx, tx, productWarehouseID)
+	lots, err := s.fetchStockLots(ctx, tx, productWarehouseID, excludedStockables)
 	if err != nil {
 		return nil, err
 	}
@@ -461,6 +528,7 @@ func (s *fifoService) allocateFromStock(
 			UsableType:         usableKey.String(),
 			UsableId:           usableID,
 			Qty:                portion,
+			AllocationPurpose:  entities.StockAllocationPurposeConsume,
 			Status:             entities.StockAllocationStatusActive,
 		})
 
@@ -497,14 +565,24 @@ func (s *fifoService) allocateFromStock(
 	}, nil
 }
 
-func (s *fifoService) fetchStockLots(ctx context.Context, tx *gorm.DB, productWarehouseID uint) ([]stockLot, error) {
+func (s *fifoService) fetchStockLots(ctx context.Context, tx *gorm.DB, productWarehouseID uint, excludedStockables []fifo.StockableKey) ([]stockLot, error) {
 	configs := fifo.Stockables()
 	if len(configs) == 0 {
 		return nil, nil
 	}
 
+	// Create exclusion set for faster lookup
+	excludedSet := make(map[fifo.StockableKey]bool)
+	for _, key := range excludedStockables {
+		excludedSet[key] = true
+	}
+
 	var lots []stockLot
 	for key, cfg := range configs {
+		// Skip excluded stockables
+		if excludedSet[key] {
+			continue
+		}
 
 		usesNumericTime := cfg.Columns.CreatedAt == cfg.Columns.ID
 
@@ -621,7 +699,13 @@ func (s *fifoService) resolvePendingForWarehouse(ctx context.Context, tx *gorm.D
 			continue
 		}
 
-		outcome, err := s.allocateFromStock(ctx, tx, productWarehouseID, candidate.UsableKey, candidate.UsableID, candidate.Pending)
+		// Get excluded stockables from candidate usable config
+		var excludedStockables []fifo.StockableKey
+		if candidate.Config.ExcludedStockables != nil {
+			excludedStockables = candidate.Config.ExcludedStockables
+		}
+
+		outcome, err := s.allocateFromStock(ctx, tx, productWarehouseID, candidate.UsableKey, candidate.UsableID, candidate.Pending, excludedStockables)
 		if err != nil {
 			return nil, err
 		}
@@ -662,6 +746,7 @@ func (s *fifoService) releaseUsagePortion(
 	usableKey fifo.UsableKey,
 	usableID uint,
 	target float64,
+	expectedWarehouseID uint,
 ) (float64, error) {
 	if target <= 0 {
 		return 0, nil
@@ -677,6 +762,18 @@ func (s *fifoService) releaseUsagePortion(
 	if len(allocations) == 0 {
 		return 0, nil
 	}
+	for i := range allocations {
+		alloc := &allocations[i]
+		if expectedWarehouseID == 0 || alloc.ProductWarehouseId == expectedWarehouseID {
+			continue
+		}
+		if err := tx.Model(&entities.StockAllocation{}).
+			Where("id = ?", alloc.Id).
+			Update("product_warehouse_id", expectedWarehouseID).Error; err != nil {
+			return 0, err
+		}
+		alloc.ProductWarehouseId = expectedWarehouseID
+	}
 
 	var (
 		remaining            = target
@@ -715,7 +812,7 @@ func (s *fifoService) releaseUsagePortion(
 			}
 		} else {
 			if err := s.allocations.PatchOne(ctx, allocation.Id, map[string]any{
-				"quantity": allocation.Qty - releaseAmt,
+				"qty": allocation.Qty - releaseAmt,
 			}, func(db *gorm.DB) *gorm.DB {
 				return s.txOrDB(tx, db)
 			}); err != nil {
@@ -773,10 +870,47 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 			cfg.Columns.CreatedAt,
 		)
 
+		if cfg.Columns.CreatedAt == cfg.Columns.ID {
 			var rows []struct {
 				ID        uint
-			Pending   float64
-			CreatedAt time.Time
+				Pending   float64 `gorm:"column:pending_qty"`
+				CreatedAt int64   `gorm:"column:created_at"`
+			}
+
+			query := tx.Table(cfg.Table).
+				Select(selectStmt).
+				Where(fmt.Sprintf("%s = ?", cfg.Columns.ProductWarehouseID), productWarehouseID).
+				Where(fmt.Sprintf("%s > 0", cfg.Columns.PendingQuantity)).
+				Limit(s.pendingBatchPerUsable)
+
+			if cfg.Scope != nil {
+				query = cfg.Scope(query)
+			}
+
+			for _, order := range s.orderClauses(cfg.OrderBy) {
+				query = query.Order(order)
+			}
+
+			if err := query.Find(&rows).Error; err != nil {
+				return nil, err
+			}
+			for _, row := range rows {
+				if row.Pending <= 0 {
+					continue
+				}
+				candidates = append(candidates, pendingCandidate{
+					UsableKey: key,
+					Config:    cfg,
+					UsableID:  row.ID,
+					Pending:   row.Pending,
+					CreatedAt: time.Unix(0, row.CreatedAt),
+				})
+			}
+		} else {
+			var rows []struct {
+				ID        uint
+				Pending   float64   `gorm:"column:pending_qty"`
+				CreatedAt time.Time `gorm:"column:created_at"`
 			}
 
 			query := tx.Table(cfg.Table).
@@ -810,6 +944,7 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 				})
 			}
 		}
+	}
 
 	if len(candidates) == 0 {
 		return nil, nil

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/common.hpp.service.go

@@ -0,0 +1,272 @@
+package service
+
+import (
+	"context"
+	"math"
+	"time"
+
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+)
+
+type HppService interface {
+	CalculateHppCost(projectFlockKandangId uint, date *time.Time) (*HppCostResponse, error)
+	GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, date *time.Time) (float64, error)
+	GetTotalProductionCost(projectFlockKandangId uint, endDate *time.Time, depresiasiTransfer float64) (float64, error)
+	GetBudgetKandangLaying(projectFlockKandangId uint, endDate *time.Time) (float64, error)
+	GetDepresiasiTransfer(projectFlockKandangId uint, date *time.Time) (float64, error)
+	GetHppEstimationDanRealisasi(totalProductionCost float64, projectFlockKandangId uint, startDate *time.Time, endDate *time.Time) (*HppCostResponse, error)
+}
+
+type HppCostResponse struct {
+	Estimation HppCostDetail `json:"estimation"`
+	Real       HppCostDetail `json:"real"`
+}
+
+type HppCostDetail struct {
+	HargaKg    float64 `json:"harga_kg"`
+	HargaButir float64 `json:"harga_butir"`
+	Total      float64 `json:"total"`
+	Kg         float64 `json:"kg"`
+	Butir      float64 `json:"butir"`
+}
+
+type hppService struct {
+	hppRepo commonRepo.HppCostRepository
+}
+
+func NewHppService(hppRepo commonRepo.HppCostRepository) HppService {
+	return &hppService{hppRepo: hppRepo}
+}
+
+func (s *hppService) CalculateHppCost(projectFlockKandangId uint, date *time.Time) (*HppCostResponse, error) {
+	if date == nil {
+		now := time.Now()
+		date = &now
+	}
+
+	location, err := time.LoadLocation("Asia/Jakarta")
+	if err != nil {
+		return nil, err
+	}
+
+	startOfDay := time.Date(date.Year(), date.Month(), date.Day(), 0, 0, 0, 0, location)
+	endOfDay := startOfDay.Add(24 * time.Hour)
+
+	depresiasiTransfer, err := s.GetDepresiasiTransfer(projectFlockKandangId, &endOfDay)
+	if err != nil {
+		return nil, err
+	}
+
+	totalProductionCost, err := s.GetTotalProductionCost(projectFlockKandangId, &endOfDay, depresiasiTransfer)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.GetHppEstimationDanRealisasi(totalProductionCost, projectFlockKandangId, &startOfDay, &endOfDay)
+
+}
+
+func (s *hppService) GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, date *time.Time) (float64, error) {
+	if date == nil {
+		now := time.Now()
+		date = &now
+	}
+
+	if s.hppRepo == nil {
+		return 0, nil
+	}
+
+	kandangIDs, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)
+	if err != nil {
+		return 0, err
+	}
+
+	docCost, err := s.hppRepo.GetDocCost(context.Background(), kandangIDs)
+	if err != nil {
+		return 0, err
+	}
+
+	budgetCost, err := s.hppRepo.GetBudgetCostByProjectFlockId(context.Background(), sourceProjectFlockID)
+	if err != nil {
+		return 0, err
+	}
+
+	expedisionCost, err := s.hppRepo.GetExpedisionCost(context.Background(), kandangIDs)
+	if err != nil {
+		return 0, err
+	}
+
+	feedCost, err := s.hppRepo.GetFeedUsageCost(context.Background(), kandangIDs, date)
+	if err != nil {
+		return 0, err
+	}
+
+	ovkCost, err := s.hppRepo.GetOvkUsageCost(context.Background(), kandangIDs, date)
+	if err != nil {
+		return 0, err
+	}
+
+	return docCost + budgetCost + expedisionCost + feedCost + ovkCost, nil
+}
+
+func (s *hppService) GetTotalProductionCost(projectFlockKandangId uint, endDate *time.Time, depresiasiTransfer float64) (float64, error) {
+	// if date == nil {
+	// 	now := time.Now()
+	// 	date = &now
+	// }
+
+	costPullet, err := s.hppRepo.GetPulletCost(context.Background(), projectFlockKandangId)
+	if err != nil {
+		return 0, err
+	}
+
+	costFeed, err := s.hppRepo.GetFeedUsageCost(context.Background(), []uint{projectFlockKandangId}, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	costOvk, err := s.hppRepo.GetOvkUsageCost(context.Background(), []uint{projectFlockKandangId}, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	costExpedision, err := s.hppRepo.GetExpedisionCost(context.Background(), []uint{projectFlockKandangId})
+	if err != nil {
+		return 0, err
+	}
+
+	costBudget, err := s.GetBudgetKandangLaying(projectFlockKandangId, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	return depresiasiTransfer + costPullet + costFeed + costOvk + costExpedision + costBudget, nil
+}
+
+func (s *hppService) GetBudgetKandangLaying(projectFlockKandangId uint, endDate *time.Time) (float64, error) {
+	// if date == nil {
+	// 	now := time.Now()
+	// 	date = &now
+	// }
+
+	if s.hppRepo == nil {
+		return 0, nil
+	}
+
+	projectFlockId, err := s.hppRepo.GetProjectFlockIDByProjectFlockKandangID(context.Background(), projectFlockKandangId)
+	if err != nil {
+		return 0, err
+	}
+
+	projectFlockKandangIds, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), projectFlockId)
+	if err != nil {
+		return 0, err
+	}
+
+	eggProduksiPiecesFlock, _, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), projectFlockKandangIds, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	eggProduksiPiecesKandang, _, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	totalBudgetCost, err := s.hppRepo.GetBudgetCostByProjectFlockId(context.Background(), projectFlockId)
+	if err != nil {
+		return 0, err
+	}
+
+	if eggProduksiPiecesFlock == 0 {
+		return 0, nil
+	}
+
+	return (totalBudgetCost * eggProduksiPiecesKandang) / eggProduksiPiecesFlock, nil
+}
+
+func (s *hppService) GetDepresiasiTransfer(projectFlockKandangId uint, endDate *time.Time) (float64, error) {
+	// if endDate == nil {
+	// 	now := time.Now()
+	// 	endDate = &now
+	// }
+
+	if s.hppRepo == nil {
+		return 0, nil
+	}
+
+	sourceProjectFlockID, transferTotalQty, err := s.hppRepo.GetTransferSourceSummary(context.Background(), projectFlockKandangId)
+	if err != nil {
+		return 0, err
+	}
+
+	kandangIDsGrowing, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)
+	if err != nil {
+		return 0, err
+	}
+
+	totalPopulationFlockGrowing, err := s.hppRepo.GetTotalPopulation(context.Background(), kandangIDsGrowing)
+	if err != nil {
+		return 0, err
+	}
+	if totalPopulationFlockGrowing == 0 {
+		return 0, nil
+	}
+
+	totalDepresiasiFlockGrowing, err := s.GetTotalDepresiasiFlockGrowing(sourceProjectFlockID, endDate)
+	if err != nil {
+		return 0, err
+	}
+
+	return (totalDepresiasiFlockGrowing * transferTotalQty) / totalPopulationFlockGrowing, nil
+}
+
+func (s *hppService) GetHppEstimationDanRealisasi(totalProductionCost float64, projectFlockKandangId uint, startDate *time.Time, endDate *time.Time) (*HppCostResponse, error) {
+
+	if s.hppRepo == nil {
+		return &HppCostResponse{}, nil
+	}
+
+	estimPieces, estimWeightKg, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
+	if err != nil {
+		return nil, err
+	}
+
+	realPieces, realWeightKg, err := s.hppRepo.GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, startDate, endDate)
+	if err != nil {
+		return nil, err
+	}
+
+	estimation := HppCostDetail{
+		Total: totalProductionCost,
+		Kg:    estimWeightKg,
+		Butir: estimPieces,
+	}
+	if estimWeightKg > 0 {
+		estimation.HargaKg = roundToTwoDecimals(totalProductionCost / estimWeightKg)
+	}
+	if estimPieces > 0 {
+		estimation.HargaButir = roundToTwoDecimals(totalProductionCost / estimPieces)
+	}
+
+	real := HppCostDetail{
+		Total: totalProductionCost,
+		Kg:    realWeightKg,
+		Butir: realPieces,
+	}
+	if realWeightKg > 0 {
+		real.HargaKg = roundToTwoDecimals(totalProductionCost / realWeightKg)
+	}
+	if realPieces > 0 {
+		real.HargaButir = roundToTwoDecimals(totalProductionCost / realPieces)
+	}
+
+	return &HppCostResponse{
+		Estimation: estimation,
+		Real:       real,
+	}, nil
+}
+
+func roundToTwoDecimals(value float64) float64 {
+	return math.Round(value*100) / 100
+}

internal/common/service/fifo_pending_policy.go

@@ -0,0 +1,104 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"gorm.io/gorm"
+)
+
+type FifoPendingPolicyInput struct {
+	Lane          string
+	FlagGroupCode string
+	FunctionCode  string
+	LegacyTypeKey string
+}
+
+type FifoPendingPolicyResult struct {
+	AllowPending bool
+	RuleSource   string
+	Found        bool
+}
+
+func ResolveFifoPendingPolicy(ctx context.Context, tx *gorm.DB, input FifoPendingPolicyInput) (*FifoPendingPolicyResult, error) {
+	if tx == nil {
+		return nil, gorm.ErrInvalidDB
+	}
+
+	lane := strings.ToUpper(strings.TrimSpace(input.Lane))
+	flagGroupCode := strings.ToUpper(strings.TrimSpace(input.FlagGroupCode))
+	functionCode := strings.ToUpper(strings.TrimSpace(input.FunctionCode))
+	legacyTypeKey := strings.ToUpper(strings.TrimSpace(input.LegacyTypeKey))
+	if lane == "" {
+		return &FifoPendingPolicyResult{
+			AllowPending: false,
+			RuleSource:   "SAFE_DEFAULT_BLOCK",
+			Found:        false,
+		}, nil
+	}
+
+	type overconsumeRuleRow struct {
+		Allow bool `gorm:"column:allow_overconsume"`
+	}
+	var overconsume overconsumeRuleRow
+	overconsumeErr := tx.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(&overconsume).Error
+	if overconsumeErr == nil {
+		return &FifoPendingPolicyResult{
+			AllowPending: overconsume.Allow,
+			RuleSource:   "OVERCONSUME_RULE",
+			Found:        true,
+		}, nil
+	}
+	if !errors.Is(overconsumeErr, gorm.ErrRecordNotFound) {
+		return nil, overconsumeErr
+	}
+
+	type routeRuleRow struct {
+		AllowPendingDefault bool `gorm:"column:allow_pending_default"`
+	}
+	var routeRule routeRuleRow
+	routeQuery := tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Select("allow_pending_default").
+		Where("is_active = TRUE").
+		Where("lane = ?", lane).
+		Where("flag_group_code = ?", flagGroupCode)
+	if legacyTypeKey != "" {
+		routeQuery = routeQuery.Where("legacy_type_key = ?", legacyTypeKey)
+	}
+	if functionCode != "" {
+		routeQuery = routeQuery.Where("function_code = ?", functionCode)
+	}
+	routeErr := routeQuery.
+		Order("id ASC").
+		Limit(1).
+		Take(&routeRule).Error
+	if routeErr == nil {
+		return &FifoPendingPolicyResult{
+			AllowPending: routeRule.AllowPendingDefault,
+			RuleSource:   "ROUTE_RULE_DEFAULT",
+			Found:        true,
+		}, nil
+	}
+	if !errors.Is(routeErr, gorm.ErrRecordNotFound) {
+		return nil, routeErr
+	}
+
+	return &FifoPendingPolicyResult{
+		AllowPending: false,
+		RuleSource:   "SAFE_DEFAULT_BLOCK",
+		Found:        false,
+	}, nil
+}

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,802 @@
+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 shouldSkipStockableForUsable(req, lot.Ref.LegacyTypeKey) {
+			continue
+		}
+		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(),
+			"allocation_purpose":   defaultAllocationPurpose(),
+			"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 shouldSkipStockableForUsable(req AllocateRequest, stockableType string) bool {
+	usableType := strings.ToUpper(strings.TrimSpace(req.Usable.LegacyTypeKey))
+	functionCode := strings.ToUpper(strings.TrimSpace(req.Usable.FunctionCode))
+	stockable := strings.ToUpper(strings.TrimSpace(stockableType))
+
+	// CHICKIN_OUT must consume physical stock sources, not population lots,
+	// otherwise approved chickin can consume its own just-created population.
+	if (usableType == "PROJECT_CHICKIN" || functionCode == "CHICKIN_OUT") && stockable == "PROJECT_FLOCK_POPULATION" {
+		return true
+	}
+	if (usableType == "STOCK_TRANSFER_OUT" || functionCode == "STOCK_TRANSFER_OUT") && stockable == "PROJECT_FLOCK_POPULATION" {
+		return true
+	}
+
+	return false
+}
+
+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 {
+		return nil, fmt.Errorf("%w: invalid reflow request", 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,
+			"as_of":                req.AsOf,
+		})
+		logRow, reused, err := s.beginOperation(
+			tx,
+			OperationReflow,
+			req.IdempotencyKey,
+			hash,
+			req.ProductWarehouseID,
+			req.FlagGroupCode,
+			"",
+			0,
+		)
+		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)
+				}
+			}()
+		}
+
+		usableRows, gatherErr := s.gatherAllRows(ctx, tx, GatherRequest{
+			FlagGroupCode:      req.FlagGroupCode,
+			Lane:               LaneUsable,
+			ProductWarehouseID: req.ProductWarehouseID,
+			Limit:              s.defaultGatherLimit,
+		})
+		if gatherErr != nil {
+			err = gatherErr
+			return gatherErr
+		}
+		result.ProcessedUsables = len(usableRows)
+
+		for _, usableRow := range usableRows {
+			desiredQty := usableRow.Quantity + usableRow.PendingQuantity
+
+			rollbackRes, rollbackErr := s.rollbackInternal(ctx, tx, RollbackRequest{
+				ProductWarehouseID: req.ProductWarehouseID,
+				Usable:             usableRow.Ref,
+				ReleaseQty:         nil,
+				Reason:             "reflow reset",
+			}, req.FlagGroupCode)
+			if rollbackErr != nil {
+				err = rollbackErr
+				return rollbackErr
+			}
+			result.Rollback.ReleasedQty += rollbackRes.ReleasedQty
+			if len(rollbackRes.Details) > 0 {
+				result.Rollback.Details = append(result.Rollback.Details, rollbackRes.Details...)
+			}
+
+			if desiredQty <= 0 {
+				continue
+			}
+			allocateRes, allocateErr := s.allocateInternal(ctx, tx, AllocateRequest{
+				FlagGroupCode:      req.FlagGroupCode,
+				ProductWarehouseID: req.ProductWarehouseID,
+				Usable:             usableRow.Ref,
+				NeedQty:            desiredQty,
+				AsOf:               nil,
+			})
+			if allocateErr != nil {
+				err = allocateErr
+				return allocateErr
+			}
+			result.Allocate.AllocatedQty += allocateRes.AllocatedQty
+			result.Allocate.PendingQty += allocateRes.PendingQty
+			if len(allocateRes.Details) > 0 {
+				result.Allocate.Details = append(result.Allocate.Details, allocateRes.Details...)
+			}
+		}
+
+		expectedQty, calcErr := s.calculateWarehouseAvailableForGroup(ctx, tx, req.ProductWarehouseID, req.FlagGroupCode, nil)
+		if calcErr != nil {
+			err = calcErr
+			return calcErr
+		}
+		actualQty, loadErr := s.loadWarehouseQty(ctx, tx, req.ProductWarehouseID)
+		if loadErr != nil {
+			err = loadErr
+			return loadErr
+		}
+		drift := expectedQty - actualQty
+		if math.Abs(drift) >= 1e-6 {
+			if adjustErr := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, drift); adjustErr != nil {
+				err = adjustErr
+				return adjustErr
+			}
+		}
+
+		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) gatherAllRows(
+	ctx context.Context,
+	tx *gorm.DB,
+	req GatherRequest,
+) ([]GatherRow, error) {
+	limit := req.Limit
+	if limit <= 0 {
+		limit = s.defaultGatherLimit
+	}
+	if limit <= 0 {
+		limit = 1000
+	}
+
+	req.Limit = limit
+	out := make([]GatherRow, 0, limit)
+
+	var cursorSortAt *time.Time
+	cursorSourceTable := ""
+	var cursorSourceID uint
+
+	for {
+		req.AfterSortAt = cursorSortAt
+		req.AfterSourceTable = cursorSourceTable
+		req.AfterSourceID = cursorSourceID
+
+		rows, err := s.gatherRows(ctx, tx, req)
+		if err != nil {
+			return nil, err
+		}
+		if len(rows) == 0 {
+			break
+		}
+
+		out = append(out, rows...)
+		if len(rows) < limit {
+			break
+		}
+
+		last := rows[len(rows)-1]
+		lastSortAt := last.SortAt
+		cursorSortAt = &lastSortAt
+		cursorSourceTable = last.SourceTable
+		cursorSourceID = last.SourceID
+	}
+
+	return out, 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 = ? AND allocation_purpose = ?", usableType, usableID, activeAllocationStatus(), defaultAllocationPurpose())
+	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
+	latestQuery := 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("allocation_purpose = ?", defaultAllocationPurpose()).
+		Where("flag_group_code IS NOT NULL AND flag_group_code <> ''")
+	if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
+		latestQuery = latestQuery.Where("function_code = ?", code)
+	}
+	err := latestQuery.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
+	}
+
+	rulesQuery := tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Where("is_active = TRUE").
+		Where("lane = ?", string(LaneUsable)).
+		Where("legacy_type_key = ?", req.Usable.LegacyTypeKey)
+	if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
+		rulesQuery = rulesQuery.Where("function_code = ?", code)
+	}
+
+	var rules []routeRule
+	err = rulesQuery.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 && req.ProductWarehouseID != 0 {
+		type candidateRow struct {
+			FlagGroupCode string `gorm:"column:flag_group_code"`
+		}
+		var candidates []candidateRow
+		byProductQuery := tx.WithContext(ctx).
+			Table("fifo_stock_v2_route_rules rr").
+			Select("DISTINCT rr.flag_group_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.lane = ?", string(LaneUsable)).
+			Where("rr.legacy_type_key = ?", req.Usable.LegacyTypeKey).
+			Where(`
+				EXISTS (
+					SELECT 1
+					FROM product_warehouses pw
+					JOIN flags f ON 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 = ?
+					  AND f.flagable_type = 'products'
+					  AND fm.flag_group_code = rr.flag_group_code
+				)
+			`, req.ProductWarehouseID)
+		if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
+			byProductQuery = byProductQuery.Where("rr.function_code = ?", code)
+		}
+		if err := byProductQuery.Order("rr.flag_group_code ASC").Scan(&candidates).Error; err != nil {
+			return "", err
+		}
+		if len(candidates) == 1 {
+			return strings.TrimSpace(candidates[0].FlagGroupCode), nil
+		}
+	}
+	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,293 @@
+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) {
+	req.AllocationPurpose = normalizeAllocationPurpose(req.AllocationPurpose)
+
+	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, 2)
+	whereExtraArgs := make([]any, 0, 1)
+
+	if req.Lane == LaneStockable {
+		if !req.IgnoreSourceUsed && rule.UsedQuantityCol != nil && strings.TrimSpace(*rule.UsedQuantityCol) != "" {
+			usedCol, _ := mustSafeIdentifier(*rule.UsedQuantityCol)
+			usedExpr = fmt.Sprintf("COALESCE(src.%s,0)::numeric", usedCol)
+		} else {
+			// NOTE:
+			// usedExpr is referenced twice in the generated SELECT:
+			// 1) as used_quantity
+			// 2) inside available_quantity = base - usedExpr
+			// plus once in stockable WHERE clause via availableExpr > 0.
+			// We split the args because the WHERE placeholder order appears
+			// after product/flag filter placeholders in the final SQL.
+			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' AND sa.allocation_purpose = ?)",
+				sourceIDCol,
+				activeAllocationStatus(),
+			)
+			extraArgs = append(extraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
+			extraArgs = append(extraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
+			whereExtraArgs = append(whereExtraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
+		}
+		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
+	}
+
+	functionCodeExpr := "?::text"
+	functionCodeArgs := []any{rule.FunctionCode}
+	if rule.SourceTable == "adjustment_stocks" {
+		functionCodeExpr = "COALESCE(NULLIF(src.function_code,''), ?::text)"
+	}
+
+	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 req.From != 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,
+			%s 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
+	`, functionCodeExpr, sourceIDCol, productWarehouseCol, sortExpr, baseQtyExpr, usedExpr, pendingExpr, availableExpr, sourceTable, joinClause, strings.Join(whereParts, " AND "))
+
+	args := []any{
+		rule.SourceTable,
+		rule.LegacyTypeKey,
+	}
+	args = append(args, functionCodeArgs...)
+	args = append(args, trait.SortPriority)
+	args = append(args, extraArgs...)
+	args = append(args,
+		req.ProductWarehouseID,
+		entity.FlagableTypeProduct,
+		req.FlagGroupCode,
+	)
+	args = append(args, whereExtraArgs...)
+
+	if req.AsOf != nil {
+		args = append(args, *req.AsOf)
+	}
+	if req.From != nil {
+		args = append(args, *req.From)
+	}
+
+	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/population_allocation.go

@@ -0,0 +1,131 @@
+package fifo_stock_v2
+
+import (
+	"context"
+	"errors"
+	"math"
+	"sort"
+
+	commonRepo "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/fifo"
+
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+)
+
+func ReleasePopulationConsumptionByUsable(
+	ctx context.Context,
+	tx *gorm.DB,
+	usableType string,
+	usableID uint,
+) error {
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if usableType == "" || usableID == 0 {
+		return errors.New("usable type and id are required")
+	}
+
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
+	allocations, err := stockAllocationRepo.FindActiveByUsable(ctx, usableType, usableID, nil)
+	if err != nil {
+		return err
+	}
+
+	for _, allocation := range allocations {
+		if allocation.StockableType != fifo.StockableKeyProjectFlockPopulation.String() || allocation.StockableId == 0 || allocation.Qty <= 0 {
+			continue
+		}
+		if err := tx.WithContext(ctx).
+			Model(&entity.ProjectFlockPopulation{}).
+			Where("id = ?", allocation.StockableId).
+			Update("total_used_qty", gorm.Expr("GREATEST(total_used_qty - ?, 0)", allocation.Qty)).Error; err != nil {
+			return err
+		}
+	}
+
+	return stockAllocationRepo.ReleaseByUsable(ctx, usableType, usableID, nil, nil)
+}
+
+func AllocatePopulationConsumption(
+	ctx context.Context,
+	tx *gorm.DB,
+	populations []entity.ProjectFlockPopulation,
+	productWarehouseID uint,
+	usableType string,
+	usableID uint,
+	consumeQty float64,
+) error {
+	if consumeQty <= 0 {
+		return nil
+	}
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if productWarehouseID == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Product warehouse tidak valid")
+	}
+	if usableType == "" || usableID == 0 {
+		return errors.New("usable type and id are required")
+	}
+	if len(populations) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan")
+	}
+
+	if err := ReleasePopulationConsumptionByUsable(ctx, tx, usableType, usableID); err != nil {
+		return err
+	}
+
+	sort.Slice(populations, func(i, j int) bool {
+		if populations[i].CreatedAt.Equal(populations[j].CreatedAt) {
+			return populations[i].Id < populations[j].Id
+		}
+		return populations[i].CreatedAt.Before(populations[j].CreatedAt)
+	})
+
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
+	remaining := consumeQty
+	for _, pop := range populations {
+		available := pop.TotalQty - pop.TotalUsedQty
+		if available <= 0 {
+			continue
+		}
+		portion := math.Min(available, remaining)
+		if portion <= 0 {
+			continue
+		}
+
+		allocation := &entity.StockAllocation{
+			ProductWarehouseId: productWarehouseID,
+			StockableType:      fifo.StockableKeyProjectFlockPopulation.String(),
+			StockableId:        pop.Id,
+			UsableType:         usableType,
+			UsableId:           usableID,
+			Qty:                portion,
+			Status:             entity.StockAllocationStatusActive,
+			AllocationPurpose:  entity.StockAllocationPurposeConsume,
+		}
+		if err := stockAllocationRepo.CreateOne(ctx, allocation, nil); err != nil {
+			return err
+		}
+
+		if err := tx.WithContext(ctx).
+			Model(&entity.ProjectFlockPopulation{}).
+			Where("id = ?", pop.Id).
+			Update("total_used_qty", gorm.Expr("total_used_qty + ?", portion)).Error; err != nil {
+			return err
+		}
+
+		remaining -= portion
+		if remaining <= 1e-6 {
+			break
+		}
+	}
+
+	if remaining > 1e-6 {
+		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak mencukupi")
+	}
+
+	return 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,277 @@
+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", "allocation_purpose"}
+	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
+}
+
+func defaultAllocationPurpose() string {
+	return entity.StockAllocationPurposeConsume
+}
+
+func normalizeAllocationPurpose(purpose string) string {
+	purpose = strings.TrimSpace(strings.ToUpper(purpose))
+	if purpose == "" {
+		return defaultAllocationPurpose()
+	}
+	return purpose
+}

internal/common/service/fifo_stock_v2/types.go

@@ -0,0 +1,143 @@
+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
+	AllocationPurpose  string
+	IgnoreSourceUsed   bool
+	ProductWarehouseID uint
+	From               *time.Time
+	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
+	AsOf               *time.Time
+	IdempotencyKey     string
+	Tx                 *gorm.DB
+}
+
+type ReflowResult struct {
+	ProcessedUsables int
+	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

@@ -54,12 +54,14 @@ var (
 	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
@@ -72,7 +74,9 @@ var (
 	S3SecretKey                    string
 	S3ForcePathStyle               bool
 	S3PublicBaseURL                string
+	S3EnvPrefix                    string
 	S3DocumentKeyPrefix            string
+	TransferToLayingGrowingMaxWeek int
 )
 
 func init() {
@@ -114,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"))
@@ -122,7 +131,12 @@ func init() {
 	S3SecretKey = strings.TrimSpace(viper.GetString("S3_SECRET_KEY"))
 	S3ForcePathStyle = viper.GetBool("S3_FORCE_PATH_STYLE")
 	S3PublicBaseURL = strings.TrimSuffix(strings.TrimSpace(viper.GetString("S3_PUBLIC_BASE_URL")), "/")
-	S3DocumentKeyPrefix = defaultString(strings.Trim(strings.TrimSpace(viper.GetString("S3_DOCUMENT_PREFIX")), "/"), "docs")
+	S3EnvPrefix = defaultString(strings.Trim(strings.TrimSpace(viper.GetString("S3_ENV_PREFIX")), "/"), "local")
+	docPrefix := strings.Trim(strings.TrimSpace(viper.GetString("S3_DOCUMENT_PREFIX")), "/")
+	if docPrefix == "" {
+		docPrefix = "docs"
+	}
+	S3DocumentKeyPrefix = joinPath(S3EnvPrefix, docPrefix)
 
 	// SSO integration
 	SSOIssuer = viper.GetString("SSO_ISSUER")
@@ -131,11 +145,16 @@ func init() {
 	SSOAuthorizeURL = viper.GetString("SSO_AUTHORIZE_URL")
 	SSOTokenURL = viper.GetString("SSO_TOKEN_URL")
 	SSOGetMeURL = viper.GetString("SSO_GETME_URL")
+	SSOPortalURL = strings.TrimSpace(viper.GetString("SSO_PORTAL_URL"))
 	SSOAccessCookieName = defaultString(viper.GetString("SSO_ACCESS_COOKIE_NAME"), "sso_access")
 	SSORefreshCookieName = defaultString(viper.GetString("SSO_REFRESH_COOKIE_NAME"), "sso_refresh")
 	SSOCookieDomain = viper.GetString("SSO_COOKIE_DOMAIN")
 	SSOCookieSecure = viper.GetBool("SSO_COOKIE_SECURE")
 	SSOCookieSameSite = defaultString(viper.GetString("SSO_COOKIE_SAMESITE"), "Lax")
+	SSOAccessTokenMaxBytes = viper.GetInt("SSO_ACCESS_TOKEN_MAX_BYTES")
+	if SSOAccessTokenMaxBytes <= 0 {
+		SSOAccessTokenMaxBytes = 4096
+	}
 	SSOTokenBlacklistPrefix = defaultString(viper.GetString("SSO_TOKEN_BLACKLIST_PREFIX"), "sso:blacklist")
 	if ttl := viper.GetInt("SSO_PKCE_TTL_SECONDS"); ttl > 0 {
 		SSOPKCETTL = time.Duration(ttl) * time.Second
@@ -240,6 +259,21 @@ func defaultString(v, def string) string {
 	return v
 }
 
+func LayingWeekStart() int {
+	return TransferToLayingGrowingMaxWeek
+}
+
+func joinPath(parts ...string) string {
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.Trim(part, "/")
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return strings.Join(out, "/")
+}
+
 func ensureProdConfig() {
 	if SSOAuthorizeURL == "" || !strings.HasPrefix(SSOAuthorizeURL, "https://") {
 		panic("SSO_AUTHORIZE_URL must be https in production")

internal/config/fiber.go

@@ -13,6 +13,7 @@ func FiberConfig() fiber.Config {
 		CaseSensitive: true,
 		ServerHeader:  "Fiber",
 		AppName:       "Fiber API",
+		BodyLimit:    8 * 1024 * 1024,
 		ErrorHandler:  utils.ErrorHandler,
 		JSONEncoder:   sonic.Marshal,
 		JSONDecoder:   sonic.Unmarshal,

internal/database/migrations/20251030134527_recreate_project_chikins_table.up.sql

@@ -29,7 +29,7 @@ ADD CONSTRAINT fk_project_chickins_kandang FOREIGN KEY (project_flock_kandang_id
 
 -- Relasi ke product_warehouses
 ALTER TABLE project_chickins
-ADD CONSTRAINT fk_project_chickins_warehouse FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses (id) ON DELETE RESTRICT ON UPDATE CASCADE;
+ADD CONSTRAINT fk_project_chickins_warehouse FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses (id) ON DELETE CASCADE ON UPDATE CASCADE;
 
 -- Relasi ke users
 ALTER TABLE project_chickins

internal/database/migrations/20251117034511_create_expenses_table.down.sql

@@ -1 +1,2 @@
+DROP SEQUENCE IF EXISTS expenses_ref_seq;
 DROP TABLE IF EXISTS expenses;

internal/database/migrations/20251210044651_create_so_number_sequence.down.sql

@@ -1,3 +1,3 @@
 -- Drop function and sequence for sales order numbers
-DROP FUNCTION IF EXISTS generate_so_number();
 DROP SEQUENCE IF EXISTS so_number_seq;
+DROP FUNCTION IF EXISTS generate_so_number();

internal/database/migrations/20251227100000_update_expense_table.down.sql

@@ -0,0 +1,24 @@
+-- Rollback: Update expense and expense_nonstocks tables
+
+-- Drop indexes
+DROP INDEX IF EXISTS idx_expenses_project_flock_id;
+DROP INDEX IF EXISTS idx_expenses_location_id;
+
+-- Drop Foreign Key constraint
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_expenses_location_id'
+    ) THEN
+        ALTER TABLE expenses
+            DROP CONSTRAINT fk_expenses_location_id;
+    END IF;
+END $$;
+
+-- Drop columns from expenses table
+ALTER TABLE expenses
+DROP COLUMN IF EXISTS project_flock_id;
+
+ALTER TABLE expenses
+DROP COLUMN IF EXISTS location_id;

internal/database/migrations/20251227100000_update_expense_table.up.sql

@@ -0,0 +1,29 @@
+-- Migration: Update expense and expense_nonstocks tables
+
+-- Add location_id column to expenses table
+ALTER TABLE expenses
+ADD COLUMN IF NOT EXISTS location_id BIGINT NOT NULL DEFAULT 1;
+
+-- Add project_flock_id column to expenses table (JSON type)
+ALTER TABLE expenses
+ADD COLUMN IF NOT EXISTS project_flock_id JSON NULL;
+
+-- Add Foreign Key constraint to locations table
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'locations') THEN
+        ALTER TABLE expenses
+            ADD CONSTRAINT fk_expenses_location_id
+            FOREIGN KEY (location_id) REFERENCES locations(id) ON DELETE RESTRICT ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+-- Create index for location_id
+CREATE INDEX IF NOT EXISTS idx_expenses_location_id ON expenses (location_id);
+
+-- Create index for project_flock_id
+CREATE INDEX IF NOT EXISTS idx_expenses_project_flock_id ON expenses ((project_flock_id::text));
+
+-- Ensure kandang_id is nullable in expense_nonstocks table
+ALTER TABLE expense_nonstocks
+ALTER COLUMN kandang_id DROP NOT NULL;

internal/database/migrations/20251227234328_create_project_flock_kandang_uniformity.down.sql

@@ -0,0 +1,6 @@
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_deleted_at;
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_created_by;
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_project_flock_kandang_week;
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_project_flock_kandang_id;
+
+DROP TABLE IF EXISTS project_flock_kandang_uniformity;

internal/database/migrations/20251227234328_create_project_flock_kandang_uniformity.up.sql

@@ -0,0 +1,58 @@
+CREATE TABLE IF NOT EXISTS project_flock_kandang_uniformity (
+    id BIGSERIAL PRIMARY KEY,
+    uniformity NUMERIC(15, 3),
+    week INT NOT NULL,
+    cv NUMERIC(15, 3),
+    chick_qty_of_weight NUMERIC(15, 3),
+    mean_up NUMERIC(15, 3),
+    mean_down NUMERIC(15, 3),
+    project_flock_kandang_id BIGINT NOT NULL,
+    uniform_qty NUMERIC(15, 3),
+    not_uniform_qty NUMERIC(15, 3),
+    uniform_date TIMESTAMPTZ,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW(),
+    deleted_at TIMESTAMPTZ,
+    created_by BIGINT NOT NULL
+);
+
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'project_flock_kandangs') THEN
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint WHERE conname = 'fk_project_flock_kandang_uniformity_project_flock_kandang'
+        ) THEN
+            EXECUTE
+            'ALTER TABLE project_flock_kandang_uniformity
+             ADD CONSTRAINT fk_project_flock_kandang_uniformity_project_flock_kandang
+             FOREIGN KEY (project_flock_kandang_id)
+             REFERENCES project_flock_kandangs(id)
+             ON DELETE RESTRICT ON UPDATE CASCADE';
+        END IF;
+    END IF;
+
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'users') THEN
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint WHERE conname = 'fk_project_flock_kandang_uniformity_created_by'
+        ) THEN
+            EXECUTE
+            'ALTER TABLE project_flock_kandang_uniformity
+             ADD CONSTRAINT fk_project_flock_kandang_uniformity_created_by
+             FOREIGN KEY (created_by)
+             REFERENCES users(id)
+             ON DELETE RESTRICT ON UPDATE CASCADE';
+        END IF;
+    END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_project_flock_kandang_id
+    ON project_flock_kandang_uniformity (project_flock_kandang_id);
+
+CREATE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_project_flock_kandang_week
+    ON project_flock_kandang_uniformity (project_flock_kandang_id, week);
+
+CREATE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_created_by
+    ON project_flock_kandang_uniformity (created_by);
+
+CREATE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_deleted_at
+    ON project_flock_kandang_uniformity (deleted_at);

internal/database/migrations/20251228015437_add_fifo_fields_to_stock_transfer_details.down.sql

@@ -0,0 +1,42 @@
+-- ===============================================================
+--  ROLLBACK: Remove FIFO fields from STOCK_TRANSFER_DETAILS
+-- ===============================================================
+
+-- Drop indexes
+DROP INDEX IF EXISTS idx_stock_transfer_details_dest_pw;
+DROP INDEX IF EXISTS idx_stock_transfer_details_source_pw;
+
+-- Drop foreign keys
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_stock_transfer_details_source_pw'
+    ) THEN
+        EXECUTE 'ALTER TABLE stock_transfer_details
+                 DROP CONSTRAINT fk_stock_transfer_details_source_pw';
+    END IF;
+
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_stock_transfer_details_dest_pw'
+    ) THEN
+        EXECUTE 'ALTER TABLE stock_transfer_details
+                 DROP CONSTRAINT fk_stock_transfer_details_dest_pw';
+    END IF;
+END $$;
+
+-- Drop FIFO columns
+ALTER TABLE stock_transfer_details
+DROP COLUMN IF EXISTS total_used,
+DROP COLUMN IF EXISTS total_qty,
+DROP COLUMN IF EXISTS pending_qty,
+DROP COLUMN IF EXISTS usage_qty,
+DROP COLUMN IF EXISTS dest_product_warehouse_id,
+DROP COLUMN IF EXISTS source_product_warehouse_id;
+
+-- Restore original columns (in case rollback)
+ALTER TABLE stock_transfer_details
+ADD COLUMN IF NOT EXISTS quantity NUMERIC(15, 3) NOT NULL DEFAULT 0,
+ADD COLUMN IF NOT EXISTS before_quantity NUMERIC(15, 3),
+ADD COLUMN IF NOT EXISTS after_quantity NUMERIC(15, 3);

internal/database/migrations/20251228015437_add_fifo_fields_to_stock_transfer_details.up.sql

@@ -0,0 +1,83 @@
+-- ===============================================================
+--  ADD FIFO FIELDS TO STOCK_TRANSFER_DETAILS
+--  Enable transfer module to work with FIFO stock system
+--
+--  Notes:
+--  - Field 'quantity' will be removed (replaced by usage_qty + pending_qty)
+--  - Fields 'before_quantity' & 'after_quantity' will be removed (unused legacy)
+--  - New FIFO fields track actual allocation instead of requested quantity
+-- ===============================================================
+
+-- Add FIFO tracking fields
+ALTER TABLE stock_transfer_details
+ADD COLUMN IF NOT EXISTS source_product_warehouse_id BIGINT,
+ADD COLUMN IF NOT EXISTS dest_product_warehouse_id BIGINT,
+ADD COLUMN IF NOT EXISTS usage_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS pending_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS total_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS total_used NUMERIC(15, 3) DEFAULT 0;
+
+-- Remove obsolete columns (quantity replaced by FIFO fields, legacy fields never used)
+ALTER TABLE stock_transfer_details
+DROP COLUMN IF EXISTS quantity,
+DROP COLUMN IF EXISTS before_quantity,
+DROP COLUMN IF EXISTS after_quantity;
+
+-- Add foreign keys for product warehouse references
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
+        -- Source warehouse foreign key
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint
+            WHERE conname = 'fk_stock_transfer_details_source_pw'
+        ) THEN
+            EXECUTE
+                'ALTER TABLE stock_transfer_details
+                 ADD CONSTRAINT fk_stock_transfer_details_source_pw
+                 FOREIGN KEY (source_product_warehouse_id)
+                 REFERENCES product_warehouses(id)
+                 ON DELETE SET NULL ON UPDATE CASCADE';
+        END IF;
+
+        -- Destination warehouse foreign key
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint
+            WHERE conname = 'fk_stock_transfer_details_dest_pw'
+        ) THEN
+            EXECUTE
+                'ALTER TABLE stock_transfer_details
+                 ADD CONSTRAINT fk_stock_transfer_details_dest_pw
+                 FOREIGN KEY (dest_product_warehouse_id)
+                 REFERENCES product_warehouses(id)
+                 ON DELETE SET NULL ON UPDATE CASCADE';
+        END IF;
+    END IF;
+END $$;
+
+-- Add indexes for FIFO operations
+CREATE INDEX IF NOT EXISTS idx_stock_transfer_details_source_pw
+ON stock_transfer_details (source_product_warehouse_id);
+
+CREATE INDEX IF NOT EXISTS idx_stock_transfer_details_dest_pw
+ON stock_transfer_details (dest_product_warehouse_id);
+
+-- Add comments for documentation
+COMMENT ON COLUMN stock_transfer_details.source_product_warehouse_id IS
+'Source product warehouse ID - referensi warehouse asal (FIFO usable)';
+
+COMMENT ON COLUMN stock_transfer_details.dest_product_warehouse_id IS
+'Destination product warehouse ID - referensi warehouse tujuan (FIFO stockable)';
+
+COMMENT ON COLUMN stock_transfer_details.usage_qty IS
+'Actual quantity successfully taken from source warehouse (FIFO usable tracking) - replaces quantity field';
+
+COMMENT ON COLUMN stock_transfer_details.pending_qty IS
+'Quantity waiting for stock availability (FIFO usable tracking)';
+
+COMMENT ON COLUMN stock_transfer_details.total_qty IS
+'Total lot quantity available at destination warehouse (FIFO stockable tracking)';
+
+COMMENT ON COLUMN stock_transfer_details.total_used IS
+'Quantity already consumed from this lot at destination warehouse (FIFO stockable tracking)';
+

internal/database/migrations/20251228112012_create_adjustment_stocks_table.down.sql

@@ -0,0 +1,16 @@
+-- Rollback: Drop adjustment_stocks table
+
+BEGIN;
+
+DROP INDEX IF EXISTS idx_adjustment_stocks_product_warehouse;
+DROP INDEX IF EXISTS idx_adjustment_stocks_stock_log;
+
+ALTER TABLE adjustment_stocks
+DROP CONSTRAINT IF EXISTS fk_adjustment_stocks_product_warehouse;
+
+ALTER TABLE adjustment_stocks
+DROP CONSTRAINT IF EXISTS fk_adjustment_stocks_stock_log;
+
+DROP TABLE IF EXISTS adjustment_stocks;
+
+COMMIT;

internal/database/migrations/20251228112012_create_adjustment_stocks_table.up.sql

@@ -0,0 +1,40 @@
+-- Migration: Create adjustment_stocks table for FIFO tracking
+-- This table tracks FIFO allocation for stock adjustments (both increase and decrease)
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS adjustment_stocks (
+    id BIGSERIAL PRIMARY KEY,
+    stock_log_id BIGINT NOT NULL,
+    product_warehouse_id BIGINT NOT NULL,
+
+    -- FIFO fields for Adjustment INCREASE (Stockable)
+    -- Tracks stock added to warehouse via adjustment
+    total_qty NUMERIC(15, 3) DEFAULT 0,
+    total_used NUMERIC(15, 3) DEFAULT 0,
+
+    -- FIFO fields for Adjustment DECREASE (Usable)
+    -- Tracks stock consumed from warehouse via adjustment
+    usage_qty NUMERIC(15, 3) DEFAULT 0,
+    pending_qty NUMERIC(15, 3) DEFAULT 0,
+
+    created_at TIMESTAMPTZ DEFAULT now(),
+    updated_at TIMESTAMPTZ DEFAULT now()
+);
+
+-- Foreign keys
+ALTER TABLE adjustment_stocks
+ADD CONSTRAINT fk_adjustment_stocks_stock_log
+FOREIGN KEY (stock_log_id) REFERENCES stock_logs(id)
+ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE adjustment_stocks
+ADD CONSTRAINT fk_adjustment_stocks_product_warehouse
+FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses(id)
+ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- Indexes
+CREATE INDEX idx_adjustment_stocks_stock_log ON adjustment_stocks(stock_log_id);
+CREATE INDEX idx_adjustment_stocks_product_warehouse ON adjustment_stocks(product_warehouse_id);
+
+COMMIT;

internal/database/migrations/20251228173112_adjustment_recording_egg_and_deleting_recording_bws.down.sql

@@ -0,0 +1,54 @@
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS recording_bws (
+    id            BIGSERIAL PRIMARY KEY,
+    recording_id  BIGINT NOT NULL,
+    avg_weight    NUMERIC(8,2) NOT NULL,
+    qty           NUMERIC(15,3) NOT NULL DEFAULT 1,
+    total_weight  NUMERIC(10,3) NOT NULL,
+    created_at    TIMESTAMPTZ DEFAULT NOW(),
+    updated_at    TIMESTAMPTZ DEFAULT NOW(),
+
+    CONSTRAINT fk_recording_bws_recording
+        FOREIGN KEY (recording_id) REFERENCES recordings(id) ON DELETE CASCADE,
+
+    CONSTRAINT chk_recording_bws_nonneg
+        CHECK (avg_weight >= 0 AND qty >= 0 AND total_weight >= 0)
+);
+
+CREATE INDEX IF NOT EXISTS idx_recording_bws_recording
+    ON recording_bws (recording_id);
+
+ALTER TABLE recordings
+    DROP CONSTRAINT IF EXISTS chk_recordings_nonnegatives_v3;
+
+ALTER TABLE recordings
+    DROP COLUMN IF EXISTS hand_day,
+    DROP COLUMN IF EXISTS hand_house,
+    DROP COLUMN IF EXISTS feed_intake,
+    DROP COLUMN IF EXISTS egg_mesh,
+    DROP COLUMN IF EXISTS egg_weight;
+
+ALTER TABLE recordings
+    ADD CONSTRAINT chk_recordings_nonnegatives_v2 CHECK (
+        (total_depletion_qty IS NULL OR total_depletion_qty >= 0) AND
+        (cum_depletion_rate  IS NULL OR cum_depletion_rate  >= 0) AND
+        (daily_gain          IS NULL OR daily_gain          >= 0) AND
+        (avg_daily_gain      IS NULL OR avg_daily_gain      >= 0) AND
+        (cum_intake          IS NULL OR cum_intake          >= 0) AND
+        (fcr_value           IS NULL OR fcr_value           >= 0) AND
+        (total_chick_qty     IS NULL OR total_chick_qty     >= 0)
+    );
+
+ALTER TABLE recording_eggs
+    DROP CONSTRAINT IF EXISTS chk_recording_eggs_qty;
+
+ALTER TABLE recording_eggs
+    ALTER COLUMN weight TYPE NUMERIC(10,3) USING weight::NUMERIC(10,3);
+
+ALTER TABLE recording_eggs
+    ADD CONSTRAINT chk_recording_eggs_qty CHECK (
+        qty >= 0 AND (weight IS NULL OR weight >= 0)
+    );
+
+COMMIT;

internal/database/migrations/20251228173112_adjustment_recording_egg_and_deleting_recording_bws.up.sql

@@ -0,0 +1,44 @@
+BEGIN;
+
+ALTER TABLE recordings
+    DROP CONSTRAINT IF EXISTS chk_recordings_nonnegatives_v2;
+
+ALTER TABLE recordings
+    ADD COLUMN IF NOT EXISTS hand_day NUMERIC(15,3),
+    ADD COLUMN IF NOT EXISTS hand_house NUMERIC(15,3),
+    ADD COLUMN IF NOT EXISTS feed_intake NUMERIC(15,3),
+    ADD COLUMN IF NOT EXISTS egg_mesh NUMERIC(15,3),
+    ADD COLUMN IF NOT EXISTS egg_weight NUMERIC(15,3);
+
+ALTER TABLE recordings
+    ADD CONSTRAINT chk_recordings_nonnegatives_v3 CHECK (
+        (total_depletion_qty IS NULL OR total_depletion_qty >= 0) AND
+        (cum_depletion_rate  IS NULL OR cum_depletion_rate  >= 0) AND
+        (daily_gain          IS NULL OR daily_gain          >= 0) AND
+        (avg_daily_gain      IS NULL OR avg_daily_gain      >= 0) AND
+        (cum_intake          IS NULL OR cum_intake          >= 0) AND
+        (fcr_value           IS NULL OR fcr_value           >= 0) AND
+        (total_chick_qty     IS NULL OR total_chick_qty     >= 0) AND
+        (hand_day            IS NULL OR hand_day            >= 0) AND
+        (hand_house          IS NULL OR hand_house          >= 0) AND
+        (feed_intake         IS NULL OR feed_intake         >= 0) AND
+        (egg_mesh            IS NULL OR egg_mesh            >= 0) AND
+        (egg_weight          IS NULL OR egg_weight          >= 0)
+    );
+
+ALTER TABLE recording_eggs
+    ALTER COLUMN weight TYPE NUMERIC(15,3) USING weight::NUMERIC(15,3);
+
+ALTER TABLE recording_eggs
+    DROP CONSTRAINT IF EXISTS chk_recording_eggs_qty;
+
+ALTER TABLE recording_eggs
+    ADD CONSTRAINT chk_recording_eggs_qty CHECK (
+        qty >= 0 AND
+        (weight IS NULL OR weight >= 0)
+    );
+
+DROP INDEX IF EXISTS idx_recording_bws_recording;
+DROP TABLE IF EXISTS recording_bws;
+
+COMMIT;

internal/database/migrations/20251229125951_adjustment_standart_production_projectflock.down.sql

@@ -0,0 +1,7 @@
+DROP INDEX IF EXISTS idx_project_flocks_production_standard_id;
+
+ALTER TABLE project_flocks
+    DROP CONSTRAINT IF EXISTS fk_project_flocks_production_standard_id;
+
+ALTER TABLE project_flocks
+    DROP COLUMN IF EXISTS production_standard_id;

internal/database/migrations/20251229125951_adjustment_standart_production_projectflock.up.sql

@@ -0,0 +1,15 @@
+-- Add production_standard_id to project_flocks
+ALTER TABLE project_flocks
+    ADD COLUMN IF NOT EXISTS production_standard_id BIGINT;
+
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'production_standards') THEN
+        ALTER TABLE project_flocks
+            ADD CONSTRAINT fk_project_flocks_production_standard_id
+            FOREIGN KEY (production_standard_id) REFERENCES production_standards (id) ON DELETE RESTRICT ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_project_flocks_production_standard_id
+    ON project_flocks (production_standard_id);

internal/database/migrations/20251230014159_alter_table_production_standards_add_fcr_column.down.sql

@@ -0,0 +1,3 @@
+-- Remove standard_fcr column from production_standard_details table
+ALTER TABLE production_standard_details
+DROP COLUMN IF EXISTS standard_fcr;

internal/database/migrations/20251230014159_alter_table_production_standards_add_fcr_column.up.sql

@@ -0,0 +1,3 @@
+-- Add standard_fcr column to production_standard_details table
+ALTER TABLE production_standard_details
+ADD COLUMN standard_fcr NUMERIC(15, 3);

internal/database/migrations/20251230201439_alter_project_chickins_fk_cascade.down.sql

@@ -0,0 +1,20 @@
+-- Drop CASCADE constraint
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_project_chickins_kandang'
+        AND conrelid = 'project_chickins'::regclass
+    ) THEN
+        ALTER TABLE project_chickins
+        DROP CONSTRAINT fk_project_chickins_kandang;
+    END IF;
+END $$;
+
+-- Recreate foreign key constraint with RESTRICT (original behavior)
+ALTER TABLE project_chickins
+ADD CONSTRAINT fk_project_chickins_kandang
+FOREIGN KEY (project_flock_kandang_id)
+REFERENCES project_flock_kandangs(id)
+ON DELETE RESTRICT ON UPDATE CASCADE;

internal/database/migrations/20251230201439_alter_project_chickins_fk_cascade.up.sql

@@ -0,0 +1,20 @@
+-- Drop existing foreign key constraint with RESTRICT
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_project_chickins_kandang'
+        AND conrelid = 'project_chickins'::regclass
+    ) THEN
+        ALTER TABLE project_chickins
+        DROP CONSTRAINT fk_project_chickins_kandang;
+    END IF;
+END $$;
+
+-- Add new foreign key constraint with CASCADE delete
+ALTER TABLE project_chickins
+ADD CONSTRAINT fk_project_chickins_kandang
+FOREIGN KEY (project_flock_kandang_id)
+REFERENCES project_flock_kandangs(id)
+ON DELETE CASCADE ON UPDATE CASCADE;

internal/database/migrations/20260102045853_fix_soft_delete_fk_casts.down.sql

@@ -0,0 +1,126 @@
+CREATE OR REPLACE FUNCTION soft_delete_handle_fk() RETURNS TRIGGER AS $$
+DECLARE
+    fk record;
+    child_column text;
+    parent_column text;
+    parent_value text;
+    child_has_deleted_at boolean;
+    ref_exists boolean;
+    sql text;
+BEGIN
+    IF OLD.deleted_at IS NULL AND NEW.deleted_at IS NOT NULL THEN
+        FOR fk IN
+            SELECT conrelid::regclass AS child_table,
+                   conkey AS child_cols,
+                   confkey AS parent_cols,
+                   confdeltype
+            FROM pg_constraint
+            WHERE contype = 'f'
+              AND confrelid = TG_RELID
+        LOOP
+            IF array_length(fk.child_cols, 1) IS DISTINCT FROM 1
+                OR array_length(fk.parent_cols, 1) IS DISTINCT FROM 1 THEN
+                RAISE NOTICE 'soft_delete_handle_fk skipped composite fk on %', fk.child_table;
+                CONTINUE;
+            END IF;
+
+            SELECT attname INTO child_column
+            FROM pg_attribute
+            WHERE attrelid = fk.child_table
+              AND attnum = fk.child_cols[1]
+              AND NOT attisdropped;
+
+            SELECT attname INTO parent_column
+            FROM pg_attribute
+            WHERE attrelid = TG_RELID
+              AND attnum = fk.parent_cols[1]
+              AND NOT attisdropped;
+
+            EXECUTE format('SELECT ($1).%I', parent_column)
+                INTO parent_value
+                USING OLD;
+
+            SELECT EXISTS (
+                SELECT 1
+                FROM pg_attribute
+                WHERE attrelid = fk.child_table
+                  AND attname = 'deleted_at'
+                  AND NOT attisdropped
+            ) INTO child_has_deleted_at;
+
+            IF fk.confdeltype IN ('r', 'a') THEN
+                sql := format(
+                    'SELECT EXISTS (SELECT 1 FROM %s WHERE %I = $1 %s)',
+                    fk.child_table,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql INTO ref_exists USING parent_value;
+                IF ref_exists THEN
+                    RAISE EXCEPTION 'Cannot soft delete %, still referenced by %',
+                        TG_TABLE_NAME, fk.child_table;
+                END IF;
+            ELSIF fk.confdeltype = 'n' THEN
+                sql := format(
+                    'UPDATE %s SET %I = NULL WHERE %I = $1 %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            ELSIF fk.confdeltype = 'c' THEN
+                IF child_has_deleted_at THEN
+                    sql := format(
+                        'UPDATE %s SET deleted_at = NOW() WHERE %I = $1 AND deleted_at IS NULL',
+                        fk.child_table,
+                        child_column
+                    );
+                    EXECUTE sql USING parent_value;
+                ELSE
+                    sql := format(
+                        'DELETE FROM %s WHERE %I = $1',
+                        fk.child_table,
+                        child_column
+                    );
+                    EXECUTE sql USING parent_value;
+                END IF;
+            ELSIF fk.confdeltype = 'd' THEN
+                sql := format(
+                    'UPDATE %s SET %I = DEFAULT WHERE %I = $1 %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            END IF;
+        END LOOP;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$
+DECLARE
+    r record;
+    trigger_name text;
+BEGIN
+    FOR r IN
+        SELECT table_schema, table_name
+        FROM information_schema.columns
+        WHERE column_name = 'deleted_at'
+          AND table_schema = 'public'
+        GROUP BY table_schema, table_name
+    LOOP
+        trigger_name := format('trg_soft_delete_fk_%s', r.table_name);
+        EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I.%I', trigger_name, r.table_schema, r.table_name);
+        EXECUTE format(
+            'CREATE TRIGGER %I BEFORE UPDATE OF deleted_at ON %I.%I FOR EACH ROW EXECUTE FUNCTION soft_delete_handle_fk()',
+            trigger_name,
+            r.table_schema,
+            r.table_name
+        );
+    END LOOP;
+END $$;

internal/database/migrations/20260102045853_fix_soft_delete_fk_casts.up.sql

@@ -0,0 +1,142 @@
+CREATE OR REPLACE FUNCTION soft_delete_handle_fk() RETURNS TRIGGER AS $$
+DECLARE
+    fk record;
+    child_column text;
+    parent_column text;
+    parent_value text;
+    child_has_deleted_at boolean;
+    ref_exists boolean;
+    sql text;
+    child_type text;
+BEGIN
+    IF OLD.deleted_at IS NULL AND NEW.deleted_at IS NOT NULL THEN
+        FOR fk IN
+            SELECT conrelid::regclass AS child_table,
+                   conkey AS child_cols,
+                   confkey AS parent_cols,
+                   confdeltype
+            FROM pg_constraint
+            WHERE contype = 'f'
+              AND confrelid = TG_RELID
+        LOOP
+            IF array_length(fk.child_cols, 1) IS DISTINCT FROM 1
+                OR array_length(fk.parent_cols, 1) IS DISTINCT FROM 1 THEN
+                RAISE NOTICE 'soft_delete_handle_fk skipped composite fk on %', fk.child_table;
+                CONTINUE;
+            END IF;
+
+            SELECT attname INTO child_column
+            FROM pg_attribute
+            WHERE attrelid = fk.child_table
+              AND attnum = fk.child_cols[1]
+              AND NOT attisdropped;
+
+            SELECT attname INTO parent_column
+            FROM pg_attribute
+            WHERE attrelid = TG_RELID
+              AND attnum = fk.parent_cols[1]
+              AND NOT attisdropped;
+
+            SELECT format_type(atttypid, atttypmod) INTO child_type
+            FROM pg_attribute
+            WHERE attrelid = fk.child_table
+              AND attname = child_column
+              AND NOT attisdropped;
+
+            IF child_type IS NULL THEN
+                child_type := 'text';
+            END IF;
+
+            EXECUTE format('SELECT ($1).%I', parent_column)
+                INTO parent_value
+                USING OLD;
+
+            SELECT EXISTS (
+                SELECT 1
+                FROM pg_attribute
+                WHERE attrelid = fk.child_table
+                  AND attname = 'deleted_at'
+                  AND NOT attisdropped
+            ) INTO child_has_deleted_at;
+
+            IF fk.confdeltype IN ('r', 'a') THEN
+                sql := format(
+                    'SELECT EXISTS (SELECT 1 FROM %s WHERE %I = $1::%s %s)',
+                    fk.child_table,
+                    child_column,
+                    child_type,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql INTO ref_exists USING parent_value;
+                IF ref_exists THEN
+                    RAISE EXCEPTION 'Cannot soft delete %, still referenced by %',
+                        TG_TABLE_NAME, fk.child_table;
+                END IF;
+            ELSIF fk.confdeltype = 'n' THEN
+                sql := format(
+                    'UPDATE %s SET %I = NULL WHERE %I = $1::%s %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    child_type,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            ELSIF fk.confdeltype = 'c' THEN
+                IF child_has_deleted_at THEN
+                    sql := format(
+                        'UPDATE %s SET deleted_at = NOW() WHERE %I = $1::%s AND deleted_at IS NULL',
+                        fk.child_table,
+                        child_column,
+                        child_type
+                    );
+                    EXECUTE sql USING parent_value;
+                ELSE
+                    sql := format(
+                        'DELETE FROM %s WHERE %I = $1::%s',
+                        fk.child_table,
+                        child_column,
+                        child_type
+                    );
+                    EXECUTE sql USING parent_value;
+                END IF;
+            ELSIF fk.confdeltype = 'd' THEN
+                sql := format(
+                    'UPDATE %s SET %I = DEFAULT WHERE %I = $1::%s %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    child_type,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            END IF;
+        END LOOP;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$
+DECLARE
+    r record;
+    trigger_name text;
+BEGIN
+    FOR r IN
+        SELECT table_schema, table_name
+        FROM information_schema.columns
+        WHERE column_name = 'deleted_at'
+          AND table_schema = 'public'
+        GROUP BY table_schema, table_name
+    LOOP
+        trigger_name := format('trg_soft_delete_fk_%s', r.table_name);
+        EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I.%I', trigger_name, r.table_schema, r.table_name);
+        EXECUTE format(
+            'CREATE TRIGGER %I BEFORE UPDATE OF deleted_at ON %I.%I FOR EACH ROW EXECUTE FUNCTION soft_delete_handle_fk()',
+            trigger_name,
+            r.table_schema,
+            r.table_name
+        );
+    END LOOP;
+END $$;

internal/database/migrations/20260102092243_update_uniformity_project_budget_cascade.down.sql

@@ -0,0 +1,86 @@
+BEGIN;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_project_flock_kandang_uniformity_project_flock_kandang'
+    ) THEN
+        ALTER TABLE project_flock_kandang_uniformity
+            DROP CONSTRAINT fk_project_flock_kandang_uniformity_project_flock_kandang;
+    END IF;
+END $$;
+
+ALTER TABLE project_flock_kandang_uniformity
+    ADD CONSTRAINT fk_project_flock_kandang_uniformity_project_flock_kandang
+        FOREIGN KEY (project_flock_kandang_id)
+        REFERENCES project_flock_kandangs (id)
+        ON DELETE RESTRICT ON UPDATE CASCADE;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_tables
+        WHERE tablename = 'project_budgets'
+    ) THEN
+        IF EXISTS (
+            SELECT 1
+            FROM pg_constraint
+            WHERE conname = 'fk_project_budgets_project_flock_id'
+        ) THEN
+            ALTER TABLE project_budgets
+                DROP CONSTRAINT fk_project_budgets_project_flock_id;
+        END IF;
+
+        ALTER TABLE project_budgets
+            ADD CONSTRAINT fk_project_budgets_project_flock_id
+            FOREIGN KEY (project_flock_id)
+            REFERENCES project_flocks(id);
+    END IF;
+END $$;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_tables
+        WHERE tablename = 'project_flock_kandang_uniformity'
+    ) THEN
+        IF NOT EXISTS (
+            SELECT 1
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+              AND table_name = 'project_flock_kandang_uniformity'
+              AND column_name = 'created_at'
+        ) THEN
+            ALTER TABLE project_flock_kandang_uniformity
+                ADD COLUMN created_at TIMESTAMPTZ DEFAULT NOW();
+        END IF;
+
+        IF NOT EXISTS (
+            SELECT 1
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+              AND table_name = 'project_flock_kandang_uniformity'
+              AND column_name = 'updated_at'
+        ) THEN
+            ALTER TABLE project_flock_kandang_uniformity
+                ADD COLUMN updated_at TIMESTAMPTZ DEFAULT NOW();
+        END IF;
+
+        IF NOT EXISTS (
+            SELECT 1
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+              AND table_name = 'project_flock_kandang_uniformity'
+              AND column_name = 'deleted_at'
+        ) THEN
+            ALTER TABLE project_flock_kandang_uniformity
+                ADD COLUMN deleted_at TIMESTAMPTZ;
+        END IF;
+    END IF;
+END $$;
+
+COMMIT;

internal/database/migrations/20260102092243_update_uniformity_project_budget_cascade.up.sql

@@ -0,0 +1,90 @@
+BEGIN;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_project_flock_kandang_uniformity_project_flock_kandang'
+    ) THEN
+        ALTER TABLE project_flock_kandang_uniformity
+            DROP CONSTRAINT fk_project_flock_kandang_uniformity_project_flock_kandang;
+    END IF;
+END $$;
+
+ALTER TABLE project_flock_kandang_uniformity
+    ADD CONSTRAINT fk_project_flock_kandang_uniformity_project_flock_kandang
+        FOREIGN KEY (project_flock_kandang_id)
+        REFERENCES project_flock_kandangs (id)
+        ON DELETE CASCADE ON UPDATE CASCADE;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_tables
+        WHERE tablename = 'project_budgets'
+    ) THEN
+        IF EXISTS (
+            SELECT 1
+            FROM pg_constraint
+            WHERE conname = 'fk_project_budgets_project_flock_id'
+        ) THEN
+            ALTER TABLE project_budgets
+                DROP CONSTRAINT fk_project_budgets_project_flock_id;
+        END IF;
+
+        ALTER TABLE project_budgets
+            ADD CONSTRAINT fk_project_budgets_project_flock_id
+            FOREIGN KEY (project_flock_id)
+            REFERENCES project_flocks(id)
+            ON DELETE CASCADE ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_trigger
+        WHERE tgname = 'trg_soft_delete_fk_project_flock_kandang_uniformity'
+    ) THEN
+        DROP TRIGGER trg_soft_delete_fk_project_flock_kandang_uniformity
+        ON project_flock_kandang_uniformity;
+    END IF;
+
+    IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'project_flock_kandang_uniformity'
+          AND column_name = 'created_at'
+    ) THEN
+        ALTER TABLE project_flock_kandang_uniformity
+            DROP COLUMN created_at;
+    END IF;
+
+    IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'project_flock_kandang_uniformity'
+          AND column_name = 'updated_at'
+    ) THEN
+        ALTER TABLE project_flock_kandang_uniformity
+            DROP COLUMN updated_at;
+    END IF;
+
+    IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'project_flock_kandang_uniformity'
+          AND column_name = 'deleted_at'
+    ) THEN
+        ALTER TABLE project_flock_kandang_uniformity
+            DROP COLUMN deleted_at;
+    END IF;
+END $$;
+
+COMMIT;

internal/database/migrations/20260105131644_create_daily_checklists_tables.down.sql

@@ -0,0 +1,14 @@
+-- Drop tables in correct order (child tables before parent tables)
+DROP TABLE IF EXISTS daily_checklist_activity_task_assignments; -- Child table with FK to daily_checklist_activity_tasks
+DROP TABLE IF EXISTS daily_checklist_activity_task_assignees;
+DROP TABLE IF EXISTS daily_checklist_activity_tasks;
+DROP TABLE IF EXISTS daily_checklist_tasks;
+DROP TABLE IF EXISTS daily_checklist_phases;
+DROP TABLE IF EXISTS daily_checklists;
+DROP TABLE IF EXISTS checklists;
+DROP TABLE IF EXISTS phase_activities;
+DROP TABLE IF EXISTS phases;
+DROP TABLE IF EXISTS employee_kandangs;
+DROP TABLE IF EXISTS employees;
+
+DROP TYPE IF EXISTS category_code;

internal/database/migrations/20260105131644_create_daily_checklists_tables.up.sql

@@ -0,0 +1,194 @@
+CREATE TYPE category_code AS ENUM (
+    'pullet_open',
+    'pullet_close',
+    'produksi_open',
+    'produksi_close'
+);
+
+-- MASTER TABLES
+
+CREATE TABLE employees (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name        varchar NOT NULL,
+  is_active   boolean NOT NULL DEFAULT true,
+  created_at  timestamptz NOT NULL DEFAULT now(),
+  updated_at  timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE employee_kandangs (
+  id           bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  employee_id  bigint NOT NULL,
+  kandang_id   bigint NOT NULL,
+  created_at   timestamptz NOT NULL DEFAULT now(),
+  updated_at   timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_employee_kandangs_employee
+    FOREIGN KEY (employee_id) REFERENCES employees(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_employee_kandangs_kandang
+    FOREIGN KEY (kandang_id) REFERENCES kandangs(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT uq_employee_kandangs UNIQUE (employee_id, kandang_id)
+);
+
+-- PHASE & CHECKLIST
+
+CREATE TABLE phases (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name        varchar NOT NULL,
+  is_active   boolean NOT NULL DEFAULT true,
+  category    category_code NOT NULL,
+  created_at  timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE phase_activities (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  phase_id    bigint NOT NULL,
+  name        varchar NOT NULL,
+  description text,
+  time_type   text,
+  created_at  timestamptz NOT NULL DEFAULT now(),
+  updated_at  timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_phase_activities_phase
+    FOREIGN KEY (phase_id) REFERENCES phases(id)
+    ON DELETE CASCADE
+);
+
+CREATE TABLE checklists (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name        varchar NOT NULL,
+  description text,
+  phase_id    bigint,
+  created_at  timestamptz NOT NULL DEFAULT now(),
+  updated_at  timestamptz NOT NULL DEFAULT now(),
+  deleted_at  timestamptz,
+
+  CONSTRAINT fk_checklists_phase
+    FOREIGN KEY (phase_id) REFERENCES phases(id)
+    ON DELETE SET NULL
+);
+
+
+-- DAILY CHECKLISTS
+CREATE TABLE daily_checklists (
+  id            bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  kandang_id    bigint NOT NULL,
+  checklist_id  bigint NOT NULL,
+  date          date NOT NULL,
+  name          varchar,
+  status        varchar,
+  category      category_code NOT NULL,
+  total_score   integer,
+  document_path varchar,
+  reject_reason text,
+  created_by    bigint,
+  created_at    timestamptz NOT NULL DEFAULT now(),
+  updated_at    timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_daily_checklists_kandang
+    FOREIGN KEY (kandang_id) REFERENCES kandangs(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_daily_checklists_checklist
+    FOREIGN KEY (checklist_id) REFERENCES checklists(id)
+    ON DELETE RESTRICT,
+
+  CONSTRAINT fk_daily_checklists_created_by
+    FOREIGN KEY (created_by) REFERENCES users(id)
+    ON DELETE SET NULL
+);
+
+
+--RELASI CHECKLIST ⇄ PHASE
+
+CREATE TABLE daily_checklist_phases (
+  id           bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  checklist_id bigint NOT NULL,
+  phase_id     bigint NOT NULL,
+  created_at   timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_dcp_checklist
+    FOREIGN KEY (checklist_id) REFERENCES checklists(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_dcp_phase
+    FOREIGN KEY (phase_id) REFERENCES phases(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT uq_daily_checklist_phases UNIQUE (checklist_id, phase_id)
+);
+
+
+--ACTIVITY TASKS & ASSIGNMENT
+
+
+CREATE TABLE daily_checklist_activity_tasks (
+  id               bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  checklist_id     bigint NOT NULL,
+  phase_id         bigint NOT NULL,
+  phase_activity_id bigint NOT NULL,
+  time_type        text,
+  notes            text,
+  created_at       timestamptz NOT NULL DEFAULT now(),
+  updated_at       timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_dcat_checklist
+    FOREIGN KEY (checklist_id) REFERENCES checklists(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_dcat_phase
+    FOREIGN KEY (phase_id) REFERENCES phases(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_dcat_phase_activity
+    FOREIGN KEY (phase_activity_id) REFERENCES phase_activities(id)
+    ON DELETE CASCADE
+);
+
+CREATE TABLE daily_checklist_activity_task_assignments (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  task_id     bigint NOT NULL,
+  employee_id bigint NOT NULL,
+  checked     boolean NOT NULL DEFAULT false,
+  note        text,
+  created_at  timestamptz NOT NULL DEFAULT now(),
+  updated_at  timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_assignment_task
+    FOREIGN KEY (task_id) REFERENCES daily_checklist_activity_tasks(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_assignment_employee
+    FOREIGN KEY (employee_id) REFERENCES employees(id)
+    ON DELETE CASCADE
+);
+
+--DAILY CHECKLIST TASK RESULT
+CREATE TABLE daily_checklist_tasks (
+  id                bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  daily_checklist_id bigint NOT NULL,
+  checklist_id      bigint NOT NULL,
+  checklist_item_id bigint,
+  is_completed      boolean NOT NULL DEFAULT false,
+  score_value       integer,
+  notes             text,
+  photo_proof       varchar,
+  status            varchar,
+  created_at        timestamptz NOT NULL DEFAULT now(),
+  updated_at        timestamptz NOT NULL DEFAULT now(),
+
+  CONSTRAINT fk_dct_daily
+    FOREIGN KEY (daily_checklist_id) REFERENCES daily_checklists(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_dct_checklist
+    FOREIGN KEY (checklist_id) REFERENCES checklists(id)
+    ON DELETE CASCADE,
+
+  CONSTRAINT fk_dct_checklist_item
+    FOREIGN KEY (checklist_item_id) REFERENCES phase_activities(id)
+    ON DELETE SET NULL
+);

internal/database/migrations/20260106090725_fk_recording_cascade.down.sql

@@ -0,0 +1,21 @@
+BEGIN;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_recordings_project_flock_kandang'
+    ) THEN
+        ALTER TABLE recordings
+            DROP CONSTRAINT fk_recordings_project_flock_kandang;
+    END IF;
+END $$;
+
+ALTER TABLE recordings
+    ADD CONSTRAINT fk_recordings_project_flock_kandang
+        FOREIGN KEY (project_flock_kandangs_id)
+        REFERENCES project_flock_kandangs (id)
+        ON DELETE RESTRICT ON UPDATE CASCADE;
+
+COMMIT;

internal/database/migrations/20260106090725_fk_recording_cascade.up.sql

@@ -0,0 +1,21 @@
+BEGIN;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'fk_recordings_project_flock_kandang'
+    ) THEN
+        ALTER TABLE recordings
+            DROP CONSTRAINT fk_recordings_project_flock_kandang;
+    END IF;
+END $$;
+
+ALTER TABLE recordings
+    ADD CONSTRAINT fk_recordings_project_flock_kandang
+        FOREIGN KEY (project_flock_kandangs_id)
+        REFERENCES project_flock_kandangs (id)
+        ON DELETE CASCADE ON UPDATE CASCADE;
+
+COMMIT;

internal/database/migrations/20260106101434_add_unique_daily_checklists.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE daily_checklists
+    DROP CONSTRAINT IF EXISTS daily_checklists_date_kandang_category_key;

internal/database/migrations/20260106101434_add_unique_daily_checklists.up.sql

@@ -0,0 +1,3 @@
+ALTER TABLE daily_checklists
+    ADD CONSTRAINT daily_checklists_date_kandang_category_key
+    UNIQUE (date, kandang_id, category);

internal/database/migrations/20260106102657_alter_daily_checklists_checklist_id_nullable.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE daily_checklists
+    ALTER COLUMN checklist_id SET NOT NULL;

internal/database/migrations/20260106102657_alter_daily_checklists_checklist_id_nullable.up.sql

@@ -0,0 +1,2 @@
+ALTER TABLE daily_checklists
+    ALTER COLUMN checklist_id DROP NOT NULL;

internal/database/migrations/20260106111217_update_daily_checklist_phases_fk.down.sql

@@ -0,0 +1,4 @@
+ALTER TABLE daily_checklist_phases
+    DROP CONSTRAINT IF EXISTS fk_dcp_daily_checklist,
+    ADD CONSTRAINT fk_dcp_checklist
+        FOREIGN KEY (checklist_id) REFERENCES checklists(id) ON DELETE CASCADE;

internal/database/migrations/20260106111217_update_daily_checklist_phases_fk.up.sql

@@ -0,0 +1,4 @@
+ALTER TABLE daily_checklist_phases
+    DROP CONSTRAINT IF EXISTS fk_dcp_checklist,
+    ADD CONSTRAINT fk_dcp_daily_checklist
+        FOREIGN KEY (checklist_id) REFERENCES daily_checklists(id) ON DELETE CASCADE;

internal/database/migrations/20260106113501_alter_expense_fk_to_cascade.down.sql

@@ -0,0 +1,15 @@
+-- Revert back to NO ACTION (RESTRICT behavior)
+ALTER TABLE expense_nonstocks DROP CONSTRAINT IF EXISTS fk_expense_nonstocks_expense_id;
+
+ALTER TABLE expense_nonstocks
+    ADD CONSTRAINT fk_expense_nonstocks_expense_id
+    FOREIGN KEY (expense_id) REFERENCES expenses(id)
+    ON DELETE NO ACTION;
+
+-- Revert expense_realizations FK
+ALTER TABLE expense_realizations DROP CONSTRAINT IF EXISTS fk_expense_realizations_nonstock_id;
+
+ALTER TABLE expense_realizations
+    ADD CONSTRAINT fk_expense_realizations_nonstock_id
+    FOREIGN KEY (expense_nonstock_id) REFERENCES expense_nonstocks(id)
+    ON DELETE NO ACTION;

internal/database/migrations/20260106113501_alter_expense_fk_to_cascade.up.sql

@@ -0,0 +1,16 @@
+-- Drop existing FK constraints
+ALTER TABLE expense_nonstocks DROP CONSTRAINT IF EXISTS fk_expense_nonstocks_expense_id;
+
+-- Recreate with ON DELETE CASCADE
+ALTER TABLE expense_nonstocks
+    ADD CONSTRAINT fk_expense_nonstocks_expense_id
+    FOREIGN KEY (expense_id) REFERENCES expenses(id)
+    ON DELETE CASCADE;
+
+-- Drop and recreate expense_realizations FK
+ALTER TABLE expense_realizations DROP CONSTRAINT IF EXISTS fk_expense_realizations_nonstock_id;
+
+ALTER TABLE expense_realizations
+    ADD CONSTRAINT fk_expense_realizations_nonstock_id
+    FOREIGN KEY (expense_nonstock_id) REFERENCES expense_nonstocks(id)
+    ON DELETE CASCADE;

internal/database/migrations/20260106113502_ensure_marketing_fk_cascade.down.sql

@@ -0,0 +1,20 @@
+-- Revert back to NO ACTION (for rollback safety)
+DO $$
+BEGIN
+    ALTER TABLE marketing_products DROP CONSTRAINT IF EXISTS fk_marketing_products_marketing_id;
+
+    ALTER TABLE marketing_products
+        ADD CONSTRAINT fk_marketing_products_marketing_id
+        FOREIGN KEY (marketing_id) REFERENCES marketings(id)
+        ON DELETE NO ACTION;
+END $$;
+
+DO $$
+BEGIN
+    ALTER TABLE marketing_delivery_products DROP CONSTRAINT IF EXISTS fk_marketing_delivery_products_marketing_product_id;
+
+    ALTER TABLE marketing_delivery_products
+        ADD CONSTRAINT fk_marketing_delivery_products_marketing_product_id
+        FOREIGN KEY (marketing_product_id) REFERENCES marketing_products(id)
+        ON DELETE NO ACTION;
+END $$;

internal/database/migrations/20260106113502_ensure_marketing_fk_cascade.up.sql

@@ -0,0 +1,35 @@
+-- Ensure marketing_products FK is CASCADE (it should already be, but let's make sure)
+DO $$
+BEGIN
+    -- Drop existing FK if exists
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_marketing_products_marketing_id'
+    ) THEN
+        ALTER TABLE marketing_products DROP CONSTRAINT fk_marketing_products_marketing_id;
+    END IF;
+
+    -- Recreate with ON DELETE CASCADE
+    ALTER TABLE marketing_products
+        ADD CONSTRAINT fk_marketing_products_marketing_id
+        FOREIGN KEY (marketing_id) REFERENCES marketings(id)
+        ON DELETE CASCADE;
+END $$;
+
+-- Ensure marketing_delivery_products FK is CASCADE
+DO $$
+BEGIN
+    -- Drop existing FK if exists
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_marketing_delivery_products_marketing_product_id'
+    ) THEN
+        ALTER TABLE marketing_delivery_products DROP CONSTRAINT fk_marketing_delivery_products_marketing_product_id;
+    END IF;
+
+    -- Recreate with ON DELETE CASCADE
+    ALTER TABLE marketing_delivery_products
+        ADD CONSTRAINT fk_marketing_delivery_products_marketing_product_id
+        FOREIGN KEY (marketing_product_id) REFERENCES marketing_products(id)
+        ON DELETE CASCADE;
+END $$;

internal/database/migrations/20260106113503_add_product_warehouse_to_laying_transfers.down.sql

@@ -0,0 +1,9 @@
+-- Drop foreign key and column
+ALTER TABLE laying_transfers
+DROP CONSTRAINT IF EXISTS fk_laying_transfers_product_warehouse_id;
+
+ALTER TABLE laying_transfers
+DROP COLUMN IF EXISTS product_warehouse_id;
+
+-- Drop index
+DROP INDEX IF EXISTS idx_laying_transfers_product_warehouse_id;

internal/database/migrations/20260106113503_add_product_warehouse_to_laying_transfers.up.sql

@@ -0,0 +1,19 @@
+-- Add product_warehouse_id to laying_transfers for FIFO support
+ALTER TABLE laying_transfers
+ADD COLUMN product_warehouse_id BIGINT;
+
+-- Add foreign key
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
+        ALTER TABLE laying_transfers
+            ADD CONSTRAINT fk_laying_transfers_product_warehouse_id
+            FOREIGN KEY (product_warehouse_id)
+            REFERENCES product_warehouses(id)
+            ON DELETE SET NULL;
+    END IF;
+END $$;
+
+-- Add index
+CREATE INDEX idx_laying_transfers_product_warehouse_id
+ON laying_transfers(product_warehouse_id);

internal/database/migrations/20260106113936_update_daily_checklist_activity_task_fk.down.sql

@@ -0,0 +1,4 @@
+ALTER TABLE daily_checklist_activity_tasks
+    DROP CONSTRAINT IF EXISTS fk_dcat_daily_checklist,
+    ADD CONSTRAINT fk_dcat_checklist
+        FOREIGN KEY (checklist_id) REFERENCES checklists(id) ON DELETE CASCADE;

internal/database/migrations/20260106113936_update_daily_checklist_activity_task_fk.up.sql

@@ -0,0 +1,4 @@
+ALTER TABLE daily_checklist_activity_tasks
+    DROP CONSTRAINT IF EXISTS fk_dcat_checklist,
+    ADD CONSTRAINT fk_dcat_daily_checklist
+        FOREIGN KEY (checklist_id) REFERENCES daily_checklists(id) ON DELETE CASCADE;

internal/database/migrations/20260106140815_add_stockable_fields_to_laying_transfers.down.sql

@@ -0,0 +1,14 @@
+-- Rollback: Remove STOCKABLE fields from laying_transfers
+
+-- Drop index
+DROP INDEX IF EXISTS idx_laying_transfers_dest_product_warehouse_id;
+
+-- Drop foreign key constraint
+ALTER TABLE laying_transfers
+DROP CONSTRAINT IF EXISTS fk_laying_transfers_dest_product_warehouse_id;
+
+-- Drop columns
+ALTER TABLE laying_transfers
+DROP COLUMN IF EXISTS dest_product_warehouse_id,
+DROP COLUMN IF EXISTS total_qty,
+DROP COLUMN IF EXISTS total_used;

internal/database/migrations/20260106140815_add_stockable_fields_to_laying_transfers.up.sql

@@ -0,0 +1,30 @@
+-- Add STOCKABLE fields to laying_transfers for destination warehouse
+-- This enables Transfer to Laying to work as DUAL ROLE (Stockable + Usable)
+
+-- Add columns for STOCKABLE role (destination warehouse)
+ALTER TABLE laying_transfers
+ADD COLUMN dest_product_warehouse_id BIGINT,
+ADD COLUMN total_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN total_used NUMERIC(15, 3) DEFAULT 0;
+
+-- Add foreign key constraint
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
+        ALTER TABLE laying_transfers
+            ADD CONSTRAINT fk_laying_transfers_dest_product_warehouse_id
+            FOREIGN KEY (dest_product_warehouse_id)
+            REFERENCES product_warehouses(id)
+            ON DELETE SET NULL;
+    END IF;
+END $$;
+
+-- Add index for performance
+CREATE INDEX idx_laying_transfers_dest_product_warehouse_id
+ON laying_transfers(dest_product_warehouse_id);
+
+-- Add comment for documentation
+COMMENT ON COLUMN laying_transfers.product_warehouse_id IS 'Product warehouse at source (Growing flock) - for USABLE role';
+COMMENT ON COLUMN laying_transfers.dest_product_warehouse_id IS 'Product warehouse at destination (Laying flock) - for STOCKABLE role';
+COMMENT ON COLUMN laying_transfers.total_qty IS 'Total lot quantity introduced to destination warehouse - for STOCKABLE role';
+COMMENT ON COLUMN laying_transfers.total_used IS 'Quantity already consumed from this lot at destination - for STOCKABLE role';

internal/database/migrations/20260106150814_add_unique_activity_task_assignments.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE daily_checklist_activity_task_assignments
+    DROP CONSTRAINT IF EXISTS daily_checklist_activity_task_assignments_task_employee_key;

internal/database/migrations/20260106150814_add_unique_activity_task_assignments.up.sql

@@ -0,0 +1,3 @@
+ALTER TABLE daily_checklist_activity_task_assignments
+    ADD CONSTRAINT daily_checklist_activity_task_assignments_task_employee_key
+    UNIQUE (task_id, employee_id);

internal/database/migrations/20260106164640_add_deleted_at_to_master_tables.down.sql

@@ -0,0 +1,8 @@
+ALTER TABLE phase_activities
+    DROP COLUMN IF EXISTS deleted_at;
+
+ALTER TABLE phases
+    DROP COLUMN IF EXISTS deleted_at;
+
+ALTER TABLE employees
+    DROP COLUMN IF EXISTS deleted_at;

internal/database/migrations/20260106164640_add_deleted_at_to_master_tables.up.sql

@@ -0,0 +1,8 @@
+ALTER TABLE employees
+    ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMPTZ;
+
+ALTER TABLE phases
+    ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMPTZ;
+
+ALTER TABLE phase_activities
+    ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMPTZ;

internal/database/migrations/20260107075608_alter_uniformity_table.down.sql

@@ -0,0 +1,7 @@
+-- Remove chart_data, uniform_date, and related indexes
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_uniform_date;
+DROP INDEX IF EXISTS idx_project_flock_kandang_uniformity_unique;
+
+ALTER TABLE project_flock_kandang_uniformity
+    DROP COLUMN IF EXISTS chart_data,
+    DROP COLUMN IF EXISTS uniform_date;

internal/database/migrations/20260107075608_alter_uniformity_table.up.sql

@@ -0,0 +1,25 @@
+-- Add uniform_date (if missing), chart_data, and unique constraint for uniformity records
+ALTER TABLE project_flock_kandang_uniformity
+    ADD COLUMN IF NOT EXISTS uniform_date TIMESTAMPTZ,
+    ADD COLUMN IF NOT EXISTS chart_data JSONB;
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'project_flock_kandang_uniformity'
+          AND column_name = 'deleted_at'
+    ) THEN
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_unique
+            ON project_flock_kandang_uniformity (project_flock_kandang_id, week, uniform_date)
+            WHERE deleted_at IS NULL;
+    ELSE
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_unique
+            ON project_flock_kandang_uniformity (project_flock_kandang_id, week, uniform_date);
+    END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_project_flock_kandang_uniformity_uniform_date
+    ON project_flock_kandang_uniformity (uniform_date);

internal/database/migrations/20260107080257_add_expense_to_stock_transfer_details.down.sql

@@ -0,0 +1,4 @@
+-- Remove expense_nonstock_id from stock_transfer_details
+ALTER TABLE stock_transfer_details DROP CONSTRAINT IF EXISTS fk_stock_transfer_details_expense_nonstock;
+ALTER TABLE stock_transfer_details DROP COLUMN IF EXISTS expense_nonstock_id;
+DROP INDEX IF EXISTS idx_stock_transfer_details_expense_nonstock_id;

internal/database/migrations/20260107080257_add_expense_to_stock_transfer_details.up.sql

@@ -0,0 +1,10 @@
+-- Add expense_nonstock_id to stock_transfer_details
+-- This allows tracking expedition/transport costs for stock transfers (same as purchase)
+
+ALTER TABLE stock_transfer_details
+ADD COLUMN expense_nonstock_id BIGINT,
+ADD CONSTRAINT fk_stock_transfer_details_expense_nonstock
+FOREIGN KEY (expense_nonstock_id) REFERENCES expense_nonstocks(id) ON DELETE SET NULL;
+
+-- Create index for better query performance
+CREATE INDEX idx_stock_transfer_details_expense_nonstock_id ON stock_transfer_details(expense_nonstock_id);

internal/database/migrations/20260107120000_create_config_checklists_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS config_checklists;

internal/database/migrations/20260107120000_create_config_checklists_table.up.sql

@@ -0,0 +1,9 @@
+CREATE TABLE IF NOT EXISTS config_checklists (
+    id BIGSERIAL PRIMARY KEY,
+    date DATE NOT NULL,
+    percentage_threshold_bad INTEGER NOT NULL,
+    percentage_threshold_enough INTEGER NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    deleted_at TIMESTAMPTZ
+);

internal/database/migrations/20260109074006_add_party_account_number_to_payments.down.sql

@@ -0,0 +1,6 @@
+BEGIN;
+
+ALTER TABLE payments
+    DROP COLUMN IF EXISTS party_account_number;
+
+COMMIT;

internal/database/migrations/20260109074006_add_party_account_number_to_payments.up.sql

@@ -0,0 +1,6 @@
+BEGIN;
+
+ALTER TABLE payments
+    ADD COLUMN IF NOT EXISTS party_account_number VARCHAR(50);
+
+COMMIT;

internal/database/migrations/20260109093155_drop_unused_tables.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS projects;

internal/database/migrations/20260109093155_drop_unused_tables.up.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS projects;

internal/database/migrations/20260109093832_update_master_data_fk_restrict.down.sql

@@ -0,0 +1,20 @@
+-- Revert master data foreign keys to CASCADE delete (except FCR)
+ALTER TABLE nonstock_suppliers
+    DROP CONSTRAINT IF EXISTS nonstock_suppliers_nonstock_id_fkey,
+    DROP CONSTRAINT IF EXISTS nonstock_suppliers_supplier_id_fkey;
+
+ALTER TABLE nonstock_suppliers
+    ADD CONSTRAINT nonstock_suppliers_nonstock_id_fkey FOREIGN KEY (nonstock_id)
+        REFERENCES nonstocks (id) ON DELETE CASCADE ON UPDATE CASCADE,
+    ADD CONSTRAINT nonstock_suppliers_supplier_id_fkey FOREIGN KEY (supplier_id)
+        REFERENCES suppliers (id) ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE product_suppliers
+    DROP CONSTRAINT IF EXISTS product_suppliers_product_id_fkey,
+    DROP CONSTRAINT IF EXISTS product_suppliers_supplier_id_fkey;
+
+ALTER TABLE product_suppliers
+    ADD CONSTRAINT product_suppliers_product_id_fkey FOREIGN KEY (product_id)
+        REFERENCES products (id) ON DELETE CASCADE ON UPDATE CASCADE,
+    ADD CONSTRAINT product_suppliers_supplier_id_fkey FOREIGN KEY (supplier_id)
+        REFERENCES suppliers (id) ON DELETE CASCADE ON UPDATE CASCADE;

internal/database/migrations/20260109093832_update_master_data_fk_restrict.up.sql

@@ -0,0 +1,20 @@
+-- Update master data foreign keys to RESTRICT delete (except FCR)
+ALTER TABLE nonstock_suppliers
+    DROP CONSTRAINT IF EXISTS nonstock_suppliers_nonstock_id_fkey,
+    DROP CONSTRAINT IF EXISTS nonstock_suppliers_supplier_id_fkey;
+
+ALTER TABLE nonstock_suppliers
+    ADD CONSTRAINT nonstock_suppliers_nonstock_id_fkey FOREIGN KEY (nonstock_id)
+        REFERENCES nonstocks (id) ON DELETE RESTRICT ON UPDATE CASCADE,
+    ADD CONSTRAINT nonstock_suppliers_supplier_id_fkey FOREIGN KEY (supplier_id)
+        REFERENCES suppliers (id) ON DELETE RESTRICT ON UPDATE CASCADE;
+
+ALTER TABLE product_suppliers
+    DROP CONSTRAINT IF EXISTS product_suppliers_product_id_fkey,
+    DROP CONSTRAINT IF EXISTS product_suppliers_supplier_id_fkey;
+
+ALTER TABLE product_suppliers
+    ADD CONSTRAINT product_suppliers_product_id_fkey FOREIGN KEY (product_id)
+        REFERENCES products (id) ON DELETE RESTRICT ON UPDATE CASCADE,
+    ADD CONSTRAINT product_suppliers_supplier_id_fkey FOREIGN KEY (supplier_id)
+        REFERENCES suppliers (id) ON DELETE RESTRICT ON UPDATE CASCADE;

internal/database/migrations/20260109145555_move_fifo_fields_from_laying_transfers_to_detail_tables.down.sql

@@ -0,0 +1,79 @@
+-- Rollback: Revert FIFO fields back to laying_transfers from detail tables
+
+-- ============================================================================
+-- PART 1: Remove FIFO columns from detail tables
+-- ============================================================================
+
+-- Add back old qty column first
+ALTER TABLE laying_transfer_sources
+    ADD COLUMN IF NOT EXISTS qty NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+ALTER TABLE laying_transfer_targets
+    ADD COLUMN IF NOT EXISTS qty NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+-- Now drop FIFO columns
+ALTER TABLE laying_transfer_sources
+    DROP COLUMN IF EXISTS usage_qty,
+    DROP COLUMN IF EXISTS pending_usage_qty;
+
+ALTER TABLE laying_transfer_targets
+    DROP COLUMN IF EXISTS total_qty,
+    DROP COLUMN IF EXISTS total_used;
+
+-- ============================================================================
+-- PART 2: Add back FIFO columns to laying_transfers table
+-- ============================================================================
+
+-- Add columns back for USABLE role (source warehouse)
+ALTER TABLE laying_transfers
+    ADD COLUMN product_warehouse_id BIGINT,
+    ADD COLUMN pending_usage_qty NUMERIC(15, 3),
+    ADD COLUMN usage_qty NUMERIC(15, 3);
+
+-- Add columns back for STOCKABLE role (destination warehouse)
+ALTER TABLE laying_transfers
+    ADD COLUMN dest_product_warehouse_id BIGINT,
+    ADD COLUMN total_qty NUMERIC(15, 3) DEFAULT 0 NOT NULL,
+    ADD COLUMN total_used NUMERIC(15, 3) DEFAULT 0 NOT NULL;
+
+-- ============================================================================
+-- PART 3: Recreate foreign key constraints
+-- ============================================================================
+
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
+        -- Add source product warehouse FK
+        ALTER TABLE laying_transfers
+            ADD CONSTRAINT fk_laying_transfers_product_warehouse_id
+            FOREIGN KEY (product_warehouse_id)
+            REFERENCES product_warehouses(id)
+            ON DELETE SET NULL;
+
+        -- Add destination product warehouse FK
+        ALTER TABLE laying_transfers
+            ADD CONSTRAINT fk_laying_transfers_dest_product_warehouse_id
+            FOREIGN KEY (dest_product_warehouse_id)
+            REFERENCES product_warehouses(id)
+            ON DELETE SET NULL;
+    END IF;
+END $$;
+
+-- ============================================================================
+-- PART 4: Recreate indexes for performance
+-- ============================================================================
+
+CREATE INDEX idx_laying_transfers_product_warehouse_id
+    ON laying_transfers(product_warehouse_id);
+
+CREATE INDEX idx_laying_transfers_dest_product_warehouse_id
+    ON laying_transfers(dest_product_warehouse_id);
+
+-- ============================================================================
+-- PART 5: Recreate comments for documentation
+-- ============================================================================
+
+COMMENT ON COLUMN laying_transfers.product_warehouse_id IS 'Product warehouse at source (Growing flock) - for USABLE role';
+COMMENT ON COLUMN laying_transfers.dest_product_warehouse_id IS 'Product warehouse at destination (Laying flock) - for STOCKABLE role';
+COMMENT ON COLUMN laying_transfers.total_qty IS 'Total lot quantity introduced to destination warehouse - for STOCKABLE role';
+COMMENT ON COLUMN laying_transfers.total_used IS 'Quantity already consumed from this lot at destination - for FIFO STOCKABLE role';