Sharkk/Sushi
Sharkk/Sushi
1
0
Fork 0
Code Releases 4 Activity

Compare commits

base: Sharkk:master
Branches Tags
Sharkk:master
Sharkk:v1.2.0
Sharkk:v1.1.1
Sharkk:v1.1.0
Sharkk:v1.0.0
..
compare: Sharkk:v1.0.0
Branches Tags
Sharkk:master
Sharkk:v1.2.0
Sharkk:v1.1.1
Sharkk:v1.1.0
Sharkk:v1.0.0

No commits in common. "master" and "v1.0.0" have entirely different histories.
master ... v1.0.0

13 changed files with 86 additions and 530 deletions
Show Stats Expand all files Collapse all files

171
README.md
View File

@ -15,7 +15,7 @@ func main() {
// Initialize sessions
sushi.InitSessions("sessions.json")
app.Get("/", func(ctx sushi.Ctx) {
app.Get("/", func(ctx sushi.Ctx, params []any) {
ctx.SendHTML("<h1>Hello Sushi!</h1>")
})
@ -41,86 +41,35 @@ api.Get("/users", listUsersHandler)
api.Post("/users", createUserHandler)
```
## Parameters and Queries
## Parameters
Sushi provides a fluent API for accessing URL parameters, query strings, and form data with automatic type conversion:
### URL Parameters (Named Routes)
URL parameters are automatically converted to the appropriate type:
```go
app.Get("/users/:id", func(ctx sushi.Ctx) {
// Get URL parameter with fluent API
userID := ctx.Param("id").Int() // /users/123 -> 123
userIDStr := ctx.Param("id").String() // /users/123 -> "123"
// With defaults
limit := ctx.Param("limit").IntDefault(10)
// Numeric parameters become integers
app.Get("/users/:id", func(ctx sushi.Ctx, params []any) {
userID := params[0].(int) // /users/123 -> 123
// ...
})
app.Get("/users/:id/posts/:slug", func(ctx sushi.Ctx) {
userID := ctx.Param("id").Int()
slug := ctx.Param("slug").String()
// Check if parameter exists
if ctx.Param("optional").Exists() {
// Handle optional parameter
}
// String parameters stay strings
app.Get("/users/:name", func(ctx sushi.Ctx, params []any) {
name := params[0].(string) // /users/john -> "john"
// ...
})
```
### Query Parameters
```go
app.Get("/search", func(ctx sushi.Ctx) {
// Get query parameters with fluent API
query := ctx.Query("q").String() // ?q=hello -> "hello"
page := ctx.Query("page").IntDefault(1) // ?page=2 -> 2
limit := ctx.Query("limit").IntDefault(20) // Default to 20 if not present
sortBy := ctx.Query("sort").StringDefault("name") // Default to "name"
// Boolean query params
includeDeleted := ctx.Query("deleted").Bool() // ?deleted=true -> true
// Float values
minPrice := ctx.Query("min_price").Float() // ?min_price=19.99 -> 19.99
// Check existence
if ctx.Query("filter").Exists() {
filter := ctx.Query("filter").String()
// Apply filter
}
})
```
## Form Data
Access form data with the fluent API:
```go
app.Post("/users", func(ctx sushi.Ctx) {
// Get form fields with fluent API
name := ctx.Input("name").String()
email := ctx.Input("email").String()
age := ctx.Input("age").IntDefault(0)
// Check if checkbox is checked
agreeToTerms := ctx.Input("terms").Bool() // Checks for "true", "on", "1", "yes"
// Validate required fields
if ctx.Input("email").IsEmpty() {
ctx.SendError(400, "Email is required")
return
}
// Get array of values (for multiple select, checkboxes)
tags := ctx.GetFormArray("tags[]")
// Mixed types
app.Get("/users/:id/posts/:slug", func(ctx sushi.Ctx, params []any) {
userID := params[0].(int) // 123
slug := params[1].(string) // "my-post"
// ...
})
```
## Response Helpers
```go
func myHandler(ctx sushi.Ctx) {
func myHandler(ctx sushi.Ctx, params []any) {
// JSON responses
ctx.SendJSON(map[string]string{"message": "success"})
@ -138,20 +87,15 @@ func myHandler(ctx sushi.Ctx) {
// Status only
ctx.SendStatus(204)
// File responses
ctx.SendFile("/path/to/file.pdf")
// Raw bytes
ctx.SendBytes(imageData, "image/png")
}
```
## Middleware
```go
// Custom middleware
func loggingMiddleware() sushi.Middleware {
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
println("Request:", string(ctx.Method()), string(ctx.Path()))
next()
println("Status:", ctx.Response.StatusCode())
@ -167,51 +111,16 @@ admin.Use(auth.RequireAuth("/login"))
## Authentication Workflow
### 1. Password Hashing
The password package supports both Argon2 (default) and Bcrypt algorithms with configurable settings:
### 1. Setup Password Hashing
```go
import "git.sharkk.net/Sharkk/Sushi/password"
// Using default Argon2 configuration
// Hash password for storage
hashedPassword := password.HashPassword("userpassword123")
// Verify password (auto-detects algorithm)
// Verify password during login
isValid, err := password.VerifyPassword("userpassword123", hashedPassword)
// Configure for Bcrypt
password.SetConfig(password.Config{
Algorithm: password.Bcrypt,
Bcrypt: password.BcryptConfig{
Cost: 12, // Higher = more secure but slower
},
})
// Configure for Argon2 with custom settings
password.SetConfig(password.Config{
Algorithm: password.Argon2,
Argon2: password.Argon2Config{
Time: 3, // Iterations
Memory: 128 * 1024, // 128 MB
Threads: 4,
KeyLen: 32,
},
})
// Use preset configurations
password.SetConfig(password.Config{
Algorithm: password.Argon2,
Argon2: password.SecureArgon2Config(), // More secure, slower
// Or: password.FastArgon2Config() for development
})
// Check if password needs rehashing (algorithm or params changed)
if password.NeedsRehash(userHashedPassword) {
// Rehash password after successful verification
newHash := password.HashPassword(plainPassword)
// Update stored hash in database
}
```
### 2. User Structure
@ -267,16 +176,9 @@ func main() {
### 4. Login Handler
```go
func loginHandler(ctx sushi.Ctx) {
// Use fluent API for form data
email := ctx.Input("email").String()
password := ctx.Input("password").String()
// Validate inputs
if ctx.Input("email").IsEmpty() || ctx.Input("password").IsEmpty() {
ctx.SendError(400, "Email and password are required")
return
}
func loginHandler(ctx sushi.Ctx, params []any) {
email := string(ctx.PostArgs().Peek("email"))
password := string(ctx.PostArgs().Peek("password"))
// Find user by email/username
user := findUserByEmail(email)
@ -302,7 +204,7 @@ func loginHandler(ctx sushi.Ctx) {
### 5. Logout Handler
```go
func logoutHandler(ctx sushi.Ctx) {
func logoutHandler(ctx sushi.Ctx, params []any) {
ctx.Logout()
ctx.Redirect("/")
}
@ -311,7 +213,7 @@ func logoutHandler(ctx sushi.Ctx) {
### 6. Getting Current User
```go
func dashboardHandler(ctx sushi.Ctx) {
func dashboardHandler(ctx sushi.Ctx, params []any) {
user := ctx.GetCurrentUser().(*User)
html := fmt.Sprintf("<h1>Welcome, %s!</h1>", user.Username)
@ -328,7 +230,7 @@ import "git.sharkk.net/Sharkk/Sushi/csrf"
app.Use(csrf.Middleware())
// In your form template
func loginPageHandler(ctx sushi.Ctx) {
func loginPageHandler(ctx sushi.Ctx, params []any) {
csrfField := csrf.CSRFHiddenField(ctx)
html := fmt.Sprintf(`
@ -364,7 +266,7 @@ app.Get("/assets/*path", sushi.StaticEmbed(files))
## Sessions
```go
func someHandler(ctx sushi.Ctx) {
func someHandler(ctx sushi.Ctx, params []any) {
sess := ctx.GetCurrentSession()
// Set session data
@ -455,7 +357,7 @@ func main() {
app.Listen(":8080")
}
func homeHandler(ctx sushi.Ctx) {
func homeHandler(ctx sushi.Ctx, params []any) {
if ctx.IsAuthenticated() {
ctx.Redirect("/dashboard")
return
@ -463,7 +365,7 @@ func homeHandler(ctx sushi.Ctx) {
ctx.SendHTML(`<a href="/login">Login</a>`)
}
func loginPageHandler(ctx sushi.Ctx) {
func loginPageHandler(ctx sushi.Ctx, params []any) {
html := fmt.Sprintf(`
<form method="POST" action="/login">
%s
@ -476,10 +378,9 @@ func loginPageHandler(ctx sushi.Ctx) {
ctx.SendHTML(html)
}
func loginHandler(ctx sushi.Ctx) {
// Use fluent API for form data
email := ctx.Input("email").String()
pass := ctx.Input("password").String()
func loginHandler(ctx sushi.Ctx, params []any) {
email := string(ctx.PostArgs().Peek("email"))
pass := string(ctx.PostArgs().Peek("password"))
user := findUserByEmail(email)
if user == nil {
@ -496,7 +397,7 @@ func loginHandler(ctx sushi.Ctx) {
ctx.Redirect("/dashboard")
}
func dashboardHandler(ctx sushi.Ctx) {
func dashboardHandler(ctx sushi.Ctx, params []any) {
user := ctx.GetCurrentUser().(*User)
html := fmt.Sprintf(`
@ -510,7 +411,7 @@ func dashboardHandler(ctx sushi.Ctx) {
ctx.SendHTML(html)
}
func logoutHandler(ctx sushi.Ctx) {
func logoutHandler(ctx sushi.Ctx, params []any) {
ctx.Logout()
ctx.Redirect("/")
}

33
auth/middleware.go
View File

@ -7,22 +7,12 @@ import (
const UserCtxKey = "user"
// Auth holds the authentication middleware and user lookup function
type Auth struct {
userLookup func(int) any
}
// New creates a new Auth instance
func New(userLookup func(int) any) *Auth {
return &Auth{userLookup: userLookup}
}
// Middleware returns the authentication middleware function
func (a *Auth) Middleware() sushi.Middleware {
return func(ctx sushi.Ctx, next func()) {
// Middleware adds authentication handling
func Middleware(userLookup func(int) any) sushi.Middleware {
return func(ctx sushi.Ctx, params []any, next func()) {
sess := sushi.GetCurrentSession(ctx)
if sess != nil && sess.UserID > 0 && a.userLookup != nil {
user := a.userLookup(sess.UserID)
if sess != nil && sess.UserID > 0 && userLookup != nil {
user := userLookup(sess.UserID)
if user != nil {
ctx.SetUserValue(UserCtxKey, user)
} else {
@ -34,15 +24,6 @@ func (a *Auth) Middleware() sushi.Middleware {
}
}
// Update refreshes the current user data in the context
func (a *Auth) Update(ctx sushi.Ctx) {
sess := sushi.GetCurrentSession(ctx)
if sess != nil && sess.UserID > 0 && a.userLookup != nil {
user := a.userLookup(sess.UserID)
ctx.SetUserValue(UserCtxKey, user)
}
}
// RequireAuth middleware that redirects unauthenticated users
func RequireAuth(redirectPath ...string) sushi.Middleware {
redirect := "/login"
@ -50,7 +31,7 @@ func RequireAuth(redirectPath ...string) sushi.Middleware {
redirect = redirectPath[0]
}
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
if !ctx.IsAuthenticated() {
ctx.Redirect(redirect, fasthttp.StatusFound)
return
@ -66,7 +47,7 @@ func RequireGuest(redirectPath ...string) sushi.Middleware {
redirect = redirectPath[0]
}
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
if ctx.IsAuthenticated() {
ctx.Redirect(redirect, fasthttp.StatusFound)
return

2
csrf/csrf.go
View File

@ -110,7 +110,7 @@ func ValidateFormCSRFToken(ctx sushi.Ctx) bool {
// Middleware returns middleware that automatically validates CSRF tokens
func Middleware() sushi.Middleware {
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
method := string(ctx.Method())
if method == "POST" || method == "PUT" || method == "PATCH" || method == "DELETE" {

13
forms.go
View File

@ -10,18 +10,13 @@ type FormValue struct {
exists bool
}
// Input gets a form field for chaining
func (ctx Ctx) Input(key string) FormValue {
// Form gets a form field for chaining
func (ctx Ctx) Form(key string) FormValue {
value := string(ctx.PostArgs().Peek(key))
exists := ctx.PostArgs().Has(key)
return FormValue{value: value, exists: exists}
}
// Form gets a form field for chaining (deprecated: use Input instead)
func (ctx Ctx) Form(key string) FormValue {
return ctx.Input(key)
}
// String returns the value as string
func (f FormValue) String() string {
return f.value
@ -106,10 +101,10 @@ func (f FormValue) IsEmpty() bool {
// GetFormArray gets multiple form values as string slice
func (ctx Ctx) GetFormArray(key string) []string {
var values []string
for k, v := range ctx.PostArgs().All() {
ctx.PostArgs().VisitAll(func(k, v []byte) {
if string(k) == key {
values = append(values, string(v))
}
}
})
return values
}

6
fs.go
View File

@ -50,7 +50,7 @@ func StaticFS(fsOptions StaticOptions) Handler {
fsHandler := fs.NewRequestHandler()
return func(ctx Ctx) {
return func(ctx Ctx, params []any) {
fsHandler(ctx.RequestCtx)
}
}
@ -62,14 +62,14 @@ func Static(root string) Handler {
// StaticFile serves a single file
func StaticFile(filePath string) Handler {
return func(ctx Ctx) {
return func(ctx Ctx, params []any) {
fasthttp.ServeFile(ctx.RequestCtx, filePath)
}
}
// StaticEmbed creates a handler for embedded files
func StaticEmbed(files map[string][]byte) Handler {
return func(ctx Ctx) {
return func(ctx Ctx, params []any) {
requestPath := string(ctx.Path())
// Try to find the file

110
params.go
View File

@ -1,110 +0,0 @@
package sushi
import (
"strconv"
"strings"
)
type ParamValue struct {
value string
exists bool
}
// Param gets a route parameter by name for chaining (requires named params)
func (ctx Ctx) Param(name string) ParamValue {
if paramMap, ok := ctx.UserValue("param_names").(map[string]string); ok {
if value, exists := paramMap[name]; exists {
return ParamValue{value: value, exists: true}
}
}
return ParamValue{value: "", exists: false}
}
// Query gets a query parameter for chaining
func (ctx Ctx) Query(key string) ParamValue {
value := string(ctx.QueryArgs().Peek(key))
exists := ctx.QueryArgs().Has(key)
return ParamValue{value: value, exists: exists}
}
// String returns the value as string
func (p ParamValue) String() string {
return p.value
}
// StringDefault returns string with default value
func (p ParamValue) StringDefault(defaultValue string) string {
if p.value == "" {
return defaultValue
}
return p.value
}
// Int returns the value as integer
func (p ParamValue) Int() int {
if p.value == "" {
return 0
}
if parsed, err := strconv.Atoi(p.value); err == nil {
return parsed
}
return 0
}
// IntDefault returns integer with default value
func (p ParamValue) IntDefault(defaultValue int) int {
if p.value == "" {
return defaultValue
}
if parsed, err := strconv.Atoi(p.value); err == nil {
return parsed
}
return defaultValue
}
// Float returns the value as float64
func (p ParamValue) Float() float64 {
if p.value == "" {
return 0.0
}
if parsed, err := strconv.ParseFloat(p.value, 64); err == nil {
return parsed
}
return 0.0
}
// FloatDefault returns float64 with default value
func (p ParamValue) FloatDefault(defaultValue float64) float64 {
if p.value == "" {
return defaultValue
}
if parsed, err := strconv.ParseFloat(p.value, 64); err == nil {
return parsed
}
return defaultValue
}
// Bool returns the value as boolean
func (p ParamValue) Bool() bool {
value := strings.ToLower(p.value)
return value == "true" || value == "on" || value == "1" || value == "yes"
}
// BoolDefault returns boolean with default value
func (p ParamValue) BoolDefault(defaultValue bool) bool {
if p.value == "" {
return defaultValue
}
return p.Bool()
}
// Exists returns true if the parameter exists
func (p ParamValue) Exists() bool {
return p.exists
}
// IsEmpty returns true if the parameter is empty or doesn't exist
func (p ParamValue) IsEmpty() bool {
return p.value == ""
}

188
password/password.go
View File

@ -8,158 +8,33 @@ import (
"strings"
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/bcrypt"
)
// Algorithm represents the hashing algorithm to use
type Algorithm int
const (
Argon2 Algorithm = iota
Bcrypt
argonTime = 1
argonMemory = 64 * 1024
argonThreads = 4
argonKeyLen = 32
)
// Argon2Config holds configuration for Argon2 hashing
type Argon2Config struct {
Time uint32 // Number of iterations
Memory uint32 // Memory usage in KB
Threads uint8 // Number of threads
KeyLen uint32 // Length of generated hash
}
// BcryptConfig holds configuration for Bcrypt hashing
type BcryptConfig struct {
Cost int // Bcrypt cost factor (4-31)
}
// Config holds the password hashing configuration
type Config struct {
Algorithm Algorithm
Argon2 Argon2Config
Bcrypt BcryptConfig
}
// DefaultArgon2Config returns recommended Argon2 settings
func DefaultArgon2Config() Argon2Config {
return Argon2Config{
Time: 1,
Memory: 64 * 1024, // 64 MB
Threads: 4,
KeyLen: 32,
}
}
// SecureArgon2Config returns more secure Argon2 settings (slower but more resistant)
func SecureArgon2Config() Argon2Config {
return Argon2Config{
Time: 3,
Memory: 128 * 1024, // 128 MB
Threads: 4,
KeyLen: 32,
}
}
// FastArgon2Config returns faster Argon2 settings (for testing/development)
func FastArgon2Config() Argon2Config {
return Argon2Config{
Time: 1,
Memory: 32 * 1024, // 32 MB
Threads: 2,
KeyLen: 32,
}
}
// DefaultBcryptConfig returns recommended Bcrypt settings
func DefaultBcryptConfig() BcryptConfig {
return BcryptConfig{
Cost: bcrypt.DefaultCost, // 10
}
}
// SecureBcryptConfig returns more secure Bcrypt settings (slower but more resistant)
func SecureBcryptConfig() BcryptConfig {
return BcryptConfig{
Cost: 12,
}
}
// DefaultConfig returns the default configuration (Argon2 with default settings)
func DefaultConfig() Config {
return Config{
Algorithm: Argon2,
Argon2: DefaultArgon2Config(),
Bcrypt: DefaultBcryptConfig(),
}
}
var globalConfig = DefaultConfig()
// SetConfig sets the global password configuration
func SetConfig(config Config) {
globalConfig = config
}
// GetConfig returns the current global password configuration
func GetConfig() Config {
return globalConfig
}
// HashPassword creates a hash of the password using the global configuration
// HashPassword creates an argon2id hash of the password
func HashPassword(password string) string {
return HashPasswordWithConfig(password, globalConfig)
}
// HashPasswordWithConfig creates a hash of the password using the specified configuration
func HashPasswordWithConfig(password string, config Config) string {
switch config.Algorithm {
case Bcrypt:
return hashBcrypt(password, config.Bcrypt)
case Argon2:
fallthrough
default:
return hashArgon2(password, config.Argon2)
}
}
// hashArgon2 creates an argon2id hash of the password
func hashArgon2(password string, config Argon2Config) string {
salt := make([]byte, 16)
rand.Read(salt)
hash := argon2.IDKey([]byte(password), salt, config.Time, config.Memory, config.Threads, config.KeyLen)
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
b64Salt := base64.RawStdEncoding.EncodeToString(salt)
b64Hash := base64.RawStdEncoding.EncodeToString(hash)
encoded := fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, config.Memory, config.Time, config.Threads, b64Salt, b64Hash)
argon2.Version, argonMemory, argonTime, argonThreads, b64Salt, b64Hash)
return encoded
}
// hashBcrypt creates a bcrypt hash of the password
func hashBcrypt(password string, config BcryptConfig) string {
hash, err := bcrypt.GenerateFromPassword([]byte(password), config.Cost)
if err != nil {
// Fallback to default cost if provided cost is invalid
hash, _ = bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
}
return string(hash)
}
// VerifyPassword checks if a password matches the hash
func VerifyPassword(password, encodedHash string) (bool, error) {
// Detect hash type by prefix
if strings.HasPrefix(encodedHash, "$2a$") || strings.HasPrefix(encodedHash, "$2b$") || strings.HasPrefix(encodedHash, "$2y$") {
return verifyBcrypt(password, encodedHash)
} else if strings.HasPrefix(encodedHash, "$argon2id$") {
return verifyArgon2(password, encodedHash)
}
return false, fmt.Errorf("unsupported hash format")
}
// verifyArgon2 checks if a password matches an argon2 hash
func verifyArgon2(password, encodedHash string) (bool, error) {
parts := strings.Split(encodedHash, "$")
if len(parts) != 6 {
return false, fmt.Errorf("invalid hash format")
@ -202,52 +77,3 @@ func verifyArgon2(password, encodedHash string) (bool, error) {
return false, nil
}
// verifyBcrypt checks if a password matches a bcrypt hash
func verifyBcrypt(password, encodedHash string) (bool, error) {
err := bcrypt.CompareHashAndPassword([]byte(encodedHash), []byte(password))
if err == bcrypt.ErrMismatchedHashAndPassword {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// NeedsRehash checks if a hash needs to be updated to current configuration
func NeedsRehash(encodedHash string) bool {
// Check if using bcrypt when we want argon2
if globalConfig.Algorithm == Argon2 && (strings.HasPrefix(encodedHash, "$2a$") || strings.HasPrefix(encodedHash, "$2b$") || strings.HasPrefix(encodedHash, "$2y$")) {
return true
}
// Check if using argon2 when we want bcrypt
if globalConfig.Algorithm == Bcrypt && strings.HasPrefix(encodedHash, "$argon2id$") {
return true
}
// For bcrypt, check if cost has changed
if strings.HasPrefix(encodedHash, "$2") {
cost, err := bcrypt.Cost([]byte(encodedHash))
if err == nil && cost != globalConfig.Bcrypt.Cost {
return true
}
}
// For argon2, check if parameters have changed
if strings.HasPrefix(encodedHash, "$argon2id$") {
parts := strings.Split(encodedHash, "$")
if len(parts) == 6 {
var m, t, p uint32
_, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &m, &t, &p)
if err == nil {
if m != globalConfig.Argon2.Memory || t != globalConfig.Argon2.Time || p != uint32(globalConfig.Argon2.Threads) {
return true
}
}
}
}
return false
}

74
router.go
View File

@ -12,7 +12,6 @@ type node struct {
children []*node
isDynamic bool
isWildcard bool
paramNames []string
maxParams uint8
}
@ -23,7 +22,7 @@ type Router struct {
patch *node
delete *node
middleware []Middleware
paramsBuffer []string
paramsBuffer []any
}
type Group struct {
@ -41,7 +40,7 @@ func NewRouter() *Router {
patch: &node{},
delete: &node{},
middleware: []Middleware{},
paramsBuffer: make([]string, 64),
paramsBuffer: make([]any, 64),
}
}
@ -50,30 +49,13 @@ func (r *Router) ServeHTTP(ctx *fasthttp.RequestCtx) {
path := string(ctx.Path())
method := string(ctx.Method())
h, params, paramNames, found := r.Lookup(method, path)
h, params, found := r.Lookup(method, path)
if !found {
ctx.SetStatusCode(fasthttp.StatusNotFound)
return
}
// Store params in context
sushiCtx := Ctx{RequestCtx: ctx, Params: params}
if len(params) > 0 {
// Create named param map if param names exist
if len(paramNames) > 0 {
paramMap := make(map[string]string)
for i, name := range paramNames {
if i < len(params) && name != "" {
paramMap[name] = params[i]
}
}
if len(paramMap) > 0 {
sushiCtx.SetUserValue("param_names", paramMap)
}
}
}
h(sushiCtx)
h(Ctx{ctx}, params)
}
// Handler returns a fasthttp request handler
@ -163,19 +145,19 @@ func applyMiddleware(h Handler, mw []Middleware) Handler {
return h
}
return func(ctx Ctx) {
return func(ctx Ctx, params []any) {
var index int
var next func()
next = func() {
if index >= len(mw) {
h(ctx)
h(ctx, params)
return
}
currentMW := mw[index]
index++
currentMW(ctx, next)
currentMW(ctx, params, next)
}
next()
@ -199,16 +181,6 @@ func readSegment(path string, start int) (segment string, end int, hasMore bool)
return path[start:end], end, end < len(path)
}
func extractParamName(segment string) string {
if len(segment) > 1 && segment[0] == ':' {
return segment[1:]
}
if len(segment) > 1 && segment[0] == '*' {
return segment[1:]
}
return ""
}
func (r *Router) addRoute(root *node, path string, h Handler, mw []Middleware) error {
h = applyMiddleware(h, mw)
if path == "/" {
@ -219,8 +191,6 @@ func (r *Router) addRoute(root *node, path string, h Handler, mw []Middleware) e
pos := 0
lastWC := false
count := uint8(0)
var paramNames []string
for {
seg, newPos, more := readSegment(path, pos)
if seg == "" {
@ -236,7 +206,6 @@ func (r *Router) addRoute(root *node, path string, h Handler, mw []Middleware) e
}
if isDyn || isWC {
count++
paramNames = append(paramNames, extractParamName(seg))
}
var child *node
for _, c := range current.children {
@ -256,36 +225,35 @@ func (r *Router) addRoute(root *node, path string, h Handler, mw []Middleware) e
pos = newPos
}
current.handler = h
current.paramNames = paramNames
return nil
}
// Lookup finds a handler matching method and path
func (r *Router) Lookup(method, path string) (Handler, []string, []string, bool) {
func (r *Router) Lookup(method, path string) (Handler, []any, bool) {
root := r.methodNode(method)
if root == nil {
return nil, nil, nil, false
return nil, nil, false
}
if path == "/" {
return root.handler, nil, nil, root.handler != nil
return root.handler, nil, root.handler != nil
}
buffer := r.paramsBuffer
if cap(buffer) < int(root.maxParams) {
buffer = make([]string, root.maxParams)
buffer = make([]any, root.maxParams)
r.paramsBuffer = buffer
}
buffer = buffer[:0]
h, paramCount, paramNames, found := match(root, path, 0, &buffer)
h, paramCount, found := match(root, path, 0, &buffer)
if !found {
return nil, nil, nil, false
return nil, nil, false
}
return h, buffer[:paramCount], paramNames, true
return h, buffer[:paramCount], true
}
func match(current *node, path string, start int, params *[]string) (Handler, int, []string, bool) {
func match(current *node, path string, start int, params *[]any) (Handler, int, bool) {
paramCount := 0
for _, c := range current.children {
@ -295,13 +263,13 @@ func match(current *node, path string, start int, params *[]string) (Handler, in
rem = rem[1:]
}
*params = append(*params, rem)
return c.handler, 1, c.paramNames, c.handler != nil
return c.handler, 1, c.handler != nil
}
}
seg, pos, more := readSegment(path, start)
if seg == "" {
return current.handler, 0, current.paramNames, current.handler != nil
return current.handler, 0, current.handler != nil
}
for _, c := range current.children {
@ -311,14 +279,14 @@ func match(current *node, path string, start int, params *[]string) (Handler, in
paramCount++
}
if !more {
return c.handler, paramCount, c.paramNames, c.handler != nil
return c.handler, paramCount, c.handler != nil
}
h, nestedCount, paramNames, ok := match(c, path, pos, params)
h, nestedCount, ok := match(c, path, pos, params)
if ok {
return h, paramCount + nestedCount, paramNames, true
return h, paramCount + nestedCount, true
}
}
}
return nil, 0, nil, false
return nil, 0, false
}

4
session.go
View File

@ -104,10 +104,6 @@ func (s *Session) GetFlash(key string) (any, bool) {
return value, exists
}
func (s *Session) DeleteFlash(key string) {
s.Delete("flash_" + key)
}
func (s *Session) GetFlashMessage(key string) string {
if flash, exists := s.GetFlash(key); exists {
if msg, ok := flash.(string); ok {

2
session/middleware.go
View File

@ -4,7 +4,7 @@ import sushi "git.sharkk.net/Sharkk/Sushi"
// Middleware provides session handling
func Middleware() sushi.Middleware {
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
sessionID := sushi.GetCookie(ctx, sushi.SessionCookieName)
var sess *sushi.Session

6
sushi.go
View File

@ -8,8 +8,8 @@ import (
"github.com/valyala/fasthttp"
)
func (h Handler) Serve(ctx Ctx) {
h(ctx)
func (h Handler) Serve(ctx Ctx, params []any) {
h(ctx, params)
}
func IsHTTPS(ctx Ctx) bool {
@ -20,7 +20,7 @@ func IsHTTPS(ctx Ctx) bool {
// StandardHandler adapts a standard fasthttp.RequestHandler to the router's Handler
func StandardHandler(handler fasthttp.RequestHandler) Handler {
return func(ctx Ctx) {
return func(ctx Ctx, _ []any) {
handler(ctx.RequestCtx)
}
}

2
timing/timing.go
View File

@ -11,7 +11,7 @@ const RequestTimerKey = "request_start_time"
// Middleware adds request timing functionality
func Middleware() sushi.Middleware {
return func(ctx sushi.Ctx, next func()) {
return func(ctx sushi.Ctx, params []any, next func()) {
startTime := time.Now()
ctx.SetUserValue(RequestTimerKey, startTime)
next()

5
types.go
View File

@ -8,11 +8,10 @@ import (
type Ctx struct {
*fasthttp.RequestCtx
Params []string
}
type Handler func(ctx Ctx)
type Middleware func(ctx Ctx, next func())
type Handler func(ctx Ctx, params []any)
type Middleware func(ctx Ctx, params []any, next func())
// SendHTML sends an HTML response
func (ctx Ctx) SendHTML(html string) {