Routing

// Package route holds the route types of the shop slice. A route
// package holds only route types.
package route

import "github.com/alternayte/gx"

// Index is the list of products. Sort and Page come from the query.
type Index struct {
	gx.Route `GET /shop`
	Sort     string `query:"sort" default:"name"`
	Page     int    `query:"page" default:"1"`
}

// Package shop is the shop slice: its pages, actions and views.
package shop

import (
	"github.com/alternayte/gx"
	"acme/shop/route"
)

// IndexPage is the list of products.
var IndexPage = gx.Page(func(c *gx.Ctx, in route.Index) (IndexViewProps, error) {
	if in.Page < 1 {
		return IndexViewProps{}, gx.NotFound()
	}
	return IndexViewProps{Sort: in.Sort, Page: in.Page}, nil
}, IndexView)

// Routes lists every page, action and form of the slice.
var Routes = gx.Collect(IndexPage)

package shop

import "acme/shop/route"

props {
  // Sort is the sort key.
  Sort string
  // Page is the page number.
  Page int
}

<gx.Head title="Shop" />
<nav class="flex gap-3 text-sm">
  <a href={route.Index{}}>By name</a>
  <a href={route.Index{Sort: "price"}}>By price</a>
  <a href={route.Index{Sort: "price", Page: 2}}>Page 2</a>
</nav>
<p class="mt-4">Sorted by {p.Sort}, page {p.Page}.</p>

Sorted by price, page 1.
href="/shop?sort=price"
href="/shop"

// Command app serves the acme app.
package main

import (
	"log"
	"net/http"
	"os"

	"github.com/alternayte/gx"
	"github.com/alternayte/gx/adapters/datastar"
	"acme/app"
	"acme/gxstyles"
	"acme/home"
	"acme/shop"
)

// noStore is plain net/http middleware.
func noStore(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Cache-Control", "no-store")
		next.ServeHTTP(w, r)
	})
}

func main() {
	setupGallery()
	gx.SetStylesheet(gxstyles.CSS())
	server := gx.New(gx.Config{Adapter: datastar.Adapter()})
	server.Group("/", app.Layout, gx.Nav(gx.MorphNavigation), noStore, home.Routes, shop.Routes)

	addr := os.Getenv("GX_DEV_ADDR")
	if addr == "" {
		addr = "127.0.0.1:8080"
	}
	log.Printf("acme listens on http://%s", addr)
	log.Fatal(http.ListenAndServe(addr, server))
}

// Package app holds the layout and the theme of the app.
package app

import "github.com/alternayte/gx"

// Layout wraps every page in the shell. The loader gets the name of the
// reader.
var Layout = gx.Layout(func(c *gx.Ctx) (string, error) {
	return gx.Once(c, func() (string, error) { return "Ada", nil })
}, func(user string, children gx.Node) gx.Node {
	return Shell(ShellProps{User: user, Children: children})
})

package app

import (
  homeroute "acme/home/route"
  shoproute "acme/shop/route"
)

props {
  // User is the name of the reader.
  User string
  // Children is the page.
  Children gx.Node
}

<gx.Head title="Acme" bodyClass="bg-background text-foreground" />
<header class="border-b border-border">
  <nav class="mx-auto flex max-w-3xl items-center gap-4 p-4 text-sm">
    <a href={homeroute.Home{}} class="font-semibold">Acme</a>
    <a href={shoproute.Index{}} active="section">Shop</a>
    <span class="ml-auto text-muted-foreground">{p.User}</span>
  </nav>
</header>
<main class="mx-auto max-w-3xl p-4">{p.Children}</main>

<title>Shop</title>
Ada
data-active

// Package legacy shows Gx inside handlers that do not use gx.App.
package legacy

import (
	"net/http"

	"github.com/alternayte/gx"
	"acme/shop"
	"acme/shop/route"
)

// Banner renders one component in a plain handler (level 1).
func Banner(w http.ResponseWriter, r *http.Request) {
	_ = gx.Render(w, r, shop.IndexView(shop.IndexViewProps{Sort: "name", Page: 1}))
}

// Mount adds one Gx page to a standard mux (level 2).
func Mount(mux *http.ServeMux) {
	mux.Handle(route.Index{}.Pattern(), shop.IndexPage)
}