Fix categories with table

List categories for self-order
Self Order - BE
2026-05-08 14:19:40 +07:00 · 2026-05-06 11:56:11 +07:00 · 2026-05-05 21:07:03 +07:00 · 2026-04-27 14:22:22 +00:00 · 2026-04-27 21:17:12 +07:00 · 2026-04-27 13:24:16 +07:00
27 changed files with 1264 additions and 824 deletions
@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y ca-certificates tzdata curl && rm -rf /
 RUN groupadd -r appuser && useradd -r -g appuser appuser
 COPY --from=build /out/app /app
 ENV TZ=Asia/Jakarta
-EXPOSE 3300
+EXPOSE 4000
 HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -fsS http://localhost:3300/health || exit 1
 USER appuser
@@ -2,7 +2,7 @@
 set -euo pipefail

 APP_NAME="apskel-pos"
-PORT="3300"
+PORT="4000"

 echo "🔄 Pulling latest code..."
 git pull
@@ -44,6 +44,14 @@ func (a *App) Initialize(cfg *config.Config) error {
 	validators := a.initValidators()
 	middleware := a.initMiddleware(services, cfg)
 	healthHandler := handler.NewHealthHandler()
+	selfOrderHandler := handler.NewSelfOrderHandler(
+		services.orderService,
+		services.categoryService,
+		services.productService,
+		repos.tableRepo,
+		repos.outletRepo,
+		repos.userRepo,
+	)

 	a.router = router.NewRouter(
 		cfg,
@@ -105,6 +113,7 @@ func (a *App) Initialize(cfg *config.Config) error {
 		services.customerPointsService,
 		services.spinGameService,
 		middleware.customerAuthMiddleware,
+		selfOrderHandler,
 	)

 	return nil
@@ -170,6 +179,7 @@ type repositories struct {
 	tableRepo                      *repository.TableRepository
 	unitRepo                       *repository.UnitRepository
 	ingredientRepo                 *repository.IngredientRepository
+	ingredientCompositionRepo      *repository.IngredientCompositionRepository
 	productRecipeRepo              *repository.ProductRecipeRepository
 	vendorRepo                     *repository.VendorRepositoryImpl
 	purchaseOrderRepo              *repository.PurchaseOrderRepositoryImpl
@@ -215,6 +225,7 @@ func (a *App) initRepositories() *repositories {
 		tableRepo:                      repository.NewTableRepository(a.db),
 		unitRepo:                       repository.NewUnitRepository(a.db),
 		ingredientRepo:                 repository.NewIngredientRepository(a.db),
+		ingredientCompositionRepo:      repository.NewIngredientCompositionRepository(a.db),
 		productRecipeRepo:              repository.NewProductRecipeRepository(a.db),
 		vendorRepo:                     repository.NewVendorRepositoryImpl(a.db),
 		purchaseOrderRepo:              repository.NewPurchaseOrderRepositoryImpl(a.db),
@@ -302,7 +313,7 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor
 		analyticsProcessor:                  processor.NewAnalyticsProcessorImpl(repos.analyticsRepo),
 		tableProcessor:                      processor.NewTableProcessor(repos.tableRepo, repos.orderRepo),
 		unitProcessor:                       processor.NewUnitProcessor(repos.unitRepo),
-		ingredientProcessor:                 processor.NewIngredientProcessor(repos.ingredientRepo, repos.unitRepo),
+		ingredientProcessor:                 processor.NewIngredientProcessor(repos.ingredientRepo, repos.unitRepo, repos.ingredientCompositionRepo),
 		productRecipeProcessor:              processor.NewProductRecipeProcessor(repos.productRecipeRepo, repos.productRepo, repos.ingredientRepo),
 		vendorProcessor:                     processor.NewVendorProcessorImpl(repos.vendorRepo),
 		purchaseOrderProcessor:              processor.NewPurchaseOrderProcessorImpl(repos.purchaseOrderRepo, repos.vendorRepo, repos.ingredientRepo, repos.unitRepo, repos.fileRepo, inventoryMovementService, repos.unitConverterRepo),
@@ -41,6 +41,7 @@ const (
 	VendorServiceEntity                  = "vendor_service"
 	PurchaseOrderServiceEntity           = "purchase_order_service"
 	IngredientUnitConverterServiceEntity = "ingredient_unit_converter_service"
+	IngredientCompositionServiceEntity   = "ingredient_composition_service"
 	TableEntity                          = "table"
 	// Gamification entities
 	CustomerPointsEntity  = "customer_points"
@@ -1,16 +0,0 @@
-package contract
-
-import (
-	"apskel-pos-be/internal/models"
-
-	"github.com/google/uuid"
-)
-
-type IngredientCompositionContract interface {
-	Create(request *models.CreateIngredientCompositionRequest, organizationID uuid.UUID) (*models.IngredientCompositionResponse, error)
-	GetByID(id uuid.UUID, organizationID uuid.UUID) (*models.IngredientCompositionResponse, error)
-	GetByParentIngredientID(parentIngredientID uuid.UUID, organizationID uuid.UUID) ([]*models.IngredientCompositionResponse, error)
-	GetByChildIngredientID(childIngredientID uuid.UUID, organizationID uuid.UUID) ([]*models.IngredientCompositionResponse, error)
-	Update(id uuid.UUID, request *models.UpdateIngredientCompositionRequest, organizationID uuid.UUID) (*models.IngredientCompositionResponse, error)
-	Delete(id uuid.UUID, organizationID uuid.UUID) error
-}
@@ -0,0 +1,69 @@
+package contract
+
+import (
+	"github.com/google/uuid"
+)
+
+type SelfOrderMenuRequest struct {
+	TableID      uuid.UUID `json:"table_id" validate:"required"`
+	CustomerName string    `json:"customer_name" validate:"required"`
+	Phone        *string   `json:"phone,omitempty"`
+}
+
+type SelfOrderMenuResponse struct {
+	OutletName string                  `json:"outlet_name"`
+	TableName  string                  `json:"table_name"`
+	Categories []SelfOrderMenuCategory `json:"categories"`
+}
+
+type SelfOrderMenuCategory struct {
+	ID          uuid.UUID           `json:"id"`
+	Name        string              `json:"name"`
+	Description *string             `json:"description,omitempty"`
+	Order       int                 `json:"order"`
+	Products    []SelfOrderMenuItem `json:"products"`
+}
+
+type SelfOrderMenuItem struct {
+	ID          uuid.UUID              `json:"id"`
+	Name        string                 `json:"name"`
+	Description *string                `json:"description,omitempty"`
+	Price       float64                `json:"price"`
+	ImageURL    *string                `json:"image_url,omitempty"`
+	Variants    []SelfOrderMenuVariant `json:"variants,omitempty"`
+}
+
+type SelfOrderMenuVariant struct {
+	ID            uuid.UUID `json:"id"`
+	Name          string    `json:"name"`
+	PriceModifier float64   `json:"price_modifier"`
+}
+
+type SelfOrderCreateOrderRequest struct {
+	TableID      uuid.UUID                  `json:"table_id" validate:"required"`
+	CustomerName string                     `json:"customer_name" validate:"required"`
+	Phone        *string                    `json:"phone,omitempty"`
+	OrderItems   []SelfOrderCreateOrderItem `json:"order_items" validate:"required,min=1,dive"`
+}
+
+type SelfOrderCreateOrderItem struct {
+	ProductID        uuid.UUID  `json:"product_id" validate:"required"`
+	ProductVariantID *uuid.UUID `json:"product_variant_id,omitempty"`
+	Quantity         int        `json:"quantity" validate:"required,min=1"`
+	Notes            *string    `json:"notes,omitempty"`
+}
+
+type SelfOrderListCategoriesRequest struct {
+	TableID string `form:"table_id" validate:"required"`
+}
+
+type SelfOrderCategoryItem struct {
+	ID          uuid.UUID `json:"id"`
+	Name        string    `json:"name"`
+	Description *string   `json:"description,omitempty"`
+	Order       int       `json:"order"`
+}
+
+type SelfOrderListCategoriesResponse struct {
+	Categories []SelfOrderCategoryItem `json:"categories"`
+}
@@ -7,17 +7,18 @@ import (
 )

 type Ingredient struct {
-	ID             uuid.UUID  `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
-	OrganizationID uuid.UUID  `gorm:"type:uuid;not null;index" json:"organization_id"`
-	OutletID       *uuid.UUID `gorm:"type:uuid;index" json:"outlet_id"`
-	Name           string     `gorm:"not null;size:255" json:"name"`
-	UnitID         uuid.UUID  `gorm:"type:uuid;not null;index" json:"unit_id"`
-	Cost           float64    `gorm:"type:decimal(10,2);default:0.00" json:"cost"`
-	Stock          float64    `gorm:"type:decimal(10,2);default:0.00" json:"stock"`
-	IsSemiFinished bool       `gorm:"default:false" json:"is_semi_finished"`
-	IsActive       bool       `gorm:"default:true" json:"is_active"`
-	Metadata       Metadata   `gorm:"type:jsonb;default:'{}'" json:"metadata"`
-	CreatedAt      time.Time  `gorm:"autoCreateTime" json:"created_at"`
-	UpdatedAt      time.Time  `gorm:"autoUpdateTime" json:"updated_at"`
-	Unit           *Unit      `gorm:"foreignKey:UnitID;references:ID" json:"unit,omitempty"`
+	ID             uuid.UUID               `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
+	OrganizationID uuid.UUID               `gorm:"type:uuid;not null;index" json:"organization_id"`
+	OutletID       *uuid.UUID              `gorm:"type:uuid;index" json:"outlet_id"`
+	Name           string                  `gorm:"not null;size:255" json:"name"`
+	UnitID         uuid.UUID               `gorm:"type:uuid;not null;index" json:"unit_id"`
+	Cost           float64                 `gorm:"type:decimal(10,2);default:0.00" json:"cost"`
+	Stock          float64                 `gorm:"type:decimal(10,2);default:0.00" json:"stock"`
+	IsSemiFinished bool                    `gorm:"default:false" json:"is_semi_finished"`
+	IsActive       bool                    `gorm:"default:true" json:"is_active"`
+	Metadata       Metadata                `gorm:"type:jsonb;default:'{}'" json:"metadata"`
+	CreatedAt      time.Time               `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt      time.Time               `gorm:"autoUpdateTime" json:"updated_at"`
+	Unit           *Unit                   `gorm:"foreignKey:UnitID;references:ID" json:"unit,omitempty"`
+	Compositions   []IngredientComposition `gorm:"foreignKey:ParentIngredientID;references:ID" json:"compositions,omitempty"`
 }
@@ -7,14 +7,14 @@ import (
 )

 type IngredientComposition struct {
-	ID                 uuid.UUID   `json:"id" db:"id"`
-	OrganizationID     uuid.UUID   `json:"organization_id" db:"organization_id"`
-	OutletID           *uuid.UUID  `json:"outlet_id" db:"outlet_id"`
-	ParentIngredientID uuid.UUID   `json:"parent_ingredient_id" db:"parent_ingredient_id"`
-	ChildIngredientID  uuid.UUID   `json:"child_ingredient_id" db:"child_ingredient_id"`
-	Quantity           float64     `json:"quantity" db:"quantity"`
-	CreatedAt          time.Time   `json:"created_at" db:"created_at"`
-	UpdatedAt          time.Time   `json:"updated_at" db:"updated_at"`
-	ParentIngredient   *Ingredient `json:"parent_ingredient,omitempty"`
-	ChildIngredient    *Ingredient `json:"child_ingredient,omitempty"`
+	ID                 uuid.UUID   `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
+	OrganizationID     uuid.UUID   `gorm:"type:uuid;not null;index" json:"organization_id"`
+	OutletID           *uuid.UUID  `gorm:"type:uuid;index" json:"outlet_id"`
+	ParentIngredientID uuid.UUID   `gorm:"type:uuid;not null;index" json:"parent_ingredient_id"`
+	ChildIngredientID  uuid.UUID   `gorm:"type:uuid;not null;index" json:"child_ingredient_id"`
+	Quantity           float64     `gorm:"type:decimal(10,4);not null" json:"quantity"`
+	CreatedAt          time.Time   `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt          time.Time   `gorm:"autoUpdateTime" json:"updated_at"`
+	ParentIngredient   *Ingredient `gorm:"foreignKey:ParentIngredientID;references:ID" json:"parent_ingredient,omitempty"`
+	ChildIngredient    *Ingredient `gorm:"foreignKey:ChildIngredientID;references:ID" json:"child_ingredient,omitempty"`
 }
@@ -18,9 +18,7 @@ type IngredientHandler struct {
 }

 func NewIngredientHandler(ingredientService IngredientService) *IngredientHandler {
-	return &IngredientHandler{
-		ingredientService: ingredientService,
-	}
+	return &IngredientHandler{ingredientService: ingredientService}
 }

 func (h *IngredientHandler) Create(c *gin.Context) {
@@ -29,53 +27,53 @@ func (h *IngredientHandler) Create(c *gin.Context) {

 	var request models.CreateIngredientRequest
 	if err := c.ShouldBindJSON(&request); err != nil {
-		logger.FromContext(c.Request.Context()).WithError(err).Error("IngredientHandler::Create -> request binding failed")
-		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Create")
+		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Create -> request binding failed")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::Create")
 		return
 	}

 	request.OrganizationID = contextInfo.OrganizationID

-	ingredientResponse, err := h.ingredientService.CreateIngredient(ctx, &request)
+	resp, err := h.ingredientService.CreateIngredient(ctx, &request)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Create -> Failed to create ingredient from service")
-		validationResponseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error())
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Create")
+		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Create -> failed")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::Create")
 		return
 	}

-	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(ingredientResponse), "IngredientHandler::Create")
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::Create")
 }

 func (h *IngredientHandler) GetByID(c *gin.Context) {
 	ctx := c.Request.Context()

-	idStr := c.Param("id")
-	id, err := uuid.Parse(idStr)
+	id, err := uuid.Parse(c.Param("id"))
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetByID -> Invalid ingredient ID")
-		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetByID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID"),
+		}), "IngredientHandler::GetByID")
 		return
 	}

-	ingredientResponse, err := h.ingredientService.GetIngredientByID(ctx, id)
+	resp, err := h.ingredientService.GetIngredientByID(ctx, id)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetByID -> Failed to get ingredient from service")
-		validationResponseError := contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "Ingredient not found")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetByID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "Ingredient not found"),
+		}), "IngredientHandler::GetByID")
 		return
 	}

-	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(ingredientResponse), "IngredientHandler::GetByID")
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::GetByID")
 }

 func (h *IngredientHandler) GetAll(c *gin.Context) {
 	ctx := c.Request.Context()
 	contextInfo := appcontext.FromGinContext(ctx)

-	// Get query parameters
 	pageStr := c.DefaultQuery("page", "1")
 	limitStr := c.DefaultQuery("limit", "10")
 	search := c.Query("search")
@@ -83,95 +81,177 @@ func (h *IngredientHandler) GetAll(c *gin.Context) {

 	page, err := strconv.Atoi(pageStr)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetAll -> Invalid page parameter")
-		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid page parameter")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetAll")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid page parameter"),
+		}), "IngredientHandler::GetAll")
 		return
 	}

 	limit, err := strconv.Atoi(limitStr)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetAll -> Invalid limit parameter")
-		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid limit parameter")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetAll")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid limit parameter"),
+		}), "IngredientHandler::GetAll")
 		return
 	}

 	var outletID *uuid.UUID
 	if outletIDStr != "" {
-		parsedOutletID, err := uuid.Parse(outletIDStr)
+		parsed, err := uuid.Parse(outletIDStr)
 		if err != nil {
-			logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetAll -> Invalid outlet ID")
-			validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
-			util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetAll")
+			util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+				contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID"),
+			}), "IngredientHandler::GetAll")
 			return
 		}
-		outletID = &parsedOutletID
+		outletID = &parsed
 	}

-	ingredientResponse, err := h.ingredientService.ListIngredients(ctx, contextInfo.OrganizationID, outletID, page, limit, search)
+	resp, err := h.ingredientService.ListIngredients(ctx, contextInfo.OrganizationID, outletID, page, limit, search)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::GetAll -> Failed to get ingredients from service")
-		validationResponseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, "Failed to get ingredients")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::GetAll")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, "Failed to get ingredients"),
+		}), "IngredientHandler::GetAll")
 		return
 	}

-	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(ingredientResponse), "IngredientHandler::GetAll")
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::GetAll")
 }

 func (h *IngredientHandler) Update(c *gin.Context) {
 	ctx := c.Request.Context()

-	idStr := c.Param("id")
-	id, err := uuid.Parse(idStr)
+	id, err := uuid.Parse(c.Param("id"))
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Update -> Invalid ingredient ID")
-		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Update")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID"),
+		}), "IngredientHandler::Update")
 		return
 	}

 	var request models.UpdateIngredientRequest
 	if err := c.ShouldBindJSON(&request); err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Update -> request binding failed")
-		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "Invalid request body")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Update")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "Invalid request body"),
+		}), "IngredientHandler::Update")
 		return
 	}

-	ingredientResponse, err := h.ingredientService.UpdateIngredient(ctx, id, &request)
+	resp, err := h.ingredientService.UpdateIngredient(ctx, id, &request)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Update -> Failed to update ingredient from service")
-		validationResponseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error())
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Update")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::Update")
 		return
 	}

-	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(ingredientResponse), "IngredientHandler::Update")
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::Update")
 }

 func (h *IngredientHandler) Delete(c *gin.Context) {
 	ctx := c.Request.Context()

-	idStr := c.Param("id")
-	id, err := uuid.Parse(idStr)
+	id, err := uuid.Parse(c.Param("id"))
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Delete -> Invalid ingredient ID")
-		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Delete")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ingredient ID"),
+		}), "IngredientHandler::Delete")
 		return
 	}

-	err = h.ingredientService.DeleteIngredient(ctx, id)
-	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("IngredientHandler::Delete -> Failed to delete ingredient from service")
-		validationResponseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error())
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "IngredientHandler::Delete")
+	if err := h.ingredientService.DeleteIngredient(ctx, id); err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::Delete")
 		return
 	}

-	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(map[string]interface{}{
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(map[string]string{
 		"message": "Ingredient deleted successfully",
 	}), "IngredientHandler::Delete")
 }
+
+// AddCompositions adds multiple composition items to a semi-finished ingredient.
+func (h *IngredientHandler) AddCompositions(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "invalid ingredient id"),
+		}), "IngredientHandler::AddCompositions")
+		return
+	}
+
+	var req models.AddIngredientCompositionsRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::AddCompositions")
+		return
+	}
+
+	resp, err := h.ingredientService.AddCompositions(ctx, id, &req)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::AddCompositions")
+		return
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::AddCompositions")
+}
+
+// UpdateComposition updates quantity/outlet of a single composition entry.
+func (h *IngredientHandler) UpdateComposition(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	id, err := uuid.Parse(c.Param("composition_id"))
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "invalid composition id"),
+		}), "IngredientHandler::UpdateComposition")
+		return
+	}
+
+	var req models.UpdateIngredientCompositionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::UpdateComposition")
+		return
+	}
+
+	resp, err := h.ingredientService.UpdateComposition(ctx, id, &req)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::UpdateComposition")
+		return
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::UpdateComposition")
+}
+
+// DeleteComposition removes a single composition entry.
+func (h *IngredientHandler) DeleteComposition(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	id, err := uuid.Parse(c.Param("composition_id"))
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "invalid composition id"),
+		}), "IngredientHandler::DeleteComposition")
+		return
+	}
+
+	resp, err := h.ingredientService.DeleteComposition(ctx, id)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error()),
+		}), "IngredientHandler::DeleteComposition")
+		return
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "IngredientHandler::DeleteComposition")
+}
@@ -13,4 +13,7 @@ type IngredientService interface {
 	DeleteIngredient(ctx context.Context, id uuid.UUID) error
 	GetIngredientByID(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error)
 	ListIngredients(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, page, limit int, search string) (*models.PaginatedResponse[models.IngredientResponse], error)
+	UpdateComposition(ctx context.Context, id uuid.UUID, req *models.UpdateIngredientCompositionRequest) (*models.IngredientCompositionResponse, error)
+	DeleteComposition(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error)
+	AddCompositions(ctx context.Context, parentID uuid.UUID, req *models.AddIngredientCompositionsRequest) (*models.AddIngredientCompositionsResponse, error)
 }
@@ -0,0 +1,378 @@
+package handler
+
+import (
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/logger"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/processor"
+	"apskel-pos-be/internal/repository"
+	"apskel-pos-be/internal/service"
+	"apskel-pos-be/internal/transformer"
+	"apskel-pos-be/internal/util"
+	"context"
+	"fmt"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type SelfOrderHandler struct {
+	orderService    service.OrderService
+	categoryService service.CategoryService
+	productService  service.ProductService
+	tableRepo       repository.TableRepositoryInterface
+	outletRepo      processor.OutletRepository
+	userRepo        processor.UserRepository
+}
+
+func NewSelfOrderHandler(
+	orderService service.OrderService,
+	categoryService service.CategoryService,
+	productService service.ProductService,
+	tableRepo repository.TableRepositoryInterface,
+	outletRepo processor.OutletRepository,
+	userRepo processor.UserRepository,
+) *SelfOrderHandler {
+	return &SelfOrderHandler{
+		orderService:    orderService,
+		categoryService: categoryService,
+		productService:  productService,
+		tableRepo:       tableRepo,
+		outletRepo:      outletRepo,
+		userRepo:        userRepo,
+	}
+}
+
+func (h *SelfOrderHandler) GetMenu(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.SelfOrderMenuRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::GetMenu -> request binding failed")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	if req.TableID == uuid.Nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "table_id is required"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	if req.CustomerName == "" {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "customer_name is required"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, req.TableID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::GetMenu -> table not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	if !table.IsActive {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "table is not active"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::GetMenu -> outlet not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.OrderServiceEntity, "outlet not found"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	isActive := true
+	catResp := h.categoryService.ListCategories(ctx, &contract.ListCategoriesRequest{
+		OrganizationID: &table.OrganizationID,
+		Page:           1,
+		Limit:          100,
+	})
+	if catResp.HasErrors() {
+		logger.FromContext(ctx).WithError(catResp.GetErrors()[0]).Error("SelfOrderHandler::GetMenu -> failed to list categories")
+		util.HandleResponse(c.Writer, c.Request, catResp, "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	prodResp := h.productService.ListProducts(ctx, &contract.ListProductsRequest{
+		OrganizationID: &table.OrganizationID,
+		IsActive:       &isActive,
+		Page:           1,
+		Limit:          1000,
+	})
+	if prodResp.HasErrors() {
+		logger.FromContext(ctx).WithError(prodResp.GetErrors()[0]).Error("SelfOrderHandler::GetMenu -> failed to list products")
+		util.HandleResponse(c.Writer, c.Request, prodResp, "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	catList, ok := catResp.Data.(*contract.ListCategoriesResponse)
+	if !ok {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.CategoryServiceEntity, "unexpected categories response type"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	prodList, ok := prodResp.Data.(*contract.ListProductsResponse)
+	if !ok {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductServiceEntity, "unexpected products response type"),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+
+	menu := h.buildMenuResponse(outlet, table, catList.Categories, prodList.Products)
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(menu), "SelfOrderHandler::GetMenu")
+}
+
+func (h *SelfOrderHandler) buildMenuResponse(
+	outlet *entities.Outlet,
+	table *entities.Table,
+	categories []contract.CategoryResponse,
+	products []contract.ProductResponse,
+) *contract.SelfOrderMenuResponse {
+	productMap := make(map[uuid.UUID][]contract.ProductResponse)
+	for _, p := range products {
+		productMap[p.CategoryID] = append(productMap[p.CategoryID], p)
+	}
+
+	menuCategories := make([]contract.SelfOrderMenuCategory, 0, len(categories))
+	for _, cat := range categories {
+		menuItems := make([]contract.SelfOrderMenuItem, 0)
+		if prods, ok := productMap[cat.ID]; ok {
+			for _, p := range prods {
+				item := contract.SelfOrderMenuItem{
+					ID:          p.ID,
+					Name:        p.Name,
+					Description: p.Description,
+					Price:       p.Price,
+					ImageURL:    p.ImageURL,
+				}
+				for _, v := range p.Variants {
+					item.Variants = append(item.Variants, contract.SelfOrderMenuVariant{
+						ID:            v.ID,
+						Name:          v.Name,
+						PriceModifier: v.PriceModifier,
+					})
+				}
+				menuItems = append(menuItems, item)
+			}
+		}
+		menuCategories = append(menuCategories, contract.SelfOrderMenuCategory{
+			ID:          cat.ID,
+			Name:        cat.Name,
+			Description: cat.Description,
+			Order:       cat.Order,
+			Products:    menuItems,
+		})
+	}
+
+	return &contract.SelfOrderMenuResponse{
+		OutletName: outlet.Name,
+		TableName:  table.TableName,
+		Categories: menuCategories,
+	}
+}
+
+func (h *SelfOrderHandler) CreateOrder(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.SelfOrderCreateOrderRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::CreateOrder -> request binding failed")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	if err := h.validateCreateOrderRequest(&req); err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, req.TableID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::CreateOrder -> table not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	if !table.IsActive || !table.IsAvailable() {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "table is not available for ordering"),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	userID, err := h.resolveOrgUser(ctx, table.OrganizationID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::CreateOrder -> failed to resolve org user")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, "failed to create self-order"),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	orderItems := make([]models.CreateOrderItemRequest, 0, len(req.OrderItems))
+	for _, item := range req.OrderItems {
+		orderItems = append(orderItems, models.CreateOrderItemRequest{
+			ProductID:        item.ProductID,
+			ProductVariantID: item.ProductVariantID,
+			Quantity:         item.Quantity,
+			Notes:            item.Notes,
+		})
+	}
+
+	metadata := make(map[string]interface{})
+	metadata["self_order"] = true
+	metadata["customer_name"] = req.CustomerName
+	if req.Phone != nil {
+		metadata["customer_phone"] = *req.Phone
+	}
+
+	tableID := req.TableID
+	modelReq := &models.CreateOrderRequest{
+		OutletID:     table.OutletID,
+		UserID:       userID,
+		TableID:      &tableID,
+		TableNumber:  &table.TableName,
+		OrderType:    constants.OrderTypeDineIn,
+		OrderItems:   orderItems,
+		CustomerName: &req.CustomerName,
+		Metadata:     metadata,
+	}
+
+	response, err := h.orderService.CreateOrder(ctx, modelReq, table.OrganizationID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::CreateOrder -> failed to create order")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, err.Error()),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+
+	contractResp := transformer.OrderModelToContract(response)
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(contractResp), "SelfOrderHandler::CreateOrder")
+}
+
+func (h *SelfOrderHandler) validateCreateOrderRequest(req *contract.SelfOrderCreateOrderRequest) error {
+	if req.TableID == uuid.Nil {
+		return fmt.Errorf("table_id is required")
+	}
+	if req.CustomerName == "" {
+		return fmt.Errorf("customer_name is required")
+	}
+	if len(req.OrderItems) == 0 {
+		return fmt.Errorf("at least one order item is required")
+	}
+	for i, item := range req.OrderItems {
+		if item.ProductID == uuid.Nil {
+			return fmt.Errorf("product_id is required for item %d", i+1)
+		}
+		if item.Quantity <= 0 {
+			return fmt.Errorf("quantity must be greater than zero for item %d", i+1)
+		}
+	}
+	return nil
+}
+
+func (h *SelfOrderHandler) ListCategories(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.SelfOrderListCategoriesRequest
+	if err := c.ShouldBindQuery(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ListCategories -> query binding failed")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	if req.TableID == "" {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "table_id is required"),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	parsedTableID, err := uuid.Parse(req.TableID)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, "table_id must be a valid UUID"),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, parsedTableID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ListCategories -> table not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	catResp := h.categoryService.ListCategories(ctx, &contract.ListCategoriesRequest{
+		OrganizationID: &table.OrganizationID,
+		Page:           1,
+		Limit:          100,
+	})
+	if catResp.HasErrors() {
+		logger.FromContext(ctx).WithError(catResp.GetErrors()[0]).Error("SelfOrderHandler::ListCategories -> failed to list categories")
+		util.HandleResponse(c.Writer, c.Request, catResp, "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	catList, ok := catResp.Data.(*contract.ListCategoriesResponse)
+	if !ok {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.CategoryServiceEntity, "unexpected categories response type"),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	items := make([]contract.SelfOrderCategoryItem, 0, len(catList.Categories))
+	for _, cat := range catList.Categories {
+		items = append(items, contract.SelfOrderCategoryItem{
+			ID:          cat.ID,
+			Name:        cat.Name,
+			Description: cat.Description,
+			Order:       cat.Order,
+		})
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(&contract.SelfOrderListCategoriesResponse{
+		Categories: items,
+	}), "SelfOrderHandler::ListCategories")
+}
+
+func (h *SelfOrderHandler) resolveOrgUser(ctx context.Context, organizationID uuid.UUID) (uuid.UUID, error) {
+	users, err := h.userRepo.GetByOrganizationID(ctx, organizationID)
+	if err != nil {
+		return uuid.Nil, fmt.Errorf("failed to get users for organization: %w", err)
+	}
+	if len(users) == 0 {
+		return uuid.Nil, fmt.Errorf("no users found for organization")
+	}
+	return users[0].ID, nil
+}
@@ -1,70 +0,0 @@
-package mappers
-
-import (
-	"apskel-pos-be/internal/entities"
-	"apskel-pos-be/internal/models"
-)
-
-func MapIngredientCompositionEntityToModel(entity *entities.IngredientComposition) *models.IngredientComposition {
-	if entity == nil {
-		return nil
-	}
-
-	return &models.IngredientComposition{
-		ID:                 entity.ID,
-		OrganizationID:     entity.OrganizationID,
-		OutletID:           entity.OutletID,
-		ParentIngredientID: entity.ParentIngredientID,
-		ChildIngredientID:  entity.ChildIngredientID,
-		Quantity:           entity.Quantity,
-		CreatedAt:          entity.CreatedAt,
-		UpdatedAt:          entity.UpdatedAt,
-		ParentIngredient:   MapIngredientEntityToModel(entity.ParentIngredient),
-		ChildIngredient:    MapIngredientEntityToModel(entity.ChildIngredient),
-	}
-}
-
-func MapIngredientCompositionModelToEntity(model *models.IngredientComposition) *entities.IngredientComposition {
-	if model == nil {
-		return nil
-	}
-
-	return &entities.IngredientComposition{
-		ID:                 model.ID,
-		OrganizationID:     model.OrganizationID,
-		OutletID:           model.OutletID,
-		ParentIngredientID: model.ParentIngredientID,
-		ChildIngredientID:  model.ChildIngredientID,
-		Quantity:           model.Quantity,
-		CreatedAt:          model.CreatedAt,
-		UpdatedAt:          model.UpdatedAt,
-		ParentIngredient:   MapIngredientModelToEntity(model.ParentIngredient),
-		ChildIngredient:    MapIngredientModelToEntity(model.ChildIngredient),
-	}
-}
-
-func MapIngredientCompositionEntitiesToModels(entities []*entities.IngredientComposition) []*models.IngredientComposition {
-	if entities == nil {
-		return nil
-	}
-
-	models := make([]*models.IngredientComposition, len(entities))
-	for i, entity := range entities {
-		models[i] = MapIngredientCompositionEntityToModel(entity)
-	}
-
-	return models
-}
-
-func MapIngredientCompositionModelsToEntities(models []*models.IngredientComposition) []*entities.IngredientComposition {
-	if models == nil {
-		return nil
-	}
-
-	entities := make([]*entities.IngredientComposition, len(models))
-	for i, model := range models {
-		entities[i] = MapIngredientCompositionModelToEntity(model)
-	}
-
-	return entities
-}
@@ -6,7 +6,11 @@ import (

 func CORS() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		c.Header("Access-Control-Allow-Origin", "*")
+		origin := c.Request.Header.Get("Origin")
+		if origin == "" {
+			origin = "*"
+		}
+		c.Header("Access-Control-Allow-Origin", origin)
 		c.Header("Access-Control-Allow-Credentials", "true")
 		c.Header("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
 		c.Header("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
@@ -26,15 +26,23 @@ type Ingredient struct {
 }

 type CreateIngredientRequest struct {
-	OrganizationID uuid.UUID         `json:"organization_id"`
-	OutletID       *uuid.UUID        `json:"outlet_id"`
-	Name           string            `json:"name" validate:"required,min=1,max=255"`
-	UnitID         uuid.UUID         `json:"unit_id" validate:"required"`
-	Cost           float64           `json:"cost" validate:"min=0"`
-	Stock          float64           `json:"stock" validate:"min=0"`
-	IsSemiFinished bool              `json:"is_semi_finished"`
-	IsActive       bool              `json:"is_active"`
-	Metadata       entities.Metadata `json:"metadata"`
+	OrganizationID uuid.UUID                `json:"organization_id"`
+	OutletID       *uuid.UUID               `json:"outlet_id"`
+	Name           string                   `json:"name" validate:"required,min=1,max=255"`
+	UnitID         uuid.UUID                `json:"unit_id" validate:"required"`
+	Cost           float64                  `json:"cost" validate:"min=0"`
+	Stock          float64                  `json:"stock" validate:"min=0"`
+	IsSemiFinished bool                     `json:"is_semi_finished"`
+	IsActive       bool                     `json:"is_active"`
+	Metadata       entities.Metadata        `json:"metadata"`
+	Compositions   []CompositionItemRequest `json:"compositions,omitempty"`
+}
+
+// CompositionItemRequest is used inside create ingredient request.
+type CompositionItemRequest struct {
+	ChildIngredientID uuid.UUID  `json:"child_ingredient_id" validate:"required"`
+	Quantity          float64    `json:"quantity" validate:"required,gt=0"`
+	OutletID          *uuid.UUID `json:"outlet_id"`
 }

 type UpdateIngredientRequest struct {
@@ -49,19 +57,18 @@ type UpdateIngredientRequest struct {
 }

 type IngredientResponse struct {
-	ID             uuid.UUID         `json:"id"`
-	OrganizationID uuid.UUID         `json:"organization_id"`
-	OutletID       *uuid.UUID        `json:"outlet_id"`
-	Name           string            `json:"name"`
-	UnitID         uuid.UUID         `json:"unit_id"`
-	Cost           float64           `json:"cost"`
-	Stock          float64           `json:"stock"`
-	IsSemiFinished bool              `json:"is_semi_finished"`
-	IsActive       bool              `json:"is_active"`
-	Metadata       entities.Metadata `json:"metadata"`
-	CreatedAt      time.Time         `json:"created_at"`
-	UpdatedAt      time.Time         `json:"updated_at"`
-
-	// Relations
-	Unit *Unit `json:"unit,omitempty"`
+	ID             uuid.UUID                        `json:"id"`
+	OrganizationID uuid.UUID                        `json:"organization_id"`
+	OutletID       *uuid.UUID                       `json:"outlet_id"`
+	Name           string                           `json:"name"`
+	UnitID         uuid.UUID                        `json:"unit_id"`
+	Cost           float64                          `json:"cost"`
+	Stock          float64                          `json:"stock"`
+	IsSemiFinished bool                             `json:"is_semi_finished"`
+	IsActive       bool                             `json:"is_active"`
+	Metadata       entities.Metadata                `json:"metadata"`
+	CreatedAt      time.Time                        `json:"created_at"`
+	UpdatedAt      time.Time                        `json:"updated_at"`
+	Unit           *Unit                            `json:"unit,omitempty"`
+	Compositions   []*IngredientCompositionResponse `json:"compositions,omitempty"`
 }
@@ -6,44 +6,33 @@ import (
 	"github.com/google/uuid"
 )

-type IngredientComposition struct {
-	ID                 uuid.UUID  `json:"id"`
-	OrganizationID     uuid.UUID  `json:"organization_id"`
-	OutletID           *uuid.UUID `json:"outlet_id"`
-	ParentIngredientID uuid.UUID  `json:"parent_ingredient_id"`
-	ChildIngredientID  uuid.UUID  `json:"child_ingredient_id"`
-	Quantity           float64    `json:"quantity"`
-	CreatedAt          time.Time  `json:"created_at"`
-	UpdatedAt          time.Time  `json:"updated_at"`
-
-	// Relations
-	ParentIngredient *Ingredient `json:"parent_ingredient,omitempty"`
-	ChildIngredient  *Ingredient `json:"child_ingredient,omitempty"`
-}
-
-type CreateIngredientCompositionRequest struct {
-	OutletID           *uuid.UUID `json:"outlet_id"`
-	ParentIngredientID uuid.UUID  `json:"parent_ingredient_id" validate:"required"`
-	ChildIngredientID  uuid.UUID  `json:"child_ingredient_id" validate:"required"`
-	Quantity           float64    `json:"quantity" validate:"required,gt=0"`
-}
-
 type UpdateIngredientCompositionRequest struct {
 	OutletID *uuid.UUID `json:"outlet_id"`
 	Quantity float64    `json:"quantity" validate:"required,gt=0"`
 }

 type IngredientCompositionResponse struct {
-	ID                 uuid.UUID  `json:"id"`
-	OrganizationID     uuid.UUID  `json:"organization_id"`
-	OutletID           *uuid.UUID `json:"outlet_id"`
-	ParentIngredientID uuid.UUID  `json:"parent_ingredient_id"`
-	ChildIngredientID  uuid.UUID  `json:"child_ingredient_id"`
-	Quantity           float64    `json:"quantity"`
-	CreatedAt          time.Time  `json:"created_at"`
-	UpdatedAt          time.Time  `json:"updated_at"`
+	ID                uuid.UUID           `json:"id"`
+	OutletID          *uuid.UUID          `json:"outlet_id"`
+	ChildIngredientID uuid.UUID           `json:"child_ingredient_id"`
+	Quantity          float64             `json:"quantity"`
+	CreatedAt         time.Time           `json:"created_at"`
+	UpdatedAt         time.Time           `json:"updated_at"`
+	ChildIngredient   *IngredientResponse `json:"child_ingredient,omitempty"`
+	ParentIngredient  *IngredientResponse `json:"parent_ingredient,omitempty"`
+}

-	// Relations
-	ParentIngredient *Ingredient `json:"parent_ingredient,omitempty"`
-	ChildIngredient  *Ingredient `json:"child_ingredient,omitempty"`
+type CompositionItem struct {
+	ChildIngredientID uuid.UUID  `json:"child_ingredient_id" validate:"required"`
+	Quantity          float64    `json:"quantity" validate:"required,gt=0"`
+	OutletID          *uuid.UUID `json:"outlet_id"`
+}
+
+type AddIngredientCompositionsRequest struct {
+	Compositions []CompositionItem `json:"compositions" validate:"required,min=1,dive"`
+}
+
+type AddIngredientCompositionsResponse struct {
+	ParentIngredient *IngredientResponse              `json:"parent_ingredient"`
+	Compositions     []*IngredientCompositionResponse `json:"compositions"`
 }
@@ -3,29 +3,31 @@ package processor
 import (
 	"apskel-pos-be/internal/appcontext"
 	"apskel-pos-be/internal/entities"
-	"apskel-pos-be/internal/mappers"
 	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/transformer"
 	"context"
+	"fmt"
 	"time"

 	"github.com/google/uuid"
 )

 type IngredientProcessorImpl struct {
-	ingredientRepo IngredientRepository
-	unitRepo       UnitRepository
+	ingredientRepo  IngredientRepository
+	unitRepo        UnitRepository
+	compositionRepo IngredientCompositionRepository
 }

-func NewIngredientProcessor(ingredientRepo IngredientRepository, unitRepo UnitRepository) *IngredientProcessorImpl {
+func NewIngredientProcessor(ingredientRepo IngredientRepository, unitRepo UnitRepository, compositionRepo IngredientCompositionRepository) *IngredientProcessorImpl {
 	return &IngredientProcessorImpl{
-		ingredientRepo: ingredientRepo,
-		unitRepo:       unitRepo,
+		ingredientRepo:  ingredientRepo,
+		unitRepo:        unitRepo,
+		compositionRepo: compositionRepo,
 	}
 }

 func (p *IngredientProcessorImpl) CreateIngredient(ctx context.Context, req *models.CreateIngredientRequest) (*models.IngredientResponse, error) {
-	_, err := p.unitRepo.GetByID(ctx, req.UnitID, req.OrganizationID)
-	if err != nil {
+	if _, err := p.unitRepo.GetByID(ctx, req.UnitID, req.OrganizationID); err != nil {
 		return nil, err
 	}

@@ -35,7 +37,7 @@ func (p *IngredientProcessorImpl) CreateIngredient(ctx context.Context, req *mod
 		OutletID:       req.OutletID,
 		Name:           req.Name,
 		UnitID:         req.UnitID,
-		Cost:           req.Cost,
+		Cost:           req.Cost, // akan di-override oleh recalculateCost kalau semi-finished
 		Stock:          req.Stock,
 		IsSemiFinished: req.IsSemiFinished,
 		IsActive:       req.IsActive,
@@ -44,70 +46,30 @@ func (p *IngredientProcessorImpl) CreateIngredient(ctx context.Context, req *mod
 		UpdatedAt:      time.Now(),
 	}

-	err = p.ingredientRepo.Create(ctx, ingredient)
-	if err != nil {
+	if req.IsSemiFinished {
+		ingredient.Cost = 0 // dihitung dari compositions
+	}
+
+	if err := p.ingredientRepo.Create(ctx, ingredient); err != nil {
 		return nil, err
 	}

-	ingredientWithUnit, err := p.ingredientRepo.GetByID(ctx, ingredient.ID, req.OrganizationID)
-	if err != nil {
-		return nil, err
+	// Save compositions if provided (only valid for semi-finished ingredients)
+	if req.IsSemiFinished && len(req.Compositions) > 0 {
+		if err := p.saveCompositions(ctx, ingredient.ID, req.OrganizationID, req.Compositions); err != nil {
+			return nil, err
+		}
 	}

-	ingredientModel := mappers.MapIngredientEntityToModel(ingredientWithUnit)
-	response := &models.IngredientResponse{
-		ID:             ingredientModel.ID,
-		OrganizationID: ingredientModel.OrganizationID,
-		OutletID:       ingredientModel.OutletID,
-		Name:           ingredientModel.Name,
-		UnitID:         ingredientModel.UnitID,
-		Cost:           ingredientModel.Cost,
-		Stock:          ingredientModel.Stock,
-		IsSemiFinished: ingredientModel.IsSemiFinished,
-		IsActive:       ingredientModel.IsActive,
-		Metadata:       ingredientModel.Metadata,
-		CreatedAt:      ingredientModel.CreatedAt,
-		UpdatedAt:      ingredientModel.UpdatedAt,
-		Unit:           ingredientModel.Unit,
-	}
-
-	return response, nil
+	return p.buildIngredientResponse(ctx, ingredient.ID, req.OrganizationID)
 }

 func (p *IngredientProcessorImpl) GetIngredientByID(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error) {
-	contextInfo := appcontext.FromGinContext(ctx)
-
-	// For now, we'll need to get organizationID from context or request
-	// This is a limitation of the current interface design
-	organizationID := contextInfo.OrganizationID // This should come from context
-
-	ingredient, err := p.ingredientRepo.GetByID(ctx, id, organizationID)
-	if err != nil {
-		return nil, err
-	}
-
-	ingredientModel := mappers.MapIngredientEntityToModel(ingredient)
-	response := &models.IngredientResponse{
-		ID:             ingredientModel.ID,
-		OrganizationID: ingredientModel.OrganizationID,
-		OutletID:       ingredientModel.OutletID,
-		Name:           ingredientModel.Name,
-		UnitID:         ingredientModel.UnitID,
-		Cost:           ingredientModel.Cost,
-		Stock:          ingredientModel.Stock,
-		IsSemiFinished: ingredientModel.IsSemiFinished,
-		IsActive:       ingredientModel.IsActive,
-		Metadata:       ingredientModel.Metadata,
-		CreatedAt:      ingredientModel.CreatedAt,
-		UpdatedAt:      ingredientModel.UpdatedAt,
-		Unit:           ingredientModel.Unit,
-	}
-
-	return response, nil
+	ctxInfo := appcontext.FromGinContext(ctx)
+	return p.buildIngredientResponse(ctx, id, ctxInfo.OrganizationID)
 }

 func (p *IngredientProcessorImpl) ListIngredients(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, page, limit int, search string) (*models.PaginatedResponse[models.IngredientResponse], error) {
-	// Set default values
 	if page < 1 {
 		page = 1
 	}
@@ -123,30 +85,9 @@ func (p *IngredientProcessorImpl) ListIngredients(ctx context.Context, organizat
 		return nil, err
 	}

-	// Map to response models
-	ingredientModels := mappers.MapIngredientEntitiesToModels(ingredients)
-	ingredientResponses := make([]models.IngredientResponse, len(ingredientModels))
+	ingredientResponses := transformer.IngredientsToResponses(ingredients)

-	for i, ingredientModel := range ingredientModels {
-		ingredientResponses[i] = models.IngredientResponse{
-			ID:             ingredientModel.ID,
-			OrganizationID: ingredientModel.OrganizationID,
-			OutletID:       ingredientModel.OutletID,
-			Name:           ingredientModel.Name,
-			UnitID:         ingredientModel.UnitID,
-			Cost:           ingredientModel.Cost,
-			Stock:          ingredientModel.Stock,
-			IsSemiFinished: ingredientModel.IsSemiFinished,
-			IsActive:       ingredientModel.IsActive,
-			Metadata:       ingredientModel.Metadata,
-			CreatedAt:      ingredientModel.CreatedAt,
-			UpdatedAt:      ingredientModel.UpdatedAt,
-			Unit:           ingredientModel.Unit,
-		}
-	}
-
-	// Create paginated response
-	paginatedResponse := &models.PaginatedResponse[models.IngredientResponse]{
+	return &models.PaginatedResponse[models.IngredientResponse]{
 		Data: ingredientResponses,
 		Pagination: models.Pagination{
 			Page:       page,
@@ -154,86 +95,250 @@ func (p *IngredientProcessorImpl) ListIngredients(ctx context.Context, organizat
 			Total:      int64(total),
 			TotalPages: (total + limit - 1) / limit,
 		},
-	}
-
-	return paginatedResponse, nil
+	}, nil
 }

 func (p *IngredientProcessorImpl) UpdateIngredient(ctx context.Context, id uuid.UUID, req *models.UpdateIngredientRequest) (*models.IngredientResponse, error) {
-	contextInfo := appcontext.FromGinContext(ctx)
-	// For now, we'll need to get organizationID from context or request
-	// This is a limitation of the current interface design
-	organizationID := contextInfo.OrganizationID // This should come from context
+	ctxInfo := appcontext.FromGinContext(ctx)
+	organizationID := ctxInfo.OrganizationID

-	// Get existing ingredient
-	existingIngredient, err := p.ingredientRepo.GetByID(ctx, id, organizationID)
+	existing, err := p.ingredientRepo.GetByID(ctx, id, organizationID)
 	if err != nil {
 		return nil, err
 	}

-	// Validate unit exists if changed
-	if req.UnitID != existingIngredient.UnitID {
-		_, err := p.unitRepo.GetByID(ctx, req.UnitID, organizationID)
-		if err != nil {
+	if req.UnitID != existing.UnitID {
+		if _, err := p.unitRepo.GetByID(ctx, req.UnitID, organizationID); err != nil {
 			return nil, err
 		}
 	}

-	// Update fields
-	if req.OutletID != nil {
-		existingIngredient.OutletID = req.OutletID
+	existing.OutletID = req.OutletID
+	existing.Name = req.Name
+	existing.UnitID = req.UnitID
+	existing.Stock = req.Stock
+	existing.IsSemiFinished = req.IsSemiFinished
+	existing.IsActive = req.IsActive
+	existing.Metadata = req.Metadata
+	existing.UpdatedAt = time.Now()
+
+	// Cost hanya dipakai kalau bukan semi-finished
+	// Kalau semi-finished, cost dihitung dari compositions
+	if !req.IsSemiFinished {
+		existing.Cost = req.Cost
 	}

-	existingIngredient.Name = req.Name
-	existingIngredient.UnitID = req.UnitID
-	existingIngredient.Cost = req.Cost
-	existingIngredient.Stock = req.Stock
-	existingIngredient.IsSemiFinished = req.IsSemiFinished
-	existingIngredient.IsActive = req.IsActive
-	existingIngredient.Metadata = req.Metadata
-	existingIngredient.UpdatedAt = time.Now()
-
-	// Save to database
-	err = p.ingredientRepo.Update(ctx, existingIngredient)
-	if err != nil {
+	if err := p.ingredientRepo.Update(ctx, existing); err != nil {
 		return nil, err
 	}

-	// Get with relations
-	ingredientWithUnit, err := p.ingredientRepo.GetByID(ctx, id, organizationID)
-	if err != nil {
-		return nil, err
-	}
-
-	// Map to response
-	ingredientModel := mappers.MapIngredientEntityToModel(ingredientWithUnit)
-	response := &models.IngredientResponse{
-		ID:             ingredientModel.ID,
-		OrganizationID: ingredientModel.OrganizationID,
-		OutletID:       ingredientModel.OutletID,
-		Name:           ingredientModel.Name,
-		UnitID:         ingredientModel.UnitID,
-		Cost:           ingredientModel.Cost,
-		Stock:          ingredientModel.Stock,
-		IsSemiFinished: ingredientModel.IsSemiFinished,
-		IsActive:       ingredientModel.IsActive,
-		Metadata:       ingredientModel.Metadata,
-		CreatedAt:      ingredientModel.CreatedAt,
-		UpdatedAt:      ingredientModel.UpdatedAt,
-		Unit:           ingredientModel.Unit,
-	}
-
-	return response, nil
+	return p.buildIngredientResponse(ctx, id, organizationID)
 }

 func (p *IngredientProcessorImpl) DeleteIngredient(ctx context.Context, id uuid.UUID) error {
-	contextInfo := appcontext.FromGinContext(ctx)
-	organizationID := contextInfo.OrganizationID
+	ctxInfo := appcontext.FromGinContext(ctx)
+	return p.ingredientRepo.Delete(ctx, id, ctxInfo.OrganizationID)
+}

-	err := p.ingredientRepo.Delete(ctx, id, organizationID)
+func (p *IngredientProcessorImpl) AddCompositions(ctx context.Context, parentID uuid.UUID, req *models.AddIngredientCompositionsRequest) (*models.AddIngredientCompositionsResponse, error) {
+	ctxInfo := appcontext.FromGinContext(ctx)
+	organizationID := ctxInfo.OrganizationID
+
+	// Parent must exist and be semi-finished
+	parent, err := p.ingredientRepo.GetByID(ctx, parentID, organizationID)
+	if err != nil {
+		return nil, fmt.Errorf("parent ingredient not found: %w", err)
+	}
+	if !parent.IsSemiFinished {
+		return nil, fmt.Errorf("parent ingredient must be marked as semi-finished")
+	}
+
+	now := time.Now()
+	createdIDs := make([]uuid.UUID, 0, len(req.Compositions))
+
+	// Validate and create all compositions
+	for _, item := range req.Compositions {
+		// Child must exist
+		if _, err := p.ingredientRepo.GetByID(ctx, item.ChildIngredientID, organizationID); err != nil {
+			return nil, fmt.Errorf("child ingredient %s not found: %w", item.ChildIngredientID, err)
+		}
+
+		if item.ChildIngredientID == parentID {
+			return nil, fmt.Errorf("child ingredient cannot be the same as parent")
+		}
+
+		// Resolve outlet
+		outletID := item.OutletID
+		if outletID == nil && ctxInfo.OutletID != uuid.Nil {
+			outletID = &ctxInfo.OutletID
+		}
+
+		compositionID := uuid.New()
+		composition := &entities.IngredientComposition{
+			ID:                 compositionID,
+			OrganizationID:     organizationID,
+			OutletID:           outletID,
+			ParentIngredientID: parentID,
+			ChildIngredientID:  item.ChildIngredientID,
+			Quantity:           item.Quantity,
+			CreatedAt:          now,
+			UpdatedAt:          now,
+		}
+
+		if err := p.compositionRepo.Create(ctx, composition); err != nil {
+			return nil, fmt.Errorf("failed to add composition: %w", err)
+		}
+
+		createdIDs = append(createdIDs, compositionID)
+	}
+
+	// Recalculate parent cost
+	if err := p.recalculateCost(ctx, parentID, organizationID); err != nil {
+		return nil, err
+	}
+
+	// Get updated parent ingredient with all compositions
+	updatedParent, err := p.buildIngredientResponse(ctx, parentID, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get created compositions with full details
+	createdCompositions := make([]*models.IngredientCompositionResponse, 0, len(createdIDs))
+	for _, id := range createdIDs {
+		comp, err := p.compositionRepo.GetByID(ctx, id, organizationID)
+		if err != nil {
+			return nil, err
+		}
+		createdCompositions = append(createdCompositions, transformer.CompositionEntityToResponse(comp))
+	}
+
+	return &models.AddIngredientCompositionsResponse{
+		ParentIngredient: updatedParent,
+		Compositions:     createdCompositions,
+	}, nil
+}
+
+func (p *IngredientProcessorImpl) UpdateComposition(ctx context.Context, id uuid.UUID, req *models.UpdateIngredientCompositionRequest) (*models.IngredientCompositionResponse, error) {
+	ctxInfo := appcontext.FromGinContext(ctx)
+
+	existing, err := p.compositionRepo.GetByID(ctx, id, ctxInfo.OrganizationID)
+	if err != nil {
+		return nil, fmt.Errorf("composition not found: %w", err)
+	}
+
+	existing.Quantity = req.Quantity
+	existing.OutletID = req.OutletID
+	existing.UpdatedAt = time.Now()
+
+	if err := p.compositionRepo.Update(ctx, existing); err != nil {
+		return nil, fmt.Errorf("failed to update composition: %w", err)
+	}
+
+	// Recalculate parent cost since quantity changed
+	if err := p.recalculateCost(ctx, existing.ParentIngredientID, ctxInfo.OrganizationID); err != nil {
+		return nil, fmt.Errorf("failed to recalculate cost: %w", err)
+	}
+
+	updated, err := p.compositionRepo.GetByID(ctx, id, ctxInfo.OrganizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return transformer.CompositionEntityToResponse(updated), nil
+}
+
+func (p *IngredientProcessorImpl) DeleteComposition(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error) {
+	ctxInfo := appcontext.FromGinContext(ctx)
+
+	existing, err := p.compositionRepo.GetByID(ctx, id, ctxInfo.OrganizationID)
+	if err != nil {
+		return nil, fmt.Errorf("composition not found: %w", err)
+	}
+
+	parentID := existing.ParentIngredientID
+
+	if err := p.compositionRepo.Delete(ctx, id, ctxInfo.OrganizationID); err != nil {
+		return nil, err
+	}
+
+	// Recalculate parent cost after removal
+	if err := p.recalculateCost(ctx, parentID, ctxInfo.OrganizationID); err != nil {
+		return nil, err
+	}
+
+	// Return updated parent ingredient
+	return p.buildIngredientResponse(ctx, parentID, ctxInfo.OrganizationID)
+}
+
+// --- private helpers ---
+
+func (p *IngredientProcessorImpl) saveCompositions(ctx context.Context, parentID, organizationID uuid.UUID, items []models.CompositionItemRequest) error {
+	ctxInfo := appcontext.FromGinContext(ctx)
+	now := time.Now()
+
+	for _, item := range items {
+		if item.ChildIngredientID == parentID {
+			return fmt.Errorf("child ingredient cannot be the same as parent")
+		}
+		if _, err := p.ingredientRepo.GetByID(ctx, item.ChildIngredientID, organizationID); err != nil {
+			return fmt.Errorf("child ingredient %s not found: %w", item.ChildIngredientID, err)
+		}
+
+		// Resolve outlet: use item's outlet if provided, otherwise fall back to context outlet
+		outletID := item.OutletID
+		if outletID == nil && ctxInfo.OutletID != uuid.Nil {
+			outletID = &ctxInfo.OutletID
+		}
+
+		composition := &entities.IngredientComposition{
+			ID:                 uuid.New(),
+			OrganizationID:     organizationID,
+			OutletID:           outletID,
+			ParentIngredientID: parentID,
+			ChildIngredientID:  item.ChildIngredientID,
+			Quantity:           item.Quantity,
+			CreatedAt:          now,
+			UpdatedAt:          now,
+		}
+		if err := p.compositionRepo.Create(ctx, composition); err != nil {
+			return fmt.Errorf("failed to save composition: %w", err)
+		}
+	}
+
+	// Recalculate cost of the semi-finished parent from child costs
+	return p.recalculateCost(ctx, parentID, organizationID)
+}
+
+// recalculateCost sums up (child.cost * composition.quantity) and updates the parent ingredient cost.
+func (p *IngredientProcessorImpl) recalculateCost(ctx context.Context, parentID, organizationID uuid.UUID) error {
+	compositions, err := p.compositionRepo.GetByParentIngredientID(ctx, parentID, organizationID)
 	if err != nil {
 		return err
 	}

-	return nil
+	var totalCost float64
+	for _, c := range compositions {
+		if c.ChildIngredient != nil {
+			totalCost += c.ChildIngredient.Cost * c.Quantity
+		}
+	}
+
+	parent, err := p.ingredientRepo.GetByID(ctx, parentID, organizationID)
+	if err != nil {
+		return err
+	}
+
+	parent.Cost = totalCost
+	parent.UpdatedAt = time.Now()
+	return p.ingredientRepo.Update(ctx, parent)
+}
+
+func (p *IngredientProcessorImpl) buildIngredientResponse(ctx context.Context, id, organizationID uuid.UUID) (*models.IngredientResponse, error) {
+	ingredient, err := p.ingredientRepo.GetByID(ctx, id, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return transformer.IngredientEntityToResponse(ingredient), nil
 }
@@ -1,180 +0,0 @@
-package processor
-
-import (
-	"context"
-	"testing"
-
-	"apskel-pos-be/internal/models"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-)
-
-// Mock repositories for testing
-type MockProductRepository struct {
-	mock.Mock
-}
-
-type MockCategoryRepository struct {
-	mock.Mock
-}
-
-type MockProductVariantRepository struct {
-	mock.Mock
-}
-
-type MockInventoryRepository struct {
-	mock.Mock
-}
-
-type MockOutletRepository struct {
-	mock.Mock
-}
-
-// Test helper functions
-func TestCreateProductWithInventory(t *testing.T) {
-	// This is a basic test structure - in a real implementation,
-	// you would use a proper testing framework with database mocks
-
-	t.Run("should create product with inventory when create_inventory is true", func(t *testing.T) {
-		// Arrange
-		productRepo := &MockProductRepository{}
-		categoryRepo := &MockCategoryRepository{}
-		productVariantRepo := &MockProductVariantRepository{}
-		inventoryRepo := &MockInventoryRepository{}
-		outletRepo := &MockOutletRepository{}
-
-		processor := NewProductProcessorImpl(
-			productRepo,
-			categoryRepo,
-			productVariantRepo,
-			inventoryRepo,
-			outletRepo,
-		)
-
-		req := &models.CreateProductRequest{
-			OrganizationID:  uuid.New(),
-			CategoryID:      uuid.New(),
-			Name:            "Test Product",
-			Price:           10.0,
-			Cost:            5.0,
-			InitialStock:    &[]int{100}[0],
-			ReorderLevel:    &[]int{20}[0],
-			CreateInventory: true,
-		}
-
-		// Mock expectations
-		categoryRepo.On("GetByID", mock.Anything, req.CategoryID).Return(&models.Category{}, nil)
-		productRepo.On("ExistsBySKU", mock.Anything, req.OrganizationID, mock.Anything, mock.Anything).Return(false, nil)
-		productRepo.On("ExistsByName", mock.Anything, req.OrganizationID, req.Name, mock.Anything).Return(false, nil)
-		productRepo.On("Create", mock.Anything, mock.Anything).Return(nil)
-		productRepo.On("GetWithCategory", mock.Anything, mock.Anything).Return(&models.Product{}, nil)
-
-		// Mock outlets
-		outlets := []*models.Outlet{
-			{ID: uuid.New()},
-			{ID: uuid.New()},
-		}
-		outletRepo.On("GetByOrganizationID", mock.Anything, req.OrganizationID).Return(outlets, nil)
-
-		// Mock inventory creation
-		inventoryRepo.On("BulkCreate", mock.Anything, mock.Anything).Return(nil)
-
-		// Act
-		result, err := processor.CreateProduct(context.Background(), req)
-
-		// Assert
-		assert.NoError(t, err)
-		assert.NotNil(t, result)
-
-		// Verify that inventory was created
-		inventoryRepo.AssertCalled(t, "BulkCreate", mock.Anything, mock.Anything)
-		outletRepo.AssertCalled(t, "GetByOrganizationID", mock.Anything, req.OrganizationID)
-	})
-
-	t.Run("should not create inventory when create_inventory is false", func(t *testing.T) {
-		// Arrange
-		productRepo := &MockProductRepository{}
-		categoryRepo := &MockCategoryRepository{}
-		productVariantRepo := &MockProductVariantRepository{}
-		inventoryRepo := &MockInventoryRepository{}
-		outletRepo := &MockOutletRepository{}
-
-		processor := NewProductProcessorImpl(
-			productRepo,
-			categoryRepo,
-			productVariantRepo,
-			inventoryRepo,
-			outletRepo,
-		)
-
-		req := &models.CreateProductRequest{
-			OrganizationID:  uuid.New(),
-			CategoryID:      uuid.New(),
-			Name:            "Test Product",
-			Price:           10.0,
-			Cost:            5.0,
-			CreateInventory: false,
-		}
-
-		// Mock expectations
-		categoryRepo.On("GetByID", mock.Anything, req.CategoryID).Return(&models.Category{}, nil)
-		productRepo.On("ExistsBySKU", mock.Anything, req.OrganizationID, mock.Anything, mock.Anything).Return(false, nil)
-		productRepo.On("ExistsByName", mock.Anything, req.OrganizationID, req.Name, mock.Anything).Return(false, nil)
-		productRepo.On("Create", mock.Anything, mock.Anything).Return(nil)
-		productRepo.On("GetWithCategory", mock.Anything, mock.Anything).Return(&models.Product{}, nil)
-
-		// Act
-		result, err := processor.CreateProduct(context.Background(), req)
-
-		// Assert
-		assert.NoError(t, err)
-		assert.NotNil(t, result)
-
-		// Verify that inventory was NOT created
-		inventoryRepo.AssertNotCalled(t, "BulkCreate", mock.Anything, mock.Anything)
-		outletRepo.AssertNotCalled(t, "GetByOrganizationID", mock.Anything, mock.Anything)
-	})
-}
-
-// Mock implementations (simplified for testing)
-func (m *MockProductRepository) Create(ctx context.Context, product *models.Product) error {
-	args := m.Called(ctx, product)
-	return args.Error(0)
-}
-
-func (m *MockProductRepository) GetByID(ctx context.Context, id uuid.UUID) (*models.Product, error) {
-	args := m.Called(ctx, id)
-	return args.Get(0).(*models.Product), args.Error(1)
-}
-
-func (m *MockProductRepository) GetWithCategory(ctx context.Context, id uuid.UUID) (*models.Product, error) {
-	args := m.Called(ctx, id)
-	return args.Get(0).(*models.Product), args.Error(1)
-}
-
-func (m *MockProductRepository) ExistsBySKU(ctx context.Context, organizationID uuid.UUID, sku string, excludeID *uuid.UUID) (bool, error) {
-	args := m.Called(ctx, organizationID, sku, excludeID)
-	return args.Bool(0), args.Error(1)
-}
-
-func (m *MockProductRepository) ExistsByName(ctx context.Context, organizationID uuid.UUID, name string, excludeID *uuid.UUID) (bool, error) {
-	args := m.Called(ctx, organizationID, name, excludeID)
-	return args.Bool(0), args.Error(1)
-}
-
-func (m *MockCategoryRepository) GetByID(ctx context.Context, id uuid.UUID) (*models.Category, error) {
-	args := m.Called(ctx, id)
-	return args.Get(0).(*models.Category), args.Error(1)
-}
-
-func (m *MockInventoryRepository) BulkCreate(ctx context.Context, inventoryItems []*models.Inventory) error {
-	args := m.Called(ctx, inventoryItems)
-	return args.Error(0)
-}
-
-func (m *MockOutletRepository) GetByOrganizationID(ctx context.Context, organizationID uuid.UUID) ([]*models.Outlet, error) {
-	args := m.Called(ctx, organizationID)
-	return args.Get(0).([]*models.Outlet), args.Error(1)
-}
@@ -82,3 +82,12 @@ type UnitRepository interface {
 	Update(ctx context.Context, unit *entities.Unit) error
 	Delete(ctx context.Context, id, organizationID uuid.UUID) error
 }
+
+type IngredientCompositionRepository interface {
+	Create(ctx context.Context, composition *entities.IngredientComposition) error
+	GetByID(ctx context.Context, id, organizationID uuid.UUID) (*entities.IngredientComposition, error)
+	GetByParentIngredientID(ctx context.Context, parentIngredientID, organizationID uuid.UUID) ([]*entities.IngredientComposition, error)
+	Update(ctx context.Context, composition *entities.IngredientComposition) error
+	Delete(ctx context.Context, id, organizationID uuid.UUID) error
+	DeleteByParentIngredientID(ctx context.Context, parentIngredientID, organizationID uuid.UUID) error
+}
@@ -77,33 +77,43 @@ func (r *AnalyticsRepositoryImpl) GetSalesAnalytics(ctx context.Context, organiz
 		dateFormat = "DATE(o.created_at)"
 	}

-	query := r.db.WithContext(ctx).
-		Table("orders o").
-		Select(`
-			`+dateFormat+` as date,
+	outletFilter := ""
+	args := []interface{}{organizationID, false, false, string(entities.PaymentStatusCompleted), dateFrom, dateTo}
+	if outletID != nil {
+		outletFilter = "AND o.outlet_id = ?"
+		args = append(args, *outletID)
+	}
+
+	rawQuery := `
+		SELECT
+			` + dateFormat + ` as date,
 			COALESCE(SUM(o.total_amount), 0) as sales,
 			COUNT(o.id) as orders,
-			COALESCE(SUM(CASE WHEN oi.status != 'cancelled' AND oi.is_fully_refunded = false THEN oi.quantity - COALESCE(oi.refund_quantity, 0) ELSE 0 END), 0) as items,
+			COALESCE(SUM(oi_agg.total_items), 0) as items,
 			COALESCE(SUM(o.tax_amount), 0) as tax,
 			COALESCE(SUM(o.discount_amount), 0) as discount,
 			COALESCE(SUM(o.total_amount - o.tax_amount - o.discount_amount), 0) as net_sales
-		`).
-		Joins("LEFT JOIN order_items oi ON o.id = oi.order_id").
-		Where("o.organization_id = ?", organizationID).
-		Where("o.is_void = ?", false).
-		Where("o.is_refund = ?", false).
-		Where("o.payment_status = ?", entities.PaymentStatusCompleted).
-		Where("o.created_at >= ? AND o.created_at <= ?", dateFrom, dateTo)
-
-	if outletID != nil {
-		query = query.Where("o.outlet_id = ?", *outletID)
-	}
-
-	err := query.
-		Group("date").
-		Order("date ASC").
-		Scan(&results).Error
+		FROM orders o
+		LEFT JOIN (
+			SELECT
+				oi.order_id,
+				SUM(oi.quantity - COALESCE(oi.refund_quantity, 0)) as total_items
+			FROM order_items oi
+			WHERE oi.status != 'cancelled'
+			  AND oi.is_fully_refunded = false
+			GROUP BY oi.order_id
+		) oi_agg ON oi_agg.order_id = o.id
+		WHERE o.organization_id = ?
+		  AND o.is_void = ?
+		  AND o.is_refund = ?
+		  AND o.payment_status = ?
+		  AND o.created_at >= ? AND o.created_at <= ?
+		  ` + outletFilter + `
+		GROUP BY date
+		ORDER BY date ASC
+	`

+	err := r.db.WithContext(ctx).Raw(rawQuery, args...).Scan(&results).Error
 	return results, err
 }

@@ -3,285 +3,81 @@ package repository
 import (
 	"apskel-pos-be/internal/entities"
 	"context"
-	"database/sql"
+	"fmt"

 	"github.com/google/uuid"
+	"gorm.io/gorm"
 )

 type IngredientCompositionRepository struct {
-	db *sql.DB
+	db *gorm.DB
 }

-func NewIngredientCompositionRepository(db *sql.DB) *IngredientCompositionRepository {
+func NewIngredientCompositionRepository(db *gorm.DB) *IngredientCompositionRepository {
 	return &IngredientCompositionRepository{db: db}
 }

 func (r *IngredientCompositionRepository) Create(ctx context.Context, composition *entities.IngredientComposition) error {
-	query := `
-		INSERT INTO ingredient_compositions (id, organization_id, outlet_id, parent_ingredient_id, child_ingredient_id, quantity, created_at, updated_at)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-	`
-
-	_, err := r.db.ExecContext(ctx, query,
-		composition.ID,
-		composition.OrganizationID,
-		composition.OutletID,
-		composition.ParentIngredientID,
-		composition.ChildIngredientID,
-		composition.Quantity,
-		composition.CreatedAt,
-		composition.UpdatedAt,
-	)
-
-	return err
+	return r.db.WithContext(ctx).Create(composition).Error
 }

 func (r *IngredientCompositionRepository) GetByID(ctx context.Context, id, organizationID uuid.UUID) (*entities.IngredientComposition, error) {
-	query := `
-		SELECT ic.id, ic.organization_id, ic.outlet_id, ic.parent_ingredient_id, ic.child_ingredient_id, ic.quantity, ic.created_at, ic.updated_at,
-		       pi.id, pi.organization_id, pi.outlet_id, pi.name, pi.unit_id, pi.cost, pi.stock, pi.is_semi_finished, pi.is_active, pi.metadata, pi.created_at, pi.updated_at,
-		       ci.id, ci.organization_id, ci.outlet_id, ci.name, ci.unit_id, ci.cost, ci.stock, ci.is_semi_finished, ci.is_active, ci.metadata, ci.created_at, ci.updated_at
-		FROM ingredient_compositions ic
-		LEFT JOIN ingredients pi ON ic.parent_ingredient_id = pi.id
-		LEFT JOIN ingredients ci ON ic.child_ingredient_id = ci.id
-		WHERE ic.id = $1 AND ic.organization_id = $2
-	`
-
-	composition := &entities.IngredientComposition{}
-	parentIngredient := &entities.Ingredient{}
-	childIngredient := &entities.Ingredient{}
-
-	err := r.db.QueryRowContext(ctx, query, id, organizationID).Scan(
-		&composition.ID,
-		&composition.OrganizationID,
-		&composition.OutletID,
-		&composition.ParentIngredientID,
-		&composition.ChildIngredientID,
-		&composition.Quantity,
-		&composition.CreatedAt,
-		&composition.UpdatedAt,
-		&parentIngredient.ID,
-		&parentIngredient.OrganizationID,
-		&parentIngredient.OutletID,
-		&parentIngredient.Name,
-		&parentIngredient.UnitID,
-		&parentIngredient.Cost,
-		&parentIngredient.Stock,
-		&parentIngredient.IsSemiFinished,
-		&parentIngredient.IsActive,
-		&parentIngredient.Metadata,
-		&parentIngredient.CreatedAt,
-		&parentIngredient.UpdatedAt,
-		&childIngredient.ID,
-		&childIngredient.OrganizationID,
-		&childIngredient.OutletID,
-		&childIngredient.Name,
-		&childIngredient.UnitID,
-		&childIngredient.Cost,
-		&childIngredient.Stock,
-		&childIngredient.IsSemiFinished,
-		&childIngredient.IsActive,
-		&childIngredient.Metadata,
-		&childIngredient.CreatedAt,
-		&childIngredient.UpdatedAt,
-	)
-
+	var composition entities.IngredientComposition
+	err := r.db.WithContext(ctx).
+		Preload("ChildIngredient.Unit").
+		Preload("ParentIngredient.Unit").
+		Preload("ParentIngredient.Compositions.ChildIngredient.Unit").
+		Where("id = ? AND organization_id = ?", id, organizationID).
+		First(&composition).Error
 	if err != nil {
 		return nil, err
 	}
-
-	composition.ParentIngredient = parentIngredient
-	composition.ChildIngredient = childIngredient
-	return composition, nil
+	return &composition, nil
 }

 func (r *IngredientCompositionRepository) GetByParentIngredientID(ctx context.Context, parentIngredientID, organizationID uuid.UUID) ([]*entities.IngredientComposition, error) {
-	query := `
-		SELECT ic.id, ic.organization_id, ic.outlet_id, ic.parent_ingredient_id, ic.child_ingredient_id, ic.quantity, ic.created_at, ic.updated_at,
-		       pi.id, pi.organization_id, pi.outlet_id, pi.name, pi.unit_id, pi.cost, pi.stock, pi.is_semi_finished, pi.is_active, pi.metadata, pi.created_at, pi.updated_at,
-		       ci.id, ci.organization_id, ci.outlet_id, ci.name, ci.unit_id, ci.cost, ci.stock, ci.is_semi_finished, ci.is_active, ci.metadata, ci.created_at, ci.updated_at
-		FROM ingredient_compositions ic
-		LEFT JOIN ingredients pi ON ic.parent_ingredient_id = pi.id
-		LEFT JOIN ingredients ci ON ic.child_ingredient_id = ci.id
-		WHERE ic.parent_ingredient_id = $1 AND ic.organization_id = $2
-		ORDER BY ic.created_at DESC
-	`
-
-	rows, err := r.db.QueryContext(ctx, query, parentIngredientID, organizationID)
+	var compositions []*entities.IngredientComposition
+	err := r.db.WithContext(ctx).
+		Preload("ChildIngredient.Unit").
+		Where("parent_ingredient_id = ? AND organization_id = ?", parentIngredientID, organizationID).
+		Order("created_at ASC").
+		Find(&compositions).Error
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-
-	var compositions []*entities.IngredientComposition
-	for rows.Next() {
-		composition := &entities.IngredientComposition{}
-		parentIngredient := &entities.Ingredient{}
-		childIngredient := &entities.Ingredient{}
-
-		err := rows.Scan(
-			&composition.ID,
-			&composition.OrganizationID,
-			&composition.OutletID,
-			&composition.ParentIngredientID,
-			&composition.ChildIngredientID,
-			&composition.Quantity,
-			&composition.CreatedAt,
-			&composition.UpdatedAt,
-			&parentIngredient.ID,
-			&parentIngredient.OrganizationID,
-			&parentIngredient.OutletID,
-			&parentIngredient.Name,
-			&parentIngredient.UnitID,
-			&parentIngredient.Cost,
-			&parentIngredient.Stock,
-			&parentIngredient.IsSemiFinished,
-			&parentIngredient.IsActive,
-			&parentIngredient.Metadata,
-			&parentIngredient.CreatedAt,
-			&parentIngredient.UpdatedAt,
-			&childIngredient.ID,
-			&childIngredient.OrganizationID,
-			&childIngredient.OutletID,
-			&childIngredient.Name,
-			&childIngredient.UnitID,
-			&childIngredient.Cost,
-			&childIngredient.Stock,
-			&childIngredient.IsSemiFinished,
-			&childIngredient.IsActive,
-			&childIngredient.Metadata,
-			&childIngredient.CreatedAt,
-			&childIngredient.UpdatedAt,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		composition.ParentIngredient = parentIngredient
-		composition.ChildIngredient = childIngredient
-		compositions = append(compositions, composition)
-	}
-
-	return compositions, nil
-}
-
-func (r *IngredientCompositionRepository) GetByChildIngredientID(ctx context.Context, childIngredientID, organizationID uuid.UUID) ([]*entities.IngredientComposition, error) {
-	query := `
-		SELECT ic.id, ic.organization_id, ic.outlet_id, ic.parent_ingredient_id, ic.child_ingredient_id, ic.quantity, ic.created_at, ic.updated_at,
-		       pi.id, pi.organization_id, pi.outlet_id, pi.name, pi.unit_id, pi.cost, pi.stock, pi.is_semi_finished, pi.is_active, pi.metadata, pi.created_at, pi.updated_at,
-		       ci.id, ci.organization_id, ci.outlet_id, ci.name, ci.unit_id, ci.cost, ci.stock, ci.is_semi_finished, ci.is_active, ci.metadata, ci.created_at, ci.updated_at
-		FROM ingredient_compositions ic
-		LEFT JOIN ingredients pi ON ic.parent_ingredient_id = pi.id
-		LEFT JOIN ingredients ci ON ic.child_ingredient_id = ci.id
-		WHERE ic.child_ingredient_id = $1 AND ic.organization_id = $2
-		ORDER BY ic.created_at DESC
-	`
-
-	rows, err := r.db.QueryContext(ctx, query, childIngredientID, organizationID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var compositions []*entities.IngredientComposition
-	for rows.Next() {
-		composition := &entities.IngredientComposition{}
-		parentIngredient := &entities.Ingredient{}
-		childIngredient := &entities.Ingredient{}
-
-		err := rows.Scan(
-			&composition.ID,
-			&composition.OrganizationID,
-			&composition.OutletID,
-			&composition.ParentIngredientID,
-			&composition.ChildIngredientID,
-			&composition.Quantity,
-			&composition.CreatedAt,
-			&composition.UpdatedAt,
-			&parentIngredient.ID,
-			&parentIngredient.OrganizationID,
-			&parentIngredient.OutletID,
-			&parentIngredient.Name,
-			&parentIngredient.UnitID,
-			&parentIngredient.Cost,
-			&parentIngredient.Stock,
-			&parentIngredient.IsSemiFinished,
-			&parentIngredient.IsActive,
-			&parentIngredient.Metadata,
-			&parentIngredient.CreatedAt,
-			&parentIngredient.UpdatedAt,
-			&childIngredient.ID,
-			&childIngredient.OrganizationID,
-			&childIngredient.OutletID,
-			&childIngredient.Name,
-			&childIngredient.UnitID,
-			&childIngredient.Cost,
-			&childIngredient.Stock,
-			&childIngredient.IsSemiFinished,
-			&childIngredient.IsActive,
-			&childIngredient.Metadata,
-			&childIngredient.CreatedAt,
-			&childIngredient.UpdatedAt,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		composition.ParentIngredient = parentIngredient
-		composition.ChildIngredient = childIngredient
-		compositions = append(compositions, composition)
-	}
-
 	return compositions, nil
 }

 func (r *IngredientCompositionRepository) Update(ctx context.Context, composition *entities.IngredientComposition) error {
-	query := `
-		UPDATE ingredient_compositions
-		SET outlet_id = $1, quantity = $2, updated_at = $3
-		WHERE id = $4 AND organization_id = $5
-	`
-
-	result, err := r.db.ExecContext(ctx, query,
-		composition.OutletID,
-		composition.Quantity,
-		composition.UpdatedAt,
-		composition.ID,
-		composition.OrganizationID,
-	)
-
-	if err != nil {
-		return err
+	result := r.db.WithContext(ctx).
+		Model(&entities.IngredientComposition{}).
+		Where("id = ? AND organization_id = ?", composition.ID, composition.OrganizationID).
+		Select("outlet_id", "quantity", "updated_at").
+		Updates(composition)
+	if result.Error != nil {
+		return result.Error
 	}
-
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return err
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("no rows affected")
 	}
-
-	if rowsAffected == 0 {
-		return sql.ErrNoRows
-	}
-
 	return nil
 }

 func (r *IngredientCompositionRepository) Delete(ctx context.Context, id, organizationID uuid.UUID) error {
-	query := `DELETE FROM ingredient_compositions WHERE id = $1 AND organization_id = $2`
-
-	result, err := r.db.ExecContext(ctx, query, id, organizationID)
-	if err != nil {
-		return err
+	result := r.db.WithContext(ctx).
+		Where("id = ? AND organization_id = ?", id, organizationID).
+		Delete(&entities.IngredientComposition{})
+	if result.Error != nil {
+		return result.Error
 	}
-
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return err
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("no rows affected")
 	}
-
-	if rowsAffected == 0 {
-		return sql.ErrNoRows
-	}
-
 	return nil
 }
+
+func (r *IngredientCompositionRepository) DeleteByParentIngredientID(ctx context.Context, parentIngredientID, organizationID uuid.UUID) error {
+	return r.db.WithContext(ctx).
+		Where("parent_ingredient_id = ? AND organization_id = ?", parentIngredientID, organizationID).
+		Delete(&entities.IngredientComposition{}).Error
+}
@@ -24,7 +24,11 @@ func (r *IngredientRepository) Create(ctx context.Context, ingredient *entities.

 func (r *IngredientRepository) GetByID(ctx context.Context, id, organizationID uuid.UUID) (*entities.Ingredient, error) {
 	var ingredient entities.Ingredient
-	err := r.db.WithContext(ctx).Preload("Unit").Where("id = ? AND organization_id = ?", id, organizationID).First(&ingredient).Error
+	err := r.db.WithContext(ctx).
+		Preload("Unit").
+		Preload("Compositions.ChildIngredient.Unit").
+		Where("id = ? AND organization_id = ?", id, organizationID).
+		First(&ingredient).Error
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +61,13 @@ func (r *IngredientRepository) GetAll(ctx context.Context, organizationID uuid.U

 	// Get paginated results with Unit preloaded
 	offset := (page - 1) * limit
-	err := query.Preload("Unit").Order("created_at DESC").Limit(limit).Offset(offset).Find(&ingredients).Error
+	err := query.
+		Preload("Unit").
+		Preload("Compositions.ChildIngredient.Unit").
+		Order("created_at DESC").
+		Limit(limit).
+		Offset(offset).
+		Find(&ingredients).Error
 	if err != nil {
 		return nil, 0, err
 	}
@@ -46,11 +46,12 @@ type Router struct {
 	customerAuthHandler               *handler.CustomerAuthHandler
 	customerPointsHandler             *handler.CustomerPointsHandler
 	spinGameHandler                   *handler.SpinGameHandler
+	selfOrderHandler                  *handler.SelfOrderHandler
 	authMiddleware                    *middleware.AuthMiddleware
 	customerAuthMiddleware            *middleware.CustomerAuthMiddleware
 }

-func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authService service.AuthService, authMiddleware *middleware.AuthMiddleware, userService *service.UserServiceImpl, userValidator *validator.UserValidatorImpl, organizationService service.OrganizationService, organizationValidator validator.OrganizationValidator, outletService service.OutletService, outletValidator validator.OutletValidator, outletSettingService service.OutletSettingService, categoryService service.CategoryService, categoryValidator validator.CategoryValidator, productService service.ProductService, productValidator validator.ProductValidator, productVariantService service.ProductVariantService, productVariantValidator validator.ProductVariantValidator, inventoryService service.InventoryService, inventoryValidator validator.InventoryValidator, orderService service.OrderService, orderValidator validator.OrderValidator, fileService service.FileService, fileValidator validator.FileValidator, customerService service.CustomerService, customerValidator validator.CustomerValidator, paymentMethodService service.PaymentMethodService, paymentMethodValidator validator.PaymentMethodValidator, analyticsService *service.AnalyticsServiceImpl, reportService service.ReportService, tableService *service.TableServiceImpl, tableValidator *validator.TableValidator, unitService handler.UnitService, ingredientService handler.IngredientService, productRecipeService service.ProductRecipeService, vendorService service.VendorService, vendorValidator validator.VendorValidator, purchaseOrderService service.PurchaseOrderService, purchaseOrderValidator validator.PurchaseOrderValidator, unitConverterService service.IngredientUnitConverterService, unitConverterValidator validator.IngredientUnitConverterValidator, chartOfAccountTypeService service.ChartOfAccountTypeService, chartOfAccountTypeValidator validator.ChartOfAccountTypeValidator, chartOfAccountService service.ChartOfAccountService, chartOfAccountValidator validator.ChartOfAccountValidator, accountService service.AccountService, accountValidator validator.AccountValidator, orderIngredientTransactionService service.OrderIngredientTransactionService, orderIngredientTransactionValidator validator.OrderIngredientTransactionValidator, gamificationService service.GamificationService, gamificationValidator validator.GamificationValidator, rewardService service.RewardService, rewardValidator validator.RewardValidator, campaignService service.CampaignService, campaignValidator validator.CampaignValidator, customerAuthService service.CustomerAuthService, customerAuthValidator validator.CustomerAuthValidator, customerPointsService service.CustomerPointsService, spinGameService service.SpinGameService, customerAuthMiddleware *middleware.CustomerAuthMiddleware) *Router {
+func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authService service.AuthService, authMiddleware *middleware.AuthMiddleware, userService *service.UserServiceImpl, userValidator *validator.UserValidatorImpl, organizationService service.OrganizationService, organizationValidator validator.OrganizationValidator, outletService service.OutletService, outletValidator validator.OutletValidator, outletSettingService service.OutletSettingService, categoryService service.CategoryService, categoryValidator validator.CategoryValidator, productService service.ProductService, productValidator validator.ProductValidator, productVariantService service.ProductVariantService, productVariantValidator validator.ProductVariantValidator, inventoryService service.InventoryService, inventoryValidator validator.InventoryValidator, orderService service.OrderService, orderValidator validator.OrderValidator, fileService service.FileService, fileValidator validator.FileValidator, customerService service.CustomerService, customerValidator validator.CustomerValidator, paymentMethodService service.PaymentMethodService, paymentMethodValidator validator.PaymentMethodValidator, analyticsService *service.AnalyticsServiceImpl, reportService service.ReportService, tableService *service.TableServiceImpl, tableValidator *validator.TableValidator, unitService handler.UnitService, ingredientService handler.IngredientService, productRecipeService service.ProductRecipeService, vendorService service.VendorService, vendorValidator validator.VendorValidator, purchaseOrderService service.PurchaseOrderService, purchaseOrderValidator validator.PurchaseOrderValidator, unitConverterService service.IngredientUnitConverterService, unitConverterValidator validator.IngredientUnitConverterValidator, chartOfAccountTypeService service.ChartOfAccountTypeService, chartOfAccountTypeValidator validator.ChartOfAccountTypeValidator, chartOfAccountService service.ChartOfAccountService, chartOfAccountValidator validator.ChartOfAccountValidator, accountService service.AccountService, accountValidator validator.AccountValidator, orderIngredientTransactionService service.OrderIngredientTransactionService, orderIngredientTransactionValidator validator.OrderIngredientTransactionValidator, gamificationService service.GamificationService, gamificationValidator validator.GamificationValidator, rewardService service.RewardService, rewardValidator validator.RewardValidator, campaignService service.CampaignService, campaignValidator validator.CampaignValidator, customerAuthService service.CustomerAuthService, customerAuthValidator validator.CustomerAuthValidator, customerPointsService service.CustomerPointsService, spinGameService service.SpinGameService, customerAuthMiddleware *middleware.CustomerAuthMiddleware, selfOrderHandler *handler.SelfOrderHandler) *Router {

 	return &Router{
 		config:                            cfg,
@@ -89,6 +90,7 @@ func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authSer
 		authMiddleware:                    authMiddleware,
 		customerAuthMiddleware:            customerAuthMiddleware,
 		productVariantHandler:             handler.NewProductVariantHandler(productVariantService, productVariantValidator),
+		selfOrderHandler:                  selfOrderHandler,
 	}
 }

@@ -145,6 +147,13 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 			customer.POST("/spin", r.spinGameHandler.PlaySpinGame)
 		}

+		selfOrder := v1.Group("/self-order")
+		{
+			selfOrder.GET("/categories", r.selfOrderHandler.ListCategories)
+			selfOrder.POST("/menu", r.selfOrderHandler.GetMenu)
+			selfOrder.POST("/order", r.selfOrderHandler.CreateOrder)
+		}
+
 		organizations := v1.Group("/organizations")
 		{
 			organizations.POST("", r.organizationHandler.CreateOrganization)
@@ -322,6 +331,9 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 				ingredients.GET("/:id", r.ingredientHandler.GetByID)
 				ingredients.PUT("/:id", r.ingredientHandler.Update)
 				ingredients.DELETE("/:id", r.ingredientHandler.Delete)
+				ingredients.POST("/:id/compositions", r.ingredientHandler.AddCompositions)
+				ingredients.PUT("/compositions/:composition_id", r.ingredientHandler.UpdateComposition)
+				ingredients.DELETE("/compositions/:composition_id", r.ingredientHandler.DeleteComposition)
 			}

 			vendors := protected.Group("/vendors")
@@ -13,4 +13,7 @@ type IngredientProcessor interface {
 	DeleteIngredient(ctx context.Context, id uuid.UUID) error
 	GetIngredientByID(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error)
 	ListIngredients(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, page, limit int, search string) (*models.PaginatedResponse[models.IngredientResponse], error)
+	UpdateComposition(ctx context.Context, id uuid.UUID, req *models.UpdateIngredientCompositionRequest) (*models.IngredientCompositionResponse, error)
+	DeleteComposition(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error)
+	AddCompositions(ctx context.Context, parentID uuid.UUID, req *models.AddIngredientCompositionsRequest) (*models.AddIngredientCompositionsResponse, error)
 }
@@ -36,3 +36,15 @@ func (s *IngredientServiceImpl) GetIngredientByID(ctx context.Context, id uuid.U
 func (s *IngredientServiceImpl) ListIngredients(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, page, limit int, search string) (*models.PaginatedResponse[models.IngredientResponse], error) {
 	return s.ingredientProcessor.ListIngredients(ctx, organizationID, outletID, page, limit, search)
 }
+
+func (s *IngredientServiceImpl) UpdateComposition(ctx context.Context, id uuid.UUID, req *models.UpdateIngredientCompositionRequest) (*models.IngredientCompositionResponse, error) {
+	return s.ingredientProcessor.UpdateComposition(ctx, id, req)
+}
+
+func (s *IngredientServiceImpl) DeleteComposition(ctx context.Context, id uuid.UUID) (*models.IngredientResponse, error) {
+	return s.ingredientProcessor.DeleteComposition(ctx, id)
+}
+
+func (s *IngredientServiceImpl) AddCompositions(ctx context.Context, parentID uuid.UUID, req *models.AddIngredientCompositionsRequest) (*models.AddIngredientCompositionsResponse, error) {
+	return s.ingredientProcessor.AddCompositions(ctx, parentID, req)
+}
@@ -483,7 +483,7 @@ func (s *OrderServiceImpl) validateCreatePaymentRequest(req *models.CreatePaymen
 				return fmt.Errorf("order item ID is required for payment item %d", i+1)
 			}

-			if item.Amount <= 0 {
+			if item.Amount < 0 {
 				return fmt.Errorf("payment item amount must be greater than zero for item %d", i+1)
 			}

@@ -0,0 +1,83 @@
+package transformer
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+)
+
+// IngredientEntityToResponse converts ingredient entity to response model
+func IngredientEntityToResponse(ingredient *entities.Ingredient) *models.IngredientResponse {
+	if ingredient == nil {
+		return nil
+	}
+
+	m := mappers.MapIngredientEntityToModel(ingredient)
+	resp := &models.IngredientResponse{
+		ID:             m.ID,
+		OrganizationID: m.OrganizationID,
+		OutletID:       m.OutletID,
+		Name:           m.Name,
+		UnitID:         m.UnitID,
+		Cost:           m.Cost,
+		Stock:          m.Stock,
+		IsSemiFinished: m.IsSemiFinished,
+		IsActive:       m.IsActive,
+		Metadata:       m.Metadata,
+		CreatedAt:      m.CreatedAt,
+		UpdatedAt:      m.UpdatedAt,
+		Unit:           m.Unit,
+	}
+
+	// Use preloaded compositions for semi-finished ingredients
+	if ingredient.IsSemiFinished && len(ingredient.Compositions) > 0 {
+		resp.Compositions = make([]*models.IngredientCompositionResponse, 0, len(ingredient.Compositions))
+		for _, c := range ingredient.Compositions {
+			resp.Compositions = append(resp.Compositions, CompositionEntityToResponse(&c))
+		}
+	}
+
+	return resp
+}
+
+// CompositionEntityToResponse converts composition entity to response model
+func CompositionEntityToResponse(c *entities.IngredientComposition) *models.IngredientCompositionResponse {
+	if c == nil {
+		return nil
+	}
+
+	resp := &models.IngredientCompositionResponse{
+		ID:                c.ID,
+		OutletID:          c.OutletID,
+		ChildIngredientID: c.ChildIngredientID,
+		Quantity:          c.Quantity,
+		CreatedAt:         c.CreatedAt,
+		UpdatedAt:         c.UpdatedAt,
+	}
+
+	if c.ChildIngredient != nil {
+		resp.ChildIngredient = mappers.MapIngredientEntityToResponse(c.ChildIngredient)
+	}
+
+	if c.ParentIngredient != nil {
+		resp.ParentIngredient = IngredientEntityToResponse(c.ParentIngredient)
+	}
+
+	return resp
+}
+
+// IngredientsToResponses converts slice of ingredient entities to response models
+func IngredientsToResponses(ingredients []*entities.Ingredient) []models.IngredientResponse {
+	if ingredients == nil {
+		return []models.IngredientResponse{}
+	}
+
+	responses := make([]models.IngredientResponse, len(ingredients))
+	for i, ing := range ingredients {
+		response := IngredientEntityToResponse(ing)
+		if response != nil {
+			responses[i] = *response
+		}
+	}
+	return responses
+}
@@ -0,0 +1,123 @@
+# Test Ingredient Composition Endpoints
+
+## 1. Add Compositions (Bulk)
+
+```bash
+POST http://localhost:4000/api/v1/ingredients/{ingredient_id}/compositions
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZW1haWwiOiJhZG1pbkBnb2t1bmEuaWQiLCJyb2xlIjoiYWRtaW4iLCJvcmdhbml6YXRpb25faWQiOiIwMzIwNWQ4Zi0yYzA2LTQ1MTMtYTk1Mi0yMWQxMTA5Zjc4ZmYiLCJpc3MiOiJhcHNrZWwtcG9zIiwic3ViIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZXhwIjoxNzg1OTE0ODQ4LCJuYmYiOjE3NzcyNzQ4NDgsImlhdCI6MTc3NzI3NDg0OH0.prO4mU1zjVUZLgi5c8hj10A6ODETCMjnEP8wUQikZ30
+Content-Type: application/json
+
+{
+  "compositions": [
+    {
+      "child_ingredient_id": "CHILD_INGREDIENT_UUID_1",
+      "quantity": 2.5
+    },
+    {
+      "child_ingredient_id": "CHILD_INGREDIENT_UUID_2",
+      "quantity": 1.0
+    }
+  ]
+}
+```
+
+**Expected Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "parent_ingredient": {
+      "id": "uuid",
+      "name": "Semi-Finished Product",
+      "cost": 15.50,
+      "compositions": [...]
+    },
+    "compositions": [
+      {
+        "id": "COMPOSITION_ID_1",
+        "child_ingredient_id": "...",
+        "quantity": 2.5,
+        "child_ingredient": {...},
+        "parent_ingredient": {...}
+      }
+    ]
+  }
+}
+```
+
+## 2. Update Composition
+
+```bash
+PUT http://localhost:4000/api/v1/ingredients/compositions/{composition_id}
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZW1haWwiOiJhZG1pbkBnb2t1bmEuaWQiLCJyb2xlIjoiYWRtaW4iLCJvcmdhbml6YXRpb25faWQiOiIwMzIwNWQ4Zi0yYzA2LTQ1MTMtYTk1Mi0yMWQxMTA5Zjc4ZmYiLCJpc3MiOiJhcHNrZWwtcG9zIiwic3ViIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZXhwIjoxNzg1OTE0ODQ4LCJuYmYiOjE3NzcyNzQ4NDgsImlhdCI6MTc3NzI3NDg0OH0.prO4mU1zjVUZLgi5c8hj10A6ODETCMjnEP8wUQikZ30
+Content-Type: application/json
+
+{
+  "quantity": 3.5
+}
+```
+
+**Expected Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "id": "composition_id",
+    "child_ingredient_id": "...",
+    "quantity": 3.5,
+    "child_ingredient": {...},
+    "parent_ingredient": {
+      "id": "...",
+      "cost": 18.75,
+      "compositions": [...]
+    }
+  }
+}
+```
+
+## 3. Delete Composition
+
+```bash
+DELETE http://localhost:4000/api/v1/ingredients/compositions/{composition_id}
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZW1haWwiOiJhZG1pbkBnb2t1bmEuaWQiLCJyb2xlIjoiYWRtaW4iLCJvcmdhbml6YXRpb25faWQiOiIwMzIwNWQ4Zi0yYzA2LTQ1MTMtYTk1Mi0yMWQxMTA5Zjc4ZmYiLCJpc3MiOiJhcHNrZWwtcG9zIiwic3ViIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZXhwIjoxNzg1OTE0ODQ4LCJuYmYiOjE3NzcyNzQ4NDgsImlhdCI6MTc3NzI3NDg0OH0.prO4mU1zjVUZLgi5c8hj10A6ODETCMjnEP8wUQikZ30
+```
+
+**Expected Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "id": "parent_ingredient_id",
+    "name": "Semi-Finished Product",
+    "cost": 12.25,
+    "compositions": [
+      // remaining compositions after deletion
+    ]
+  }
+}
+```
+
+## Steps to Test:
+
+1. **Get a semi-finished ingredient ID** (or create one first)
+2. **Get child ingredient IDs** (raw ingredients to add as compositions)
+3. **Add compositions** using the bulk endpoint
+4. **Copy composition ID** from the response
+5. **Update or Delete** using that composition ID
+
+## cURL Commands:
+
+### Delete Composition:
+```bash
+curl --request DELETE \
+  --url 'http://localhost:4000/api/v1/ingredients/compositions/YOUR_COMPOSITION_ID_HERE' \
+  --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZW1haWwiOiJhZG1pbkBnb2t1bmEuaWQiLCJyb2xlIjoiYWRtaW4iLCJvcmdhbml6YXRpb25faWQiOiIwMzIwNWQ4Zi0yYzA2LTQ1MTMtYTk1Mi0yMWQxMTA5Zjc4ZmYiLCJpc3MiOiJhcHNrZWwtcG9zIiwic3ViIjoiNmM2ZDI0MjAtNzA0MS00ZWE5LWE3MjYtYTM0MDAxNGJiMjRkIiwiZXhwIjoxNzg1OTE0ODQ4LCJuYmYiOjE3NzcyNzQ4NDgsImlhdCI6MTc3NzI3NDg0OH0.prO4mU1zjVUZLgi5c8hj10A6ODETCMjnEP8wUQikZ30'
+```
+
+## Notes:
+
+- Replace `{ingredient_id}` with actual parent ingredient UUID
+- Replace `{composition_id}` with actual composition UUID
+- Replace `CHILD_INGREDIENT_UUID_1` and `CHILD_INGREDIENT_UUID_2` with actual child ingredient UUIDs
+- Parent ingredient must have `is_semi_finished: true`
+- All responses now include the updated parent ingredient with recalculated cost
Author	SHA1	Message	Date
ryan	fe57aab3b4	Fix categories with table	2026-05-08 14:19:40 +07:00
ryan	3721fb3cd7	List categories for self-order	2026-05-06 11:56:11 +07:00
ryan	2d6df8e4c6	Self Order - BE	2026-05-05 21:07:03 +07:00
aefril	2c76962959	Merge pull request 'ingredient composition' (#2 ) from feature/ingredient-composition into main Reviewed-on: #2	2026-04-27 14:22:22 +00:00
Efril	a7022dd4c1	ingredient composition	2026-04-27 21:17:12 +07:00
Efril	3542104050	fix sales	2026-04-27 13:24:16 +07:00
Efril	eb95459578	fix if order amount 0	2026-04-26 23:40:01 +07:00
Efril	1a5ddd2b34	update	2026-04-26 23:25:54 +07:00
Efril	0aa280462c	fix cors	2026-04-26 23:14:11 +07:00
aefril	421475006b	Merge pull request 'hpp' (#1 ) from hpp into main Reviewed-on: #1	2026-04-26 16:08:02 +00:00