Xun

https://github.com/yaitoo/xun
Admin
Xun is a lightweight, fast, and easy-to-use web framework for Go, built on its native...
Tokens:19,250
Snippets:97
Trust Score:4.8
License:Apache-2.0
Update:11 months ago
Show doc for...
Tokens:
Raw
### Minimal Production-Ready Xun Example

Source: https://github.com/yaitoo/xun/blob/main/AGENTS.md

This Go code snippet demonstrates how to set up a minimal, production-ready Xun application. It includes options for development mode with hot reloading and a production mode using embedded file system. It also configures a basic GET route and starts the HTTP server.

```go
//go:embed app
var fsys embed.FS
func main(){
  var dev bool
  flag.BoolVar(&dev, "dev", false, "dev")
  flag.Parse()
  var opts []xun.Option
  if dev { opts = []xun.Option{xun.WithFsys(os.DirFS("./app")), xun.WithWatch()} } 
  else { v, _ := fs.Sub(fsys, "app"); opts = []xun.Option{xun.WithFsys(v)} }
  app := xun.New(opts..., xun.WithCompressor(&xun.GzipCompressor{}))
  app.Get("/{$}", func(c *xun.Context) error { return c.View(map[string]string{"hello":"xun"}) })
  app.Start(); defer app.Close()
  http.ListenAndServe(":80", http.DefaultServeMux)
}
```

--------------------------------

### Create and Start Xun App

Source: https://github.com/yaitoo/xun/blob/main/AGENTS.md

Initializes a new Xun application with specified configurations like middleware, file system, hot-reloading, and compression. It then starts the app and ensures it's closed gracefully using defer. The application listens for HTTP requests on port 80.

```go
app := xun.New(
  xun.WithMux(http.DefaultServeMux),
  xun.WithFsys(viewsFS),          // fs root of components/layouts/pages/views/public/text
  xun.WithWatch(),                // dev only
  xun.WithCompressor(&xun.GzipCompressor{}, &xun.DeflateCompressor{}),
)
app.Start()
def app.Close()
http.ListenAndServe(":80", http.DefaultServeMux)

```

--------------------------------

### Install Xun Web Framework (Go)

Source: https://github.com/yaitoo/xun/blob/main/README.md

Installs the Xun web framework using Go modules. Supports installation from the main branch or the latest release.

```go
go get github.com/yaitoo/xun@main
```

```go
go get github.com/yaitoo/xun@latest
```

--------------------------------

### Setup SSE Server with Go

Source: https://context7.com/yaitoo/xun/llms.txt

Implement a Server-Sent Events (SSE) server using the yaitoo/xun/ext/sse package for real-time push notifications. This setup includes creating an SSE server, handling client connections, sending messages to specific users, broadcasting messages to all clients, and managing server shutdown. It requires the `github.com/yaitoo/xun` and `github.com/yaitoo/xun/ext/sse` packages.

```go
package main

import (
	"context"
	"net/http"
	"time"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/sse"
)

func main() {
	app := xun.New()

	// Create SSE server
	sseServer := sse.New()

	// Start keep-alive goroutine
	go sseServer.KeepAlive(context.Background())

	// SSE endpoint
	app.Get("/events/{userID}", func(c *xun.Context) error {
		userID := c.Request.PathValue("userID")

		// Join SSE connection
		client, connID, isNew, err := sseServer.Join(userID, c.Response)
		if err != nil {
			c.WriteStatus(http.StatusBadRequest)
			return xun.ErrCancelled
		}

		// Send welcome message to new clients
		if isNew {
			client.Send(sse.TextEvent{
				Name: "welcome",
				Data: "Connected to event stream",
			})
		}

		// Wait for disconnect
		client.Wait()

		// Clean up
		sseServer.Leave(userID, connID)

		return nil
	})

	// Send message to specific user
	app.Post("/notify/{userID}", func(c *xun.Context) error {
		userID := c.Request.PathValue("userID")
		client := sseServer.Get(userID)

		if client == nil {
			c.WriteStatus(http.StatusNotFound)
			return c.View(map[string]string{"error": "user not connected"})
		}

		err := client.Send(sse.TextEvent{
			Name: "notification",
			Data: "You have a new message",
		})

		if err != nil {
			return err
		}

		return c.View(map[string]string{"status": "sent"})
	})

	// Broadcast to all connected users
	app.Post("/broadcast", func(c *xun.Context) error {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()

		errors, err := sseServer.Broadcast(ctx, sse.TextEvent{
			Name: "announcement",
			Data: "Server maintenance in 10 minutes",
		})

		if err != nil {
			return err
		}

		return c.View(map[string]any{
			"status": "broadcast complete",
			"errors": len(errors),
		})
	})

	// Shutdown endpoint
	app.Post("/shutdown", func(c *xun.Context) error {
		sseServer.Shutdown()
		return c.View(map[string]string{"status": "shutdown complete"})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}

```

--------------------------------

### Serve HTTP with Proxy Protocol in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet shows how to start an HTTP server that supports the PROXY protocol. It configures a new Xun application with a ServeMux, starts the app, and then uses proxyproto.ListenAndServe to serve traffic.

```go
	mux := http.NewServeMux()

	srv := &http.Server{
		Addr:    ":80",
		Handler: mux,
	}

	app := xun.New(WithMux(mux))
	app.Start()
	defer app.Close()

	//   srv.ListenAndServe()
	proxyproto.ListenAndServe(srv)

```

--------------------------------

### Bash: Install Tailwind CSS

Source: https://github.com/yaitoo/xun/blob/main/README.md

This bash script demonstrates the initial steps for installing Tailwind CSS. It uses npm to install the tailwindcss package as a development dependency and then generates the tailwind.config.js configuration file. These commands are essential prerequisites for setting up Tailwind CSS in a project.

```bash
npm install -D tailwindcss
npx tailwindcss init

```

--------------------------------

### ACL Configuration File

Source: https://github.com/yaitoo/xun/blob/main/README.md

An example INI-formatted configuration file for the ACL middleware in Xun. It demonstrates how to define rules for allowed/denied hosts, IP networks, countries, and host redirection settings.

```ini
[allow_hosts]
abc.com
www.abc.com
[allow_ipnets]
89.207.132.170/24
# ::1
; 127.0.0.1
[deny_ipnets]
*
[allow_countries]

[deny_countries]
us

[host_redirect]
url=http://yaitoo.cn
status_code=302
```

--------------------------------

### Serve HTTPS with Proxy Protocol and Auto TLS in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet illustrates how to configure and start an HTTPS server that supports the PROXY protocol and automatic TLS certificate management. It sets up autotls, configures both HTTP and HTTPS servers, and uses proxyproto.ListenAndServeTLS.

```go
	httpsServer := &http.Server{
		Addr:    ":443",
		Handler: mux,
	}

	autotls.New(autotls.WithCache(autocert.DirCache("./certs")),
		autotls.WithHosts("yaitoo.cn", "www.yaitoo.cn")),
		Configure(srv, httpsServer)

  // httpsServer.ListenAndServeTLS( ", ")
	proxyproto.ListenAndServeTLS(httpsServer, "", "")

```

--------------------------------

### Create Group with Middleware and Route

Source: https://github.com/yaitoo/xun/blob/main/AGENTS.md

Creates a new route group '/admin' and applies a global authentication middleware ('authMiddleware') to all routes within this group. A GET route is then defined at '/{$}' within the admin group, which will be handled by the 'handler' function after the middleware.

```go
admin := app.Group("/admin")
admin.Use(authMiddleware)
admin.Get("/{$}", handler)

```

--------------------------------

### Set and Get Cookie in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

These Go snippets show how to set, get, and delete cookies using the 'cookie' package. It covers basic cookie operations, URL encoding for values, and signed cookies with HMAC validation.

```go
cookie.Set(ctx,  http.Cookie{Name: "test", Value: "value"}) // Set-Cookie: test=dmFsdWU=

```

```go
v, err := cookie.Get(ctx,"test")

fmt.Println(v) // value

```

```go
ts, err := cookie.SetSigned(ctx,http.Cookie{Name: "test", Value: "value"},[]byte("secret")) // ts is current timestamp

v, ts, err := cookie.GetSigned(ctx, "test",[]byte("secret")) // v is value, ts is the timestamp that was signed

```

```go
cookie.Delete(ctx, http.Cookie{Name: "test", Value: "dmFsdWU="}) // Set-Cookie: test=; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0

```

--------------------------------

### Xun Go Context Operations for Request/Response Handling

Source: https://context7.com/yaitoo/xun/llms.txt

Illustrates how to use the Xun Context object to access request data such as path parameters and headers, and manipulate responses by setting status codes, writing headers, and rendering views. Includes examples for redirects and retrieving referer URLs.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
)

func main() {
	app := xun.New()

	app.Get("/profile", func(c *xun.Context) error {
		// Get path parameters
		id := c.Request.PathValue("id")

		// Get Accept header languages
		languages := c.AcceptLanguage()

		// Get Accept header MIME types
		acceptTypes := c.Accept()

		// Store temporary data in context
		c.Set("UserID", id)
		c.Set("Language", languages[0])

		// Retrieve data from context
		userID := c.Get("UserID").(string)

		// Write custom headers
		c.WriteHeader("X-User-ID", userID)
		c.WriteHeader("X-Request-ID", "req-123")

		// Set status code
		c.WriteStatus(http.StatusOK)

		// Render view with data
		return c.View(map[string]any{
			"ID":       userID,
			"Language": languages[0],
			"Accept":   acceptTypes[0].String(),
		})
	})

	// Redirect example
	app.Get("/old-path", func(c *xun.Context) error {
		c.Redirect("/new-path", http.StatusMovedPermanently)
		return xun.ErrCancelled
	})

	// Get referer
	app.Post("/submit", func(c *xun.Context) error {
		referer := c.RequestReferer()
		c.Set("RefererURL", referer)
		return c.View(map[string]string{"status": "success"})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}
```

--------------------------------

### Handle PROXY Protocol Headers with Go

Source: https://context7.com/yaitoo/xun/llms.txt

This Go code snippet demonstrates how to enable support for HAProxy PROXY protocol v1 and v2 within an HTTP server. It utilizes the `proxyproto` extension from the `github.com/yaitoo/xun/ext/proxyproto` package to preserve the real client IP address when behind a load balancer. The code configures a standard `http.Server` and then uses `proxyproto.ListenAndServe` to start it, ensuring that incoming requests are correctly parsed.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/proxyproto"
)

func main() {
	mux := http.NewServeMux()
	app := xun.New(xun.WithMux(mux))

	app.Get("/", func(c *xun.Context) error {
		// Real client IP is preserved through proxy
		clientIP := c.Request.RemoteAddr
		return c.View(map[string]string{
			"client_ip": clientIP,
			"status":    "ok",
		})
	})

	app.Start()
	defer app.Close()

	// HTTP server with PROXY protocol support
	httpServer := &http.Server{
		Addr:    ":80",
		Handler: mux,
	}

	// Use proxyproto.ListenAndServe instead of httpServer.ListenAndServe()
	proxyproto.ListenAndServe(httpServer)

	// For HTTPS with PROXY protocol
	// httpsServer := &http.Server{
	// 	Addr:    ":443",
	// 	Handler: mux,
	// }
	// proxyproto.ListenAndServeTLS(httpsServer, "cert.pem", "key.pem")
}

```

--------------------------------

### Define Route with Explicit Viewer

Source: https://github.com/yaitoo/xun/blob/main/AGENTS.md

Defines a GET route for the root path '/{$}'. The handler function returns a JSON view containing a map with a 'Name' field. An explicit HtmlViewer is provided as an option, allowing for content negotiation to render via HTML templates if configured.

```go
app.Get("/{$}", func(c *xun.Context) error {
  return c.View(map[string]string{"Name":"xun"})
}, xun.WithViewer(&xun.HtmlViewer{/* render via views/... if you set it */}))

```

--------------------------------

### Define Route with Dynamic Segment and View Response

Source: https://github.com/yaitoo/xun/blob/main/AGENTS.md

Defines a GET route with a dynamic segment '/users/{id}'. The handler extracts the 'id' from the request path parameters and renders a User view with the extracted ID. It returns an error, which Xun framework handles.

```go
app.Get("/users/{id}", func(c *xun.Context) error {
  id := c.Request.PathValue("id")
  return c.View(User{Name: id})
})

```

--------------------------------

### Integrate HTMX for Dynamic Server-Side Rendering in Go

Source: https://context7.com/yaitoo/xun/llms.txt

This Go code snippet demonstrates how to integrate HTMX for dynamic server-side rendering using the Xun framework. It sets up an HTMX extension using `htmx.New()` and provides handlers for serving the HTMX extension JavaScript, handling login forms with validation, and performing redirects. The example showcases how to use `htmx.WriteHeader` to send custom HTMX triggers and `c.Redirect` for HTMX-aware redirects.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/form"
	"github.com/yaitoo/xun/ext/htmx"
)

type LoginForm struct {
	Email    string `form:"email" validate:"required,email"
	Password string `form:"password" validate:"required"
}

func main() {
	app := xun.New(xun.WithInterceptor(htmx.New()))

	// Serve HTMX extension JavaScript
	app.Get("/htmx-ext.js", htmx.HandleFunc())

	app.Get("/login", func(c *xun.Context) error {
		return c.View(map[string]string{"title": "Login"})
	})

	app.Post("/login", func(c *xun.Context) error {
		loginForm, err := form.BindForm[LoginForm](c.Request)
		if err != nil {
			c.WriteStatus(http.StatusBadRequest)
			return xun.ErrCancelled
		}

		if !loginForm.Validate(c.AcceptLanguage()...){
			c.WriteStatus(http.StatusBadRequest)
			return c.View(loginForm)
		}

		// Check credentials
		if loginForm.Data.Email != "user@example.com" || loginForm.Data.Password != "secret" {
			// Send custom HTMX trigger
			htmx.WriteHeader(c, htmx.HxTrigger, htmx.HxHeader[string]{
				"showMessage": "Invalid email or password",
			})
			c.WriteStatus(http.StatusBadRequest)
			return c.View(loginForm)
		}

		// Set session cookie
		http.SetCookie(c.Response, &http.Cookie{
			Name:     "session",
			Value:    loginForm.Data.Email,
			Path:     "/",
			MaxAge:   3600,
			HttpOnly: true,
			Secure:   true,
			SameSite: http.SameSiteLaxMode,
		})

		// Redirect via HTMX
		c.Redirect("/dashboard")
		return nil
	})

	app.Get("/dashboard", func(c *xun.Context) error {
		session, err := c.Request.Cookie("session")
		if err != nil || session.Value == "" {
			c.Redirect("/login")
			return xun.ErrCancelled
		}

		return c.View(map[string]string{
			"user": session.Value,
		})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}

```

--------------------------------

### Register Route Handlers in Xun Go Application

Source: https://context7.com/yaitoo/xun/llms.txt

Shows how to register HTTP route handlers for different methods (GET, POST, PUT, DELETE) in a Xun application, including handling dynamic path parameters and rendering different response types.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
)

type User struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func main() {
	app := xun.New()

	// GET route
	app.Get("/{$}", func(c *xun.Context) error {
		return c.View(map[string]string{
			"Name": "go-xun",
		})
	})

	// POST route
	app.Post("/users", func(c *xun.Context) error {
		user := User{
			ID:    "123",
			Name:  "John Doe",
			Email: "john@example.com",
		}
		return c.View(user)
	})

	// Dynamic route with path parameter
	app.Get("/user/{id}", func(c *xun.Context) error {
		id := c.Request.PathValue("id")
		user := User{
			ID:   id,
			Name: "User " + id,
		}
		return c.View(user)
	})

	// PUT and DELETE routes
	app.Put("/users/{id}", func(c *xun.Context) error {
		c.WriteStatus(http.StatusOK)
		return nil
	})

	app.Delete("/users/{id}", func(c *xun.Context) error {
		c.WriteStatus(http.StatusNoContent)
		return nil
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}
```

--------------------------------

### Go: Send SSE Events

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code demonstrates how to send Server-Sent Events (SSE) using the 'sse' extension. It shows how to retrieve a specific SSE connection by user ID and send a named text event, or broadcast an event to all connected clients. It also includes an example of shutting down the SSE server and closing all connections. Dependencies include the 'sse' extension and Go's 'context' package.

```go
// push an event to the user
u := ss.Get("user_id")
if u != nil {
	u.Send(sse.TextEvent{
		Name:"showMessage",
		Data:"Hello",
	})
}

// broadcast an event to all users
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defuncancel()
ss.Broadcast(ctx, sse.TextEvent{
	Name:"shutdown",
	Data:"Server is shutting down",
})

// shutdown server and close all user connections
ss.Shutdown()

```

--------------------------------

### HTML: Link Compiled CSS and JS

Source: https://github.com/yaitoo/xun/blob/main/README.md

This HTML snippet shows how to link the compiled Tailwind CSS file (`theme.css`) and the application JavaScript file (`app.js`) in the `assets.html` file. It also includes a link to `skin.css`. This setup ensures that the project's styles and scripts are correctly loaded in the browser.

```html
<link rel="stylesheet" href="/skin.css">
<link rel="stylesheet" href="/theme.css">
<script type="text/javascript" src="/app.js"></script>

```

--------------------------------

### HTML: Include htmx.js and htmx-ext.js

Source: https://github.com/yaitoo/xun/blob/main/README.md

This HTML snippet illustrates how to include the htmx.js library and the custom `htmx-ext.js` script in a web page. It also includes links to CSS files and the main application JavaScript (`app.js`). This setup is crucial for enabling dynamic content loading and interactive features powered by htmx.

```html
<link rel="stylesheet" href="/skin.css">
<link rel="stylesheet" href="/theme.css">
<script src="https://unpkg.com/htmx.org@2.0.4" integrity="sha384-HGfztofotfshcF7+8n44JQL2oJmowVChPTg48S+jvZoztPfvwD79OC/LTtG6dMp+" crossorigin="anonymous"></script>
<script type="text/javascript" src="/htmx-ext.js"></script>
<script type="text/javascript" src="/app.js" defer></script>

```

--------------------------------

### Cookie Management in Go with Xun

Source: https://context7.com/yaitoo/xun/llms.txt

Provides functions for setting, getting, and deleting cookies in Go using the Xun framework's cookie extension. Supports both standard and signed (HMAC protected) cookies with automatic encoding/decoding.

```go
package main

import (
	"net/http"
	"time"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/cookie"
)

func main() {
	app := xun.New()
	secretKey := []byte("my-secret-key-32-bytes-long!!")

	// Set cookie (base64 encoded)
	app.Get("/set-cookie", func(c *xun.Context) error {
		err := cookie.Set(c, http.Cookie{
			Name:     "user_pref",
			Value:    "theme=dark;lang=en",
			Path:     "/",
			MaxAge:   3600,
			HttpOnly: true,
			Secure:   true,
			SameSite: http.SameSiteLaxMode,
		})
		if err != nil {
			return err
		}
		return c.View(map[string]string{"status": "cookie set"})
	})

	// Get cookie (automatically decoded from base64)
	app.Get("/get-cookie", func(c *xun.Context) error {
		value, err := cookie.Get(c, "user_pref")
		if err != nil {
			c.WriteStatus(http.StatusNotFound)
			return c.View(map[string]string{"error": "cookie not found"})
		}
		return c.View(map[string]string{"value": value})
	})

	// Set signed cookie (HMAC protected)
	app.Get("/set-signed", func(c *xun.Context) error {
		timestamp, err := cookie.SetSigned(c, http.Cookie{
			Name:     "session",
			Value:    "user-id-123",
			Path:     "/",
			MaxAge:   7200,
			HttpOnly: true,
			Secure:   true,
		}, secretKey)
		if err != nil {
			return err
		}
		c.Set("timestamp", timestamp)
		return c.View(map[string]any{"status": "signed cookie set", "ts": timestamp})
	})

	// Get signed cookie (validates HMAC)
	app.Get("/get-signed", func(c *xun.Context) error {
		value, timestamp, err := cookie.GetSigned(c, "session", secretKey)
		if err != nil {
			c.WriteStatus(http.StatusUnauthorized)
			return c.View(map[string]string{"error": "invalid or missing session"})
		}
		return c.View(map[string]any{
			"value":     value,
			"timestamp": timestamp,
		})
	})

	// Delete cookie
	app.Get("/delete-cookie", func(c *xun.Context) error {
		err := cookie.Delete(c, http.Cookie{Name: "user_pref"})
		if err != nil {
			return err
		}
		return c.View(map[string]string{"status": "cookie deleted"})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}
```

--------------------------------

### Initialize Xun Web Application in Go

Source: https://context7.com/yaitoo/xun/llms.txt

Demonstrates how to initialize a new Xun application with default settings, custom file system and watch options, or custom configurations like HTTP multiplexers and response compressors.

```go
package main

import (
	"net/http"
	"os"

	"github.com/yaitoo/xun"
)

func main() {
	// Basic application with default settings
	app := xun.New()

	// Application with file system and view engines
	app := xun.New(
		xun.WithFsys(os.DirFS("./app")),
		xun.WithWatch(), // Enable hot reload in development
	)

	// Application with custom configuration
	mux := http.NewServeMux()
	app := xun.New(
		xun.WithMux(mux),
		xun.WithCompressor(&xun.GzipCompressor{}, &xun.DeflateCompressor{}),
		xun.WithHandlerViewers(&xun.JsonViewer{}, &xun.HtmlViewer{}),
	)

	app.Start()
	defer app.Close()

	http.ListenAndServe(":8080", http.DefaultServeMux)
}
```

--------------------------------

### Set up Auto TLS Certificates in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code demonstrates setting up automatic TLS certificate management using autotls.Configure. It initializes a new autotls instance with certificate cache and hosts, then configures HTTP and HTTPS servers.

```go
mux := http.NewServeMux()

app := xun.New(xun.WithMux(mux))

//...

httpServer := &http.Server{
	Addr: ":http",
	//...
}

httpsServer := &http.Server{
	Addr: ":https",
	//...
}

autotls.
	New(autotls.WithCache(autocert.DirCache("./certs")),
		autotls.WithHosts("abc.com", "123.com")),
	Configure(httpServer, httpsServer)

go httpServer.ListenAndServe()
go httpsServer.ListenAndServeTLS("", "")

```

--------------------------------

### Go: Serve htmx-ext.js

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet demonstrates how to serve the `htmx-ext.js` file within a Xun web application. It uses the `htmx.HandleFunc()` to provide the necessary JavaScript library that enables seamless integration between native JavaScript methods and htmx features, enhancing interactive capabilities.

```go
app.Get("/htmx-ext.js", htmx.HandleFunc())

```

--------------------------------

### Deploy Application with Go Embed Directive

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet demonstrates how to embed application assets into a single binary using Go's `//go:embed` directive. It differentiates between development (using local filesystem and watching for changes) and production (using embedded resources) environments. This approach creates dependency-free deployment.

```go
//go:embed app
var fsys embed.FS

func main() {
	var dev bool
	flag.BoolVar(&dev, "dev", false, "it is development environment")

	flag.Parse()

	var opts []xun.Option
	if dev {
		// use local filesystem in development, and watch files to reload automatically
		opts = []xun.Option{xun.WithFsys(os.DirFS("./app")), xun.WithWatch()}
	} else {
		// use embed resources in production environment
		views, _ := fs.Sub(fsys, "app")
		opts = []xun.Option{xun.WithFsys(views)}
	}

	app := xun.New(opts...)
	//...

	app.Start()
	defer app.Close()

	if dev {
		slog.Default().Info("xun-admin is running in development")
	} else {
		slog.Default().Info("xun-admin is running in production")
	}

	err := http.ListenAndServe(":80", http.DefaultServeMux)
	if err != nil {
		panic(err)
	}
}
```

--------------------------------

### Go: Handle SSE Connections with Xun

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet demonstrates how to initialize the SSE extension and handle incoming SSE connections within a Xun web application. It sets up a route to join SSE topics, manage client requests, and return errors for invalid requests. Dependencies include the 'sse' extension and the Xun framework.

```go
ss := sse.New()

app.Get("/topic/{id}", func(ctx *xun.Context)error {
	id := c.Get("SessionID").(string)
	s, err := ss.Join(c.Request.Context(), id, c.Response)
	if err != nil {
		c.WriteStatus(http.StatusBadRequest)
		return xun.ErrCancelled
	}

	s.Wait()

	ss.Leave(id)

	return nil
})

```

--------------------------------

### Configure GZip and Deflate Compression in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet configures the Xun application to use GZip and Deflate compression for handling 'Accept-Encoding' headers. It initializes the compressor with both GzipCompressor and DeflateCompressor.

```go
app := xun.New(WithCompressor(&GzipCompressor{}, &DeflateCompressor{}))

```

--------------------------------

### Virtual Host Routing with net/http (Go)

Source: https://github.com/yaitoo/xun/blob/main/README.md

Illustrates how to configure routing in Go's standard net/http package to handle requests for different hostnames that resolve to the same IP address. It defines handlers for specific domains.

```go
mux.HandleFunc("GET /", func(w http.ResponseWriter, req *http.Request) {...})
 mux.HandleFunc("GET abc.com/", func(w http.ResponseWriter, req *http.Request) {...})
 mux.HandleFunc("GET 123.com/", func(w http.ResponseWriter, req *http.Request) {...})
```

--------------------------------

### Multiple Viewers based on Accept Header (Bash)

Source: https://github.com/yaitoo/xun/blob/main/README.md

Demonstrates how to make requests to an HTTP server and receive different responses based on the 'Accept' header, falling back to a default viewer if no specific match is found. This showcases content negotiation.

```bash
curl -v http://127.0.0.1
> GET / HTTP/1.1
> Host: 127.0.0.1
> User-Agent: curl/8.7.1
> Accept: */*
>
* Request completely sent off
< HTTP/1.1 200 OK
< Date: Thu, 26 Dec 2024 07:46:13 GMT
< Content-Length: 19
< Content-Type: text/plain; charset=utf-8
>
{"Name":"go-xun"}

curl --header "Accept: text/html; \*/\*" http://127.0.0.1
```
> GET / HTTP/1.1
> Host: 127.0.0.1
> User-Agent: curl/8.7.1
> Accept: text/html; */*
>
* Request completely sent off
< HTTP/1.1 200 OK
< Date: Thu, 26 Dec 2024 07:49:47 GMT
< Content-Length: 343
< Content-Type: text/html; charset=utf-8
>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Xun-Admin</title>
    <link rel="stylesheet" href="/skin.css">
<script type="text/javascript" src="/app.js"></script>
  </head>
  <body>

    <div id="app">hello go-xun</div>

  </body>
</html>
```
```

--------------------------------

### Configure Request Logging with Go

Source: https://context7.com/yaitoo/xun/llms.txt

Set up request logging for a web application using the yaitoo/xun/ext/reqlog package. This allows logging all incoming requests with a customizable format, including user and visitor identification extracted from cookies. It requires the `github.com/yaitoo/xun` and its extensions `github.com/yaitoo/xun/ext/cookie`, `github.com/yaitoo/xun/ext/reqlog` packages.

```go
package main

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

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/cookie"
	"github.com/yaitoo/xun/ext/reqlog"
)

func main() {
	app := xun.New()

	// Setup logger
	logFile, err := os.OpenFile("./access.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		panic(err)
	}
	defer logFile.Close()

	logger := log.New(logFile, "", 0)

	// Visitor ID extractor
	getVisitorID := func(c *xun.Context) string {
		value, err := cookie.Get(c, "visitor_id")
		if err != nil {
			return ""
		}
		return value
	}

	// User ID extractor
	getUserID := func(c *xun.Context) string {
		secretKey := []byte("secret-key")
		value, _, err := cookie.GetSigned(c, "session_id", secretKey)
		if err != nil {
			return ""
		}
		return value
	}

	// Enable request logging middleware
	app.Use(reqlog.New(
		reqlog.WithLogger(logger),
		reqlog.WithUser(getUserID),
		reqlog.WithVisitor(getVisitorID),
		reqlog.WithFormat(reqlog.Combined), // Combined Log Format (XLF/ELF)
	))

	app.Get("/", func(c *xun.Context) error {
		return c.View(map[string]string{"page": "home"})
	})

	app.Get("/api/users", func(c *xun.Context) error {
		return c.View([]map[string]string{
			{"id": "1", "name": "Alice"},
			{"id": "2", "name": "Bob"},
		})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}

```

--------------------------------

### Layout and Content Definition (Xun HTML)

Source: https://github.com/yaitoo/xun/blob/main/README.md

Demonstrates how to create a shared layout in Xun and define content blocks within a specific page that utilize the layout. Uses Go's html/template syntax.

```html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Xun-Admin</title>
  </head>
  <body>
    {{ block "content" .}} {{ end }}
  </body>
</html>
```

```html
<!--layout:home-->
{{ define "content" }}
    <div id="app">hello world</div>
{{ end }}
```

--------------------------------

### Go Route Handler for Basic View

Source: https://github.com/yaitoo/xun/blob/main/README.md

A Go route handler that renders a view with a simple string map as data. The page defined at `/{$}` will be rendered.

```go
	app.Get("/{$", func(c *xun.Context) error {
		return c.View(map[string]string{
			"Name": "go-xun",
		})
	})
```

--------------------------------

### Organize Routes with Route Groups in Go

Source: https://context7.com/yaitoo/xun/llms.txt

This Go code demonstrates how to organize routes with shared prefixes and middleware using route groups in the Xun framework. It sets up API versioning with specific middleware for each version. Dependencies include the 'net/http' package and the 'github.com/yaitoo/xun' library.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
)

func main() {
	app := xun.New()

	// API v1 group
	v1 := app.Group("/api/v1")
	v1.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			c.WriteHeader("X-API-Version", "v1")
			return next(c)
		}
	})

	v1.Get("/users", func(c *xun.Context) error {
		return c.View([]map[string]string{
			{"id": "1", "name": "Alice"},
			{"id": "2", "name": "Bob"},
		})
	})

	v1.Get("/users/{id}", func(c *xun.Context) error {
		id := c.Request.PathValue("id")
		return c.View(map[string]string{"id": id, "name": "User " + id})
	})

	// API v2 group
	v2 := app.Group("/api/v2")
	v2.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			c.WriteHeader("X-API-Version", "v2")
			return next(c)
		}
	})

	v2.Get("/users", func(c *xun.Context) error {
		return c.View(map[string]any{
			"version": "2",
			"data": []map[string]string{
				{"id": "1", "name": "Alice", "email": "alice@example.com"},
			},
		})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}

```

--------------------------------

### Serve Real-time Report with Xun

Source: https://github.com/yaitoo/xun/blob/main/README.md

Serves the real-time HTML analysis report generated by GoAccess through a Xun application endpoint. This Go code snippet defines a route to serve the static HTML file.

```go
	app.Get("/reports/realtime.html", func(c *xun.Context) error {
		http.ServeFile(c.Response, c.Request, "./realtime.html")
		return nil
	})
```

--------------------------------

### Implement HSTS Redirect and Header in Go

Source: https://github.com/yaitoo/xun/blob/main/README.md

These Go snippets demonstrate how to implement HTTP Strict Transport Security (HSTS) using the 'hsts' package. It shows how to configure HSTS to redirect HTTP requests to HTTPS and how to write the HSTS header for HTTPS requests.

```go
app.Use(hsts.Redirect())

```

```go
app.Use(hsts.WriteHeader())

```

--------------------------------

### Apply Middleware for Cross-Cutting Concerns in Go

Source: https://context7.com/yaitoo/xun/llms.txt

This Go code demonstrates how to create and apply middleware for handling cross-cutting concerns such as logging and authentication within an application using the Xun framework. It shows global middleware application and middleware specific to route groups. Dependencies include the 'log', 'net/http', 'time' packages, and the 'github.com/yaitoo/xun' library.

```go
package main

import (
	"log"
	"net/http"
	"time"

	"github.com/yaitoo/xun"
)

func main() {
	app := xun.New()

	// Global logging middleware
	app.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			start := time.Now()
			defer func() {
				duration := time.Since(start)
				log.Printf("%s %s - %v", c.Request.Method, c.Routing.Pattern, duration)
			}()
			return next(c)
		}
	})

	// Authentication middleware
	app.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			token := c.Request.Header.Get("X-Token")
			if token == "" {
				c.WriteStatus(http.StatusUnauthorized)
				return xun.ErrCancelled
			}
			c.Set("Token", token)
			return next(c)
		}
	})

	// Group with specific middleware
	admin := app.Group("/admin")
	admin.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			token := c.Request.Header.Get("X-Admin-Token")
			if token != "admin-secret" {
				c.WriteStatus(http.StatusForbidden)
				return xun.ErrCancelled
			}
			return next(c)
		}
	})

	admin.Get("/{$}", func(c *xun.Context) error {
		return c.View(map[string]string{"page": "admin dashboard"})
	})

	app.Get("/public", func(c *xun.Context) error {
		return c.View(map[string]string{"page": "public"})
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}

```

--------------------------------

### Go Route for XML Sitemap Rendering

Source: https://github.com/yaitoo/xun/blob/main/README.md

A Go route handler that renders an XML sitemap using a text template. It specifies the data model and the template file to use for rendering.

```go
	app.Get("/sitemap.xml", func(c *xun.Context) error {
		return c.View(Sitemap{
			LastMod: time.Now(),
		}, "text/sitemap.xml") // use `text/sitemap.xml` as current Viewer to render
	})
```

--------------------------------

### Logging Middleware (Go)

Source: https://github.com/yaitoo/xun/blob/main/README.md

A simple logging middleware for a Go application using the Xun framework. It logs the request pattern and the time taken to process the request, providing insights into request duration.

```go
app.Use(func(next xun.HandleFunc) xun.HandleFunc {
		return func(c *xun.Context) error {
			n := time.Now()
			defer func() {
					duration := time.Since(n)

					log.Println(c.Routing.Pattern, duration)
				}()
			return next(c)
		}
	})
```

--------------------------------

### Enable CSRF Middleware in Go

Source: https://context7.com/yaitoo/xun/llms.txt

Protects web applications against Cross-Site Request Forgery (CSRF) attacks by integrating CSRF middleware. This Go code snippet demonstrates how to initialize the Xun application, set a secret key, and apply the CSRF middleware. It also shows how to serve the CSRF JavaScript token handler and configure routes for form submission and updates, with automatic CSRF token validation.

```go
package main

import (
	"net/http"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/csrf"
)

func main() {
	app := xun.New()
	secretKey := []byte("your-secret-key-32-bytes-long!")

	// Enable CSRF middleware
	app.Use(csrf.New(secretKey))

	// Serve CSRF JavaScript token handler
	app.Get("/assets/csrf.js", csrf.HandleFunc(secretKey))

	// Enable CSRF with JavaScript token for bot prevention
	app.Use(csrf.New(secretKey, csrf.WithJsToken()))

	app.Get("/form", func(c *xun.Context) error {
		return c.View(map[string]string{
			"title": "Contact Form",
		})
	})

	app.Post("/submit", func(c *xun.Context) error {
		// CSRF token is automatically validated
		// If invalid, request returns 418 (I'm a teapot) status
		return c.View(map[string]string{"status": "success"})
	})

	app.Put("/update/{id}", func(c *xun.Context) error {
		id := c.Request.PathValue("id")
		return c.View(map[string]string{"status": "updated", "id": id})
	})

	app.Delete("/delete/{id}", func(c *xun.Context) error {
		id := c.Request.PathValue("id")
		c.WriteStatus(http.StatusNoContent)
		return nil
	})

	app.Start()
	http.ListenAndServe(":8080", nil)
}
```

--------------------------------

### Bash: Build Tailwind CSS

Source: https://github.com/yaitoo/xun/blob/main/README.md

This bash command initiates the Tailwind CSS build process using the CLI tool. It specifies the input CSS file (`./app/tailwind.css`), the output file (`./app/public/theme.css`), and enables watch mode (`--watch`) to automatically recompile CSS when source files change. This command is used to generate the final CSS that will be included in your HTML.

```bash
npx tailwindcss -i ./app/tailwind.css -o ./app/public/theme.css --watch

```

--------------------------------

### Automatic SSL Certificate Management with Go

Source: https://context7.com/yaitoo/xun/llms.txt

Configure automatic SSL certificate issuance and renewal using Let's Encrypt with the yaitoo/xun/ext/autotls package. This involves setting up HTTP and HTTPS servers, configuring certificate caching, and specifying the hosts for which certificates should be managed. It requires the `github.com/yaitoo/xun` and `github.com/yaitoo/xun/ext/autotls` packages, as well as `golang.org/x/crypto/acme/autocert`.

```go
package main

import (
	"net/http"

	"golang.org/x/crypto/acme/autocert"

	"github.com/yaitoo/xun"
	"github.com/yaitoo/xun/ext/autotls"
)

func main() {
	mux := http.NewServeMux()
	app := xun.New(xun.WithMux(mux))

	app.Get("/", func(c *xun.Context) error {
		return c.View(map[string]string{"status": "secure"})
	})

	app.Start()

	// HTTP server (handles ACME challenges)
	httpServer := &http.Server{
		Addr:    ":http",
		Handler: mux,
	}

	// HTTPS server
	httpsServer := &http.Server{
		Addr:    ":https",
		Handler: mux,
	}

	// Configure AutoTLS
	autotls.New(
		autotls.WithCache(autocert.DirCache("./certs")),
		autotls.WithHosts("example.com", "www.example.com"),
	).Configure(httpServer, httpsServer)

	// Start both servers
	go httpServer.ListenAndServe()
	httpsServer.ListenAndServeTLS("", "")
}

```

--------------------------------

### Request Logging with Xun

Source: https://github.com/yaitoo/xun/blob/main/README.md

Configures the request logging middleware for the Xun application. It allows customization of log format and enables integration with a provided logger. Dependencies include the 'reqlog' middleware and standard Go libraries for file operations and logging.

```go
func main(){
 	//....
  logger, _ := setupLogger()

  app.Use(reqlog.New(reqlog.WithLogger(logger),
			reqlog.WithUser(getUserID),
			reqlog.WithVisitor(getVisitorID),
			reqlog.WithFormat(reqlog.Combined))))
 	//...
}

func setupLogger() (*log.Logger, error) {
	logFile, err := os.OpenFile("./access.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return nil, err
	}
	return log.New(logFile, "", 0), nil
}

func getVisitorID(c *xun.Context) string {
	v, err := c.Request.Cookie("visitor_id") // use fingerprintjs to generate visitor id in client's cookie
	if err != nil {
		return ""
	}

	return v.Value
}

func getUserID(c *xun.Context) string {
	v, _, err := cookie.GetSigned(c, "session_id", secretKey)
	if err != nil {
		return ""
	}

	return v
}
```

--------------------------------

### Basic HTML Page Structure (Xun)

Source: https://github.com/yaitoo/xun/blob/main/README.md

Defines a basic HTML page structure for a Xun application. This serves as the entry point for a route, typically the index page.

```html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Xun-Admin</title>
  </head>
  <body>
    <div id="app">hello world</div>
  </body>
</html>
```

--------------------------------

### Apply HTMX Interceptor (Go)

Source: https://github.com/yaitoo/xun/blob/main/README.md

This Go code snippet shows how to create a new Xun application instance and apply an HTMX interceptor. The `xun.WithInterceptor(htmx.New())` option integrates HTMX functionality into the application's request processing pipeline.

```go
	app := xun.New(xun.WithInterceptor(htmx.New()))

```
Tokens:
Raw