add fixture-invoicing example, sample-room wrap, kind cluster support

- examples/fixture-invoicing/: FastAPI + Vue + Postgres demo (4-entity invoice fixture)
- cfg/sample/: wraps the fixture (managed.repos points at examples/)
- ctrl/kind-{up,down,status}.sh + per-room k8s render in soleprint/ctrl/k8s/
- build.py: relative repo paths, resilient rmtree, optional k8s render hook
- cfg/.gitignore: stop ignoring sample/ and standalone/ template rooms

Manifests render cleanly but kind cluster has not been run end-to-end yet.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

examples/fixture-invoicing/backend/api/customers.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from db import get_session
+from models import Customer
+from schemas import CustomerIn, CustomerOut
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[CustomerOut])
+def list_customers(session: Session = Depends(get_session)):
+    return session.query(Customer).order_by(Customer.id).all()
+
+
+@router.post("", response_model=CustomerOut, status_code=201)
+def create_customer(payload: CustomerIn, session: Session = Depends(get_session)):
+    customer = Customer(**payload.model_dump())
+    session.add(customer)
+    session.commit()
+    session.refresh(customer)
+    return customer
+
+
+@router.get("/{customer_id}", response_model=CustomerOut)
+def get_customer(customer_id: int, session: Session = Depends(get_session)):
+    customer = session.get(Customer, customer_id)
+    if not customer:
+        raise HTTPException(404, "customer not found")
+    return customer
+
+
+@router.put("/{customer_id}", response_model=CustomerOut)
+def update_customer(
+    customer_id: int, payload: CustomerIn, session: Session = Depends(get_session)
+):
+    customer = session.get(Customer, customer_id)
+    if not customer:
+        raise HTTPException(404, "customer not found")
+    for k, v in payload.model_dump().items():
+        setattr(customer, k, v)
+    session.commit()
+    session.refresh(customer)
+    return customer
+
+
+@router.delete("/{customer_id}", status_code=204)
+def delete_customer(customer_id: int, session: Session = Depends(get_session)):
+    customer = session.get(Customer, customer_id)
+    if not customer:
+        raise HTTPException(404, "customer not found")
+    session.delete(customer)
+    session.commit()

examples/fixture-invoicing/backend/api/invoices.py

@@ -0,0 +1,71 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session, joinedload
+
+from db import get_session
+from models import Invoice
+from schemas import InvoiceDetail, InvoiceIn, InvoiceOut
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[InvoiceOut])
+def list_invoices(
+    status: str | None = None,
+    customer_id: int | None = None,
+    session: Session = Depends(get_session),
+):
+    query = session.query(Invoice).order_by(Invoice.issued_at.desc())
+    if status:
+        query = query.filter(Invoice.status == status)
+    if customer_id:
+        query = query.filter(Invoice.customer_id == customer_id)
+    return query.all()
+
+
+@router.post("", response_model=InvoiceOut, status_code=201)
+def create_invoice(payload: InvoiceIn, session: Session = Depends(get_session)):
+    invoice = Invoice(**payload.model_dump())
+    session.add(invoice)
+    session.commit()
+    session.refresh(invoice)
+    return invoice
+
+
+@router.get("/{invoice_id}", response_model=InvoiceDetail)
+def get_invoice(invoice_id: int, session: Session = Depends(get_session)):
+    invoice = (
+        session.query(Invoice)
+        .options(
+            joinedload(Invoice.customer),
+            joinedload(Invoice.line_items),
+            joinedload(Invoice.payments),
+        )
+        .filter(Invoice.id == invoice_id)
+        .first()
+    )
+    if not invoice:
+        raise HTTPException(404, "invoice not found")
+    return invoice
+
+
+@router.put("/{invoice_id}", response_model=InvoiceOut)
+def update_invoice(
+    invoice_id: int, payload: InvoiceIn, session: Session = Depends(get_session)
+):
+    invoice = session.get(Invoice, invoice_id)
+    if not invoice:
+        raise HTTPException(404, "invoice not found")
+    for k, v in payload.model_dump().items():
+        setattr(invoice, k, v)
+    session.commit()
+    session.refresh(invoice)
+    return invoice
+
+
+@router.delete("/{invoice_id}", status_code=204)
+def delete_invoice(invoice_id: int, session: Session = Depends(get_session)):
+    invoice = session.get(Invoice, invoice_id)
+    if not invoice:
+        raise HTTPException(404, "invoice not found")
+    session.delete(invoice)
+    session.commit()

examples/fixture-invoicing/backend/api/line_items.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from db import get_session
+from models import Invoice, LineItem
+from schemas import LineItemIn, LineItemOut
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[LineItemOut])
+def list_line_items(
+    invoice_id: int | None = None, session: Session = Depends(get_session)
+):
+    query = session.query(LineItem).order_by(LineItem.id)
+    if invoice_id:
+        query = query.filter(LineItem.invoice_id == invoice_id)
+    return query.all()
+
+
+@router.post("/invoices/{invoice_id}", response_model=LineItemOut, status_code=201)
+def add_line_item(
+    invoice_id: int, payload: LineItemIn, session: Session = Depends(get_session)
+):
+    if not session.get(Invoice, invoice_id):
+        raise HTTPException(404, "invoice not found")
+    item = LineItem(invoice_id=invoice_id, **payload.model_dump())
+    session.add(item)
+    session.commit()
+    session.refresh(item)
+    return item
+
+
+@router.delete("/{line_item_id}", status_code=204)
+def delete_line_item(line_item_id: int, session: Session = Depends(get_session)):
+    item = session.get(LineItem, line_item_id)
+    if not item:
+        raise HTTPException(404, "line item not found")
+    session.delete(item)
+    session.commit()

examples/fixture-invoicing/backend/api/payments.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from db import get_session
+from models import Invoice, Payment
+from schemas import PaymentIn, PaymentOut
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[PaymentOut])
+def list_payments(
+    invoice_id: int | None = None, session: Session = Depends(get_session)
+):
+    query = session.query(Payment).order_by(Payment.paid_at.desc())
+    if invoice_id:
+        query = query.filter(Payment.invoice_id == invoice_id)
+    return query.all()
+
+
+@router.post("/invoices/{invoice_id}", response_model=PaymentOut, status_code=201)
+def record_payment(
+    invoice_id: int, payload: PaymentIn, session: Session = Depends(get_session)
+):
+    invoice = session.get(Invoice, invoice_id)
+    if not invoice:
+        raise HTTPException(404, "invoice not found")
+    payment = Payment(invoice_id=invoice_id, **payload.model_dump())
+    session.add(payment)
+
+    total_paid = sum(
+        (p.amount for p in invoice.payments), start=payment.amount
+    )
+    total_owed = sum((li.unit_price * li.quantity for li in invoice.line_items), start=0)
+    if total_owed > 0 and total_paid >= total_owed:
+        invoice.status = "paid"
+
+    session.commit()
+    session.refresh(payment)
+    return payment
+
+
+@router.delete("/{payment_id}", status_code=204)
+def delete_payment(payment_id: int, session: Session = Depends(get_session)):
+    payment = session.get(Payment, payment_id)
+    if not payment:
+        raise HTTPException(404, "payment not found")
+    session.delete(payment)
+    session.commit()