fe

Documentation

Overview

Package fe mounts the Githome web front: the human-facing, server-rendered HTML surface that sits beside the REST and GraphQL APIs in the same binary. It owns no domain logic. It resolves data through the domain services, builds view models with fe/view, and renders them with fe/render; its middleware live in fe/webmw and its URL rules in fe/route. The front never calls the public API over HTTP: it shares the process and the domain layer directly. See implementation/00 and implementation/02.

Index

• func Mount(root *mizu.Router, d Deps) http.Handler
• type AuthPwStore
• type Deps

Functions

func Mount

func Mount(root *mizu.Router, d Deps) http.Handler

Mount registers the web front's dynamic routes on root and returns the servable handler: the asset tree peeled off in front of root. It does not touch the global middleware or the error handler the API surface installed: it registers its routes through scoped subrouters, so the web middleware chain applies to web routes only and the API keeps its own. The page chain carries recovery, the session, the color mode, the CSRF guard and the flash reader; the asset chain carries only recovery, so a static file does not pay for a session lookup.

The returned handler, not root, is what the server must serve when the web front is enabled. The static asset tree cannot share root's net/http mux: it is served under a greedy /assets/{file...} pattern, and that overlaps the front's own /{owner}/{repo}/... wildcards (an owner could be named "assets") in a way the Go 1.22 mux refuses to register. So assets live on their own router and are dispatched ahead of root by path prefix. See implementation/02.

Types

type AuthPwStore

type AuthPwStore interface {
	PasswordHashFor(ctx context.Context, login string) (pk int64, hash string, err error)
	InsertUserWithPassword(ctx context.Context, login, email, hash string) (int64, error)
	UserLoginExists(ctx context.Context, login string) (bool, error)
}

AuthPwStore is the narrow password-auth interface the auth handlers need. The concrete *store.Store satisfies it; cmd/githome passes the store directly since it already imports store. fe/mount never imports store directly (doc 01 §6).

type Deps

type Deps struct {
	Render        *render.Set
	View          *view.Builder
	Auth          AuthPwStore
	OAuthSvc      webauth.OAuthService
	Tokens        websettings.TokenService
	Repos         *domain.RepoService
	Hooks         *domain.HookService
	Checks        *domain.ChecksService
	Issues        *domain.IssueService
	Pulls         *domain.PRService
	Reviews       *domain.ReviewService
	Search        *domain.SearchService
	Users         *domain.UserService
	Events        *domain.EventService
	Social        *domain.SocialService
	Notifications *domain.NotificationService
	URLs          *presenter.URLBuilder
	Markup        *markup.Renderer
	Sessions      *webmw.Sessions
	CSRF          *webmw.CSRF
	Flash         *webmw.Flash
	Logger        *slog.Logger
	HomeHandler   mizu.Handler // optional: overrides the default landing page
}

Deps are the web front's dependencies. F0 needs the render set, the view builder, and the three stateful middleware (session, CSRF, flash) plus a logger. F1 adds the domain repo service and the presenter URL builder its code-browsing handlers read; a zero service leaves its routes unmounted, mirroring how the REST surface mounts. F2 adds the shared markup renderer the README and Markdown blob views render through; a nil renderer falls back to the escaped-source view, so the front still serves with markup unconfigured. Auth (added F1) is the password store the sign-in/join routes need; nil leaves those routes unmounted. HomeHandler overrides the default landing page; browse mode uses it to redirect straight to the repository root.