LINUS ROUND 1: Delete dead code (rust/c), generic Store[T], tests, slim main.go

- Removed rust-service/, c-runtime/, kafka stubs
- Generic Store[T] pattern with real tests
- Slimmed main.go from 324 to ~50 lines
- Added config, middleware, store, ledger, pdf tests
- Frontend SPA shell with router
- Binary: 15.5MB -> 12MB

backend/ledger/client.go

@@ -0,0 +1,106 @@
+// Package ledger provides a client for aamos-ledger integration.
+// One proxy method, not six copies. Linus-style.
+package ledger
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"time"
+)
+
+var baseURL = getEnv("LEDGER_URL", "http://localhost:3250")
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}
+
+// Client handles communication with aamos-ledger
+type Client struct {
+	baseURL string
+	client  *http.Client
+}
+
+// NewClient creates a new ledger client
+func NewClient() *Client {
+	return &Client{
+		baseURL: baseURL,
+		client:  &http.Client{Timeout: 10 * time.Second},
+	}
+}
+
+// Get proxies a GET request to the ledger and returns the JSON response.
+// This replaces 6 identical methods with one.
+func (c *Client) Get(ctx context.Context, path string) (map[string]interface{}, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("ledger unavailable: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("ledger error: status %d", resp.StatusCode)
+	}
+
+	var result map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("decode error: %w", err)
+	}
+
+	return result, nil
+}
+
+// Handler wraps the client for HTTP handlers
+type Handler struct {
+	client *Client
+}
+
+// NewHandler creates a new ledger HTTP handler
+func NewHandler() *Handler {
+	return &Handler{client: NewClient()}
+}
+
+// Proxy handles any ledger endpoint with a single method
+func (h *Handler) Proxy(w http.ResponseWriter, r *http.Request, ledgerPath string) {
+	result, err := h.client.Get(r.Context(), ledgerPath)
+	if err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusServiceUnavailable)
+		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(result)
+}
+
+// Convenience methods that use Proxy internally
+func (h *Handler) GetBalanceSheet(w http.ResponseWriter, r *http.Request) {
+	h.Proxy(w, r, "/api/ledger/reports/balance")
+}
+
+func (h *Handler) GetIncomeStatement(w http.ResponseWriter, r *http.Request) {
+	h.Proxy(w, r, "/api/ledger/reports/income")
+}
+
+func (h *Handler) GetMomsReport(w http.ResponseWriter, r *http.Request) {
+	h.Proxy(w, r, "/api/ledger/tax/moms")
+}
+
+func (h *Handler) GetAccounts(w http.ResponseWriter, r *http.Request) {
+	h.Proxy(w, r, "/api/ledger/accounts")
+}
+
+func (h *Handler) GetInvoices(w http.ResponseWriter, r *http.Request) {
+	h.Proxy(w, r, "/api/ledger/invoices")
+}

backend/ledger/client_test.go

@@ -0,0 +1,92 @@
+package ledger
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_Get_Success(t *testing.T) {
+	expected := map[string]interface{}{"balance": 1000.0}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, "/api/ledger/reports/balance", r.URL.Path)
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(expected)
+	}))
+	defer server.Close()
+
+	client := &Client{baseURL: server.URL, client: &http.Client{}}
+	result, err := client.Get(context.Background(), "/api/ledger/reports/balance")
+
+	require.NoError(t, err)
+	assert.Equal(t, 1000.0, result["balance"])
+}
+
+func TestClient_Get_ServerError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer server.Close()
+
+	client := &Client{baseURL: server.URL, client: &http.Client{}}
+	_, err := client.Get(context.Background(), "/api/ledger/reports/balance")
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "ledger error")
+}
+
+func TestClient_Get_Unavailable(t *testing.T) {
+	client := &Client{baseURL: "http://localhost:1", client: &http.Client{}}
+	_, err := client.Get(context.Background(), "/api/ledger/reports/balance")
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unavailable")
+}
+
+func TestHandler_Proxy(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	}))
+	defer server.Close()
+
+	h := &Handler{client: &Client{baseURL: server.URL, client: &http.Client{}}}
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/finance/balance", nil)
+	rr := httptest.NewRecorder()
+
+	h.Proxy(rr, req, "/api/ledger/reports/balance")
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var result map[string]string
+	err := json.Unmarshal(rr.Body.Bytes(), &result)
+	require.NoError(t, err)
+	assert.Equal(t, "ok", result["status"])
+}
+
+func TestHandler_GetBalanceSheet(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, "/api/ledger/reports/balance", r.URL.Path)
+		json.NewEncoder(w).Encode(map[string]int{"total": 5000})
+	}))
+	defer server.Close()
+
+	h := &Handler{client: &Client{baseURL: server.URL, client: &http.Client{}}}
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/finance/balance", nil)
+	rr := httptest.NewRecorder()
+
+	h.GetBalanceSheet(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var result map[string]int
+	err := json.Unmarshal(rr.Body.Bytes(), &result)
+	require.NoError(t, err)
+	assert.Equal(t, 5000, result["total"])
+}