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.

git tag -d $(git tag)

Bu komut, yerel repodaki bütün tag’leri tek seferde siler. git-scm İstersen önce hangi tag’ler olduğunu görmek için:

git tag

Bir remote’daki tag’leri silmek farklı bir işlemdir; bu komut sadece local tag’leri kaldırır. git-scm

• Commit’i geri al, değişiklikleri stage’de tut:

  git reset --soft HEAD~1

• Commit’i geri al, değişiklikleri working tree’de tut:

  git reset --mixed HEAD~1

• Commit’i tamamen sil, değişiklikleri de at:

  git reset --hard HEAD~1

Eğer commit’i remote’a push ettiysen, reset --hard yerine çoğu zaman şu daha güvenlidir:

git revert HEAD

git commit --amend ise son commit’i silmez; son commit’i düzeltmek için kullanılır. atlassian

git push --tags

Belirli bir remote’a göndermek istersen:

git push origin --tags

Sadece tek bir tag göndermek için:

git push origin <tag-adi>

--tags tüm local tag’leri yollar; --follow-tags ise yalnızca commit’lerle ilişkili annotated tag’leri gönderir. git-scm

📁 Folder Structure

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

module example.com/hexagonal-go

go 1.22

2) Domain Layer

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.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

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

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

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

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

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

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

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

go run ./cmd/api

Example requests:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

curl -X POST localhost:8080/orders/ord_xxx/complete

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

module example.com/hexagonal-go

go 1.22

2) Domain katmanı

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.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

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

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

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

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

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

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

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

go run ./cmd/api

Örnek istek:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

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.

// 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:

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.

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

• 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
• Solution: You must refresh all open tabs or restart your browser after disabling an extension to ensure all its scripts are fully cleared. stackoverflow

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

• 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
• Attackers often use stolen session tokens to maintain access to your accounts even after the extension is deleted. thehackernews

Extension Status Comparison

The following table illustrates the capabilities of an extension based on its state:

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

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

• 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
• Çözüm: Eklentiyi kapattıktan sonra açık olan tüm sekmeleri yenilemek (Refresh) bu riski tamamen ortadan kaldırır. stackoverflow

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

Güvenli Kullanım Tablosu

Eklenti durumuna göre yetki ve risk dağılımı şu şekildedir:

Şü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

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