Token and session implementation with Redis

Reviewed-on: #2

Dockerfile

@@ -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

cmd/server/main.go

@@ -12,13 +12,18 @@ func main() {
 	cfg := config.LoadConfig()
 	logger.Setup(cfg.LogLevel(), cfg.LogFormat())
 
-	db, err := db.NewPostgres(cfg.Database)
+	pg, err := db.NewPostgres(cfg.Database)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	redisClient, err := db.NewRedisClient(cfg.Redis)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	logger.NonContext.Info("helloworld")
-	application := app.NewApp(db)
+	application := app.NewApp(pg, redisClient)
 
 	if err := application.Initialize(cfg); err != nil {
 		log.Fatalf("Failed to initialize application: %v", err)

config/configs.go

@@ -26,6 +26,7 @@ var (
 type Config struct {
 	Server   Server   `mapstructure:"server"`
 	Database Database `mapstructure:"postgresql"`
+	Redis    Redis    `mapstructure:"redis"`
 	Jwt      Jwt      `mapstructure:"jwt"`
 	Log      Log      `mapstructure:"log"`
 	S3Config S3Config `mapstructure:"s3"`

config/redis.go

@@ -0,0 +1,55 @@
+package config
+
+import (
+	"fmt"
+	"time"
+)
+
+type Redis struct {
+	Host               string `mapstructure:"host"`
+	Port               int    `mapstructure:"port"`
+	Password           string `mapstructure:"password"`
+	DB                 int    `mapstructure:"db"`
+	DialTimeout        string `mapstructure:"dial_timeout"`
+	ReadTimeout        string `mapstructure:"read_timeout"`
+	WriteTimeout       string `mapstructure:"write_timeout"`
+	PoolSize           int    `mapstructure:"pool_size"`
+	MinIdleConnections int    `mapstructure:"min_idle_connections"`
+}
+
+func (r Redis) Addr() string {
+	return fmt.Sprintf("%s:%d", r.Host, r.Port)
+}
+
+func (r Redis) ParseDialTimeout() time.Duration {
+	if r.DialTimeout == "" {
+		return 5 * time.Second
+	}
+	d, err := time.ParseDuration(r.DialTimeout)
+	if err != nil {
+		return 5 * time.Second
+	}
+	return d
+}
+
+func (r Redis) ParseReadTimeout() time.Duration {
+	if r.ReadTimeout == "" {
+		return 3 * time.Second
+	}
+	d, err := time.ParseDuration(r.ReadTimeout)
+	if err != nil {
+		return 3 * time.Second
+	}
+	return d
+}
+
+func (r Redis) ParseWriteTimeout() time.Duration {
+	if r.WriteTimeout == "" {
+		return 3 * time.Second
+	}
+	d, err := time.ParseDuration(r.WriteTimeout)
+	if err != nil {
+		return 3 * time.Second
+	}
+	return d
+}

deployment.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 APP_NAME="apskel-pos"
-PORT="3300"
+PORT="4000"
 
 echo "🔄 Pulling latest code..."
 git pull

go.mod

@@ -1,6 +1,6 @@
 module apskel-pos-be
 
-go 1.21
+go 1.24
 
 require (
 	github.com/gin-gonic/gin v1.9.1
@@ -13,6 +13,7 @@ require (
 
 require (
 	github.com/bytedance/sonic v1.10.2 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -31,7 +32,7 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.6 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -49,11 +50,11 @@ require (
 	github.com/subosito/gotenv v1.4.2 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	go.uber.org/atomic v1.10.0 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
 	go.uber.org/multierr v1.8.0 // indirect
 	golang.org/x/arch v0.7.0 // indirect
 	golang.org/x/net v0.30.0 // indirect
-	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
 	golang.org/x/text v0.20.0 // indirect
 	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
@@ -63,6 +64,7 @@ require (
 require (
 	github.com/aws/aws-sdk-go v1.55.7
 	github.com/golang-jwt/jwt/v5 v5.2.3
+	github.com/redis/go-redis/v9 v9.19.0
 	github.com/sirupsen/logrus v1.9.3
 	github.com/stretchr/testify v1.8.4
 	go.uber.org/zap v1.21.0

go.sum

@@ -42,11 +42,17 @@ github.com/aws/aws-sdk-go v1.55.7 h1:UJrkFq7es5CShfBwlWAC8DA077vp8PyVbQd3lqLiztE
 github.com/aws/aws-sdk-go v1.55.7/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
 github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
 github.com/bytedance/sonic v1.10.2 h1:GQebETVBxYB7JGWJtLBi07OVzWwt+8dWA00gEVW2ZFE=
 github.com/bytedance/sonic v1.10.2/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
@@ -181,8 +187,8 @@ github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
-github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -218,6 +224,8 @@ github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qR
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/redis/go-redis/v9 v9.19.0 h1:XPVaaPSnG6RhYf7p+rmSa9zZfeVAnWsH5h3lxthOm/k=
+github.com/redis/go-redis/v9 v9.19.0/go.mod h1:v/M13XI1PVCDcm01VtPFOADfZtHf8YW3baQf57KlIkA=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
@@ -261,6 +269,8 @@ github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
@@ -268,8 +278,8 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
-go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=
 go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
@@ -428,8 +438,8 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=

infra/development.yaml

@@ -27,6 +27,17 @@ postgresql:
   connection-max-life-time-in-second: 600
   debug: false
 
+redis:
+  host: 127.0.0.1
+  port: 6379
+  password: "CmICdmnX1EZPhVBYzQPEGw==U"
+  db: 0
+  dial_timeout: 5s
+  read_timeout: 3s
+  write_timeout: 3s
+  pool_size: 10
+  min_idle_connections: 5
+
 s3:
   access_key_id: cf9a475e18bc7626cbdbf09709d82a64
   access_key_secret: 91f3321294d3e23035427a0ecb893ada

internal/app/app.go

@@ -20,20 +20,23 @@ import (
 	"apskel-pos-be/internal/service"
 	"apskel-pos-be/internal/validator"
 
+	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
 
 type App struct {
-	server   *http.Server
-	db       *gorm.DB
-	router   *router.Router
-	shutdown chan os.Signal
+	server      *http.Server
+	db          *gorm.DB
+	redisClient *redis.Client
+	router      *router.Router
+	shutdown    chan os.Signal
 }
 
-func NewApp(db *gorm.DB) *App {
+func NewApp(db *gorm.DB, redisClient *redis.Client) *App {
 	return &App{
-		db:       db,
-		shutdown: make(chan os.Signal, 1),
+		db:          db,
+		redisClient: redisClient,
+		shutdown:    make(chan os.Signal, 1),
 	}
 }
 
@@ -44,6 +47,15 @@ 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,
+		repos.sessionRepo,
+	)
 
 	a.router = router.NewRouter(
 		cfg,
@@ -105,6 +117,7 @@ func (a *App) Initialize(cfg *config.Config) error {
 		services.customerPointsService,
 		services.spinGameService,
 		middleware.customerAuthMiddleware,
+		selfOrderHandler,
 	)
 
 	return nil
@@ -170,6 +183,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
@@ -190,6 +204,7 @@ type repositories struct {
 	customerAuthRepo               repository.CustomerAuthRepository
 	customerPointsRepo             repository.CustomerPointsRepository
 	otpRepo                        repository.OtpRepository
+	sessionRepo                    repository.SessionRepository
 	txManager                      *repository.TxManager
 }
 
@@ -215,6 +230,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),
@@ -235,6 +251,7 @@ func (a *App) initRepositories() *repositories {
 		customerAuthRepo:               repository.NewCustomerAuthRepository(a.db),
 		customerPointsRepo:             repository.NewCustomerPointsRepository(a.db),
 		otpRepo:                        repository.NewOtpRepository(a.db),
+		sessionRepo:                    repository.NewSessionRepository(a.redisClient),
 		txManager:                      repository.NewTxManager(a.db),
 	}
 }
@@ -302,7 +319,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),
@@ -373,7 +390,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
 	productService := service.NewProductService(processors.productProcessor)
 	productVariantService := service.NewProductVariantService(processors.productVariantProcessor)
 	inventoryService := service.NewInventoryService(processors.inventoryProcessor)
-	orderService := service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, nil, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager) // Will be updated after orderIngredientTransactionService is created
+	orderService := service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, nil, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager, repos.sessionRepo) // Will be updated after orderIngredientTransactionService is created
 	paymentMethodService := service.NewPaymentMethodService(processors.paymentMethodProcessor)
 	fileService := service.NewFileServiceImpl(processors.fileProcessor)
 	var customerService service.CustomerService = service.NewCustomerService(processors.customerProcessor)
@@ -398,7 +415,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
 	spinGameService := service.NewSpinGameService(processors.gamePlayProcessor, repos.txManager)
 
 	// Update order service with order ingredient transaction service
-	orderService = service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, orderIngredientTransactionService, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager)
+	orderService = service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, orderIngredientTransactionService, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager, repos.sessionRepo)
 
 	return &services{
 		userService:                       service.NewUserService(processors.userProcessor),

internal/constants/error.go

@@ -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"

internal/contract/ingredient_composition_contract.go

@@ -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
-}

internal/contract/self_order_contract.go

@@ -0,0 +1,75 @@
+package contract
+
+import (
+	"github.com/google/uuid"
+)
+
+type SelfOrderTableTokenResponse struct {
+	SessionID      string `json:"session_id"`
+	TableID        string `json:"table_id"`
+	OrganizationID string `json:"organization_id"`
+	OutletID       string `json:"outlet_id"`
+	TableName      string `json:"table_name"`
+	OutletName     string `json:"outlet_name"`
+	Status         string `json:"status"`
+}
+
+type SelfOrderMenuRequest struct {
+	SessionID string `json:"session_id" validate:"required"`
+}
+
+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 {
+	SessionID  string                     `json:"session_id" validate:"required"`
+	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 {
+	SessionID string `form:"session_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"`
+}

internal/db/redis.go

@@ -0,0 +1,30 @@
+package db
+
+import (
+	"apskel-pos-be/config"
+	"fmt"
+
+	"github.com/redis/go-redis/v9"
+)
+
+func NewRedisClient(c config.Redis) (*redis.Client, error) {
+	opts := &redis.Options{
+		Addr:         c.Addr(),
+		Password:     c.Password,
+		DB:           c.DB,
+		DialTimeout:  c.ParseDialTimeout(),
+		ReadTimeout:  c.ParseReadTimeout(),
+		WriteTimeout: c.ParseWriteTimeout(),
+	}
+	if c.PoolSize > 0 {
+		opts.PoolSize = c.PoolSize
+	}
+	if c.MinIdleConnections > 0 {
+		opts.MinIdleConns = c.MinIdleConnections
+	}
+
+	client := redis.NewClient(opts)
+
+	fmt.Println("Successfully connected to Redis")
+	return client, nil
+}

internal/entities/ingredient.go

@@ -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"`
 }

internal/entities/ingredient_composition.go

@@ -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"`
 }

internal/entities/table.go

@@ -1,6 +1,7 @@
 package entities
 
 import (
+	"apskel-pos-be/internal/pkg/tabletoken"
 	"time"
 
 	"github.com/google/uuid"
@@ -12,6 +13,7 @@ type Table struct {
 	OrganizationID uuid.UUID  `gorm:"type:uuid;not null;index" json:"organization_id" validate:"required"`
 	OutletID       uuid.UUID  `gorm:"type:uuid;not null;index" json:"outlet_id" validate:"required"`
 	TableName      string     `gorm:"not null;size:100" json:"table_name" validate:"required"`
+	Token          string     `gorm:"uniqueIndex;not null;size:255" json:"token"`
 	StartTime      *time.Time `gorm:"" json:"start_time"`
 	Status         string     `gorm:"default:'available';size:50" json:"status"`
 	OrderID        *uuid.UUID `gorm:"type:uuid;index" json:"order_id"`
@@ -33,6 +35,9 @@ func (t *Table) BeforeCreate(tx *gorm.DB) error {
 	if t.ID == uuid.Nil {
 		t.ID = uuid.New()
 	}
+	if t.Token == "" {
+		t.Token = tabletoken.Encode(t.ID, t.OrganizationID, t.OutletID)
+	}
 	return nil
 }
 

internal/handler/ingredient_handler.go

@@ -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")
+}

internal/handler/ingredient_service.go

@@ -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)
 }

internal/handler/self_order_handler.go

@@ -0,0 +1,474 @@
+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/pkg/tabletoken"
+	"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
+	sessionRepo     repository.SessionRepository
+}
+
+func NewSelfOrderHandler(
+	orderService service.OrderService,
+	categoryService service.CategoryService,
+	productService service.ProductService,
+	tableRepo repository.TableRepositoryInterface,
+	outletRepo processor.OutletRepository,
+	userRepo processor.UserRepository,
+	sessionRepo repository.SessionRepository,
+) *SelfOrderHandler {
+	return &SelfOrderHandler{
+		orderService:    orderService,
+		categoryService: categoryService,
+		productService:  productService,
+		tableRepo:       tableRepo,
+		outletRepo:      outletRepo,
+		userRepo:        userRepo,
+		sessionRepo:     sessionRepo,
+	}
+}
+
+func (h *SelfOrderHandler) ValidateToken(c *gin.Context) {
+	ctx := c.Request.Context()
+	token := c.Param("token")
+
+	if token == "" {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "token is required"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	tableID, orgID, outletID, err := tabletoken.Decode(token)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> invalid token")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, "invalid table token"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, tableID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> table not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+		}), "SelfOrderHandler::ValidateToken")
+		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::ValidateToken")
+		return
+	}
+
+	if table.OrganizationID != orgID || table.OutletID != outletID {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "token does not match table"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> outlet not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.OrderServiceEntity, "outlet not found"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	existingSession, err := h.sessionRepo.GetActiveByTableID(ctx, table.ID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> failed to check session")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, "failed to check session"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	var sessionStatus string
+	var sessionID string
+
+	if existingSession != nil {
+		sessionStatus = "joined_session"
+		sessionID = existingSession.ID
+	} else {
+		session := &models.SelfOrderSession{
+			TableID:        table.ID,
+			OrganizationID: table.OrganizationID,
+			OutletID:       table.OutletID,
+		}
+		if err := h.sessionRepo.Create(ctx, session); err != nil {
+			logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> failed to create session")
+			util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+				contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, "failed to create session"),
+			}), "SelfOrderHandler::ValidateToken")
+			return
+		}
+		sessionStatus = "new_session"
+		sessionID = session.ID
+	}
+
+	resp := &contract.SelfOrderTableTokenResponse{
+		SessionID:      sessionID,
+		TableID:        table.ID.String(),
+		OrganizationID: table.OrganizationID.String(),
+		OutletID:       table.OutletID.String(),
+		TableName:      table.TableName,
+		OutletName:     outlet.Name,
+		Status:         sessionStatus,
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "SelfOrderHandler::ValidateToken")
+}
+
+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
+	}
+
+	session, table, outlet, err := h.resolveSession(ctx, req.SessionID)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::GetMenu")
+		return
+	}
+	if session == nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
+		}), "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
+	}
+
+	session, table, _, err := h.resolveSession(ctx, req.SessionID)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+	if session == nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
+		}), "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["session_id"] = session.ID
+
+	tableID := table.ID
+	modelReq := &models.CreateOrderRequest{
+		OutletID:    table.OutletID,
+		UserID:      userID,
+		TableID:     &tableID,
+		TableNumber: &table.TableName,
+		OrderType:   constants.OrderTypeDineIn,
+		OrderItems:  orderItems,
+		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.SessionID == "" {
+		return fmt.Errorf("session_id 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.SessionID == "" {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "session_id is required"),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+
+	session, table, _, err := h.resolveSession(ctx, req.SessionID)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::ListCategories")
+		return
+	}
+	if session == nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
+		}), "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) resolveSession(ctx context.Context, sessionID string) (*models.SelfOrderSession, *entities.Table, *entities.Outlet, error) {
+	session, err := h.sessionRepo.GetByID(ctx, sessionID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("failed to get session: %w", err)
+	}
+	if session == nil {
+		return nil, nil, nil, nil
+	}
+	if session.Status != "active" {
+		return nil, nil, nil, fmt.Errorf("session is no longer active")
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, session.TableID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("table not found for session")
+	}
+
+	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("outlet not found for session")
+	}
+
+	return session, table, outlet, nil
+}
+
+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
+}

internal/mappers/ingredient_composition_mapper.go

@@ -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
-}

internal/middleware/cors.go

@@ -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")

internal/models/ingredient.go

@@ -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"`
 }

internal/models/ingredient_composition.go

@@ -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"`
 }

internal/models/session.go

@@ -0,0 +1,18 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type SelfOrderSession struct {
+	ID             string     `json:"id"`
+	TableID        uuid.UUID  `json:"table_id"`
+	OrganizationID uuid.UUID  `json:"organization_id"`
+	OutletID       uuid.UUID  `json:"outlet_id"`
+	Status         string     `json:"status"`
+	CustomerName   string     `json:"customer_name"`
+	CreatedAt      time.Time  `json:"created_at"`
+	ClosedAt       *time.Time `json:"closed_at,omitempty"`
+}

internal/pkg/tabletoken/token.go

@@ -0,0 +1,43 @@
+package tabletoken
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+type TableTokenPayload struct {
+	TableID        uuid.UUID `json:"table_id"`
+	OrganizationID uuid.UUID `json:"organization_id"`
+	OutletID       uuid.UUID `json:"outlet_id"`
+}
+
+func Encode(tableID, organizationID, outletID uuid.UUID) string {
+	payload := TableTokenPayload{
+		TableID:        tableID,
+		OrganizationID: organizationID,
+		OutletID:       outletID,
+	}
+	jsonBytes, _ := json.Marshal(payload)
+	return base64.URLEncoding.EncodeToString(jsonBytes)
+}
+
+func Decode(token string) (tableID, organizationID, outletID uuid.UUID, err error) {
+	jsonBytes, err := base64.URLEncoding.DecodeString(token)
+	if err != nil {
+		return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("invalid token encoding: %w", err)
+	}
+
+	var payload TableTokenPayload
+	if err := json.Unmarshal(jsonBytes, &payload); err != nil {
+		return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("invalid token format: %w", err)
+	}
+
+	if payload.TableID == uuid.Nil || payload.OrganizationID == uuid.Nil || payload.OutletID == uuid.Nil {
+		return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("token missing required fields")
+	}
+
+	return payload.TableID, payload.OrganizationID, payload.OutletID, nil
+}

internal/processor/ingredient_processor.go

@@ -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
 }

internal/processor/product_processor_test.go

@@ -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)
-}

internal/processor/repository_interfaces.go

@@ -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
+}

internal/repository/analytics_repository.go

@@ -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
 }
 

internal/repository/ingredient_composition_repository.go

@@ -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
+}

internal/repository/ingredient_repository.go

@@ -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
 	}

internal/repository/session_repository.go

@@ -0,0 +1,141 @@
+package repository
+
+import (
+	"apskel-pos-be/internal/models"
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	sessionKeyPrefix      = "self_order:session:"
+	tableSessionKeyPrefix = "self_order:table_session:"
+	sessionTTL            = 24 * time.Hour
+	sessionStatusActive   = "active"
+	sessionStatusClosed   = "closed"
+)
+
+type SessionRepository interface {
+	Create(ctx context.Context, session *models.SelfOrderSession) error
+	GetByID(ctx context.Context, sessionID string) (*models.SelfOrderSession, error)
+	GetActiveByTableID(ctx context.Context, tableID uuid.UUID) (*models.SelfOrderSession, error)
+	Close(ctx context.Context, sessionID string) error
+	CloseByTableID(ctx context.Context, tableID uuid.UUID) error
+}
+
+type sessionRepository struct {
+	client *redis.Client
+}
+
+func NewSessionRepository(client *redis.Client) SessionRepository {
+	return &sessionRepository{client: client}
+}
+
+func (r *sessionRepository) Create(ctx context.Context, session *models.SelfOrderSession) error {
+	if session.ID == "" {
+		session.ID = uuid.New().String()
+	}
+	session.Status = sessionStatusActive
+	session.CreatedAt = time.Now()
+
+	data, err := json.Marshal(session)
+	if err != nil {
+		return fmt.Errorf("failed to marshal session: %w", err)
+	}
+
+	sessionKey := sessionKeyPrefix + session.ID
+	tableSessionKey := tableSessionKeyPrefix + session.TableID.String()
+
+	pipe := r.client.Pipeline()
+	pipe.Set(ctx, sessionKey, data, sessionTTL)
+	pipe.Set(ctx, tableSessionKey, session.ID, sessionTTL)
+
+	if _, err := pipe.Exec(ctx); err != nil {
+		return fmt.Errorf("failed to store session in redis: %w", err)
+	}
+
+	return nil
+}
+
+func (r *sessionRepository) GetByID(ctx context.Context, sessionID string) (*models.SelfOrderSession, error) {
+	data, err := r.client.Get(ctx, sessionKeyPrefix+sessionID).Bytes()
+	if err != nil {
+		if err == redis.Nil {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get session: %w", err)
+	}
+
+	var session models.SelfOrderSession
+	if err := json.Unmarshal(data, &session); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal session: %w", err)
+	}
+
+	return &session, nil
+}
+
+func (r *sessionRepository) GetActiveByTableID(ctx context.Context, tableID uuid.UUID) (*models.SelfOrderSession, error) {
+	sessionID, err := r.client.Get(ctx, tableSessionKeyPrefix+tableID.String()).Result()
+	if err != nil {
+		if err == redis.Nil {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get session for table: %w", err)
+	}
+
+	session, err := r.GetByID(ctx, sessionID)
+	if err != nil {
+		return nil, err
+	}
+
+	if session != nil && session.Status != sessionStatusActive {
+		return nil, nil
+	}
+
+	return session, nil
+}
+
+func (r *sessionRepository) Close(ctx context.Context, sessionID string) error {
+	session, err := r.GetByID(ctx, sessionID)
+	if err != nil {
+		return err
+	}
+	if session == nil {
+		return fmt.Errorf("session not found")
+	}
+
+	now := time.Now()
+	session.Status = sessionStatusClosed
+	session.ClosedAt = &now
+
+	data, err := json.Marshal(session)
+	if err != nil {
+		return fmt.Errorf("failed to marshal session: %w", err)
+	}
+
+	pipe := r.client.Pipeline()
+	pipe.Set(ctx, sessionKeyPrefix+session.ID, data, sessionTTL)
+	pipe.Del(ctx, tableSessionKeyPrefix+session.TableID.String())
+
+	if _, err := pipe.Exec(ctx); err != nil {
+		return fmt.Errorf("failed to close session: %w", err)
+	}
+
+	return nil
+}
+
+func (r *sessionRepository) CloseByTableID(ctx context.Context, tableID uuid.UUID) error {
+	session, err := r.GetActiveByTableID(ctx, tableID)
+	if err != nil {
+		return err
+	}
+	if session == nil {
+		return nil
+	}
+
+	return r.Close(ctx, session.ID)
+}

internal/repository/table_repository.go

@@ -36,6 +36,20 @@ func (r *TableRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.
 	return &table, nil
 }
 
+func (r *TableRepository) GetByToken(ctx context.Context, token string) (*entities.Table, error) {
+	var table entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("token = ?", token).
+		First(&table).Error
+	if err != nil {
+		return nil, err
+	}
+	return &table, nil
+}
+
 func (r *TableRepository) GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
 	var tables []entities.Table
 	err := r.db.WithContext(ctx).

internal/repository/table_repository_interface.go

@@ -13,6 +13,7 @@ import (
 type TableRepositoryInterface interface {
 	Create(ctx context.Context, table *entities.Table) error
 	GetByID(ctx context.Context, id uuid.UUID) (*entities.Table, error)
+	GetByToken(ctx context.Context, token string) (*entities.Table, error)
 	GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error)
 	GetByOrganizationID(ctx context.Context, organizationID uuid.UUID) ([]entities.Table, error)
 	Update(ctx context.Context, table *entities.Table) error

internal/router/router.go

@@ -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,14 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 			customer.POST("/spin", r.spinGameHandler.PlaySpinGame)
 		}
 
+		selfOrder := v1.Group("/self-order")
+		{
+			selfOrder.GET("/table/:token", r.selfOrderHandler.ValidateToken)
+			selfOrder.GET("/categories", r.selfOrderHandler.ListCategories)
+			selfOrder.POST("/menu", r.selfOrderHandler.GetMenu)
+			selfOrder.POST("/orders", r.selfOrderHandler.CreateOrder)
+		}
+
 		organizations := v1.Group("/organizations")
 		{
 			organizations.POST("", r.organizationHandler.CreateOrganization)
@@ -322,6 +332,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")

internal/service/ingredient_processor.go

@@ -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)
 }

internal/service/ingredient_service.go

@@ -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)
+}

internal/service/order_service.go

@@ -37,9 +37,10 @@ type OrderServiceImpl struct {
 	orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor
 	productRecipeRepo                   repository.ProductRecipeRepository
 	txManager                           *repository.TxManager
+	sessionRepo                         repository.SessionRepository
 }
 
-func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repository.TableRepositoryInterface, orderIngredientTransactionService *OrderIngredientTransactionService, orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor, productRecipeRepo repository.ProductRecipeRepository, txManager *repository.TxManager) *OrderServiceImpl {
+func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repository.TableRepositoryInterface, orderIngredientTransactionService *OrderIngredientTransactionService, orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor, productRecipeRepo repository.ProductRecipeRepository, txManager *repository.TxManager, sessionRepo repository.SessionRepository) *OrderServiceImpl {
 	return &OrderServiceImpl{
 		orderProcessor:                      orderProcessor,
 		tableRepo:                           tableRepo,
@@ -47,6 +48,7 @@ func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repo
 		orderIngredientTransactionProcessor: orderIngredientTransactionProcessor,
 		productRecipeRepo:                   productRecipeRepo,
 		txManager:                           txManager,
+		sessionRepo:                         sessionRepo,
 	}
 }
 
@@ -483,7 +485,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)
 			}
 
@@ -621,6 +623,12 @@ func (s *OrderServiceImpl) handleTableReleaseOnPayment(ctx context.Context, orde
 			if err := s.tableRepo.ReleaseTable(ctx, table.ID, order.TotalAmount); err != nil {
 				return fmt.Errorf("failed to release table: %w", err)
 			}
+
+			if s.sessionRepo != nil {
+				if err := s.sessionRepo.CloseByTableID(ctx, table.ID); err != nil {
+					fmt.Printf("Warning: failed to close self-order session for table %s: %v\n", table.ID, err)
+				}
+			}
 		}
 	}
 

internal/transformer/ingredient_transformer.go

@@ -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
+}

migrations/000063_add_token_to_tables.down.sql

@@ -0,0 +1 @@
+ALTER TABLE tables DROP COLUMN IF EXISTS token;

migrations/000063_add_token_to_tables.up.sql

@@ -0,0 +1 @@
+ALTER TABLE tables ADD COLUMN token VARCHAR(255) UNIQUE NOT NULL DEFAULT gen_random_uuid()::text;

test_composition_endpoints.md

@@ -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