fix

internal/app/app.go

@@ -65,6 +65,7 @@ func (a *App) Initialize(cfg *config.Config) error {
 		repos.userRepo,
 		repos.sessionRepo,
 		repos.orderRepo,
+		services.productOutletPriceService,
 	)
 
 	a.router = router.NewRouter(
@@ -131,6 +132,8 @@ func (a *App) Initialize(cfg *config.Config) error {
 		validators.userDeviceValidator,
 		services.notificationService,
 		validators.notificationValidator,
+		services.productOutletPriceService,
+		validators.productOutletPriceValidator,
 		selfOrderHandler,
 	)
 
@@ -232,6 +235,7 @@ type repositories struct {
 	notificationRepo               *repository.NotificationRepositoryImpl
 	notificationReceiverRepo       *repository.NotificationReceiverRepositoryImpl
 	notificationDeliveryRepo       *repository.NotificationDeliveryRepositoryImpl
+	productOutletPriceRepo         *repository.ProductOutletPriceRepositoryImpl
 }
 
 func (a *App) initRepositories() *repositories {
@@ -283,6 +287,7 @@ func (a *App) initRepositories() *repositories {
 		notificationRepo:               repository.NewNotificationRepository(a.db),
 		notificationReceiverRepo:       repository.NewNotificationReceiverRepository(a.db),
 		notificationDeliveryRepo:       repository.NewNotificationDeliveryRepository(a.db),
+		productOutletPriceRepo:         repository.NewProductOutletPriceRepositoryImpl(a.db),
 	}
 }
 
@@ -327,6 +332,7 @@ type processors struct {
 	inventoryMovementService            service.InventoryMovementService
 	userDeviceProcessor                 *processor.UserDeviceProcessorImpl
 	notificationProcessor               *processor.NotificationProcessorImpl
+	productOutletPriceProcessor         processor.ProductOutletPriceProcessor
 }
 
 func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processors {
@@ -344,7 +350,7 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor
 		productProcessor:                    processor.NewProductProcessorImpl(repos.productRepo, repos.categoryRepo, repos.productVariantRepo, repos.inventoryRepo, repos.outletRepo),
 		productVariantProcessor:             processor.NewProductVariantProcessorImpl(repos.productVariantRepo, repos.productRepo),
 		inventoryProcessor:                  processor.NewInventoryProcessorImpl(repos.inventoryRepo, repos.productRepo, repos.outletRepo, repos.ingredientRepo, repos.inventoryMovementRepo),
-		orderProcessor:                      processor.NewOrderProcessorImpl(repos.orderRepo, repos.orderItemRepo, repos.paymentRepo, repos.paymentOrderItemRepo, repos.productRepo, repos.paymentMethodRepo, repos.inventoryRepo, repos.inventoryMovementRepo, repos.productVariantRepo, repos.outletRepo, repos.customerRepo, repos.txManager, repos.productRecipeRepo, repos.ingredientRepo, inventoryMovementService),
+		orderProcessor:                      processor.NewOrderProcessorImpl(repos.orderRepo, repos.orderItemRepo, repos.paymentRepo, repos.paymentOrderItemRepo, repos.productRepo, repos.paymentMethodRepo, repos.inventoryRepo, repos.inventoryMovementRepo, repos.productVariantRepo, repos.outletRepo, repos.customerRepo, repos.txManager, repos.productRecipeRepo, repos.ingredientRepo, inventoryMovementService, repos.productOutletPriceRepo),
 		paymentMethodProcessor:              processor.NewPaymentMethodProcessorImpl(repos.paymentMethodRepo),
 		fileProcessor:                       processor.NewFileProcessorImpl(repos.fileRepo, fileClient),
 		customerProcessor:                   processor.NewCustomerProcessor(repos.customerRepo),
@@ -376,6 +382,7 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor
 		inventoryMovementService:            inventoryMovementService,
 		userDeviceProcessor:                 processor.NewUserDeviceProcessorImpl(repos.userDeviceRepo),
 		notificationProcessor:               buildNotificationProcessor(cfg, repos),
+		productOutletPriceProcessor:         processor.NewProductOutletPriceProcessorImpl(repos.productOutletPriceRepo),
 	}
 }
 
@@ -414,6 +421,7 @@ type services struct {
 	spinGameService                   service.SpinGameService
 	userDeviceService                 service.UserDeviceService
 	notificationService               service.NotificationService
+	productOutletPriceService         service.ProductOutletPriceService
 }
 
 func (a *App) initServices(processors *processors, repos *repositories, cfg *config.Config) *services {
@@ -490,6 +498,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
 		spinGameService:                   spinGameService,
 		userDeviceService:                 userDeviceService,
 		notificationService:               notificationService,
+		productOutletPriceService:         service.NewProductOutletPriceService(processors.productOutletPriceProcessor),
 	}
 }
 
@@ -531,6 +540,7 @@ type validators struct {
 	customerAuthValidator               validator.CustomerAuthValidator
 	userDeviceValidator                 *validator.UserDeviceValidatorImpl
 	notificationValidator               *validator.NotificationValidatorImpl
+	productOutletPriceValidator         *validator.ProductOutletPriceValidatorImpl
 }
 
 func (a *App) initValidators() *validators {
@@ -560,6 +570,7 @@ func (a *App) initValidators() *validators {
 		customerAuthValidator:               validator.NewCustomerAuthValidator(),
 		userDeviceValidator:                 validator.NewUserDeviceValidator(),
 		notificationValidator:               validator.NewNotificationValidator(),
+		productOutletPriceValidator:         validator.NewProductOutletPriceValidator(),
 	}
 }
 

internal/constants/error.go

@@ -44,21 +44,22 @@ const (
 	IngredientCompositionServiceEntity   = "ingredient_composition_service"
 	TableEntity                          = "table"
 	// Gamification entities
-	CustomerPointsEntity      = "customer_points"
-	CustomerTokensEntity      = "customer_tokens"
-	TierEntity                = "tier"
-	GameEntity                = "game"
-	GamePrizeEntity           = "game_prize"
-	GamePlayEntity            = "game_play"
-	OmsetTrackerEntity        = "omset_tracker"
-	RewardEntity              = "reward"
-	CampaignEntity            = "campaign"
-	CampaignRuleEntity        = "campaign_rule"
-	CustomerEntity            = "customer"
-	SpinGameHandlerEntity     = "spin_game_handler"
-	UserDeviceServiceEntity   = "user_device_service"
-	NotificationServiceEntity = "notification_service"
-	NotificationHandlerEntity = "notification_handler"
+	CustomerPointsEntity            = "customer_points"
+	CustomerTokensEntity            = "customer_tokens"
+	TierEntity                      = "tier"
+	GameEntity                      = "game"
+	GamePrizeEntity                 = "game_prize"
+	GamePlayEntity                  = "game_play"
+	OmsetTrackerEntity              = "omset_tracker"
+	RewardEntity                    = "reward"
+	CampaignEntity                  = "campaign"
+	CampaignRuleEntity              = "campaign_rule"
+	CustomerEntity                  = "customer"
+	SpinGameHandlerEntity           = "spin_game_handler"
+	UserDeviceServiceEntity         = "user_device_service"
+	NotificationServiceEntity       = "notification_service"
+	NotificationHandlerEntity       = "notification_handler"
+	ProductOutletPriceServiceEntity = "product_outlet_price_service"
 )
 
 var HttpErrorMap = map[string]int{

internal/contract/category_contract.go

@@ -8,25 +8,22 @@ import (
 
 type CreateCategoryRequest struct {
 	Name         string                 `json:"name" validate:"required,min=1,max=255"`
-	OutletID     *uuid.UUID             `json:"outlet_id,omitempty"`
 	Description  *string                `json:"description,omitempty"`
 	BusinessType *string                `json:"business_type,omitempty"`
-	Order        *int                   `json:"order,omitempty"`
+	Order 		 *int                	`json:"order,omitempty"`
 	Metadata     map[string]interface{} `json:"metadata,omitempty"`
 }
 
 type UpdateCategoryRequest struct {
 	Name         *string                `json:"name,omitempty" validate:"omitempty,min=1,max=255"`
-	OutletID     *uuid.UUID             `json:"outlet_id,omitempty"`
 	Description  *string                `json:"description,omitempty"`
 	BusinessType *string                `json:"business_type,omitempty"`
-	Order        *int                   `json:"order,omitempty"`
+	Order 		 *int                	`json:"order,omitempty"`
 	Metadata     map[string]interface{} `json:"metadata,omitempty"`
 }
 
 type ListCategoriesRequest struct {
 	OrganizationID *uuid.UUID `json:"organization_id,omitempty"`
-	OutletID       *uuid.UUID `json:"outlet_id,omitempty"`
 	BusinessType   string     `json:"business_type,omitempty"`
 	Search         string     `json:"search,omitempty"`
 	Page           int        `json:"page" validate:"required,min=1"`
@@ -37,11 +34,10 @@ type ListCategoriesRequest struct {
 type CategoryResponse struct {
 	ID             uuid.UUID              `json:"id"`
 	OrganizationID uuid.UUID              `json:"organization_id"`
-	OutletID       *uuid.UUID             `json:"outlet_id,omitempty"`
 	Name           string                 `json:"name"`
 	Description    *string                `json:"description"`
 	BusinessType   string                 `json:"business_type"`
-	Order          int                    `json:"order"`
+	Order 		   int                	  `json:"order"`
 	Metadata       map[string]interface{} `json:"metadata"`
 	CreatedAt      time.Time              `json:"created_at"`
 	UpdatedAt      time.Time              `json:"updated_at"`

internal/contract/product_contract.go

@@ -7,7 +7,6 @@ import (
 )
 
 type CreateProductRequest struct {
-	OutletID        *uuid.UUID                    `json:"outlet_id,omitempty"`
 	CategoryID      uuid.UUID                     `json:"category_id" validate:"required"`
 	SKU             *string                       `json:"sku,omitempty"`
 	Name            string                        `json:"name" validate:"required,min=1,max=255"`
@@ -26,7 +25,6 @@ type CreateProductRequest struct {
 }
 
 type UpdateProductRequest struct {
-	OutletID     *uuid.UUID             `json:"outlet_id,omitempty"`
 	CategoryID   *uuid.UUID             `json:"category_id,omitempty"`
 	SKU          *string                `json:"sku,omitempty"`
 	Name         *string                `json:"name,omitempty" validate:"omitempty,min=1,max=255"`
@@ -60,7 +58,6 @@ type UpdateProductVariantRequest struct {
 type ProductResponse struct {
 	ID             uuid.UUID                `json:"id"`
 	OrganizationID uuid.UUID                `json:"organization_id"`
-	OutletID       *uuid.UUID               `json:"outlet_id"`
 	CategoryID     uuid.UUID                `json:"category_id"`
 	CategoryName   string                   `json:"category_name"`
 	SKU            *string                  `json:"sku"`
@@ -92,7 +89,6 @@ type ProductVariantResponse struct {
 
 type ListProductsRequest struct {
 	OrganizationID *uuid.UUID `json:"organization_id,omitempty"`
-	OutletID       *uuid.UUID `json:"outlet_id,omitempty"`
 	CategoryID     *uuid.UUID `json:"category_id,omitempty"`
 	BusinessType   string     `json:"business_type,omitempty"`
 	IsActive       *bool      `json:"is_active,omitempty"`

internal/contract/product_outlet_price_contract.go

@@ -0,0 +1,41 @@
+package contract
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type CreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID `json:"product_id" validate:"required"`
+	OutletID  uuid.UUID `json:"outlet_id" validate:"required"`
+	Price     float64   `json:"price" validate:"required,min=0"`
+}
+
+type UpdateProductOutletPriceRequest struct {
+	Price float64 `json:"price" validate:"required,min=0"`
+}
+
+type ProductOutletPriceResponse struct {
+	ID        uuid.UUID `json:"id"`
+	ProductID uuid.UUID `json:"product_id"`
+	OutletID  uuid.UUID `json:"outlet_id"`
+	Price     float64   `json:"price"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+type ListProductOutletPricesResponse struct {
+	Prices     []ProductOutletPriceResponse `json:"prices"`
+	TotalCount int                          `json:"total_count"`
+}
+
+type BulkCreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID                                  `json:"product_id" validate:"required"`
+	Prices    []CreateProductOutletPricePerOutletRequest `json:"prices" validate:"required,dive"`
+}
+
+type CreateProductOutletPricePerOutletRequest struct {
+	OutletID uuid.UUID `json:"outlet_id" validate:"required"`
+	Price    float64   `json:"price" validate:"required,min=0"`
+}

internal/entities/category.go

@@ -31,19 +31,17 @@ func (m *Metadata) Scan(value interface{}) error {
 }
 
 type Category 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" validate:"required"`
-	OutletID       *uuid.UUID `gorm:"type:uuid;index" json:"outlet_id,omitempty"`
-	Name           string     `gorm:"not null;size:255" json:"name" validate:"required,min=1,max=255"`
-	Description    *string    `gorm:"type:text" json:"description"`
-	Order          int        `gorm:"default:0" json:"order"`
-	BusinessType   string     `gorm:"size:50;default:'restaurant'" json:"business_type"`
-	Metadata       Metadata   `gorm:"type:jsonb;default:'{}'" json:"metadata"`
-	CreatedAt      time.Time  `gorm:"autoCreateTime" json:"created_at"`
-	UpdatedAt      time.Time  `gorm:"autoUpdateTime" json:"updated_at"`
+	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" validate:"required"`
+	Name           string    `gorm:"not null;size:255" json:"name" validate:"required,min=1,max=255"`
+	Description    *string   `gorm:"type:text" json:"description"`
+	Order    	   int  	 `gorm:"default:0" json:"order"`
+	BusinessType   string    `gorm:"size:50;default:'restaurant'" json:"business_type"`
+	Metadata       Metadata  `gorm:"type:jsonb;default:'{}'" json:"metadata"`
+	CreatedAt      time.Time `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt      time.Time `gorm:"autoUpdateTime" json:"updated_at"`
 
 	Organization Organization `gorm:"foreignKey:OrganizationID" json:"organization,omitempty"`
-	Outlet       Outlet       `gorm:"foreignKey:OutletID" json:"outlet,omitempty"`
 	Products     []Product    `gorm:"foreignKey:CategoryID" json:"products,omitempty"`
 }
 

internal/entities/entities.go

@@ -41,6 +41,7 @@ func GetAllEntities() []interface{} {
 		&Notification{},
 		&NotificationReceiver{},
 		&NotificationDelivery{},
+		&ProductOutletPrice{},
 	}
 }
 

internal/entities/product.go

@@ -10,7 +10,6 @@ import (
 type Product 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" validate:"required"`
-	OutletID       *uuid.UUID `gorm:"type:uuid;index" json:"outlet_id"`
 	CategoryID     uuid.UUID  `gorm:"type:uuid;not null;index" json:"category_id" validate:"required"`
 	SKU            *string    `gorm:"size:100;index" json:"sku"`
 	Name           string     `gorm:"not null;size:255" json:"name" validate:"required,min=1,max=255"`
@@ -27,14 +26,13 @@ type Product struct {
 	CreatedAt      time.Time  `gorm:"autoCreateTime" json:"created_at"`
 	UpdatedAt      time.Time  `gorm:"autoUpdateTime" json:"updated_at"`
 
-	Organization       Organization        `gorm:"foreignKey:OrganizationID" json:"organization,omitempty"`
-	Outlet             *Outlet             `gorm:"foreignKey:OutletID" json:"outlet,omitempty"`
-	Category           Category            `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
-	Unit               *Unit               `gorm:"foreignKey:UnitID" json:"unit,omitempty"`
-	ProductVariants    []ProductVariant    `gorm:"foreignKey:ProductID" json:"variants,omitempty"`
-	ProductRecipes []ProductRecipe `gorm:"foreignKey:ProductID" json:"product_recipes,omitempty"`
-	Inventory          []Inventory         `gorm:"foreignKey:ProductID" json:"inventory,omitempty"`
-	OrderItems         []OrderItem         `gorm:"foreignKey:ProductID" json:"order_items,omitempty"`
+	Organization    Organization     `gorm:"foreignKey:OrganizationID" json:"organization,omitempty"`
+	Category        Category         `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
+	Unit            *Unit            `gorm:"foreignKey:UnitID" json:"unit,omitempty"`
+	ProductVariants []ProductVariant `gorm:"foreignKey:ProductID" json:"variants,omitempty"`
+	ProductRecipes  []ProductRecipe  `gorm:"foreignKey:ProductID" json:"product_recipes,omitempty"`
+	Inventory       []Inventory      `gorm:"foreignKey:ProductID" json:"inventory,omitempty"`
+	OrderItems      []OrderItem      `gorm:"foreignKey:ProductID" json:"order_items,omitempty"`
 }
 
 func (p *Product) BeforeCreate(tx *gorm.DB) error {

internal/entities/product_outlet_price.go

@@ -0,0 +1,31 @@
+package entities
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ProductOutletPrice struct {
+	ID        uuid.UUID `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
+	ProductID uuid.UUID `gorm:"type:uuid;not null;index" json:"product_id"`
+	OutletID  uuid.UUID `gorm:"type:uuid;not null;index" json:"outlet_id"`
+	Price     float64   `gorm:"type:decimal(10,2);not null" json:"price"`
+	CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
+
+	Product Product `gorm:"foreignKey:ProductID" json:"product,omitempty"`
+	Outlet  Outlet  `gorm:"foreignKey:OutletID" json:"outlet,omitempty"`
+}
+
+func (p *ProductOutletPrice) BeforeCreate(tx *gorm.DB) error {
+	if p.ID == uuid.Nil {
+		p.ID = uuid.New()
+	}
+	return nil
+}
+
+func (ProductOutletPrice) TableName() string {
+	return "product_outlet_prices"
+}

internal/handler/category_handler.go

@@ -170,12 +170,6 @@ func (h *CategoryHandler) ListCategories(c *gin.Context) {
 		req.BusinessType = businessType
 	}
 
-	if outletIDStr := c.Query("outlet_id"); outletIDStr != "" {
-		if outletID, err := uuid.Parse(outletIDStr); err == nil {
-			req.OutletID = &outletID
-		}
-	}
-
 	if organizationIDStr := c.Query("organization_id"); organizationIDStr != "" {
 		if organizationID, err := uuid.Parse(organizationIDStr); err == nil {
 			req.OrganizationID = &organizationID

internal/handler/product_handler.go

@@ -172,12 +172,6 @@ func (h *ProductHandler) ListProducts(c *gin.Context) {
 		}
 	}
 
-	if outletIDStr := c.Query("outlet_id"); outletIDStr != "" {
-		if outletID, err := uuid.Parse(outletIDStr); err == nil {
-			req.OutletID = &outletID
-		}
-	}
-
 	if categoryIDStr := c.Query("category_id"); categoryIDStr != "" {
 		if categoryID, err := uuid.Parse(categoryIDStr); err == nil {
 			req.CategoryID = &categoryID

internal/handler/product_outlet_price_handler.go

@@ -0,0 +1,135 @@
+package handler
+
+import (
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/logger"
+	"apskel-pos-be/internal/service"
+	"apskel-pos-be/internal/util"
+	"apskel-pos-be/internal/validator"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceHandler struct {
+	service   service.ProductOutletPriceService
+	validator validator.ProductOutletPriceValidator
+}
+
+func NewProductOutletPriceHandler(svc service.ProductOutletPriceService, v validator.ProductOutletPriceValidator) *ProductOutletPriceHandler {
+	return &ProductOutletPriceHandler{
+		service:   svc,
+		validator: v,
+	}
+}
+
+func (h *ProductOutletPriceHandler) Upsert(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.CreateProductOutletPriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::Upsert -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
+		return
+	}
+
+	if validationErr, code := h.validator.ValidateCreateRequest(&req); validationErr != nil {
+		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
+		return
+	}
+
+	resp := h.service.Upsert(ctx, &req)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Upsert")
+}
+
+func (h *ProductOutletPriceHandler) GetByProductAndOutlet(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	productIDStr := c.Param("product_id")
+	productID, err := uuid.Parse(productIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
+		return
+	}
+
+	outletIDStr := c.Param("outlet_id")
+	outletID, err := uuid.Parse(outletIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
+		return
+	}
+
+	resp := h.service.GetByProductAndOutlet(ctx, productID, outletID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProductAndOutlet")
+}
+
+func (h *ProductOutletPriceHandler) GetByProduct(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	productIDStr := c.Param("product_id")
+	productID, err := uuid.Parse(productIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProduct")
+		return
+	}
+
+	resp := h.service.GetByProduct(ctx, productID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProduct")
+}
+
+func (h *ProductOutletPriceHandler) GetByOutlet(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	outletIDStr := c.Param("outlet_id")
+	outletID, err := uuid.Parse(outletIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByOutlet")
+		return
+	}
+
+	resp := h.service.GetByOutlet(ctx, outletID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByOutlet")
+}
+
+func (h *ProductOutletPriceHandler) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	idStr := c.Param("id")
+	id, err := uuid.Parse(idStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Delete")
+		return
+	}
+
+	resp := h.service.Delete(ctx, id)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Delete")
+}
+
+func (h *ProductOutletPriceHandler) BulkUpsert(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.BulkCreateProductOutletPriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::BulkUpsert -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
+		return
+	}
+
+	if validationErr, code := h.validator.ValidateBulkCreateRequest(&req); validationErr != nil {
+		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
+		return
+	}
+
+	resp := h.service.BulkUpsert(ctx, &req)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::BulkUpsert")
+}

internal/handler/self_order_handler.go

@@ -21,14 +21,15 @@ import (
 )
 
 type SelfOrderHandler struct {
-	orderService    service.OrderService
-	categoryService service.CategoryService
-	productService  service.ProductService
-	tableRepo       repository.TableRepositoryInterface
-	outletRepo      processor.OutletRepository
-	userRepo        processor.UserRepository
-	sessionRepo     repository.SessionRepository
-	orderRepo       repository.OrderRepository
+	orderService              service.OrderService
+	categoryService           service.CategoryService
+	productService            service.ProductService
+	tableRepo                 repository.TableRepositoryInterface
+	outletRepo                processor.OutletRepository
+	userRepo                  processor.UserRepository
+	sessionRepo               repository.SessionRepository
+	orderRepo                 repository.OrderRepository
+	productOutletPriceService service.ProductOutletPriceService
 }
 
 func NewSelfOrderHandler(
@@ -40,16 +41,18 @@ func NewSelfOrderHandler(
 	userRepo processor.UserRepository,
 	sessionRepo repository.SessionRepository,
 	orderRepo repository.OrderRepository,
+	productOutletPriceService service.ProductOutletPriceService,
 ) *SelfOrderHandler {
 	return &SelfOrderHandler{
-		orderService:    orderService,
-		categoryService: categoryService,
-		productService:  productService,
-		tableRepo:       tableRepo,
-		outletRepo:      outletRepo,
-		userRepo:        userRepo,
-		sessionRepo:     sessionRepo,
-		orderRepo:       orderRepo,
+		orderService:              orderService,
+		categoryService:           categoryService,
+		productService:            productService,
+		tableRepo:                 tableRepo,
+		outletRepo:                outletRepo,
+		userRepo:                  userRepo,
+		sessionRepo:               sessionRepo,
+		orderRepo:                 orderRepo,
+		productOutletPriceService: productOutletPriceService,
 	}
 }
 
@@ -216,16 +219,29 @@ func (h *SelfOrderHandler) GetMenu(c *gin.Context) {
 		return
 	}
 
-	menu := h.buildMenuResponse(outlet, table, catList.Categories, prodList.Products)
+	menu := h.buildMenuResponse(ctx, outlet, table, catList.Categories, prodList.Products)
 	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(menu), "SelfOrderHandler::GetMenu")
 }
 
 func (h *SelfOrderHandler) buildMenuResponse(
+	ctx context.Context,
 	outlet *entities.Outlet,
 	table *entities.Table,
 	categories []contract.CategoryResponse,
 	products []contract.ProductResponse,
 ) *contract.SelfOrderMenuResponse {
+	outletPriceMap := make(map[uuid.UUID]float64)
+	if h.productOutletPriceService != nil {
+		priceResp := h.productOutletPriceService.GetByOutlet(ctx, outlet.ID)
+		if priceResp != nil && !priceResp.HasErrors() {
+			if priceList, ok := priceResp.Data.(*contract.ListProductOutletPricesResponse); ok {
+				for _, p := range priceList.Prices {
+					outletPriceMap[p.ProductID] = p.Price
+				}
+			}
+		}
+	}
+
 	productMap := make(map[uuid.UUID][]contract.ProductResponse)
 	for _, p := range products {
 		productMap[p.CategoryID] = append(productMap[p.CategoryID], p)
@@ -236,11 +252,15 @@ func (h *SelfOrderHandler) buildMenuResponse(
 		menuItems := make([]contract.SelfOrderMenuItem, 0)
 		if prods, ok := productMap[cat.ID]; ok {
 			for _, p := range prods {
+				price := p.Price
+				if outletPrice, exists := outletPriceMap[p.ID]; exists {
+					price = outletPrice
+				}
 				item := contract.SelfOrderMenuItem{
 					ID:          p.ID,
 					Name:        p.Name,
 					Description: p.Description,
-					Price:       p.Price,
+					Price:       price,
 					ImageURL:    p.ImageURL,
 				}
 				for _, v := range p.Variants {

internal/mappers/product_outlet_price_mapper.go

@@ -0,0 +1,48 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+func ProductOutletPriceEntityToModel(entity *entities.ProductOutletPrice) *models.ProductOutletPrice {
+	if entity == nil {
+		return nil
+	}
+
+	return &models.ProductOutletPrice{
+		ID:        entity.ID,
+		ProductID: entity.ProductID,
+		OutletID:  entity.OutletID,
+		Price:     entity.Price,
+		CreatedAt: entity.CreatedAt,
+		UpdatedAt: entity.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceModelToEntity(model *models.ProductOutletPrice) *entities.ProductOutletPrice {
+	if model == nil {
+		return nil
+	}
+
+	return &entities.ProductOutletPrice{
+		ID:        model.ID,
+		ProductID: model.ProductID,
+		OutletID:  model.OutletID,
+		Price:     model.Price,
+		CreatedAt: model.CreatedAt,
+		UpdatedAt: model.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceEntitiesToModels(entities []*entities.ProductOutletPrice) []*models.ProductOutletPrice {
+	if entities == nil {
+		return nil
+	}
+
+	models := make([]*models.ProductOutletPrice, len(entities))
+	for i, entity := range entities {
+		models[i] = ProductOutletPriceEntityToModel(entity)
+	}
+	return models
+}

internal/models/category.go

@@ -9,11 +9,10 @@ import (
 type Category struct {
 	ID             uuid.UUID
 	OrganizationID uuid.UUID
-	OutletID       *uuid.UUID
 	Name           string
 	Description    *string
 	ImageURL       *string
-	Order          int
+	Order      	   int
 	IsActive       bool
 	CreatedAt      time.Time
 	UpdatedAt      time.Time
@@ -21,30 +20,27 @@ type Category struct {
 
 type CreateCategoryRequest struct {
 	OrganizationID uuid.UUID `validate:"required"`
-	OutletID       *uuid.UUID
-	Name           string  `validate:"required,min=1,max=255"`
-	Description    *string `validate:"omitempty,max=1000"`
-	ImageURL       *string `validate:"omitempty,url"`
-	Order          int     `validate:"min=0"`
+	Name           string    `validate:"required,min=1,max=255"`
+	Description    *string   `validate:"omitempty,max=1000"`
+	ImageURL       *string   `validate:"omitempty,url"`
+	Order      	   int       `validate:"min=0"`
 }
 
 type UpdateCategoryRequest struct {
-	OutletID    *uuid.UUID `validate:"omitempty,required"`
-	Name        *string    `validate:"omitempty,min=1,max=255"`
-	Description *string    `validate:"omitempty,max=1000"`
-	ImageURL    *string    `validate:"omitempty,url"`
-	Order       *int       `validate:"omitempty,min=0"`
+	Name        *string `validate:"omitempty,min=1,max=255"`
+	Description *string `validate:"omitempty,max=1000"`
+	ImageURL    *string `validate:"omitempty,url"`
+	Order       *int    `validate:"omitempty,min=0"`
 	IsActive    *bool
 }
 
 type CategoryResponse struct {
 	ID             uuid.UUID
 	OrganizationID uuid.UUID
-	OutletID       *uuid.UUID
 	Name           string
 	Description    *string
 	ImageURL       *string
-	Order          int
+	Order      int
 	IsActive       bool
 	CreatedAt      time.Time
 	UpdatedAt      time.Time

internal/models/product.go

@@ -10,7 +10,6 @@ import (
 type Product struct {
 	ID             uuid.UUID
 	OrganizationID uuid.UUID
-	OutletID       *uuid.UUID
 	CategoryID     uuid.UUID
 	SKU            *string
 	Name           string
@@ -41,7 +40,6 @@ type ProductVariant struct {
 
 type CreateProductRequest struct {
 	OrganizationID uuid.UUID              `validate:"required"`
-	OutletID       *uuid.UUID             `validate:"omitempty"`
 	CategoryID     uuid.UUID              `validate:"required"`
 	SKU            *string                `validate:"omitempty,max=100"`
 	Name           string                 `validate:"required,min=1,max=255"`
@@ -62,7 +60,6 @@ type CreateProductRequest struct {
 }
 
 type UpdateProductRequest struct {
-	OutletID       *uuid.UUID `validate:"omitempty"`
 	CategoryID     *uuid.UUID `validate:"omitempty"`
 	SKU            *string    `validate:"omitempty,max=100"`
 	Name           *string    `validate:"omitempty,min=1,max=255"`
@@ -97,7 +94,6 @@ type UpdateProductVariantRequest struct {
 type ProductResponse struct {
 	ID             uuid.UUID
 	OrganizationID uuid.UUID
-	OutletID       *uuid.UUID
 	CategoryID     uuid.UUID
 	CategoryName   string
 	SKU            *string

internal/models/product_outlet_price.go

@@ -0,0 +1,35 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPrice struct {
+	ID        uuid.UUID
+	ProductID uuid.UUID
+	OutletID  uuid.UUID
+	Price     float64
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+type CreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID `validate:"required"`
+	OutletID  uuid.UUID `validate:"required"`
+	Price     float64   `validate:"required,min=0"`
+}
+
+type UpdateProductOutletPriceRequest struct {
+	Price *float64 `validate:"required,min=0"`
+}
+
+type ProductOutletPriceResponse struct {
+	ID        uuid.UUID `json:"id"`
+	ProductID uuid.UUID `json:"product_id"`
+	OutletID  uuid.UUID `json:"outlet_id"`
+	Price     float64   `json:"price"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}

internal/processor/category_processor.go

@@ -55,7 +55,6 @@ func (p *CategoryProcessorImpl) CreateCategory(ctx context.Context, req *models.
 
 	// Map request to entity
 	categoryEntity := mappers.CreateCategoryRequestToEntity(req)
-	categoryEntity.OutletID = req.OutletID
 
 	// Create category
 	if err := p.categoryRepo.Create(ctx, categoryEntity); err != nil {
@@ -87,9 +86,6 @@ func (p *CategoryProcessorImpl) UpdateCategory(ctx context.Context, id uuid.UUID
 
 	// Apply updates to entity
 	mappers.UpdateCategoryEntityFromRequest(existingCategory, req)
-	if req.OutletID != nil {
-		existingCategory.OutletID = req.OutletID
-	}
 
 	// Update category
 	if err := p.categoryRepo.Update(ctx, existingCategory); err != nil {

internal/processor/order_processor.go

@@ -108,6 +108,7 @@ type OrderProcessorImpl struct {
 	productRecipeRepo        *repository.ProductRecipeRepository
 	ingredientRepo           IngredientRepository
 	inventoryMovementService InventoryMovementService
+	productOutletPriceRepo   repository.ProductOutletPriceRepository
 }
 
 func NewOrderProcessorImpl(
@@ -126,6 +127,7 @@ func NewOrderProcessorImpl(
 	productRecipeRepo *repository.ProductRecipeRepository,
 	ingredientRepo IngredientRepository,
 	inventoryMovementService InventoryMovementService,
+	productOutletPriceRepo repository.ProductOutletPriceRepository,
 ) *OrderProcessorImpl {
 	return &OrderProcessorImpl{
 		orderRepo:                orderRepo,
@@ -144,6 +146,7 @@ func NewOrderProcessorImpl(
 		productRecipeRepo:        productRecipeRepo,
 		ingredientRepo:           ingredientRepo,
 		inventoryMovementService: inventoryMovementService,
+		productOutletPriceRepo:   productOutletPriceRepo,
 	}
 }
 
@@ -170,6 +173,12 @@ func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.Create
 		unitPrice := product.Price
 		unitCost := product.Cost
 
+		if p.productOutletPriceRepo != nil {
+			if outletPrice, err := p.productOutletPriceRepo.GetByProductAndOutlet(ctx, itemReq.ProductID, req.OutletID); err == nil {
+				unitPrice = outletPrice.Price
+			}
+		}
+
 		if itemReq.ProductVariantID != nil {
 			variant, err := p.productVariantRepo.GetByID(ctx, *itemReq.ProductVariantID)
 			if err != nil {
@@ -293,6 +302,12 @@ func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID,
 		unitPrice := product.Price
 		unitCost := product.Cost
 
+		if p.productOutletPriceRepo != nil {
+			if outletPrice, err := p.productOutletPriceRepo.GetByProductAndOutlet(ctx, itemReq.ProductID, order.OutletID); err == nil {
+				unitPrice = outletPrice.Price
+			}
+		}
+
 		// Handle product variant if specified
 		if itemReq.ProductVariantID != nil {
 			variant, err := p.productVariantRepo.GetByID(ctx, *itemReq.ProductVariantID)

internal/processor/product_outlet_price_processor.go

@@ -0,0 +1,121 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/repository"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceProcessor interface {
+	Upsert(ctx context.Context, req *models.CreateProductOutletPriceRequest) (*models.ProductOutletPrice, error)
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*models.ProductOutletPrice, error)
+	GetByProduct(ctx context.Context, productID uuid.UUID) ([]*models.ProductOutletPrice, error)
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*models.ProductOutletPrice, error)
+	Delete(ctx context.Context, id uuid.UUID) error
+	ResolvePrice(ctx context.Context, productID, outletID uuid.UUID, fallbackPrice float64) float64
+	BulkUpsert(ctx context.Context, productID uuid.UUID, prices []models.CreateProductOutletPriceRequest) ([]*models.ProductOutletPrice, error)
+}
+
+type ProductOutletPriceProcessorImpl struct {
+	repo        repository.ProductOutletPriceRepository
+	productRepo ProductRepository
+	outletRepo  OutletRepository
+}
+
+func NewProductOutletPriceProcessorImpl(repo repository.ProductOutletPriceRepository, productRepo ProductRepository, outletRepo OutletRepository) *ProductOutletPriceProcessorImpl {
+	return &ProductOutletPriceProcessorImpl{
+		repo:        repo,
+		productRepo: productRepo,
+		outletRepo:  outletRepo,
+	}
+}
+
+func (p *ProductOutletPriceProcessorImpl) Upsert(ctx context.Context, req *models.CreateProductOutletPriceRequest) (*models.ProductOutletPrice, error) {
+	if _, err := p.productRepo.GetByID(ctx, req.ProductID); err != nil {
+		return nil, fmt.Errorf("product not found: %w", err)
+	}
+
+	if _, err := p.outletRepo.GetByID(ctx, req.OutletID); err != nil {
+		return nil, fmt.Errorf("outlet not found: %w", err)
+	}
+
+	entity := &entities.ProductOutletPrice{
+		ProductID: req.ProductID,
+		OutletID:  req.OutletID,
+		Price:     req.Price,
+	}
+
+	if err := p.repo.Upsert(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to upsert product outlet price: %w", err)
+	}
+
+	actual, err := p.repo.GetByProductAndOutlet(ctx, req.ProductID, req.OutletID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve upserted product outlet price: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntityToModel(actual), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*models.ProductOutletPrice, error) {
+	entity, err := p.repo.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		return nil, fmt.Errorf("product outlet price not found: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntityToModel(entity), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByProduct(ctx context.Context, productID uuid.UUID) ([]*models.ProductOutletPrice, error) {
+	entities, err := p.repo.GetByProduct(ctx, productID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get product outlet prices: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntitiesToModels(entities), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*models.ProductOutletPrice, error) {
+	entities, err := p.repo.GetByOutlet(ctx, outletID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get outlet prices: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntitiesToModels(entities), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := p.repo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("failed to delete product outlet price: %w", err)
+	}
+	return nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) ResolvePrice(ctx context.Context, productID, outletID uuid.UUID, fallbackPrice float64) float64 {
+	outletPrice, err := p.repo.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		return fallbackPrice
+	}
+	return outletPrice.Price
+}
+
+func (p *ProductOutletPriceProcessorImpl) BulkUpsert(ctx context.Context, productID uuid.UUID, prices []models.CreateProductOutletPriceRequest) ([]*models.ProductOutletPrice, error) {
+	var results []*models.ProductOutletPrice
+
+	for _, req := range prices {
+		req.ProductID = productID
+		result, err := p.Upsert(ctx, &req)
+		if err != nil {
+			return nil, fmt.Errorf("failed to upsert price for outlet %s: %w", req.OutletID, err)
+		}
+		results = append(results, result)
+	}
+
+	return results, nil
+}

internal/repository/category_repository.go

@@ -25,7 +25,7 @@ func (r *CategoryRepositoryImpl) Create(ctx context.Context, category *entities.
 
 func (r *CategoryRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*entities.Category, error) {
 	var category entities.Category
-	err := r.db.WithContext(ctx).Preload("Outlet").First(&category, "id = ?", id).Error
+	err := r.db.WithContext(ctx).First(&category, "id = ?", id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -34,7 +34,7 @@ func (r *CategoryRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*en
 
 func (r *CategoryRepositoryImpl) GetWithProducts(ctx context.Context, id uuid.UUID) (*entities.Category, error) {
 	var category entities.Category
-	err := r.db.WithContext(ctx).Preload("Products").Preload("Outlet").First(&category, "id = ?", id).Error
+	err := r.db.WithContext(ctx).Preload("Products").First(&category, "id = ?", id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +81,7 @@ func (r *CategoryRepositoryImpl) List(ctx context.Context, filters map[string]in
 		return nil, 0, err
 	}
 
-	err := query.Preload("Outlet").Order("\"order\" ASC").Limit(limit).Offset(offset).Find(&categories).Error
+	err := query.Order("\"order\" ASC").Limit(limit).Offset(offset).Find(&categories).Error
 	return categories, total, err
 }
 

internal/repository/product_outlet_price_repository.go

@@ -0,0 +1,71 @@
+package repository
+
+import (
+	"context"
+
+	"apskel-pos-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type ProductOutletPriceRepository interface {
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.ProductOutletPrice, error)
+	GetByProduct(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	Upsert(ctx context.Context, price *entities.ProductOutletPrice) error
+	Delete(ctx context.Context, id uuid.UUID) error
+	GetByID(ctx context.Context, id uuid.UUID) (*entities.ProductOutletPrice, error)
+}
+
+type ProductOutletPriceRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewProductOutletPriceRepositoryImpl(db *gorm.DB) *ProductOutletPriceRepositoryImpl {
+	return &ProductOutletPriceRepositoryImpl{
+		db: db,
+	}
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.ProductOutletPrice, error) {
+	var price entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("product_id = ? AND outlet_id = ?", productID, outletID).First(&price).Error
+	if err != nil {
+		return nil, err
+	}
+	return &price, nil
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProduct(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("product_id = ?", productID).Find(&prices).Error
+	return prices, err
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("outlet_id = ?", outletID).Find(&prices).Error
+	return prices, err
+}
+
+func (r *ProductOutletPriceRepositoryImpl) Upsert(ctx context.Context, price *entities.ProductOutletPrice) error {
+	return r.db.WithContext(ctx).Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "product_id"}, {Name: "outlet_id"}},
+		DoUpdates: clause.AssignmentColumns([]string{"price", "updated_at"}),
+	}).Create(price).Error
+}
+
+func (r *ProductOutletPriceRepositoryImpl) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.ProductOutletPrice{}, "id = ?", id).Error
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*entities.ProductOutletPrice, error) {
+	var price entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).First(&price, "id = ?", id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &price, nil
+}

internal/router/router.go

@@ -49,11 +49,12 @@ type Router struct {
 	userDeviceHandler                 *handler.UserDeviceHandler
 	notificationHandler               *handler.NotificationHandler
 	selfOrderHandler                  *handler.SelfOrderHandler
+	productOutletPriceHandler         *handler.ProductOutletPriceHandler
 	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, userDeviceService service.UserDeviceService, userDeviceValidator validator.UserDeviceValidator, notificationService service.NotificationService, notificationValidator validator.NotificationValidator, selfOrderHandler *handler.SelfOrderHandler) *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, userDeviceService service.UserDeviceService, userDeviceValidator validator.UserDeviceValidator, notificationService service.NotificationService, notificationValidator validator.NotificationValidator, productOutletPriceService service.ProductOutletPriceService, productOutletPriceValidator validator.ProductOutletPriceValidator, selfOrderHandler *handler.SelfOrderHandler) *Router {
 
 	return &Router{
 		config:                            cfg,
@@ -95,6 +96,7 @@ func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authSer
 		userDeviceHandler:                 handler.NewUserDeviceHandler(userDeviceService, userDeviceValidator),
 		notificationHandler:               handler.NewNotificationHandler(notificationService, notificationValidator),
 		selfOrderHandler:                  selfOrderHandler,
+		productOutletPriceHandler:         handler.NewProductOutletPriceHandler(productOutletPriceService, productOutletPriceValidator),
 	}
 }
 
@@ -228,6 +230,17 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 				products.DELETE("/:id", r.productHandler.DeleteProduct)
 			}
 
+			productOutletPrices := protected.Group("/product-outlet-prices")
+			productOutletPrices.Use(r.authMiddleware.RequireAdminOrManager())
+			{
+				productOutletPrices.POST("", r.productOutletPriceHandler.Upsert)
+				productOutletPrices.POST("/bulk", r.productOutletPriceHandler.BulkUpsert)
+				productOutletPrices.GET("/product/:product_id", r.productOutletPriceHandler.GetByProduct)
+				productOutletPrices.GET("/outlet/:outlet_id", r.productOutletPriceHandler.GetByOutlet)
+				productOutletPrices.GET("/product/:product_id/outlet/:outlet_id", r.productOutletPriceHandler.GetByProductAndOutlet)
+				productOutletPrices.DELETE("/:id", r.productOutletPriceHandler.Delete)
+			}
+
 			productVariants := protected.Group("/product-variants")
 			{
 				productVariants.POST("", r.productVariantHandler.CreateProductVariant)

internal/service/category_service.go

@@ -88,9 +88,6 @@ func (s *CategoryServiceImpl) ListCategories(ctx context.Context, req *contract.
 	if req.BusinessType != "" {
 		filters["business_type"] = req.BusinessType
 	}
-	if req.OutletID != nil {
-		filters["outlet_id"] = *req.OutletID
-	}
 	if req.Search != "" {
 		filters["search"] = req.Search
 	}

internal/service/product_outlet_price_service.go

@@ -0,0 +1,125 @@
+package service
+
+import (
+	"context"
+	"errors"
+
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/processor"
+	"apskel-pos-be/internal/transformer"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ProductOutletPriceService interface {
+	Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response
+	GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response
+	Delete(ctx context.Context, id uuid.UUID) *contract.Response
+	BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response
+}
+
+type ProductOutletPriceServiceImpl struct {
+	processor processor.ProductOutletPriceProcessor
+}
+
+func NewProductOutletPriceService(proc processor.ProductOutletPriceProcessor) *ProductOutletPriceServiceImpl {
+	return &ProductOutletPriceServiceImpl{
+		processor: proc,
+	}
+}
+
+func (s *ProductOutletPriceServiceImpl) Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response {
+	modelReq := transformer.CreateProductOutletPriceRequestToModel(req)
+
+	result, err := s.processor.Upsert(ctx, modelReq)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResp := transformer.ProductOutletPriceModelToResponse(result)
+	return contract.BuildSuccessResponse(contractResp)
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response {
+	result, err := s.processor.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		code := constants.InternalServerErrorCode
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			code = constants.NotFoundErrorCode
+		}
+		errorResp := contract.NewResponseError(code, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResp := transformer.ProductOutletPriceModelToResponse(result)
+	return contract.BuildSuccessResponse(contractResp)
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response {
+	results, err := s.processor.GetByProduct(ctx, productID)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response {
+	results, err := s.processor.GetByOutlet(ctx, outletID)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) Delete(ctx context.Context, id uuid.UUID) *contract.Response {
+	err := s.processor.Delete(ctx, id)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	return contract.BuildSuccessResponse(map[string]interface{}{
+		"message": "Product outlet price deleted successfully",
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response {
+	prices := make([]models.CreateProductOutletPriceRequest, len(req.Prices))
+	for i, p := range req.Prices {
+		prices[i] = models.CreateProductOutletPriceRequest{
+			ProductID: req.ProductID,
+			OutletID:  p.OutletID,
+			Price:     p.Price,
+		}
+	}
+
+	results, err := s.processor.BulkUpsert(ctx, req.ProductID, prices)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}

internal/service/product_service.go

@@ -85,9 +85,6 @@ func (s *ProductServiceImpl) ListProducts(ctx context.Context, req *contract.Lis
 	if req.OrganizationID != nil {
 		filters["organization_id"] = *req.OrganizationID
 	}
-	if req.OutletID != nil {
-		filters["outlet_id"] = *req.OutletID
-	}
 	if req.CategoryID != nil {
 		filters["category_id"] = *req.CategoryID
 	}

internal/transformer/category_transformer.go

@@ -9,7 +9,6 @@ import (
 func CreateCategoryRequestToModel(apctx *appcontext.ContextInfo, req *contract.CreateCategoryRequest) *models.CreateCategoryRequest {
 	return &models.CreateCategoryRequest{
 		OrganizationID: apctx.OrganizationID,
-		OutletID:       req.OutletID,
 		Name:           req.Name,
 		Description:    req.Description,
 		ImageURL:       nil,
@@ -19,7 +18,6 @@ func CreateCategoryRequestToModel(apctx *appcontext.ContextInfo, req *contract.C
 
 func UpdateCategoryRequestToModel(req *contract.UpdateCategoryRequest) *models.UpdateCategoryRequest {
 	return &models.UpdateCategoryRequest{
-		OutletID:    req.OutletID,
 		Name:        req.Name,
 		Description: req.Description,
 		ImageURL:    nil,
@@ -36,7 +34,6 @@ func CategoryModelResponseToResponse(cat *models.CategoryResponse) *contract.Cat
 	return &contract.CategoryResponse{
 		ID:             cat.ID,
 		OrganizationID: cat.OrganizationID,
-		OutletID:       cat.OutletID,
 		Name:           cat.Name,
 		Description:    cat.Description,
 		BusinessType:   "restaurant", // Default business type

internal/transformer/product_outlet_price_transformer.go

@@ -0,0 +1,55 @@
+package transformer
+
+import (
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/models"
+)
+
+func CreateProductOutletPriceRequestToModel(req *contract.CreateProductOutletPriceRequest) *models.CreateProductOutletPriceRequest {
+	if req == nil {
+		return nil
+	}
+
+	return &models.CreateProductOutletPriceRequest{
+		ProductID: req.ProductID,
+		OutletID:  req.OutletID,
+		Price:     req.Price,
+	}
+}
+
+func UpdateProductOutletPriceRequestToModel(req *contract.UpdateProductOutletPriceRequest) *models.UpdateProductOutletPriceRequest {
+	if req == nil {
+		return nil
+	}
+
+	return &models.UpdateProductOutletPriceRequest{
+		Price: &req.Price,
+	}
+}
+
+func ProductOutletPriceModelToResponse(m *models.ProductOutletPrice) *contract.ProductOutletPriceResponse {
+	if m == nil {
+		return nil
+	}
+
+	return &contract.ProductOutletPriceResponse{
+		ID:        m.ID,
+		ProductID: m.ProductID,
+		OutletID:  m.OutletID,
+		Price:     m.Price,
+		CreatedAt: m.CreatedAt,
+		UpdatedAt: m.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceModelsToResponses(ms []*models.ProductOutletPrice) []contract.ProductOutletPriceResponse {
+	if ms == nil {
+		return nil
+	}
+
+	responses := make([]contract.ProductOutletPriceResponse, len(ms))
+	for i, m := range ms {
+		responses[i] = *ProductOutletPriceModelToResponse(m)
+	}
+	return responses
+}

internal/transformer/product_transformer.go

@@ -39,7 +39,6 @@ func CreateProductRequestToModel(apctx *appcontext.ContextInfo, req *contract.Cr
 
 	return &models.CreateProductRequest{
 		OrganizationID: apctx.OrganizationID,
-		OutletID:       req.OutletID,
 		CategoryID:     req.CategoryID,
 		SKU:            req.SKU,
 		Name:           req.Name,
@@ -61,8 +60,7 @@ func UpdateProductRequestToModel(req *contract.UpdateProductRequest) *models.Upd
 	}
 
 	return &models.UpdateProductRequest{
-		OutletID:     req.OutletID,
-		CategoryID:   req.CategoryID,
+		CategoryID:  req.CategoryID,
 		SKU:         req.SKU,
 		Name:        req.Name,
 		Description: req.Description,
@@ -102,7 +100,6 @@ func ProductModelResponseToResponse(prod *models.ProductResponse) *contract.Prod
 	return &contract.ProductResponse{
 		ID:             prod.ID,
 		OrganizationID: prod.OrganizationID,
-		OutletID:       prod.OutletID,
 		CategoryID:     prod.CategoryID,
 		CategoryName:   prod.CategoryName,
 		SKU:            prod.SKU,

internal/validator/category_validator.go

@@ -59,7 +59,7 @@ func (v *CategoryValidatorImpl) ValidateUpdateCategoryRequest(req *contract.Upda
 	}
 
 	// At least one field should be provided for update
-	if req.Name == nil && req.Description == nil && req.BusinessType == nil && req.Metadata == nil && req.OutletID == nil {
+	if req.Name == nil && req.Description == nil && req.BusinessType == nil && req.Metadata == nil {
 		return errors.New("at least one field must be provided for update"), constants.MissingFieldErrorCode
 	}
 

internal/validator/product_outlet_price_validator.go

@@ -0,0 +1,80 @@
+package validator
+
+import (
+	"errors"
+	"fmt"
+
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceValidator interface {
+	ValidateCreateRequest(req *contract.CreateProductOutletPriceRequest) (error, string)
+	ValidateUpdateRequest(req *contract.UpdateProductOutletPriceRequest) (error, string)
+	ValidateBulkCreateRequest(req *contract.BulkCreateProductOutletPriceRequest) (error, string)
+}
+
+type ProductOutletPriceValidatorImpl struct{}
+
+func NewProductOutletPriceValidator() *ProductOutletPriceValidatorImpl {
+	return &ProductOutletPriceValidatorImpl{}
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateCreateRequest(req *contract.CreateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.ProductID == uuid.Nil {
+		return errors.New("product_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.OutletID == uuid.Nil {
+		return errors.New("outlet_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.Price < 0 {
+		return errors.New("price must be non-negative"), constants.MalformedFieldErrorCode
+	}
+
+	return nil, ""
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateUpdateRequest(req *contract.UpdateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.Price < 0 {
+		return errors.New("price must be non-negative"), constants.MalformedFieldErrorCode
+	}
+
+	return nil, ""
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateBulkCreateRequest(req *contract.BulkCreateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.ProductID == uuid.Nil {
+		return errors.New("product_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if len(req.Prices) == 0 {
+		return errors.New("at least one price entry is required"), constants.MissingFieldErrorCode
+	}
+
+	for i, p := range req.Prices {
+		if p.OutletID == uuid.Nil {
+			return errors.New("outlet_id is required for each price entry"), constants.MissingFieldErrorCode
+		}
+		if p.Price < 0 {
+			return fmt.Errorf("price at index %d must be non-negative", i), constants.MalformedFieldErrorCode
+		}
+	}
+
+	return nil, ""
+}

migrations/000068_add_outlet_id_to_categories.down.sql

@@ -1,3 +0,0 @@
-DROP INDEX IF EXISTS idx_categories_outlet_id;
-ALTER TABLE categories DROP CONSTRAINT IF EXISTS fk_categories_outlet;
-ALTER TABLE categories DROP COLUMN IF EXISTS outlet_id;

migrations/000068_add_outlet_id_to_categories.up.sql

@@ -1,3 +0,0 @@
-ALTER TABLE categories ADD COLUMN outlet_id UUID;
-ALTER TABLE categories ADD CONSTRAINT fk_categories_outlet FOREIGN KEY (outlet_id) REFERENCES outlets(id) ON DELETE SET NULL;
-CREATE INDEX idx_categories_outlet_id ON categories(outlet_id);

migrations/000068_create_product_outlet_prices_table.down.sql

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

migrations/000068_create_product_outlet_prices_table.up.sql

@@ -0,0 +1,12 @@
+CREATE TABLE product_outlet_prices (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    product_id UUID NOT NULL REFERENCES products(id) ON DELETE CASCADE,
+    outlet_id UUID NOT NULL REFERENCES outlets(id) ON DELETE CASCADE,
+    price DECIMAL(10,2) NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX idx_product_outlet_prices_product_outlet ON product_outlet_prices(product_id, outlet_id);
+CREATE INDEX idx_product_outlet_prices_product_id ON product_outlet_prices(product_id);
+CREATE INDEX idx_product_outlet_prices_outlet_id ON product_outlet_prices(outlet_id);

migrations/000069_add_outlet_id_to_products.down.sql

@@ -1,8 +0,0 @@
--- Remove foreign key constraint
-ALTER TABLE products DROP CONSTRAINT IF EXISTS fk_products_outlet;
-
--- Remove index
-DROP INDEX IF EXISTS idx_products_outlet_id;
-
--- Remove outlet_id column
-ALTER TABLE products DROP COLUMN IF EXISTS outlet_id;

migrations/000069_add_outlet_id_to_products.up.sql

@@ -1,8 +0,0 @@
--- Add nullable outlet_id column to products table
-ALTER TABLE products ADD COLUMN outlet_id UUID;
-
--- Create index on outlet_id for faster queries
-CREATE INDEX idx_products_outlet_id ON products (outlet_id);
-
--- Add foreign key constraint
-ALTER TABLE products ADD CONSTRAINT fk_products_outlet FOREIGN KEY (outlet_id) REFERENCES outlets(id) ON DELETE SET NULL;