remove zerlog + panic

Author: nidorx

chain.go

@@ -1,29 +1,11 @@
 package chain
 
-import (
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-	"os"
-	"time"
-)
-
-func _l(msg string) string {
-	return "[chain] " + msg
-}
-
-func init() {
-	log.Logger = log.Output(zerolog.ConsoleWriter{
-		Out:        os.Stderr,
-		TimeFormat: time.RFC3339,
-	})
-}
-
 func New() *Router {
 	router := &Router{
-		RedirectTrailingSlash:  true,
+		HandleOPTIONS:          true,
 		RedirectFixedPath:      true,
+		RedirectTrailingSlash:  true,
 		HandleMethodNotAllowed: true,
-		HandleOPTIONS:          true,
 	}
 	router.contextPool.New = func() any {
 		return &Context{}

context.go

@@ -35,21 +35,11 @@ type Context struct {
 	MatchedRoutePath  string
 	Writer            http.ResponseWriter
 	Request           *http.Request
-	Crypto            *cryptoShortcuts
+	Crypto            *cryptoImpl
 	root              *Context
 	children          []*Context
 }
 
-// async(runnable)                       // lifts request out of Jetty's ThreadPool, and moves it to Javalin's AsyncThreadPool
-// async(asyncConfig, runnable)          // same as above, but with additonal config
-// handlerType()                         // handler type of the current handler (BEFORE, AFTER, GET, etc)
-// appData(typedKey)                     // get data from the Javalin instance (see app data section below)
-// with(pluginClass)                     // get context plugin by class, see plugin section below
-// matchedPath()                         // get the path that was used to match this request (ex, "/hello/{name}")
-// endpointHandlerPath()                 // get the path of the endpoint handler that was used to match this request
-// cookieStore()                         // see cookie store section below
-// skipRemainingHandlers()               // skip all remaining handlers for this request
-
 // Set define um valor compartilhado no contexto de execução da requisição
 func (ctx *Context) Set(key any, value any) {
 	if ctx.root != nil {
@@ -62,34 +52,16 @@ func (ctx *Context) Set(key any, value any) {
 }
 
 // Get obtém um valor compartilhado no contexto de execução da requisição
-func (ctx *Context) Get(key any) any {
+func (ctx *Context) Get(key any) (any, bool) {
 	if ctx.root != nil {
 		return ctx.root.Get(key)
 	}
 
 	if ctx.data == nil {
-		return nil
-	}
-	if value, exists := ctx.data[key]; exists {
-		return value
+		return nil, false
 	}
-	return nil
-}
-
-// GetParam returns the value of the first Param which key matches the given name.
-// If no matching Param is found, an empty string is returned.
-func (ctx *Context) GetParam(name string) string {
-	for i := 0; i < ctx.paramCount; i++ {
-		if ctx.paramNames[i] == name {
-			return ctx.paramValues[i]
-		}
-	}
-	return ""
-}
-
-// GetParamByIndex get one parameter per index
-func (ctx *Context) GetParamByIndex(index int) string {
-	return ctx.paramValues[index]
+	value, exists := ctx.data[key]
+	return value, exists
 }
 
 func (ctx *Context) WithParams(names []string, values []string) *Context {
@@ -145,21 +117,21 @@ func (ctx *Context) Router() *Router {
 // Callbacks are invoked in the reverse order they are defined (callbacks defined first are invoked last).
 func (ctx *Context) BeforeSend(callback func()) error {
 	if spy, is := ctx.Writer.(*ResponseWriterSpy); is {
-		return spy.beforeSend(callback)
+		return spy.beforeWriteHeader(callback)
 	}
 	return nil
 }
 
 func (ctx *Context) AfterSend(callback func()) error {
 	if spy, is := ctx.Writer.(*ResponseWriterSpy); is {
-		return spy.afterSend(callback)
+		return spy.afterWrite(callback)
 	}
 	return nil
 }
 
 func (ctx *Context) write() {
 	if spy, is := ctx.Writer.(*ResponseWriterSpy); is {
-		if !spy.wrote {
+		if !spy.writeStarted {
 			ctx.WriteHeader(http.StatusOK)
 		}
 	}

context_request.go

@@ -4,18 +4,12 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 )
 
-// BodyAs(obj) err                     // request body as specified class (deserialized from JSON)
-// QueryAs(obj) err                    // request body as specified class (deserialized from JSON)
-
-// Request methods
-// body()                                // request body as string
-// bodyAsBytes()                         // request body as array of bytes
-
 // BodyBytes get body as array of bytes
 func (ctx *Context) BodyBytes() (body []byte, err error) {
-	if cb := ctx.Get(BodyBytesKey); cb != nil {
+	if cb, exist := ctx.Get(BodyBytesKey); exist && cb != nil {
 		if cbb, ok := cb.([]byte); ok {
 			body = cbb
 		}
@@ -32,51 +26,47 @@ func (ctx *Context) BodyBytes() (body []byte, err error) {
 	return
 }
 
-// bodyStreamAsClass(clazz)              // request body as specified class (memory optimized version of above)
-// bodyValidator(clazz)                  // request body as validator typed as specified class
-// bodyInputStream()                     // the underyling input stream of the request
-
-// formParam("name")                     // form parameter by name, as string
-// formParamAsClass("name", clazz)       // f orm parameter by name, as validator typed as specified class
-// formParams("name")                    // list of form parameters by name
-// formParamMap()                        // map of all form parameters
-
-// pathParam("name")                     // path parameter by name as string
-// pathParamAsClass("name", clazz)       // path parameter as validator typed as specified class
-// pathParamMap()                        // map of all path parameters
-
-// queryParam("name")                    // query param by name as string
-// queryParamAsClass("name", clazz)      // query param parameter by name, as validator typed as specified class
-// queryParams("name")                   // list of query parameters by name
-// queryParamMap()                       // map of all query parameters
-// queryString()                         // full query string
-
-// uploadedFile("name")                  // uploaded file by name
-// uploadedFiles("name")                 // all uploaded files by name
-// uploadedFiles()                       // all uploaded files as list
-// uploadedFileMap()                     // all uploaded files as a "names by files" map
-
-// basicAuthCredentials()                // basic auth credentials (or null if not set)
-
-// attribute("name", value)              // set an attribute on the request
-// attribute("name")                     // get an attribute on the request
-// attributeOrCompute("name", ctx -> {}) // get an attribute or compute it based on the context if absent
-// attributeMap()                        // map of all attributes on the request
+// GetParam returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ctx *Context) GetParam(name string) string {
+	for i := 0; i < ctx.paramCount; i++ {
+		if ctx.paramNames[i] == name {
+			return ctx.paramValues[i]
+		}
+	}
+	return ""
+}
 
-// contentLength()                       // content length of the request body
-// contentType()                         // request content type
+// GetParamByIndex get one parameter per index
+func (ctx *Context) GetParamByIndex(index int) string {
+	return ctx.paramValues[index]
+}
 
-// isMultipart()                         // true if the request is multipart
-// isMultipartFormData()                 // true if the request is multipart/formdata
+// @TODO: cache
+func (ctx *Context) QueryParam(name string, defaultValue ...string) string {
+	if val := ctx.Request.URL.Query().Get(name); val != "" {
+		return val
+	}
+	for _, v := range defaultValue {
+		return v
+	}
+	return ""
+}
 
-// sessionAttribute("name", value)       // set a session attribute
-// sessionAttribute("name")              // get a session attribute
-// consumeSessionAttribute("name")       // get a session attribute, and set value to null
-// cachedSessionAttribute("name", value) // set a session attribute, and cache the value as a request attribute
-// cachedSessionAttribute("name")        // get a session attribute, and cache the value as a request attribute
-// cachedSessionAttributeOrCompute(...)  // same as above, but compute and set if value is absent
-// sessionAttributeMap()                 // map of all session attributes
-// cookieMap()                           // map of all request cookies
+func (ctx *Context) QueryParamInt(name string, defaultValue ...int) int {
+	str := ctx.QueryParam(name, "0")
+	if str == "" {
+		for _, v := range defaultValue {
+			return v
+		}
+		return 0
+	}
+	val, err := strconv.Atoi(str)
+	if err != nil {
+		return 0
+	}
+	return val
+}
 
 // Host host as string
 func (ctx *Context) Host() string {
@@ -118,10 +108,6 @@ func (ctx *Context) GetCookie(name string) *http.Cookie {
 	return nil
 }
 
-// header("name")                        // request header by name (can be used with Header.HEADERNAME)
-// headerAsClass("name", clazz)          // request header by name, as validator typed as specified class
-// headerMap()                           // map of all request headers
-
 // GetHeader gets the first value associated with the given key. If there are no values associated with the key,
 // GetHeader returns "".
 // It is case insensitive; textproto.CanonicalMIMEHeaderKey is used to canonicalize the provided key. Get assumes

context_response.go

@@ -22,6 +22,30 @@ func (ctx *Context) Json(v any) {
 	}
 }
 
+// WriteStarted returns true if the ctx.Writer.Write or ctx.Writer.WriteHeader method was called
+func (ctx *Context) WriteStarted() bool {
+	if w, ok := ctx.Writer.(*ResponseWriterSpy); ok {
+		return w.writeStarted
+	}
+	return true
+}
+
+// WriteCalled returns true if the ctx.Writer.Write method was called
+func (ctx *Context) WriteCalled() bool {
+	if w, ok := ctx.Writer.(*ResponseWriterSpy); ok {
+		return w.writeCalled
+	}
+	return true
+}
+
+// WriteCalled returns true if the ctx.Writer.WriteHeader method was called
+func (ctx *Context) WriteHeaderCalled() bool {
+	if w, ok := ctx.Writer.(*ResponseWriterSpy); ok {
+		return w.writeHeaderCalled
+	}
+	return true
+}
+
 // ServeContent replies to the request using the content in the
 // provided. The main benefit of ServeContent over io.Copy
 // is that it handles Range requests properly, sets the MIME type, and

crypto/crypto.go

@@ -0,0 +1,11 @@
+package crypto
+
+type Crypto interface {
+	Decrypt(secret []byte, encrypted []byte, aad []byte) (plain []byte, err error)
+	Encrypt(secret []byte, data []byte, aad []byte) (encrypted []byte, err error)
+	KeyGenerate(secret []byte, salt []byte, iterations int, length int, digest string) []byte
+	MessageDecrypt(secret []byte, encoded []byte, aad []byte) (content []byte, err error)
+	MessageEncrypt(secret []byte, content []byte, aad []byte) (encoded string, err error)
+	MessageSign(secret []byte, message []byte, digest string) string
+	MessageVerify(secret []byte, signed []byte) (decoded []byte, err error)
+}

crypto_keyring.go

@@ -1,8 +1,9 @@
 package chain
 
 import (
+	"log/slog"
+
 	"github.com/nidorx/chain/crypto"
-	"github.com/rs/zerolog/log"
 )
 
 // NewKeyring starts a Keyring that will be updated whenever SecretKeySync() is invoked
@@ -27,7 +28,7 @@ func NewKeyring(salt string, iterations int, length int, digest string) *crypto.
 	SecretKeySync(func(secretKeyBase string) {
 		key := crypt.KeyGenerate([]byte(secretKeyBase), []byte(salt), iterations, length, digest)
 		if err := k.AddKey(key); err != nil {
-			log.Error().Err(err).Msg(_l("[chain.keyring] error deriving key from SecretKeyBase"))
+			slog.Error("[chain.keyring] error deriving key from SecretKeyBase", slog.Any("error", err))
 			return
 		}
 	})

crypto_shortcuts.go

@@ -3,60 +3,60 @@ package chain
 import "github.com/nidorx/chain/crypto"
 
 var (
-	crypt        = &cryptoShortcuts{}
-	msgEncryptor = crypto.MessageEncryptor{}
+	crypt        = &cryptoImpl{}
 	msgVerifier  = crypto.MessageVerifier{}
+	msgEncryptor = crypto.MessageEncryptor{}
 	keyGenerator = crypto.KeyGenerator{}
 )
 
 // Crypto get the reference to a structure that has shortcut to all encryption related functions
-func Crypto() *cryptoShortcuts {
+func Crypto() crypto.Crypto {
 	return crypt
 }
 
-type cryptoShortcuts struct{}
+type cryptoImpl struct{}
 
 // Encrypt is used to encrypt a data with a given key.
-func (c *cryptoShortcuts) Encrypt(secret []byte, data []byte, aad []byte) (encrypted []byte, err error) {
+func (c *cryptoImpl) Encrypt(secret []byte, data []byte, aad []byte) (encrypted []byte, err error) {
 	return crypto.Encrypt(secret, data, aad)
 }
 
 // Decrypt is used to decrypt a message with a given key, and verify it's contents.
-func (c *cryptoShortcuts) Decrypt(secret []byte, encrypted []byte, aad []byte) (plain []byte, err error) {
+func (c *cryptoImpl) Decrypt(secret []byte, encrypted []byte, aad []byte) (plain []byte, err error) {
 	return crypto.Decrypt(secret, encrypted, aad)
 }
 
 // KeyGenerate Returns a derived key suitable for use.
 //
 // See crypto.KeyGenerator.Generate()
-func (c *cryptoShortcuts) KeyGenerate(secret []byte, salt []byte, iterations int, length int, digest string) []byte {
+func (c *cryptoImpl) KeyGenerate(secret []byte, salt []byte, iterations int, length int, digest string) []byte {
 	return keyGenerator.Generate(secret, salt, iterations, length, digest)
 }
 
 // MessageSign generates a signed message for the provided value.
 //
 // See crypto.MessageVerifier.Sign()
-func (c *cryptoShortcuts) MessageSign(secret []byte, message []byte, digest string) string {
+func (c *cryptoImpl) MessageSign(secret []byte, message []byte, digest string) string {
 	return msgVerifier.Sign(secret, message, digest)
 }
 
 // MessageVerify decodes and verifies the encoded binary was not tampered with.
 //
 // See crypto.MessageVerifier.Verify()
-func (c *cryptoShortcuts) MessageVerify(secret []byte, signed []byte) (decoded []byte, err error) {
+func (c *cryptoImpl) MessageVerify(secret []byte, signed []byte) (decoded []byte, err error) {
 	return msgVerifier.Verify(secret, signed)
 }
 
 // MessageEncrypt encrypts and authenticates a message using AES128-GCM mode.
 //
 // See crypto.MessageEncryptor.Encrypt()
-func (c *cryptoShortcuts) MessageEncrypt(secret []byte, content []byte, aad []byte) (encoded string, err error) {
+func (c *cryptoImpl) MessageEncrypt(secret []byte, content []byte, aad []byte) (encoded string, err error) {
 	return msgEncryptor.Encrypt(secret, content, aad)
 }
 
 // MessageDecrypt decrypt a message using authenticated encryption.
 //
 // See crypto.MessageEncryptor.Decrypt()
-func (c *cryptoShortcuts) MessageDecrypt(secret []byte, encoded []byte, aad []byte) (content []byte, err error) {
+func (c *cryptoImpl) MessageDecrypt(secret []byte, encoded []byte, aad []byte) (content []byte, err error) {
 	return msgEncryptor.Decrypt(secret, encoded, aad)
 }