Bu eksikliği fark etme sürecimi adım adım şöyle özetleyebilirim:

**1. “Burada Hatalar Var” Sözü Üzerine İlk Hipotezler**
Siz bana `”burada hatalar var, tekrar düzenle”` dediğinizde ilk iş olarak arka planda `go build ./…` ve `go vet ./…` komutlarını çalıştırdım. Kod hiçbir derleme veya sözdizimi (syntax) hatası vermedi. Derleme hatası olmadığına göre sorunun **mantıksal (logical)** veya **eksik bir entegrasyon** olduğunu anladım.

**2. Veri Akışını (Data Flow) Zihnimde Canlandırma**
Sisteminize yeni alanlar (`Word`, `RootAndStructure` vb.) eklemiştik. Bir verinin dışarıdan (API veya form) gelip veritabanına yazılma yolculuğunu düşündüm:
`HTTP Handler -> App Service -> Domain Model -> Outbound Adapters (Postgres, Mongo vb.)`

Domain modeline ve Postgres’e bu alanları eklediğimi biliyordum. Ancak verinin bu iki nokta arasında kaybolabileceği yerleri aramaya başladım.

**3. Uygulama (Service) Katmanındaki Gözden Kaçan Detayı Bulma**
Akışı takip ederek ilk olarak `app/service.go` dosyasına baktım. Gördüm ki `CreateDi` ve `UpdateDi` metotlarında, dışarıdan gelen `input` objesindeki veriler `Di` modeline manuel olarak kopyalanıyordu (`current.Explanation = input.Explanation` gibi). Ancak benim eklediğim yeni alanların hiçbiri burada atanmıyordu! Yani siz formu doldurup göndersiniz bile, Service katmanı bu yeni alanları umursamayıp çöpe atıyordu.

**4. “Service Katmanını Unuttuysam, Başka Neyi Unutmuş Olabilirim?” Sorusu**
Service katmanındaki bu eşleştirmeyi atladığımı fark edince, kendi kendime *”Domain’i ve Postgres’i güncelledim ama demek ki bu modülün dışarıya bağlandığı diğer portları kontrol etmedim”* dedim.

Hemen `adapters/outbound` dizininin içine baktım. Orada sadece `postgres` olmadığını, bir de `mongodb` klasörü bulunduğunu gördüm.

**5. MongoDB’nin Yapısal Farklılığını Hatırlama ve Kontrol**
Golang’de Postgres için `gorm` etiketleri kullanılır ve biz bunu `postgres/repository.go` içinde halletmiştik. Ancak MongoDB tamamen farklı bir NoSQL veritabanıdır ve verileri BSON formatında dökümanlar (documents) olarak tutar. Bu yüzden MongoDB’nin kendi struct’ları (genelde `bson` etiketlerine sahip) ve kendi Mapping (eşleştirme) fonksiyonları (`toDocument`, `toDomain`, `Upsert` işlemleri içindeki `bson.M{}`) olmak zorundaydı.

Hemen `adapters/outbound/mongodb/repository.go` dosyasını açıp okudum ve teorimin doğru olduğunu gördüm: Oradaki `DiDocument` struct’ında ve MongoDB’ye kayıt atan `Upsert` sorgusunda yeni alanların hiçbiri yoktu.

**Özetle:**
Sizin “hata var” uyarınız derleme hatası üretmeyince, dedektif gibi verinin yaşam döngüsünü (Handler -> Service -> Database) adım adım izledim. Service katmanındaki kopukluğu bulunca, mimarinin diğer uç noktalarına da (MongoDB gibi) şüpheyle yaklaştım ve hatanın kök nedenini bu sistematik takip sayesinde fark ettim.

“`bash
git tag -d $(git tag)
“`

Bu komut, yerel repodaki bütün tag’leri tek seferde siler. [git-scm](https://git-scm.com/docs/git-commit)
İstersen önce hangi tag’ler olduğunu görmek için:

“`bash
git tag
“`

Bir remote’daki tag’leri silmek farklı bir işlemdir; bu komut sadece **local** tag’leri kaldırır. [git-scm](https://git-scm.com/docs/git-commit)

– Commit’i geri al, değişiklikleri stage’de tut:
“`bash
git reset –soft HEAD~1
“`

– Commit’i geri al, değişiklikleri working tree’de tut:
“`bash
git reset –mixed HEAD~1
“`

– Commit’i tamamen sil, değişiklikleri de at:
“`bash
git reset –hard HEAD~1
“`

Eğer commit’i remote’a push ettiysen, `reset –hard` yerine çoğu zaman şu daha güvenlidir:
“`bash
git revert HEAD
“`

`git commit –amend` ise son commit’i silmez; son commit’i düzeltmek için kullanılır. [atlassian](https://www.atlassian.com/git/tutorials/saving-changes/git-commit)

“`bash
git push –tags
“`

Belirli bir remote’a göndermek istersen:

“`bash
git push origin –tags
“`

Sadece tek bir tag göndermek için:

“`bash
git push origin
“`

`–tags` tüm local tag’leri yollar; `–follow-tags` ise yalnızca commit’lerle ilişkili annotated tag’leri gönderir. [git-scm](https://git-scm.com/book/en/v2/Git-Basics-Tagging)

—

# 📁 Folder Structure

“`text
hexagonal-go/
├── go.mod
├── cmd/
│ └── api/
│ └── main.go
└── internal/
├── domain/
│ └── order/
│ ├── money.go
│ ├── order.go
│ ├── order_id.go
│ ├── order_status.go
│ └── repository.go
├── application/
│ └── order_service.go
└── adapters/
├── http/
│ └── order_handler.go
└── persistence/
└── memory/
└── order_repository.go
“`

—

# 1) `go.mod`

“`go
module example.com/hexagonal-go

go 1.22
“`

—

# 2) Domain Layer

### `internal/domain/order/order_id.go`

“`go
package order

type OrderID string
“`

### `internal/domain/order/order_status.go`

“`go
package order

type OrderStatus string

const (
OrderStatusCreated OrderStatus = “CREATED”
OrderStatusCompleted OrderStatus = “COMPLETED”
)
“`

### `internal/domain/order/money.go`

“`go
package order

import “fmt”

type Money struct {
Cents int64
}

func NewMoney(cents int64) (Money, error) {
if cents < 0 { return Money{}, fmt.Errorf("money cannot be negative") } return Money{Cents: cents}, nil } func (m Money) Add(other Money) Money { return Money{Cents: m.Cents + other.Cents} } ``` ### `internal/domain/order/order.go` ```go package order import "fmt" type OrderItem struct { ProductID string Quantity int UnitPrice Money } type Order struct { id OrderID items []OrderItem status OrderStatus } func NewOrder(id OrderID) *Order { return &Order{ id: id, items: make([]OrderItem, 0), status: OrderStatusCreated, } } func (o *Order) ID() OrderID { return o.id } func (o *Order) Status() OrderStatus { return o.status } func (o *Order) Items() []OrderItem { copied := make([]OrderItem, len(o.items)) copy(copied, o.items) return copied } func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error { if o.status != OrderStatusCreated { return fmt.Errorf("order cannot be modified after completion") } if productID == "" { return fmt.Errorf("product id cannot be empty") } if quantity <= 0 { return fmt.Errorf("quantity must be greater than zero") } o.items = append(o.items, OrderItem{ ProductID: productID, Quantity: quantity, UnitPrice: unitPrice, }) return nil } func (o *Order) Complete() error { if len(o.items) == 0 { return fmt.Errorf("order must have at least one item") } o.status = OrderStatusCompleted return nil } func (o *Order) Total() Money { total := Money{Cents: 0} for _, item := range o.items { total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)}) } return total } ``` ### `internal/domain/order/repository.go` ```go package order import "context" type Repository interface { Save(ctx context.Context, order *Order) error FindByID(ctx context.Context, id OrderID) (*Order, error) } ``` --- # 3) Application Layer ### `internal/application/order_service.go` ```go package application import ( "context" "fmt" "time" "example.com/hexagonal-go/internal/domain/order" ) type OrderService struct { repo order.Repository } func NewOrderService(repo order.Repository) *OrderService { return &OrderService{repo: repo} } func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) { id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano())) newOrder := order.NewOrder(id) if err := s.repo.Save(ctx, newOrder); err != nil { return nil, err } return newOrder, nil } func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) { o, err := s.repo.FindByID(ctx, orderID) if err != nil { return nil, err } price, err := order.NewMoney(priceCents) if err != nil { return nil, err } if err := o.AddItem(productID, quantity, price); err != nil { return nil, err } if err := s.repo.Save(ctx, o); err != nil { return nil, err } return o, nil } func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) { o, err := s.repo.FindByID(ctx, orderID) if err != nil { return nil, err } if err := o.Complete(); err != nil { return nil, err } if err := s.repo.Save(ctx, o); err != nil { return nil, err } return o, nil } func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) { return s.repo.FindByID(ctx, orderID) } ``` --- # 4) Persistence Adapter (In-Memory) ### `internal/adapters/persistence/memory/order_repository.go` ```go package memory import ( "context" "fmt" "sync" "example.com/hexagonal-go/internal/domain/order" ) type OrderRepository struct { mu sync.RWMutex orders map[order.OrderID]*order.Order } func NewOrderRepository() *OrderRepository { return &OrderRepository{ orders: make(map[order.OrderID]*order.Order), } } func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error { r.mu.Lock() defer r.mu.Unlock() r.orders[o.ID()] = o return nil } func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) { r.mu.RLock() defer r.mu.RUnlock() o, ok := r.orders[id] if !ok { return nil, fmt.Errorf("order not found: %s", id) } return o, nil } ``` --- # 5) HTTP Adapter ### `internal/adapters/http/order_handler.go` ```go package httpadapter import ( "encoding/json" "net/http" "strings" "example.com/hexagonal-go/internal/application" "example.com/hexagonal-go/internal/domain/order" ) type OrderHandler struct { service *application.OrderService } func NewOrderHandler(service *application.OrderService) *OrderHandler { return &OrderHandler{service: service} } func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) { mux.HandleFunc("POST /orders", h.createOrder) mux.HandleFunc("GET /orders/", h.getOrder) mux.HandleFunc("POST /orders/{id}/items", h.addItem) mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder) } func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) { o, err := h.service.CreateOrder(r.Context()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } respondJSON(w, http.StatusCreated, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) o, err := h.service.GetOrder(r.Context(), order.OrderID(id)) if err != nil { http.Error(w, err.Error(), http.StatusNotFound) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "items": o.Items(), "total": o.Total().Cents, }) } func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) var req struct { ProductID string `json:"product_id"` Quantity int `json:"quantity"` PriceCents int64 `json:"price_cents"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, "invalid json", http.StatusBadRequest) return } o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id)) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func extractID(path string) string { parts := strings.Split(strings.Trim(path, "/"), "/") if len(parts) >= 2 {
return parts[1]
}
return “”
}

func respondJSON(w http.ResponseWriter, status int, payload any) {
w.Header().Set(“Content-Type”, “application/json”)
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(payload)
}
“`

—

# 6) Application Entry Point

### `cmd/api/main.go`

“`go
package main

import (
“log”
“net/http”

httpadapter “example.com/hexagonal-go/internal/adapters/http”
“example.com/hexagonal-go/internal/adapters/persistence/memory”
“example.com/hexagonal-go/internal/application”
)

func main() {
repo := memory.NewOrderRepository()
service := application.NewOrderService(repo)
handler := httpadapter.NewOrderHandler(service)

mux := http.NewServeMux()
handler.RegisterRoutes(mux)

log.Println(“server started on :8080”)
if err := http.ListenAndServe(“:8080”, mux); err != nil {
log.Fatal(err)
}
}
“`

—

# 7) How It Works

* **HTTP adapter** receives the request
* **Application service** executes the use case
* **Domain** applies business rules
* **Repository (port)** is defined in the domain
* **Adapter (memory)** implements it

👉 The domain layer:

* does NOT know `net/http`
* does NOT know databases
* does NOT know frameworks

—

# 8) Simple Test Example

### `internal/domain/order/order_test.go`

“`go
package order

import “testing”

func TestOrderCompleteWithoutItems(t *testing.T) {
o := NewOrder(“1”)

if err := o.Complete(); err == nil {
t.Fatal(“expected error when completing empty order”)
}
}

func TestOrderTotal(t *testing.T) {
o := NewOrder(“1”)
price, _ := NewMoney(500)

if err := o.AddItem(“p1”, 2, price); err != nil {
t.Fatal(err)
}

if o.Total().Cents != 1000 {
t.Fatalf(“expected 1000, got %d”, o.Total().Cents)
}
}
“`

—

# 9) Run the Project

“`bash
go run ./cmd/api
“`

Example requests:

“`bash
curl -X POST localhost:8080/orders
“`

“`bash
curl -X POST localhost:8080/orders/ord_xxx/items \
-H ‘Content-Type: application/json’ \
-d ‘{“product_id”:”p1″,”quantity”:2,”price_cents”:500}’
“`

“`bash
curl -X POST localhost:8080/orders/ord_xxx/complete
“`

—

“`text
hexagonal-go/
├── go.mod
├── cmd/
│ └── api/
│ └── main.go
└── internal/
├── domain/
│ └── order/
│ ├── money.go
│ ├── order.go
│ ├── order_id.go
│ ├── order_status.go
│ └── repository.go
├── application/
│ └── order_service.go
└── adapters/
├── http/
│ └── order_handler.go
└── persistence/
└── memory/
└── order_repository.go
“`

—

## 1) `go.mod`

“`go
module example.com/hexagonal-go

go 1.22
“`

—

## 2) Domain katmanı

### `internal/domain/order/order_id.go`

“`go
package order

type OrderID string
“`

### `internal/domain/order/order_status.go`

“`go
package order

type OrderStatus string

const (
OrderStatusCreated OrderStatus = “CREATED”
OrderStatusCompleted OrderStatus = “COMPLETED”
)
“`

### `internal/domain/order/money.go`

“`go
package order

import “fmt”

type Money struct {
Cents int64
}

func NewMoney(cents int64) (Money, error) {
if cents < 0 { return Money{}, fmt.Errorf("money cannot be negative") } return Money{Cents: cents}, nil } func (m Money) Add(other Money) Money { return Money{Cents: m.Cents + other.Cents} } ``` ### `internal/domain/order/order.go` ```go package order import "fmt" type OrderItem struct { ProductID string Quantity int UnitPrice Money } type Order struct { id OrderID items []OrderItem status OrderStatus } func NewOrder(id OrderID) *Order { return &Order{ id: id, items: make([]OrderItem, 0), status: OrderStatusCreated, } } func (o *Order) ID() OrderID { return o.id } func (o *Order) Status() OrderStatus { return o.status } func (o *Order) Items() []OrderItem { copied := make([]OrderItem, len(o.items)) copy(copied, o.items) return copied } func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error { if o.status != OrderStatusCreated { return fmt.Errorf("order cannot be modified after completion") } if productID == "" { return fmt.Errorf("product id cannot be empty") } if quantity <= 0 { return fmt.Errorf("quantity must be greater than zero") } o.items = append(o.items, OrderItem{ ProductID: productID, Quantity: quantity, UnitPrice: unitPrice, }) return nil } func (o *Order) Complete() error { if len(o.items) == 0 { return fmt.Errorf("order must have at least one item") } o.status = OrderStatusCompleted return nil } func (o *Order) Total() Money { total := Money{Cents: 0} for _, item := range o.items { total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)}) } return total } ``` ### `internal/domain/order/repository.go` ```go package order import "context" type Repository interface { Save(ctx context.Context, order *Order) error FindByID(ctx context.Context, id OrderID) (*Order, error) } ``` --- ## 3) Application katmanı ### `internal/application/order_service.go` ```go package application import ( "context" "fmt" "time" "example.com/hexagonal-go/internal/domain/order" ) type OrderService struct { repo order.Repository } func NewOrderService(repo order.Repository) *OrderService { return &OrderService{repo: repo} } func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) { id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano())) newOrder := order.NewOrder(id) if err := s.repo.Save(ctx, newOrder); err != nil { return nil, err } return newOrder, nil } func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) { o, err := s.repo.FindByID(ctx, orderID) if err != nil { return nil, err } price, err := order.NewMoney(priceCents) if err != nil { return nil, err } if err := o.AddItem(productID, quantity, price); err != nil { return nil, err } if err := s.repo.Save(ctx, o); err != nil { return nil, err } return o, nil } func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) { o, err := s.repo.FindByID(ctx, orderID) if err != nil { return nil, err } if err := o.Complete(); err != nil { return nil, err } if err := s.repo.Save(ctx, o); err != nil { return nil, err } return o, nil } func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) { return s.repo.FindByID(ctx, orderID) } ``` --- ## 4) Persistence adapter (in-memory) ### `internal/adapters/persistence/memory/order_repository.go` ```go package memory import ( "context" "fmt" "sync" "example.com/hexagonal-go/internal/domain/order" ) type OrderRepository struct { mu sync.RWMutex orders map[order.OrderID]*order.Order } func NewOrderRepository() *OrderRepository { return &OrderRepository{ orders: make(map[order.OrderID]*order.Order), } } func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error { r.mu.Lock() defer r.mu.Unlock() r.orders[o.ID()] = o return nil } func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) { r.mu.RLock() defer r.mu.RUnlock() o, ok := r.orders[id] if !ok { return nil, fmt.Errorf("order not found: %s", id) } return o, nil } ``` --- ## 5) HTTP adapter ### `internal/adapters/http/order_handler.go` ```go package httpadapter import ( "encoding/json" "net/http" "strings" "example.com/hexagonal-go/internal/application" "example.com/hexagonal-go/internal/domain/order" ) type OrderHandler struct { service *application.OrderService } func NewOrderHandler(service *application.OrderService) *OrderHandler { return &OrderHandler{service: service} } func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) { mux.HandleFunc("POST /orders", h.createOrder) mux.HandleFunc("GET /orders/", h.getOrder) mux.HandleFunc("POST /orders/{id}/items", h.addItem) mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder) } func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) { o, err := h.service.CreateOrder(r.Context()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } respondJSON(w, http.StatusCreated, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) o, err := h.service.GetOrder(r.Context(), order.OrderID(id)) if err != nil { http.Error(w, err.Error(), http.StatusNotFound) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "items": o.Items(), "total": o.Total().Cents, }) } func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) var req struct { ProductID string `json:"product_id"` Quantity int `json:"quantity"` PriceCents int64 `json:"price_cents"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, "invalid json", http.StatusBadRequest) return } o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) { id := extractID(r.URL.Path) o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id)) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } respondJSON(w, http.StatusOK, map[string]any{ "id": o.ID(), "status": o.Status(), "total": o.Total().Cents, }) } func extractID(path string) string { parts := strings.Split(strings.Trim(path, "/"), "/") if len(parts) >= 2 {
return parts[1]
}
return “”
}

func respondJSON(w http.ResponseWriter, status int, payload any) {
w.Header().Set(“Content-Type”, “application/json”)
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(payload)
}
“`

—

## 6) Uygulama başlangıcı

### `cmd/api/main.go`

“`go
package main

import (
“log”
“net/http”

httpadapter “example.com/hexagonal-go/internal/adapters/http”
“example.com/hexagonal-go/internal/adapters/persistence/memory”
“example.com/hexagonal-go/internal/application”
)

func main() {
repo := memory.NewOrderRepository()
service := application.NewOrderService(repo)
handler := httpadapter.NewOrderHandler(service)

mux := http.NewServeMux()
handler.RegisterRoutes(mux)

log.Println(“server started on :8080”)
if err := http.ListenAndServe(“:8080”, mux); err != nil {
log.Fatal(err)
}
}
“`

—

## 7) Akış nasıl çalışıyor?

* **HTTP adapter** isteği alır.
* **Application service** use-case’i yürütür.
* **Domain** iş kurallarını uygular.
* **Repository port** domain tarafından tanımlanır.
* **Memory adapter** bu portu implement eder.

Bu yapı sayesinde domain katmanı:

* `net/http` bilmez,
* database bilmez,
* framework bilmez.

—

## 8) Kısa test örneği

### `internal/domain/order/order_test.go`

“`go
package order

import “testing”

func TestOrderCompleteWithoutItems(t *testing.T) {
o := NewOrder(“1”)

if err := o.Complete(); err == nil {
t.Fatal(“expected error when completing empty order”)
}
}

func TestOrderTotal(t *testing.T) {
o := NewOrder(“1”)
price, _ := NewMoney(500)

if err := o.AddItem(“p1”, 2, price); err != nil {
t.Fatal(err)
}

if o.Total().Cents != 1000 {
t.Fatalf(“expected 1000, got %d”, o.Total().Cents)
}
}
“`

—

## 9) Çalıştırma

“`bash
go run ./cmd/api
“`

Örnek istek:

“`bash
curl -X POST localhost:8080/orders
“`

“`bash
curl -X POST localhost:8080/orders/ord_xxx/items \
-H ‘Content-Type: application/json’ \
-d ‘{“product_id”:”p1″,”quantity”:2,”price_cents”:500}’
“`

“`bash
curl -X POST localhost:8080/orders/ord_xxx/complete
“`

—

Yani `*fiber.Ctx` nesnesini dışarıdan manuel olarak “başlatamazsınız” (instantiate edemezsiniz). Ancak, bu nesneyi ihtiyaç duyduğunuz yardımcı fonksiyonlara **parametre olarak** geçirebilirsiniz.

İşte temiz ve modüler bir mimari için uygulayabileceğiniz yöntemler:

### 1. Yöntem: Handler İçinde Hazırlık ve Parametre Olarak Geçirme (En İyi Pratik)

Handler fonksiyonu Fiber ile konuşur, ancak asıl işi yapan “Service” katmanındaki fonksiyonlara `*fiber.Ctx` yerine sadece ihtiyacı olan verileri (örneğin sadece `limit` veya `search` değerini) geçirmek en iyi yaklaşımdır.

“`go
// Service Katmanı (Logic fonksiyonu)
func GetPostsFromDB(db *gorm.DB, start int, length int, search string) ([]Post, int64, error) {
// Sadece veriyle ilgilenir, Fiber’den bağımsızdır.
var posts []Post
var count int64

// İşlemler…
return posts, count, nil
}

// Handler Katmanı
app.Get(“/api/posts”, func(c *fiber.Ctx) error {
// Fiber’den verileri al
start := c.QueryInt(“start”, 0)

// Servis fonksiyonunu çağır
posts, count, _ := GetPostsFromDB(db, start, 10, “”)

return c.JSON(fiber.Map{“data”: posts, “total”: count})
})
“`

### 2. Yöntem: Context’i Fonksiyona Taşımak

Eğer fonksiyonun içinde `c.Status()`, `c.JSON()` veya `c.Params()` gibi Fiber özelliklerine sürekli ihtiyacınız varsa, fonksiyon imzasını şu şekilde kurabilirsiniz:

“`go
func HandleRequestData(c *fiber.Ctx) error {
// Bu fonksiyon doğrudan Fiber context’ini kullanabilir
search := c.Query(“search”)

// … işlemler
return c.JSON(fiber.Map{“search”: search})
}

// Kullanımı
app.Get(“/search”, HandleRequestData)
“`

### 3. Yöntem: `Locals` Kullanımı (Veri Paylaşımı)

`*fiber.Ctx` içerisindeki `.Locals()` fonksiyonunu kullanarak, middleware’de başlattığınız bir veriyi (örneğin Auth bilgisi veya User ID) tüm fonksiyonlarınızda kullanabilirsiniz.

“`go
// Middleware
app.Use(func(c *fiber.Ctx) error {
c.Locals(“userID”, 123) // Bir kez set et
return c.Next()
})

// İstediğiniz herhangi bir fonksiyonda
func MyHandler(c *fiber.Ctx) error {
userID := c.Locals(“userID”) // Buradan al
return c.SendString(fmt.Sprintf(“User: %v”, userID))
}
“`

### Neden `*fiber.Ctx` ile “Init” yapmamalısınız?

* **Test Edilebilirlik:** Eğer fonksiyonlarınızı `*fiber.Ctx`’e bağımlı yaparsanız, o fonksiyonu bir HTTP isteği olmadan test edemezsiniz (Unit test yazamazsınız).
* **Bağımsızlık:** Fonksiyonlarınızı `c.Query()`, `c.Params()` yerine doğrudan `int`, `string` gibi standart Go tiplerini kabul edecek şekilde tasarlarsanız, aynı fonksiyonu hem HTTP API’nizde hem de bir CLI komutunda veya bir background job’da değiştirmeden kullanabilirsiniz.

**Özetle:** `*fiber.Ctx` nesnesini başlatmaya çalışmayın. `*fiber.Ctx`’ten verileri çıkarın (`c.QueryInt` gibi) ve bu saf verileri kendi yazdığınız fonksiyonlara parametre olarak gönderin.

Bu şekilde kodunuzu “Fiber’e bağlı” olmaktan kurtarıp “saf Go kodu” haline getirmiş olursunuz. Bu yaklaşım kod tabanınızı uzun vadede çok daha sürdürülebilir kılacaktır. Başka bir katman mimarisi (Service/Repository pattern) üzerinde çalışıyor musunuz?

ServBay’in ücretsiz sürümü, ücretli Laravel Herd Pro’yu tam anlamıyla karşılayabilir. ServBay’de özel alan adları destekleniyor mu? Elbette! ServBay, özel alan …Read more

I made an App like Laravel Herd. supports caddy, nginx, apache, php, nodejs, mysql, mariadb, postgresql, mongodb, redis, memcached…
byu/PhpWebStudy inmacapps

https://dudi.dev/laravel-development-environment-comparison

macos valet install

laravel valet

However, there are two critical security nuances to consider:

### Residual Risks in Open Tabs
If a malicious extension was active and you disabled it while having several tabs open, its “content scripts” might still be running in those specific pages until they are refreshed. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)
– These scripts could potentially leak data through indirect methods like hidden images or CSS if the site’s Content Security Policy (CSP) is weak. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)
– **Solution:** You must refresh all open tabs or restart your browser after disabling an extension to ensure all its scripts are fully cleared. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)

### Previously Stolen Data
Disabling an extension only stops **future** data collection; it does not “undo” what was already stolen while the extension was active. [youtube](https://www.youtube.com/watch?v=Rhxz_i8rDcM)
– If a malicious extension captured your passwords, session cookies, or personal data while it was enabled, that information is likely already stored on the attacker’s server (C2 server). [linkedin](https://www.linkedin.com/pulse/warning-malicious-chrome-extensions-steal-your-gtrae)
– Attackers often use stolen session tokens to maintain access to your accounts even after the extension is deleted. [thehackernews](https://thehackernews.com/2026/02/malicious-chrome-extensions-caught.html)

### Extension Status Comparison
The following table illustrates the capabilities of an extension based on its state:

| Status | Web Page Access | Real-time Data Leak | Historical Data Risk |
| :— | :— | :— | :— |
| **Enabled** | Full Access [reddit](https://www.reddit.com/r/chrome/comments/1ckcd1s/can_chrome_extensions_scrape_my_pages_and_steal/) | High [youtube](https://www.youtube.com/watch?v=Rhxz_i8rDcM) | Continuous Access |
| **Disabled** | Blocked [support.google](https://support.google.com/chrome/thread/11119336/can-chrome-extensions-affect-computer-performance-even-if-they-are-turned-off?hl=en) | Very Low (Residual) | Stored on External Server |
| **Removed** | Impossible | Impossible | Stored on External Server |

If you suspect an extension is malicious, simply disabling it is not enough. You should **remove** it entirely, clear your browser cookies, and change your passwords for sensitive accounts. [support.google](https://support.google.com/chrome/thread/306226825/chrome-extensions-might-steal-passwords?hl=en)

Which specific extension are you concerned about?

Ancak güvenlik açısından dikkat edilmesi gereken iki önemli istisna bulunmaktadır:

### Aktif Sekmelerdeki Kalıntı Riskler
Bir eklentiyi devre dışı bıraktığınız an, o sırada açık olan sekmelerde halihazırda enjekte edilmiş olan “içerik betikleri” (content scripts) çalışmaya devam edebilir. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)
– Bu betikler eklenti merkezine veri gönderemez ancak sitenin kendi güvenlik politikası (CSP) zayıfsa, verileri gizli görseller veya CSS üzerinden dışarı sızdırmaya çalışabilir. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)
– **Çözüm:** Eklentiyi kapattıktan sonra açık olan tüm sekmeleri yenilemek (Refresh) bu riski tamamen ortadan kaldırır. [stackoverflow](https://stackoverflow.com/questions/69368249/what-data-is-accessible-to-a-disabled-chrome-extension)

### Geçmişte Toplanan Veriler
Eklentinin devre dışı bırakılması sadece gelecekteki veri akışını keser.
– Eğer eklenti aktif olduğu süre boyunca şifrelerinizi, çerezlerinizi (cookies) veya kişisel verilerinizi uzak bir sunucuya (C2 server) gönderdiyse, bu veriler saldırganın elinde kalmaya devam eder. [youtube](https://www.youtube.com/watch?v=Rhxz_i8rDcM)
– Kötü niyetli eklentiler genellikle oturum jetonlarını (session tokens) çalarak, siz eklentiyi silseniz bile hesaplarınıza erişim sağlamaya devam edebilir. [linkedin](https://www.linkedin.com/pulse/warning-malicious-chrome-extensions-steal-your-gtrae)

### Güvenli Kullanım Tablosu
Eklenti durumuna göre yetki ve risk dağılımı şu şekildedir:

| Durum | Web Sayfası Okuma | Veri Sızdırma | Geçmiş Veri Erişimi |
| :— | :— | :— | :— |
| **Aktif** | Tam Yetki [reddit](https://www.reddit.com/r/chrome/comments/1ckcd1s/can_chrome_extensions_scrape_my_pages_and_steal/) | Mümkün [youtube](https://www.youtube.com/watch?v=Rhxz_i8rDcM) | Sürekli Erişim |
| **Devre Dışı** | Engellenir [support.google](https://support.google.com/chrome/thread/11119336/can-chrome-extensions-affect-computer-performance-even-if-they-are-turned-off?hl=en) | Çok Düşük (Kalıntı Betik) | Saldırganın Sunucusunda Saklı |
| **Kaldırılmış** | İmkansız | İmkansız | Saldırganın Sunucusunda Saklı |

Şüphelendiğiniz bir eklenti varsa sadece devre dışı bırakmak yerine doğrudan **kaldırmanız** ve ardından tarayıcı çerezlerini temizleyerek şifrelerinizi değiştirmeniz en güvenli yoldur. [thehackernews](https://thehackernews.com/2026/02/malicious-chrome-extensions-caught.html)

Hangi eklenti hakkında bu endişeyi taşıyorsunuz?