server

ExampleHealthManager demonstrates basic health check setup

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager(
		server.WithHealthCheckTimeout(5 * time.Second),
	)

	// Register a custom health checker
	hm.RegisterChecker(server.NewHealthCheckFunc("my-service", func(ctx context.Context) *server.CheckResult {
		// Perform your health check logic here
		return &server.CheckResult{
			Status:    server.StatusHealthy,
			LatencyMs: 5,
		}
	}))

	// Create server and register health routes
	srv := server.NewServer()
	if err := srv.RegisterHealthRoutes(hm); err != nil {
		log.Fatal(err)
	}

	fmt.Println("Health routes registered: /health/live, /health/ready, /health")
}

Output:

Health routes registered: /health/live, /health/ready, /health

ExampleHealthManager_customChecker demonstrates creating a custom health checker

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager()

	// Create a custom health checker with specific logic
	customChecker := server.NewHealthCheckFunc("redis", func(ctx context.Context) *server.CheckResult {
		start := time.Now()

		// Perform your custom health check logic
		// For example, check Redis connection
		// err := redisClient.Ping(ctx).Err()

		latency := time.Since(start).Milliseconds()

		// Simulate a healthy check
		return &server.CheckResult{
			Status:    server.StatusHealthy,
			LatencyMs: latency,
			Message:   "Redis is operational",
		}
	})

	hm.RegisterChecker(customChecker)

	fmt.Println("Custom Redis health checker registered")
}

Output:

Custom Redis health checker registered

ExampleHealthManager_databaseChecker demonstrates database health checking

package main

import (
	"context"
	"database/sql"
	"fmt"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager()

	// Simulate a database connection (in real code, use your actual DB)
	var db *sql.DB // This would be your actual database connection

	// Register a database health checker
	dbChecker := server.NewDatabaseHealthChecker("database", func(ctx context.Context) error {
		// In real code, use db.PingContext(ctx)
		if db == nil {
			return nil // For this example
		}
		return db.PingContext(ctx)
	})

	hm.RegisterChecker(dbChecker)

	fmt.Println("Database health checker registered")
}

Output:

Database health checker registered

ExampleHealthManager_degradedStatus demonstrates handling degraded service status

package main

import (
	"context"
	"fmt"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a custom checker that returns degraded status
	checker := server.NewHealthCheckFunc("slow-service", func(ctx context.Context) *server.CheckResult {
		// Simulate a slow but functional service
		return &server.CheckResult{
			Status:    server.StatusDegraded,
			LatencyMs: 250,
			Message:   "Service is slow but operational",
		}
	})

	fmt.Println(checker.Name())
	result := checker.Check(context.Background())
	fmt.Println(result.Status)
}

Output:

slow-service
degraded

ExampleHealthManager_httpChecker demonstrates external service health checking

package main

import (
	"fmt"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager()

	// Register an HTTP service health checker
	apiChecker, err := server.NewHTTPHealthChecker("external-api", "https://api.example.com/health")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	hm.RegisterChecker(apiChecker)

	fmt.Println("External API health checker registered")
}

Output:

External API health checker registered

ExampleHealthManager_multipleCheckers demonstrates using multiple health checkers

package main

import (
	"fmt"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager()

	// Register multiple checkers
	hm.RegisterChecker(server.NewStaticHealthChecker("database", server.StatusHealthy))
	hm.RegisterChecker(server.NewStaticHealthChecker("redis", server.StatusHealthy))
	hm.RegisterChecker(server.NewStaticHealthChecker("elasticsearch", server.StatusHealthy))

	fmt.Println("3 health checkers registered")
}

Output:

3 health checkers registered

ExampleHealthManager_standaloneHTTP demonstrates using health handlers without the GLYPHLANG server

package main

import (
	"fmt"
	"net/http"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager
	hm := server.NewHealthManager()

	// Register some checkers
	hm.RegisterChecker(server.NewStaticHealthChecker("db", server.StatusHealthy))

	// Use with standard http.ServeMux
	mux := http.NewServeMux()
	mux.HandleFunc("/health/live", server.LivenessHTTPHandler())
	mux.HandleFunc("/health/ready", server.ReadinessHTTPHandler(hm))

	fmt.Println("Health endpoints registered with http.ServeMux")
}

Output:

Health endpoints registered with http.ServeMux

ExampleHealthManager_timeout demonstrates health check with timeout

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create a health manager with short timeout
	hm := server.NewHealthManager(
		server.WithHealthCheckTimeout(100 * time.Millisecond),
	)

	// Register a checker that respects context timeout
	hm.RegisterChecker(server.NewHealthCheckFunc("service", func(ctx context.Context) *server.CheckResult {
		select {
		case <-ctx.Done():
			return &server.CheckResult{
				Status: server.StatusUnhealthy,
				Error:  "timeout exceeded",
			}
		case <-time.After(50 * time.Millisecond):
			return &server.CheckResult{
				Status: server.StatusHealthy,
			}
		}
	}))

	fmt.Println("Health manager configured with 100ms timeout")
}

Output:

Health manager configured with 100ms timeout

ExampleServer demonstrates basic server usage

package main

import (
	"fmt"
	"net/http/httptest"

	"github.com/glyphlang/glyph/pkg/server"
)

// exampleMockInterpreter implements server.Interpreter for examples
type exampleMockInterpreter struct {
	Response interface{}
}

func (m *exampleMockInterpreter) Execute(route *server.Route, ctx *server.Context) (interface{}, error) {
	if m.Response != nil {
		return m.Response, nil
	}

	query := make(map[string]interface{})
	for k, v := range ctx.QueryParams {
		if len(v) == 1 {
			query[k] = v[0]
		} else {
			query[k] = v
		}
	}
	response := map[string]interface{}{
		"message":    "Mock response",
		"path":       ctx.Request.URL.Path,
		"method":     ctx.Request.Method,
		"pathParams": ctx.PathParams,
		"query":      query,
	}
	if ctx.Body != nil && len(ctx.Body) > 0 {
		response["body"] = ctx.Body
	}
	return response, nil
}

func main() {
	// Create a new server with mock interpreter
	srv := server.NewServer(
		server.WithInterpreter(&exampleMockInterpreter{
			Response: map[string]interface{}{
				"message": "Hello, World!",
			},
		}),
	)

	// Register a simple route
	srv.RegisterRoute(&server.Route{
		Method: server.GET,
		Path:   "/hello",
	})

	// Make a test request
	req := httptest.NewRequest("GET", "/hello", nil)
	w := httptest.NewRecorder()

	srv.GetHandler().ServeHTTP(w, req)

	fmt.Println(w.Code)
}

Output:

200

ExampleServer_customHandler demonstrates custom request handlers

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http/httptest"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	srv := server.NewServer()

	// Register route with custom handler
	srv.RegisterRoute(&server.Route{
		Method: server.POST,
		Path:   "/api/users",
		Handler: func(ctx *server.Context) error {
			// Access request body
			name := ctx.Body["name"].(string)

			// Send custom response
			return server.SendJSON(ctx, 201, map[string]interface{}{
				"message": fmt.Sprintf("User %s created", name),
				"id":      "new-id-123",
			})
		},
	})

	// Make request
	body, _ := json.Marshal(map[string]string{"name": "John"})
	req := httptest.NewRequest("POST", "/api/users", bytes.NewBuffer(body))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.GetHandler().ServeHTTP(w, req)

	fmt.Println(w.Code)
}

Output:

201

ExampleServer_middleware demonstrates middleware usage

package main

import (
	"fmt"
	"net/http/httptest"

	"github.com/glyphlang/glyph/pkg/server"
)

func main() {
	// Create middleware that adds a header
	headerMiddleware := func(next server.RouteHandler) server.RouteHandler {
		return func(ctx *server.Context) error {
			ctx.ResponseWriter.Header().Set("X-Custom", "value")
			return next(ctx)
		}
	}

	srv := server.NewServer()

	// Register route with middleware
	srv.RegisterRoute(&server.Route{
		Method:      server.GET,
		Path:        "/test",
		Middlewares: []server.Middleware{headerMiddleware},
		Handler: func(ctx *server.Context) error {
			return server.SendJSON(ctx, 200, map[string]string{"status": "ok"})
		},
	})

	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()

	srv.GetHandler().ServeHTTP(w, req)

	fmt.Println(w.Header().Get("X-Custom"))
}

Output:

value

ExampleServer_pathParams demonstrates path parameter extraction

package main

import (
	"encoding/json"
	"fmt"
	"net/http/httptest"

	"github.com/glyphlang/glyph/pkg/server"
)

// exampleMockInterpreter implements server.Interpreter for examples
type exampleMockInterpreter struct {
	Response interface{}
}

func (m *exampleMockInterpreter) Execute(route *server.Route, ctx *server.Context) (interface{}, error) {
	if m.Response != nil {
		return m.Response, nil
	}

	query := make(map[string]interface{})
	for k, v := range ctx.QueryParams {
		if len(v) == 1 {
			query[k] = v[0]
		} else {
			query[k] = v
		}
	}
	response := map[string]interface{}{
		"message":    "Mock response",
		"path":       ctx.Request.URL.Path,
		"method":     ctx.Request.Method,
		"pathParams": ctx.PathParams,
		"query":      query,
	}
	if ctx.Body != nil && len(ctx.Body) > 0 {
		response["body"] = ctx.Body
	}
	return response, nil
}

func main() {
	srv := server.NewServer(
		server.WithInterpreter(&exampleMockInterpreter{}),
	)

	// Register route with path parameters
	srv.RegisterRoute(&server.Route{
		Method: server.GET,
		Path:   "/users/:id",
	})

	// Make request
	req := httptest.NewRequest("GET", "/users/123", nil)
	w := httptest.NewRecorder()

	srv.GetHandler().ServeHTTP(w, req)

	var response map[string]interface{}
	json.Unmarshal(w.Body.Bytes(), &response)

	pathParams := response["pathParams"].(map[string]interface{})
	fmt.Println(pathParams["id"])
}

Output:

123