Intermediate

// Package app holds port interfaces for the supplier bounded context.
// Ports are defined here so the domain never depends on infrastructure.
package app
 
import (
    "context"
    // domain package defines the Supplier aggregate and SupplierID type.
    "procurement/supplier/domain"
)
 
// SupplierRepository is an output port.
// Any struct that implements these three methods satisfies the interface.
// No 'implements' keyword required — Go structural typing handles dispatch.
type SupplierRepository interface {
    // FindByID retrieves a supplier by its identity.
    // Returns domain.ErrNotFound when the supplier does not exist.
    FindByID(ctx context.Context, id domain.SupplierID) (domain.Supplier, error)
 
    // Save persists a supplier aggregate (create or update).
    // The adapter decides whether to INSERT or UPDATE.
    Save(ctx context.Context, s domain.Supplier) error
 
    // FindApproved returns all suppliers whose status is Approved.
    // Used by the purchasing context eligibility guard.
    FindApproved(ctx context.Context) ([]domain.Supplier, error)
}

// Package domain holds the Supplier aggregate for the supplier context.
// No framework imports, no database tags, no HTTP concerns.
package domain
 
import "errors"
 
// SupplierStatus enumerates legal lifecycle states.
// Using a distinct string type prevents mixing with arbitrary strings.
type SupplierStatus string
 
const (
    // SupplierPending is the initial state after registration.
    SupplierPending  SupplierStatus = "PENDING"
    // SupplierApproved means the supplier passed compliance review.
    SupplierApproved SupplierStatus = "APPROVED"
    // SupplierRejected is terminal — cannot be reversed.
    SupplierRejected SupplierStatus = "REJECTED"
)
 
// Supplier is the aggregate root for the supplier context.
type Supplier struct {
    // ID uniquely identifies this supplier across the platform.
    ID     SupplierID
    // Name is the legal trading name, required and non-empty.
    Name   string
    // Status tracks the compliance lifecycle.
    Status SupplierStatus
}
 
// Approve transitions the supplier from Pending to Approved.
// Returns ErrInvalidTransition when the current state disallows it.
func (s *Supplier) Approve() error {
    if s.Status != SupplierPending {
        // Only Pending suppliers may be approved; Rejected is terminal.
        return ErrInvalidTransition
    }
    // Transition is valid — update the in-memory state.
    s.Status = SupplierApproved
    return nil
}
 
// Reject transitions the supplier from Pending to Rejected.
// Rejected is a terminal state — calling Reject again returns an error.
func (s *Supplier) Reject() error {
    if s.Status != SupplierPending {
        // Neither Approved nor Rejected may be rejected again.
        return ErrInvalidTransition
    }
    s.Status = SupplierRejected
    return nil
}
 
// IsApproved is a convenience predicate used by the eligibility guard.
// Callers check this instead of comparing status strings directly.
func (s Supplier) IsApproved() bool {
    // True only when the supplier has passed compliance review.
    return s.Status == SupplierApproved
}
 
var (
    // ErrInvalidTransition signals an illegal lifecycle change.
    ErrInvalidTransition = errors.New("invalid status transition")
    // ErrNotFound signals that a lookup returned no result.
    ErrNotFound          = errors.New("supplier not found")
)

// Package mem provides in-memory adapters for the supplier context.
// Used in unit tests and in fast-startup environments (no Postgres needed).
package mem
 
import (
    "context"
    "sync"
    "procurement/supplier/app"
    "procurement/supplier/domain"
)
 
// SupplierRepo is a thread-safe in-memory implementation of app.SupplierRepository.
// The struct satisfies the interface implicitly — no 'implements' declaration.
type SupplierRepo struct {
    // mu protects the store map from concurrent reads and writes.
    mu    sync.RWMutex
    // store maps SupplierID to its latest aggregate snapshot.
    store map[domain.SupplierID]domain.Supplier
}
 
// NewSupplierRepo constructs an empty SupplierRepo with an initialised map.
func NewSupplierRepo() *SupplierRepo {
    // Return a pointer so callers share the same store; value copy would lose data.
    return &SupplierRepo{store: make(map[domain.SupplierID]domain.Supplier)}
}
 
// FindByID looks up a supplier by identity.
// RLock allows concurrent reads without blocking other readers.
func (r *SupplierRepo) FindByID(ctx context.Context, id domain.SupplierID) (domain.Supplier, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    // Map lookup: ok is false when the key is absent.
    s, ok := r.store[id]
    if !ok {
        // Return the sentinel error the port contract specifies.
        return domain.Supplier{}, domain.ErrNotFound
    }
    return s, nil
}
 
// Save writes the supplier aggregate into the in-memory store.
// Lock (not RLock) prevents concurrent writes from interleaving.
func (r *SupplierRepo) Save(ctx context.Context, s domain.Supplier) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    // Overwrite any existing entry — same as an SQL upsert.
    r.store[s.ID] = s
    return nil
}
 
// FindApproved returns all suppliers with status APPROVED.
// Iterates the entire map; acceptable for tests and low-volume starts.
func (r *SupplierRepo) FindApproved(ctx context.Context) ([]domain.Supplier, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    var result []domain.Supplier
    for _, s := range r.store {
        if s.IsApproved() {
            // Append only APPROVED entries to the result slice.
            result = append(result, s)
        }
    }
    // Returning nil slice when empty is idiomatic Go — callers use len().
    return result, nil
}
 
// Compile-time assertion: *SupplierRepo must satisfy app.SupplierRepository.
// If the interface changes, this line causes a build error before any test runs.
var _ app.SupplierRepository = (*SupplierRepo)(nil)

// Package app holds the IssuePurchaseOrderService for the purchasing context.
// The service orchestrates domain logic and delegates I/O to port implementations.
package app
 
import (
    "context"
    "errors"
    "procurement/purchasing/domain"
    supplierApp "procurement/supplier/app"
    supplierDomain "procurement/supplier/domain"
)
 
// ErrSupplierNotApproved is returned when the named supplier is not APPROVED.
// Application-layer error, not a domain error — the domain does not know suppliers.
var ErrSupplierNotApproved = errors.New("supplier is not approved")
 
// IssuePurchaseOrderService orchestrates PO issuance with supplier eligibility.
type IssuePurchaseOrderService struct {
    // poRepo persists PurchaseOrder aggregates; defined in this package as a port.
    poRepo       PurchaseOrderRepository
    // supplierRepo is a cross-context dependency: the supplier output port.
    supplierRepo supplierApp.SupplierRepository
    // clock provides deterministic time for domain event timestamps.
    clock        Clock
}
 
// Issue validates supplier eligibility then persists the purchase order.
// Returns ErrSupplierNotApproved when the supplier has not passed compliance.
func (s *IssuePurchaseOrderService) Issue(ctx context.Context, cmd IssueCommand) (domain.PurchaseOrderID, error) {
    // Step 1: fetch supplier — crosses context boundary via output port.
    supplier, err := s.supplierRepo.FindByID(ctx, supplierDomain.SupplierID(cmd.SupplierID))
    if err != nil {
        // FindByID returns ErrNotFound when the supplier does not exist.
        return "", err
    }
    // Step 2: eligibility guard — domain aggregate method, not a raw string compare.
    if !supplier.IsApproved() {
        // Guard rejects early; no PO is created, no ID is allocated.
        return "", ErrSupplierNotApproved
    }
    // Step 3: create the domain aggregate using the current clock time.
    po, err := domain.NewPurchaseOrder(cmd.SupplierID, cmd.Items, s.clock.Now())
    if err != nil {
        return "", err
    }
    // Step 4: persist the new aggregate via the output port.
    if err := s.poRepo.Save(ctx, po); err != nil {
        return "", err
    }
    // Step 5: return the new aggregate identity to the caller (HTTP adapter).
    return po.ID, nil
}

// Package app_test exercises IssuePurchaseOrderService eligibility guard.
// No Postgres, no HTTP server, no test framework beyond standard library.
package app_test
 
import (
    "context"
    "testing"
    "procurement/purchasing/app"
    purchasingMem "procurement/purchasing/adapter/out/mem"
    supplierMem   "procurement/supplier/adapter/out/mem"
    supplierDomain "procurement/supplier/domain"
)
 
// TestIssue_RejectsNonApprovedSupplier verifies the eligibility guard fires
// when the supplier exists but has not been approved.
func TestIssue_RejectsNonApprovedSupplier(t *testing.T) {
    // Arrange — seed a PENDING supplier in the in-memory adapter.
    supplierRepo := supplierMem.NewSupplierRepo()
    pendingSupplier := supplierDomain.Supplier{
        ID:     "S-001",
        Name:   "ACME Corp",
        // Status is PENDING — not eligible to receive purchase orders.
        Status: supplierDomain.SupplierPending,
    }
    // Save the pending supplier so FindByID will find it.
    _ = supplierRepo.Save(context.Background(), pendingSupplier)
 
    // Wire the service with in-memory adapters — no composition root needed.
    svc := app.NewIssuePurchaseOrderService(
        purchasingMem.NewPurchaseOrderRepo(),
        supplierRepo,
        app.FixedClock{},
    )
 
    // Act — attempt to issue a PO against the PENDING supplier.
    _, err := svc.Issue(context.Background(), app.IssueCommand{
        SupplierID: "S-001",
        Items:      []app.LineItem{{SKU: "WIDGET-42", Quantity: 10}},
    })
 
    // Assert — the service must return ErrSupplierNotApproved, nothing else.
    if err != app.ErrSupplierNotApproved {
        // Fail with a diagnostic message that names both expected and actual errors.
        t.Errorf("expected ErrSupplierNotApproved, got %v", err)
    }
}

// Package postgres provides a Postgres-backed PurchaseOrderRepository.
// It depends on database/sql and pgx — infrastructure concerns isolated here.
package postgres
 
import (
    "context"
    "database/sql"
    "procurement/purchasing/app"
    "procurement/purchasing/domain"
)
 
// PurchaseOrderRepo implements app.PurchaseOrderRepository against Postgres.
// The struct holds a *sql.DB from which it obtains connections per request.
type PurchaseOrderRepo struct {
    // db is the database handle; shared across all requests via connection pool.
    db *sql.DB
}
 
// NewPurchaseOrderRepo constructs a repo given an open database handle.
// The caller (main.go) owns the DB lifecycle — this repo does not close it.
func NewPurchaseOrderRepo(db *sql.DB) *PurchaseOrderRepo {
    return &PurchaseOrderRepo{db: db}
}
 
// Save inserts or updates a PurchaseOrder row in the database.
// Uses an upsert so callers do not distinguish create from update.
func (r *PurchaseOrderRepo) Save(ctx context.Context, po domain.PurchaseOrder) error {
    const q = `
        INSERT INTO purchase_orders (id, supplier_id, status, created_at)
        VALUES ($1, $2, $3, $4)
        ON CONFLICT (id) DO UPDATE
            SET status = EXCLUDED.status`
    // QueryContext propagates the request context for cancellation and timeouts.
    _, err := r.db.ExecContext(ctx, q, po.ID, po.SupplierID, string(po.Status), po.CreatedAt)
    // Return the raw database error; the service maps it if needed.
    return err
}
 
// FindByID retrieves a single purchase order row by primary key.
// Scans the result set into the domain struct; no ORM, no reflection.
func (r *PurchaseOrderRepo) FindByID(ctx context.Context, id domain.PurchaseOrderID) (domain.PurchaseOrder, error) {
    const q = `SELECT id, supplier_id, status, created_at FROM purchase_orders WHERE id = $1`
    row := r.db.QueryRowContext(ctx, q, id)
    var po domain.PurchaseOrder
    var status string
    // Scan maps columns to fields by position; field order must match SELECT list.
    err := row.Scan(&po.ID, &po.SupplierID, &status, &po.CreatedAt)
    if err == sql.ErrNoRows {
        // Translate database absence into the port-contract sentinel error.
        return domain.PurchaseOrder{}, domain.ErrNotFound
    }
    if err != nil {
        return domain.PurchaseOrder{}, err
    }
    // Re-hydrate the typed status from the stored string.
    po.Status = domain.POStatus(status)
    return po, nil
}
 
// Compile-time assertion: *PurchaseOrderRepo must satisfy app.PurchaseOrderRepository.
var _ app.PurchaseOrderRepository = (*PurchaseOrderRepo)(nil)

// main.go — composition root that selects adapters based on environment.
// No framework, no DI container, no reflection — plain Go constructor calls.
package main
 
import (
    "database/sql"
    "log"
    "os"
    "procurement/purchasing/adapter/in/http"
    "procurement/purchasing/app"
    purchasingMem  "procurement/purchasing/adapter/out/mem"
    purchasingPG   "procurement/purchasing/adapter/out/postgres"
    _ "github.com/jackc/pgx/v5/stdlib" // Register pgx as a database/sql driver.
)
 
func main() {
    // Determine adapter choice by checking DATABASE_URL at startup.
    var poRepo app.PurchaseOrderRepository
    dbURL := os.Getenv("DATABASE_URL")
    if dbURL != "" {
        // Postgres path — open connection pool and wrap in the Postgres adapter.
        db, err := sql.Open("pgx", dbURL)
        if err != nil {
            log.Fatalf("cannot open database: %v", err)
        }
        // NewPurchaseOrderRepo wraps the *sql.DB behind the port interface.
        poRepo = purchasingPG.NewPurchaseOrderRepo(db)
        log.Println("using postgres adapter")
    } else {
        // In-memory path — no external dependency needed.
        poRepo = purchasingMem.NewPurchaseOrderRepo()
        log.Println("using in-memory adapter (no DATABASE_URL set)")
    }
    // The service is constructed identically regardless of which adapter was chosen.
    svc := app.NewIssuePurchaseOrderService(poRepo, /* supplierRepo, clock */ nil, nil)
    // Mount HTTP routes — the handler holds the service, not the repository.
    router := http.NewRouter(svc)
    log.Fatal(router.ListenAndServe(":8080"))
}

// Package postgres_test runs integration tests against a real Postgres container.
// Requires Docker; will be skipped in environments without it.
package postgres_test
 
import (
    "context"
    "database/sql"
    "testing"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
    purchasingPG "procurement/purchasing/adapter/out/postgres"
    "procurement/purchasing/domain"
)
 
// TestPurchaseOrderRepo_SaveAndFind is an integration test against a real Postgres.
// Uses testcontainers-go to start a throwaway container per test binary run.
func TestPurchaseOrderRepo_SaveAndFind(t *testing.T) {
    ctx := context.Background()
    // Start a Postgres container — image, database, user, password configured here.
    container, err := postgres.RunContainer(ctx,
        testcontainers.WithImage("postgres:16-alpine"),
        postgres.WithDatabase("procurement"),
        postgres.WithUsername("test"),
        postgres.WithPassword("test"),
    )
    if err != nil {
        t.Fatalf("failed to start container: %v", err)
    }
    // Ensure the container is terminated after the test, even on failure.
    defer container.Terminate(ctx)
 
    // Obtain the connection string from the running container.
    connStr, _ := container.ConnectionString(ctx, "sslmode=disable")
    db, _ := sql.Open("pgx", connStr)
    // Run schema migrations so the purchase_orders table exists.
    runMigrations(t, db)
 
    // Begin a transaction — all test writes will be rolled back.
    tx, _ := db.BeginTx(ctx, nil)
    defer tx.Rollback() // Rollback undoes all inserts after the test.
 
    // Construct the adapter using the transaction as the database handle.
    repo := purchasingPG.NewPurchaseOrderRepo(tx)
    po := domain.PurchaseOrder{ID: "PO-TEST-1", SupplierID: "S-001", Status: domain.PODraft}
    // Save through the adapter — writes go into the transaction, not committed.
    if err := repo.Save(ctx, po); err != nil {
        t.Fatalf("Save failed: %v", err)
    }
    // FindByID reads within the same transaction — uncommitted data is visible.
    found, err := repo.FindByID(ctx, "PO-TEST-1")
    if err != nil {
        t.Fatalf("FindByID failed: %v", err)
    }
    if found.SupplierID != "S-001" {
        t.Errorf("expected supplier S-001, got %v", found.SupplierID)
    }
    // Rollback in defer ensures the purchase_orders table is unchanged after the test.
}

// Package suppliergateway translates external supplier API responses
// into the supplier domain type used by the purchasing context.
// This adapter isolates the domain from the external supplier service's schema.
package suppliergateway
 
import "procurement/supplier/domain"
 
// ExternalSupplierDTO represents the JSON shape returned by the supplier microservice.
// Field names match the external API contract; they are not the domain field names.
type ExternalSupplierDTO struct {
    // SupplierCode is the external identifier — not the same as domain.SupplierID format.
    SupplierCode   string `json:"supplier_code"`
    // LegalName differs from the domain's Name field by convention.
    LegalName      string `json:"legal_name"`
    // ApprovalStatus uses the external service's vocabulary ("VETTED", "BLOCKED", etc.).
    ApprovalStatus string `json:"approval_status"`
}
 
// ToDomain converts an ExternalSupplierDTO into the purchasing context's domain.Supplier.
// This is the ACL translation function — the domain's Supplier never knows about ExternalSupplierDTO.
func (dto ExternalSupplierDTO) ToDomain() domain.Supplier {
    return domain.Supplier{
        // Map external SupplierCode to domain SupplierID with a type cast.
        ID:   domain.SupplierID(dto.SupplierCode),
        // Map legal_name to the domain's Name field.
        Name: dto.LegalName,
        // Translate external vocabulary to domain SupplierStatus values.
        Status: translateStatus(dto.ApprovalStatus),
    }
}
 
// translateStatus converts external status strings to domain enum values.
// Unknown statuses map to Pending — a conservative safe default.
func translateStatus(external string) domain.SupplierStatus {
    switch external {
    case "VETTED":
        // External VETTED maps to domain Approved.
        return domain.SupplierApproved
    case "BLOCKED", "REJECTED":
        // Both external blocking states map to domain Rejected.
        return domain.SupplierRejected
    default:
        // Unknown or new external statuses default to Pending (safe, not approved).
        return domain.SupplierPending
    }
}

// Package app defines the EventPublisher output port for the purchasing context.
// The port interface lives here; concrete adapters live in adapter/out/.
package app
 
import "context"
 
// DomainEvent carries the type name and payload for a single domain event.
// Using an interface keeps the port generic — callers decide the concrete event type.
type DomainEvent interface {
    // EventType returns a string name used for routing (e.g., "PurchaseOrderIssued").
    EventType() string
}
 
// EventPublisher is an output port for publishing domain events.
// Implementations include: in-memory (tests), outbox+Postgres, NATS, Kafka.
type EventPublisher interface {
    // Publish delivers a domain event to whatever bus or store backs this port.
    // Callers do not know whether delivery is synchronous or asynchronous.
    Publish(ctx context.Context, event DomainEvent) error
}
 
// InMemoryEventPublisher collects published events for test inspection.
// No external dependency — useful for verifying that services emit expected events.
type InMemoryEventPublisher struct {
    // Events holds all published events in publication order.
    Events []DomainEvent
}
 
// Publish appends the event to the in-memory slice.
// Not thread-safe by design — unit tests run sequentially.
func (p *InMemoryEventPublisher) Publish(_ context.Context, event DomainEvent) error {
    // Append to slice; no mutex needed for sequential unit tests.
    p.Events = append(p.Events, event)
    return nil
}
 
// Compile-time assertion: *InMemoryEventPublisher must satisfy EventPublisher.
var _ EventPublisher = (*InMemoryEventPublisher)(nil)

// Package app defines the ApprovalRouterPort output port.
// Routing POs to approval workflows is an infrastructure concern — the domain does not own it.
package app
 
import (
    "context"
    "procurement/purchasing/domain"
)
 
// ApprovalRouterPort routes a submitted PurchaseOrder to an approval workflow.
// Concrete adapters: InMemoryApprovalRouter (tests), BPMNEngineRouter (production).
type ApprovalRouterPort interface {
    // Route sends the purchase order to the correct approval workflow.
    // Returns the assigned workflow ID for tracking.
    Route(ctx context.Context, po domain.PurchaseOrder) (WorkflowID, error)
}
 
// WorkflowID identifies an approval workflow instance in the external BPMN engine.
type WorkflowID string
 
// InMemoryApprovalRouter records which POs were routed and with what workflow ID.
// Used in unit tests to verify that the service calls Route after submission.
type InMemoryApprovalRouter struct {
    // Routed maps PurchaseOrderID to the assigned WorkflowID for test inspection.
    Routed map[domain.PurchaseOrderID]WorkflowID
}
 
// NewInMemoryApprovalRouter constructs a router with an initialised map.
func NewInMemoryApprovalRouter() *InMemoryApprovalRouter {
    return &InMemoryApprovalRouter{Routed: make(map[domain.PurchaseOrderID]WorkflowID)}
}
 
// Route records the routing decision and returns a synthetic WorkflowID.
func (r *InMemoryApprovalRouter) Route(_ context.Context, po domain.PurchaseOrder) (WorkflowID, error) {
    // Assign a deterministic workflow ID for test reproducibility.
    wfID := WorkflowID("WF-" + string(po.ID))
    // Record the routing so tests can assert the correct PO was routed.
    r.Routed[po.ID] = wfID
    return wfID, nil
}
 
// Compile-time assertion: *InMemoryApprovalRouter must satisfy ApprovalRouterPort.
var _ ApprovalRouterPort = (*InMemoryApprovalRouter)(nil)

// main.go — composition root wiring purchasing and supplier contexts.
// No DI framework: all dependencies are explicit constructor arguments.
package main
 
import (
    "database/sql"
    "log"
    "os"
    purchasingApp  "procurement/purchasing/app"
    purchasingHTTP "procurement/purchasing/adapter/in/http"
    purchasingPG   "procurement/purchasing/adapter/out/postgres"
    purchasingMem  "procurement/purchasing/adapter/out/mem"
    supplierApp    "procurement/supplier/app"
    supplierPG     "procurement/supplier/adapter/out/postgres"
    supplierMem    "procurement/supplier/adapter/out/mem"
)
 
func main() {
    dbURL := os.Getenv("DATABASE_URL")
    // shared is the single EventPublisher used by both contexts.
    // One publisher means one place to change when the event bus changes.
    var shared purchasingApp.EventPublisher
 
    var poRepo    purchasingApp.PurchaseOrderRepository
    var supRepo   supplierApp.SupplierRepository
 
    if dbURL != "" {
        // Both contexts share the same database handle but use separate adapter instances.
        db, err := sql.Open("pgx", dbURL)
        if err != nil { log.Fatalf("db open: %v", err) }
        // Each adapter wraps the shared *sql.DB; no state is shared between adapters.
        poRepo  = purchasingPG.NewPurchaseOrderRepo(db)
        supRepo = supplierPG.NewSupplierRepo(db)
        // In production, EventPublisher is the outbox adapter writing to the same DB.
        shared = purchasingPG.NewOutboxEventPublisher(db)
    } else {
        // In-memory adapters for local development and unit test binary.
        poRepo  = purchasingMem.NewPurchaseOrderRepo()
        supRepo = supplierMem.NewSupplierRepo()
        // In-memory publisher — collects events for inspection, no external bus.
        shared = &purchasingApp.InMemoryEventPublisher{}
    }
 
    // Wire the purchasing service with its three dependencies.
    // The service sees only port interfaces — concrete types are invisible.
    purchasingSvc := purchasingApp.NewIssuePurchaseOrderService(poRepo, supRepo, shared)
    // Mount the HTTP router with the service as the only dependency.
    router := purchasingHTTP.NewRouter(purchasingSvc)
    log.Fatal(router.ListenAndServe(":8080"))
}

// explicit_wiring.go — excerpt showing deep constructor injection for the purchasing service.
// Every dependency is visible as a constructor argument; nothing is hidden in a container.
package main
 
import (
    purchasingApp "procurement/purchasing/app"
    purchasingMem "procurement/purchasing/adapter/out/mem"
    supplierMem   "procurement/supplier/adapter/out/mem"
)
 
// wirePurchasingService constructs the full service graph without a DI framework.
// Step through this function in a debugger to trace any dependency.
func wirePurchasingService() *purchasingApp.IssuePurchaseOrderService {
    // Level 3 (leaf) — in-memory adapters need no dependencies of their own.
    poRepo      := purchasingMem.NewPurchaseOrderRepo()
    supRepo     := supplierMem.NewSupplierRepo()
    publisher   := &purchasingApp.InMemoryEventPublisher{}
    approvalRtr := purchasingApp.NewInMemoryApprovalRouter()
    clock       := purchasingApp.FixedClock{} // deterministic time for dev/test.
 
    // Level 2 — the service depends on four port implementations.
    // All four are visible on a single line; a DI container would hide them.
    return purchasingApp.NewIssuePurchaseOrderService(
        poRepo,
        supRepo,
        publisher,
        approvalRtr,
        clock,
    )
}

// Package http is the primary HTTP adapter for the purchasing context.
// It receives JSON, validates it, and converts to the application command type.
package http
 
import (
    "encoding/json"
    "net/http"
    "procurement/purchasing/app"
)
 
// issuePORequest is the JSON body for POST /purchase-orders.
// This struct exists only in the adapter layer — it is not an app or domain type.
type issuePORequest struct {
    // SupplierID is required; empty string is rejected by validate().
    SupplierID string            `json:"supplier_id"`
    // Items is required; empty slice is rejected by validate().
    Items      []lineItemRequest `json:"items"`
}
 
// lineItemRequest is the JSON line-item shape; maps 1-to-1 with app.LineItem.
type lineItemRequest struct {
    SKU      string `json:"sku"`
    Quantity int    `json:"quantity"`
}
 
// validate enforces required-field rules before the command enters the service.
// Returns a human-readable error string; never returns a domain error.
func (r issuePORequest) validate() error {
    if r.SupplierID == "" {
        // SupplierID is mandatory — reject early with a clear message.
        return errBadRequest("supplier_id is required")
    }
    if len(r.Items) == 0 {
        // At least one line item is required to issue a purchase order.
        return errBadRequest("items must not be empty")
    }
    return nil
}
 
// HandleIssuePO is the chi handler for POST /purchase-orders.
func HandleIssuePO(svc app.IssuePurchaseOrderUseCase) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        var req issuePORequest
        // Decode JSON body into the adapter-local DTO struct.
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            http.Error(w, "invalid JSON", http.StatusBadRequest)
            return
        }
        // Validate at the adapter boundary before calling the service.
        if err := req.validate(); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        // Convert the DTO to the application command type — no domain import needed.
        cmd := app.IssueCommand{
            SupplierID: req.SupplierID,
            Items:      toAppLineItems(req.Items),
        }
        // Delegate to the application service; the adapter does no business logic.
        id, err := svc.Issue(r.Context(), cmd)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(map[string]string{"id": string(id)})
    }
}

// dependency_check_test.go — CI guard verifying the dependency rule.
// This test fails the build if any domain package imports an adapter package.
package infra_test
 
import (
    "os/exec"
    "strings"
    "testing"
)
 
// TestDomainPackageHasNoAdapterImports uses 'go list' to extract the import graph
// and asserts that domain packages never import adapter packages.
func TestDomainPackageHasNoAdapterImports(t *testing.T) {
    // 'go list -f {{.ImportPath}} {{.Imports}}' prints each package's imports.
    // The './purchasing/domain/...' pattern matches all sub-packages.
    out, err := exec.Command(
        "go", "list", "-f", "{{.ImportPath}} {{.Imports}}",
        "./purchasing/domain/...",
    ).Output()
    if err != nil {
        t.Fatalf("go list failed: %v", err)
    }
    // Scan each line; fail if any domain package imports adapter or app.
    for _, line := range strings.Split(string(out), "\n") {
        if strings.Contains(line, "adapter/") {
            // Found an illegal cross-layer import — print the offending line.
            t.Errorf("domain package imports adapter: %s", line)
        }
        if strings.Contains(line, "/app") {
            // domain must not import app — app may import domain, never the reverse.
            t.Errorf("domain package imports app: %s", line)
        }
    }
}

// Package app shows why splitting command and query ports improves the design.
// Before CQRS: one repository interface for both reads and writes.
package app
 
// Before — single port mixes command and query responsibilities.
// The command service (Issue) does not need FindByStatus or FindPendingApproval.
// Including those methods forces every command adapter to implement unused methods.
type PurchaseOrderRepositoryBefore interface {
    Save(ctx context.Context, po domain.PurchaseOrder) error
    FindByID(ctx context.Context, id domain.PurchaseOrderID) (domain.PurchaseOrder, error)
    // These two methods are only needed by query services — not by command services.
    FindByStatus(ctx context.Context, status domain.POStatus) ([]domain.PurchaseOrder, error)
    FindPendingApproval(ctx context.Context) ([]domain.PurchaseOrder, error)
}
 
// After CQRS — two focused ports.
// PurchaseOrderWriter is the command-side port: write-only.
type PurchaseOrderWriter interface {
    Save(ctx context.Context, po domain.PurchaseOrder) error
    FindByID(ctx context.Context, id domain.PurchaseOrderID) (domain.PurchaseOrder, error)
}
 
// PurchaseOrderReader is the query-side port: read-only, returns read models not aggregates.
type PurchaseOrderReader interface {
    FindByStatus(ctx context.Context, status domain.POStatus, page, pageSize int) ([]PurchaseOrderSummary, error)
    FindPendingApproval(ctx context.Context) ([]PurchaseOrderSummary, error)
}

// Package app — command service for the purchasing context.
// IssuePurchaseOrderCommandService handles only the write side.
package app
 
import (
    "context"
    "procurement/purchasing/domain"
)
 
// IssuePurchaseOrderCommandService orchestrates PO creation on the write side.
// It depends on PurchaseOrderWriter (not the full Repository) — CQRS segregation.
type IssuePurchaseOrderCommandService struct {
    // writer is the command-side port; does not expose query methods.
    writer   PurchaseOrderWriter
    // supRepo cross-context port for supplier eligibility check.
    supRepo  SupplierRepository
    // clock deterministic time for domain aggregate timestamps.
    clock    Clock
    // publisher sends PurchaseOrderIssued event after successful write.
    publisher EventPublisher
}
 
// Issue processes the command and returns only the new aggregate identity.
// It does NOT return the full PurchaseOrder — that is the query service's job.
func (s *IssuePurchaseOrderCommandService) Issue(ctx context.Context, cmd IssueCommand) (domain.PurchaseOrderID, error) {
    // Eligibility guard — cross-context call via output port.
    sup, err := s.supRepo.FindByID(ctx, cmd.SupplierID)
    if err != nil || !sup.IsApproved() {
        return "", ErrSupplierNotApproved
    }
    // Create domain aggregate using clock-provided timestamp.
    po, err := domain.NewPurchaseOrder(cmd.SupplierID, cmd.Items, s.clock.Now())
    if err != nil {
        return "", err
    }
    // Persist via write-side port only.
    if err := s.writer.Save(ctx, po); err != nil {
        return "", err
    }
    // Publish domain event; caller does not see the event — only the ID.
    _ = s.publisher.Publish(ctx, domain.PurchaseOrderIssuedEvent{ID: po.ID})
    // Return only the identity — no read model, no full aggregate.
    return po.ID, nil
}

// Package app — query service for the purchasing context.
// FindPurchaseOrdersQueryService handles only the read side.
package app
 
import "context"
 
// FindPurchaseOrdersQueryService serves read-only queries.
// It depends on PurchaseOrderReader (not the full Repository) — CQRS segregation.
type FindPurchaseOrdersQueryService struct {
    // reader is the query-side port; Save and FindByID are not accessible.
    reader PurchaseOrderReader
}
 
// FindPendingApproval returns read models for POs awaiting reviewer action.
// Returns []PurchaseOrderSummary — not []domain.PurchaseOrder.
// Read models are leaner: no business methods, no lifecycle invariants.
func (s *FindPurchaseOrdersQueryService) FindPendingApproval(ctx context.Context) ([]PurchaseOrderSummary, error) {
    // Delegate entirely to the read-side port; no domain logic applied here.
    return s.reader.FindPendingApproval(ctx)
}
 
// FindByStatus returns a paginated set of summaries filtered by status.
// Page numbering is 1-based; pageSize is clamped by the adapter if too large.
func (s *FindPurchaseOrdersQueryService) FindByStatus(ctx context.Context, status string, page, pageSize int) ([]PurchaseOrderSummary, error) {
    // Convert the string status to the typed domain enum before calling the port.
    return s.reader.FindByStatus(ctx, domain.POStatus(status), page, pageSize)
}

// Package mem provides an in-memory read-side adapter for the purchasing context.
// It implements PurchaseOrderReader returning PurchaseOrderSummary read models.
package mem
 
import (
    "context"
    "procurement/purchasing/app"
    "procurement/purchasing/domain"
    "sync"
)
 
// InMemoryPurchaseOrderReader holds summaries projected from saved aggregates.
// In a real system this might tail an event log; here it shares the write store.
type InMemoryPurchaseOrderReader struct {
    mu       sync.RWMutex
    // summaries maps PurchaseOrderID to its read-model projection.
    summaries map[domain.PurchaseOrderID]app.PurchaseOrderSummary
}
 
// NewInMemoryPurchaseOrderReader constructs a reader with an empty summary store.
func NewInMemoryPurchaseOrderReader() *InMemoryPurchaseOrderReader {
    return &InMemoryPurchaseOrderReader{
        summaries: make(map[domain.PurchaseOrderID]app.PurchaseOrderSummary),
    }
}
 
// Project updates the read-side store when a new aggregate is saved.
// Called by tests and the in-memory write adapter after each save.
func (r *InMemoryPurchaseOrderReader) Project(po domain.PurchaseOrder) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.summaries[po.ID] = app.PurchaseOrderSummary{
        ID:         string(po.ID),
        SupplierID: string(po.SupplierID),
        // Status is formatted for display; domain enum is the source of truth.
        Status:     string(po.Status),
    }
}
 
// FindPendingApproval returns all summaries with PENDING_APPROVAL status.
func (r *InMemoryPurchaseOrderReader) FindPendingApproval(ctx context.Context) ([]app.PurchaseOrderSummary, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    var result []app.PurchaseOrderSummary
    for _, s := range r.summaries {
        if s.Status == string(domain.POPendingApproval) {
            result = append(result, s)
        }
    }
    return result, nil
}
 
// FindByStatus returns summaries filtered by status with simple page/pageSize slicing.
func (r *InMemoryPurchaseOrderReader) FindByStatus(ctx context.Context, status domain.POStatus, page, pageSize int) ([]app.PurchaseOrderSummary, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    var all []app.PurchaseOrderSummary
    for _, s := range r.summaries {
        if s.Status == string(status) {
            all = append(all, s)
        }
    }
    // Compute slice bounds for pagination — avoids out-of-bounds panic.
    start := (page - 1) * pageSize
    if start >= len(all) {
        return nil, nil
    }
    end := start + pageSize
    if end > len(all) {
        end = len(all)
    }
    return all[start:end], nil
}
 
// Compile-time assertion: *InMemoryPurchaseOrderReader must satisfy app.PurchaseOrderReader.
var _ app.PurchaseOrderReader = (*InMemoryPurchaseOrderReader)(nil)

// Package query holds read models for the purchasing context.
// Read models are plain structs shaped for API responses — no business logic.
package query
 
// PurchaseOrderSummary is a read-model projection of the PurchaseOrder aggregate.
// It lives in app/query/, not in domain/ — consumers shape it, not the domain.
type PurchaseOrderSummary struct {
    // ID is the purchase order identity as a plain string for JSON serialisation.
    ID string `json:"id"`
    // SupplierID identifies the supplier, formatted for display.
    SupplierID string `json:"supplier_id"`
    // SupplierName is a denormalized display field; not in the aggregate.
    // Populated by the read adapter from a JOIN or a separate lookup.
    SupplierName string `json:"supplier_name,omitempty"`
    // Status is a human-readable string derived from the domain enum.
    Status string `json:"status"`
    // TotalAmount is a precomputed display value; the aggregate uses Money.
    TotalAmount string `json:"total_amount"`
    // CreatedAt is an ISO 8601 string for display; the aggregate uses time.Time.
    CreatedAt string `json:"created_at"`
}
// Note: PurchaseOrderSummary has no methods. It is a data bag for the API layer.
// The domain PurchaseOrder has methods (Submit, Approve) that this struct must not copy.

// Package app — paginated query use case for the purchasing context.
// FindByStatusQuery carries both filter and pagination parameters.
package app
 
import "context"
 
// FindByStatusQuery carries the filter and pagination parameters for a status query.
// A dedicated query struct is cleaner than a long parameter list.
type FindByStatusQuery struct {
    // Status filters POs to a specific lifecycle state.
    Status string
    // Page is 1-based; page 1 returns the first pageSize records.
    Page int
    // PageSize is the maximum number of records per page; clamped by the adapter.
    PageSize int
}
 
// Page wraps a slice of items with the total count for the client to paginate.
type Page[T any] struct {
    // Items is the current page's slice of read models.
    Items []T
    // Total is the total number of matching records across all pages.
    Total int
}
 
// FindPurchaseOrdersQueryService — paginated query method.
// FindByStatus returns a Page of PurchaseOrderSummary for the given status and page.
func (s *FindPurchaseOrdersQueryService) FindByStatus(ctx context.Context, q FindByStatusQuery) (Page[PurchaseOrderSummary], error) {
    // Clamp pageSize to prevent enormous result sets from overwhelming the client.
    if q.PageSize <= 0 || q.PageSize > 100 {
        // Default to 20 if the caller provides an invalid page size.
        q.PageSize = 20
    }
    // Delegate to the read port; service does not know whether this is Postgres or memory.
    items, err := s.reader.FindByStatus(ctx, domain.POStatus(q.Status), q.Page, q.PageSize)
    if err != nil {
        return Page[PurchaseOrderSummary]{}, err
    }
    // Fetch the total count for pagination metadata.
    total, err := s.reader.CountByStatus(ctx, domain.POStatus(q.Status))
    if err != nil {
        return Page[PurchaseOrderSummary]{}, err
    }
    return Page[PurchaseOrderSummary]{Items: items, Total: total}, nil
}

// main.go — CQRS composition root wiring command and query services separately.
package main
 
import (
    "database/sql"
    "log"
    "os"
    purchasingApp  "procurement/purchasing/app"
    purchasingHTTP "procurement/purchasing/adapter/in/http"
    purchasingPG   "procurement/purchasing/adapter/out/postgres"
    purchasingMem  "procurement/purchasing/adapter/out/mem"
)
 
func main() {
    dbURL := os.Getenv("DATABASE_URL")
 
    var writer    purchasingApp.PurchaseOrderWriter
    var reader    purchasingApp.PurchaseOrderReader
    var publisher purchasingApp.EventPublisher
 
    if dbURL != "" {
        db, err := sql.Open("pgx", dbURL)
        if err != nil { log.Fatalf("db open: %v", err) }
        // Command-side adapter — wraps *sql.DB behind the write port.
        pgRepo := purchasingPG.NewPurchaseOrderRepo(db)
        writer = pgRepo   // pgRepo implements both writer and reader ports.
        reader = purchasingPG.NewPurchaseOrderReadRepo(db)
        publisher = purchasingPG.NewOutboxEventPublisher(db)
    } else {
        memRepo := purchasingMem.NewPurchaseOrderRepo()
        writer = memRepo
        // In-memory reader shares projection state with the writer via a shared reference.
        memReader := purchasingMem.NewInMemoryPurchaseOrderReader()
        reader    = memReader
        publisher = &purchasingApp.InMemoryEventPublisher{}
    }
 
    // Command service depends on the write port only.
    cmdSvc := purchasingApp.NewIssuePurchaseOrderCommandService(writer, nil, nil, publisher)
    // Query service depends on the read port only — completely separate.
    qrySvc := purchasingApp.NewFindPurchaseOrdersQueryService(reader)
 
    // Mount both services on the HTTP router.
    router := purchasingHTTP.NewRouter(cmdSvc, qrySvc)
    log.Fatal(router.ListenAndServe(":8080"))
}

// Package app — port extension by embedding the old interface.
// Embedding avoids forcing all existing adapters to break at once.
package app
 
import (
    "context"
    "procurement/purchasing/domain"
)
 
// PurchaseOrderRepository is the original port with three methods.
type PurchaseOrderRepository interface {
    Save(ctx context.Context, po domain.PurchaseOrder) error
    FindByID(ctx context.Context, id domain.PurchaseOrderID) (domain.PurchaseOrder, error)
    FindByStatus(ctx context.Context, status domain.POStatus) ([]domain.PurchaseOrder, error)
}
 
// PurchaseOrderRepositoryV2 extends the port by embedding V1 and adding FindBySupplier.
// Adapters that satisfy V1 satisfy V2 only after implementing FindBySupplier.
// This allows gradual migration: update one adapter at a time.
type PurchaseOrderRepositoryV2 interface {
    // Embed the previous interface — all V1 methods are implicitly part of V2.
    PurchaseOrderRepository
    // FindBySupplier is the new method required by the supplier-dashboard feature.
    // Returns all POs for a given supplier regardless of status.
    FindBySupplier(ctx context.Context, id domain.SupplierID) ([]domain.PurchaseOrder, error)
}
 
// DefaultFindBySupplier provides a fallback implementation for adapters not yet updated.
// Callers that need the real implementation must update their adapter.
func DefaultFindBySupplier(_ context.Context, _ domain.SupplierID) ([]domain.PurchaseOrder, error) {
    // Returns an empty result — safe default until the adapter is upgraded.
    return nil, nil
}

// Package app — deprecating a port method with a no-op default adapter.
// The method stays in the interface during the deprecation window; the adapter no-ops it.
package app
 
import "context"
 
// EventPublisherV2 adds PublishBatch and deprecates Publish.
// Callers should migrate to PublishBatch during the deprecation window.
type EventPublisherV2 interface {
    // Publish is DEPRECATED. Use PublishBatch with a single-element slice instead.
    // Will be removed in the next major version after all callers migrate.
    Publish(ctx context.Context, event DomainEvent) error
    // PublishBatch delivers multiple events in a single operation.
    // More efficient than calling Publish in a loop; supports atomic delivery.
    PublishBatch(ctx context.Context, events []DomainEvent) error
}
 
// NoOpPublish is a default implementation of the deprecated Publish method.
// Adapters can embed this struct to satisfy the interface while migrating.
type NoOpPublish struct{}
 
// Publish does nothing — callers must migrate to PublishBatch.
// Logs a deprecation warning in development; silent in production.
func (NoOpPublish) Publish(_ context.Context, _ DomainEvent) error {
    // No-op: this method is deprecated; the adapter will remove it after migration.
    return nil
}

// Package app — interface segregation: split PurchaseOrderRepository into two.
// Existing adapters satisfy both; new adapters satisfy only the side they need.
package app
 
import (
    "context"
    "procurement/purchasing/domain"
)
 
// PurchaseOrderWriter is the command-side segregated port.
// Contains only the methods that modify purchase order state.
type PurchaseOrderWriter interface {
    // Save persists a new or updated aggregate.
    Save(ctx context.Context, po domain.PurchaseOrder) error
    // FindByID retrieves an aggregate for optimistic-lock checks before save.
    FindByID(ctx context.Context, id domain.PurchaseOrderID) (domain.PurchaseOrder, error)
}
 
// PurchaseOrderReader is the query-side segregated port.
// Contains only the methods that read state without modifying it.
type PurchaseOrderReader interface {
    // FindByStatus returns summaries filtered by the given status.
    FindByStatus(ctx context.Context, status domain.POStatus, page, pageSize int) ([]PurchaseOrderSummary, error)
    // CountByStatus returns the total record count for pagination metadata.
    CountByStatus(ctx context.Context, status domain.POStatus) (int, error)
}
 
// PurchaseOrderRepository composes both ports for adapters that implement everything.
// The in-memory and Postgres adapters both implement PurchaseOrderRepository.
// Services use the narrower Writer or Reader — not this combined interface.
type PurchaseOrderRepository interface {
    PurchaseOrderWriter
    PurchaseOrderReader
}

// Package app defines the SupplierNotifierPort for the supplier context.
// Notification channel (email, SMS, push) is an infrastructure concern isolated here.
package app
 
import (
    "context"
    "procurement/supplier/domain"
)
 
// SupplierNotifierPort sends notifications to suppliers about status changes.
// Concrete adapters: NoOp (tests), Email, SMS, Push (production).
type SupplierNotifierPort interface {
    // NotifyApproved sends a notification when a supplier is approved.
    // The adapter decides whether to send email, SMS, or both.
    NotifyApproved(ctx context.Context, s domain.Supplier) error
    // NotifyRejected sends a notification when a supplier is rejected.
    // Includes the rejection reason if the adapter supports it.
    NotifyRejected(ctx context.Context, s domain.Supplier, reason string) error
}
 
// NoOpSupplierNotifier satisfies SupplierNotifierPort without sending real messages.
// Used in unit tests to prevent real notifications during test runs.
type NoOpSupplierNotifier struct{}
 
// NotifyApproved does nothing — no real notification is sent.
func (NoOpSupplierNotifier) NotifyApproved(_ context.Context, _ domain.Supplier) error {
    return nil // No-op: safe to call in tests without email server.
}
 
// NotifyRejected does nothing — no real notification is sent.
func (NoOpSupplierNotifier) NotifyRejected(_ context.Context, _ domain.Supplier, _ string) error {
    return nil // No-op: safe to call in tests without SMS gateway.
}
 
// Compile-time assertion: NoOpSupplierNotifier must satisfy SupplierNotifierPort.
var _ SupplierNotifierPort = NoOpSupplierNotifier{}

// Package nats provides an EventPublisher adapter backed by NATS JetStream.
// The domain's PurchaseOrderIssuedEvent is serialised here — not in the domain.
package nats
 
import (
    "context"
    "encoding/json"
    "fmt"
    natsgo "github.com/nats-io/nats.go"
    "procurement/purchasing/app"
)
 
// NATSEventPublisher wraps a NATS JetStream connection behind the EventPublisher port.
// The domain package has zero knowledge of NATS — only this adapter imports the client.
type NATSEventPublisher struct {
    // js is the JetStream context used for durable, acknowledged publishing.
    js natsgo.JetStreamContext
}
 
// NewNATSEventPublisher constructs the adapter given an open JetStream context.
func NewNATSEventPublisher(js natsgo.JetStreamContext) *NATSEventPublisher {
    return &NATSEventPublisher{js: js}
}
 
// Publish serialises the domain event to JSON and publishes it to NATS JetStream.
// The subject is derived from EventType() — e.g., "PurchaseOrderIssued".
func (p *NATSEventPublisher) Publish(_ context.Context, event app.DomainEvent) error {
    // Serialise the domain event to JSON; domain never knows JSON is used here.
    payload, err := json.Marshal(event)
    if err != nil {
        return fmt.Errorf("serialise event: %w", err)
    }
    // Derive the NATS subject from the event type — routing is adapter responsibility.
    subject := "procurement." + event.EventType()
    // Publish with acknowledgement; JetStream retries on transient network failures.
    _, err = p.js.Publish(subject, payload)
    return err
}
 
// Compile-time assertion: *NATSEventPublisher must satisfy app.EventPublisher.
var _ app.EventPublisher = (*NATSEventPublisher)(nil)

// Package app_test — table-driven unit tests for IssuePurchaseOrderCommandService.
// All tests use in-memory adapters; zero Docker, zero network, zero filesystem.
package app_test
 
import (
    "context"
    "testing"
    "procurement/purchasing/app"
    purchasingMem "procurement/purchasing/adapter/out/mem"
    supplierMem   "procurement/supplier/adapter/out/mem"
    supplierDomain "procurement/supplier/domain"
)
 
// issueTestCase describes a single scenario for the table-driven test.
type issueTestCase struct {
    name           string
    supplierStatus supplierDomain.SupplierStatus
    // wantErr is the expected error; nil means the command should succeed.
    wantErr        error
}
 
// TestIssuePurchaseOrderCommandService_Issue covers the main eligibility paths.
func TestIssuePurchaseOrderCommandService_Issue(t *testing.T) {
    // Table of test cases: one row per eligibility scenario.
    cases := []issueTestCase{
        {name: "approved supplier succeeds", supplierStatus: supplierDomain.SupplierApproved, wantErr: nil},
        {name: "pending supplier rejected",  supplierStatus: supplierDomain.SupplierPending,  wantErr: app.ErrSupplierNotApproved},
        {name: "rejected supplier blocked",  supplierStatus: supplierDomain.SupplierRejected, wantErr: app.ErrSupplierNotApproved},
    }
    for _, tc := range cases {
        // t.Run isolates each case; a failing case does not stop subsequent ones.
        t.Run(tc.name, func(t *testing.T) {
            // Arrange — seed supplier with the test case's status.
            supRepo := supplierMem.NewSupplierRepo()
            _ = supRepo.Save(context.Background(), supplierDomain.Supplier{
                ID:     "S-001",
                Name:   "ACME",
                Status: tc.supplierStatus,
            })
            // Wire service with in-memory adapters for this sub-test.
            svc := app.NewIssuePurchaseOrderCommandService(
                purchasingMem.NewPurchaseOrderRepo(),
                supRepo,
                app.FixedClock{},
                &app.InMemoryEventPublisher{},
            )
            // Act — attempt to issue a PO against the seeded supplier.
            _, err := svc.Issue(context.Background(), app.IssueCommand{
                SupplierID: "S-001",
                Items:      []app.LineItem{{SKU: "X", Quantity: 1}},
            })
            // Assert — compare actual error to expected.
            if err != tc.wantErr {
                t.Errorf("[%s] expected %v, got %v", tc.name, tc.wantErr, err)
            }
        })
    }
}