《后端架构设计·演进与治理》1.2 拆分粒度：业务能力、数据所有权与变更频率

I = Ce / (Ca + Ce)

// file: internal/platform/split/graph.go
// tier: L1
// verify: go test ./internal/platform/split/ -count=1
package split

import (
	"fmt"
	"sort"
)

// Edge is one dependency direction between modules.
type Edge struct{ From, To string }

// Module describes one candidate module. Owns lists tables it writes;
// DependsOn lists modules it calls.
type Module struct {
	Name       string
	Capability string
	Owns       []string
	DependsOn  []string
}

// Graph is an immutable module dependency graph.
type Graph struct {
	modules map[string]Module
	names   []string
}

// NewGraph validates names, capabilities and dependency targets.
func NewGraph(modules []Module) (*Graph, error) {
	g := &Graph{modules: make(map[string]Module, len(modules))}
	for _, m := range modules {
		if m.Name == "" || m.Capability == "" {
			return nil, fmt.Errorf("split: module name and capability are required")
		}
		if _, ok := g.modules[m.Name]; ok {
			return nil, fmt.Errorf("split: duplicate module %q", m.Name)
		}
		g.modules[m.Name] = m
		g.names = append(g.names, m.Name)
	}
	for _, m := range modules {
		for _, dep := range m.DependsOn {
			if dep == m.Name {
				return nil, fmt.Errorf("split: module %q depends on itself", m.Name)
			}
			if _, ok := g.modules[dep]; !ok {
				return nil, fmt.Errorf("split: module %q depends on unknown %q", m.Name, dep)
			}
		}
	}
	sort.Strings(g.names)
	return g, nil
}

func unique(items []string) []string {
	seen := make(map[string]bool, len(items))
	out := make([]string, 0, len(items))
	for _, item := range items {
		if !seen[item] {
			seen[item] = true
			out = append(out, item)
		}
	}
	sort.Strings(out)
	return out
}

// Metrics is Martin's coupling pair and instability I = Ce/(Ca+Ce).
type Metrics struct {
	Ca, Ce      int
	Instability float64
}

// Metrics computes afferent and efferent coupling for one module.
func (g *Graph) Metrics(name string) (Metrics, error) {
	m, ok := g.modules[name]
	if !ok {
		return Metrics{}, fmt.Errorf("split: unknown module %q", name)
	}
	ce := len(unique(m.DependsOn))
	ca := 0
	for _, other := range g.names {
		if other == name {
			continue
		}
		for _, dep := range unique(g.modules[other].DependsOn) {
			if dep == name {
				ca++
				break
			}
		}
	}
	instability := 0.0
	if ca+ce > 0 {
		instability = float64(ce) / float64(ca+ce)
	}
	return Metrics{Ca: ca, Ce: ce, Instability: instability}, nil
}

// MaxCrossEdges is the budget above which every extra edge needs a contract
// test; it is a review trigger, not a hard architectural law.
const MaxCrossEdges = 3

// Verdict is the boundary decision.
type Verdict string

const (
	Accept Verdict = "accept"
	Revise Verdict = "revise"
	Reject Verdict = "reject"
)

// BoundaryReport explains whether one partition is a service boundary.
type BoundaryReport struct {
	CrossEdges        []Edge
	CrossEdgeShare    float64
	SharedTables      []string
	SplitCapabilities []string
	Bidirectional     bool
	Verdict           Verdict
}

func bothSides(sides map[string][2]bool) []string {
	var out []string
	for name, flags := range sides {
		if flags[0] && flags[1] {
			out = append(out, name)
		}
	}
	sort.Strings(out)
	return out
}

// EvaluateBoundary checks a complete two-way partition against capability
// cohesion, data ownership and the cross-edge budget.
func (g *Graph) EvaluateBoundary(left, right []string) (BoundaryReport, error) {
	side := make(map[string]int, len(g.names))
	for _, name := range left {
		if _, ok := g.modules[name]; !ok {
			return BoundaryReport{}, fmt.Errorf("split: unknown module %q on left", name)
		}
		if side[name] != 0 {
			return BoundaryReport{}, fmt.Errorf("split: module %q appears twice or on both sides", name)
		}
		side[name] = -1
	}
	for _, name := range right {
		if _, ok := g.modules[name]; !ok {
			return BoundaryReport{}, fmt.Errorf("split: unknown module %q on right", name)
		}
		if side[name] != 0 {
			return BoundaryReport{}, fmt.Errorf("split: module %q appears twice or on both sides", name)
		}
		side[name] = 1
	}
	if len(side) != len(g.names) {
		return BoundaryReport{}, fmt.Errorf("split: partition covers %d of %d modules", len(side), len(g.names))
	}
	report := BoundaryReport{}
	edges := make(map[string]bool)
	total := 0
	tableSides := make(map[string][2]bool)
	capabilitySides := make(map[string][2]bool)
	for _, from := range g.names {
		index := 0
		if side[from] > 0 {
			index = 1
		}
		for _, table := range g.modules[from].Owns {
			flags := tableSides[table]
			flags[index] = true
			tableSides[table] = flags
		}
		flags := capabilitySides[g.modules[from].Capability]
		flags[index] = true
		capabilitySides[g.modules[from].Capability] = flags
		for _, to := range unique(g.modules[from].DependsOn) {
			total++
			edges[from+"\x00"+to] = true
			if side[from] != side[to] {
				report.CrossEdges = append(report.CrossEdges, Edge{From: from, To: to})
			}
		}
	}
	sort.Slice(report.CrossEdges, func(i, j int) bool {
		if report.CrossEdges[i].From != report.CrossEdges[j].From {
			return report.CrossEdges[i].From < report.CrossEdges[j].From
		}
		return report.CrossEdges[i].To < report.CrossEdges[j].To
	})
	if total > 0 {
		report.CrossEdgeShare = float64(len(report.CrossEdges)) / float64(total)
	}
	report.SharedTables = bothSides(tableSides)
	report.SplitCapabilities = bothSides(capabilitySides)
	for _, edge := range report.CrossEdges {
		if edges[edge.To+"\x00"+edge.From] {
			report.Bidirectional = true
			break
		}
	}
	switch {
	case len(report.SharedTables) > 0 || report.Bidirectional:
		report.Verdict = Reject
	case len(report.SplitCapabilities) > 0 || len(report.CrossEdges) > MaxCrossEdges:
		report.Verdict = Revise
	default:
		report.Verdict = Accept
	}
	return report, nil
}

// file: internal/platform/split/graph_test.go
// tier: L1
// verify: go test ./internal/platform/split/ -count=1
package split

import "testing"

func archLabGraph(t *testing.T) *Graph {
	t.Helper()
	g, err := NewGraph([]Module{
		{Name: "order-api", Capability: "order", Owns: []string{"orders"}, DependsOn: []string{"order-worker", "inventory", "payment"}},
		{Name: "order-worker", Capability: "order", Owns: []string{"order_events"}, DependsOn: []string{"inventory"}},
		{Name: "inventory", Capability: "inventory", Owns: []string{"stock"}},
		{Name: "payment", Capability: "payment", Owns: []string{"payments"}},
		{Name: "notify", Capability: "notification", Owns: []string{"notifications"}, DependsOn: []string{"order-worker"}},
	})
	if err != nil {
		t.Fatalf("NewGraph: %v", err)
	}
	return g
}

func TestEvaluateBoundary(t *testing.T) {
	g := archLabGraph(t)
	wide, err := g.EvaluateBoundary(
		[]string{"order-api", "order-worker"},
		[]string{"inventory", "payment", "notify"},
	)
	if err != nil {
		t.Fatalf("EvaluateBoundary: %v", err)
	}
	t.Logf("wide: verdict=%s cross=%d share=%.2f", wide.Verdict, len(wide.CrossEdges), wide.CrossEdgeShare)
	if wide.Verdict != Revise || len(wide.CrossEdges) != 4 {
		t.Fatalf("wide: verdict=%s cross=%d, want revise/4", wide.Verdict, len(wide.CrossEdges))
	}
	narrow, err := g.EvaluateBoundary(
		[]string{"order-api", "order-worker", "payment"},
		[]string{"inventory", "notify"},
	)
	if err != nil {
		t.Fatalf("EvaluateBoundary: %v", err)
	}
	t.Logf("narrow: verdict=%s cross=%d share=%.2f", narrow.Verdict, len(narrow.CrossEdges), narrow.CrossEdgeShare)
	if narrow.Verdict != Accept || len(narrow.CrossEdges) != 3 {
		t.Fatalf("narrow: verdict=%s cross=%d, want accept/3", narrow.Verdict, len(narrow.CrossEdges))
	}
}

$ cd .local/checks/be-arch-gov-ch01
$ gofmt -l .
$ go vet ./...
$ go test ./internal/platform/split/ -run '^(TestInstability|TestEvaluateBoundary|TestBoundaryRejections|TestNewGraphValidation)$' -count=1 -v
=== RUN   TestInstability
    graph_test.go:42: module=order-api Ca=0 Ce=3 I=1.000
    graph_test.go:42: module=order-worker Ca=2 Ce=1 I=0.333
    graph_test.go:42: module=inventory Ca=2 Ce=0 I=0.000
    graph_test.go:42: module=payment Ca=1 Ce=0 I=0.000
    graph_test.go:42: module=notify Ca=0 Ce=1 I=1.000
--- PASS: TestInstability (0.00s)
=== RUN   TestEvaluateBoundary
    graph_test.go:58: wide: verdict=revise cross=4 share=0.80
    graph_test.go:69: narrow: verdict=accept cross=3 share=0.60
--- PASS: TestEvaluateBoundary (0.00s)
=== RUN   TestBoundaryRejections
=== RUN   TestBoundaryRejections/shared_table
    graph_test.go:105: verdict=reject tables=[orders] capabilities=[] bidir=false
=== RUN   TestBoundaryRejections/split_capability
    graph_test.go:105: verdict=revise tables=[] capabilities=[order] bidir=false
=== RUN   TestBoundaryRejections/bidirectional
    graph_test.go:105: verdict=reject tables=[] capabilities=[] bidir=true
--- PASS: TestBoundaryRejections (0.00s)
    --- PASS: TestBoundaryRejections/shared_table (0.00s)
    --- PASS: TestBoundaryRejections/split_capability (0.00s)
    --- PASS: TestBoundaryRejections/bidirectional (0.00s)
=== RUN   TestNewGraphValidation
=== RUN   TestNewGraphValidation/duplicate
=== RUN   TestNewGraphValidation/unknown_dep
=== RUN   TestNewGraphValidation/self_dep
=== RUN   TestNewGraphValidation/empty_capability
--- PASS: TestNewGraphValidation (0.00s)
    --- PASS: TestNewGraphValidation/duplicate (0.00s)
    --- PASS: TestNewGraphValidation/unknown_dep (0.00s)
    --- PASS: TestNewGraphValidation/self_dep (0.00s)
    --- PASS: TestNewGraphValidation/empty_capability (0.00s)
PASS
ok  	archlab/internal/platform/split	0.243s