feat: adjustments in packages and other qol fixes

Author: ConsoleTVs

contract/session.go

@@ -33,10 +33,10 @@ type Session interface {
 	// for extending a session's lifetime during active use.
 	Extend(expiresAt time.Time)
 
-	// Regenerate creates a new session ID and associates it with this session, updating
-	// the expiration time. This is commonly used after authentication to prevent session
+	// Regenerate creates a new session ID and associates it with this session.
+	// This is commonly used after authentication to prevent session
 	// fixation attacks. It returns an error if the regeneration process fails.
-	Regenerate(expiresAt time.Time) error
+	Regenerate() error
 
 	// Clear removes all data from the session while maintaining the session itself.
 	Clear()

framework/cache/memory/cache.go framework/cache/memory.goframework/cache/memory/cache.go renamed to framework/cache/memory.go

@@ -1,4 +1,4 @@
-package memory
+package cache
 
 import (
 	"context"
@@ -15,7 +15,7 @@ type Memory struct {
 	store *cache.Cache
 }
 
-func New(expiration time.Duration, cleanup time.Duration) *Memory {
+func NewMemory(expiration time.Duration, cleanup time.Duration) *Memory {
 	return &Memory{
 		store: cache.New(expiration, cleanup),
 		mux:   sync.Mutex{},

framework/cache/redis/cache.go framework/cache/redis.goframework/cache/redis/cache.go renamed to framework/cache/redis.go

@@ -1,4 +1,4 @@
-package redis
+package cache
 
 import (
 	"context"
@@ -11,16 +11,16 @@ import (
 	"github.com/studiolambda/cosmos/contract"
 )
 
-type Options redis.Options
+type RedisOptions = redis.Options
 
-type Client redis.Client
+type RedisClient redis.Client
 
-func New(options *Options) *Client {
-	return (*Client)(redis.NewClient((*redis.Options)(options)))
+func NewRedis(options *RedisOptions) *RedisClient {
+	return (*RedisClient)(redis.NewClient((*redis.Options)(options)))
 }
 
 // Get retrieves a value by key or returns contract.ErrNotFound if missing.
-func (c *Client) Get(ctx context.Context, key string) (any, error) {
+func (c *RedisClient) Get(ctx context.Context, key string) (any, error) {
 	v, err := (*redis.Client)(c).Get(ctx, key).Result()
 
 	if errors.Is(err, redis.Nil) {
@@ -35,17 +35,17 @@ func (c *Client) Get(ctx context.Context, key string) (any, error) {
 }
 
 // Put sets a key with value and TTL.
-func (c *Client) Put(ctx context.Context, key string, value any, ttl time.Duration) error {
+func (c *RedisClient) Put(ctx context.Context, key string, value any, ttl time.Duration) error {
 	return (*redis.Client)(c).Set(ctx, key, value, ttl).Err()
 }
 
 // Delete removes a key.
-func (c *Client) Delete(ctx context.Context, key string) error {
+func (c *RedisClient) Delete(ctx context.Context, key string) error {
 	return (*redis.Client)(c).Del(ctx, key).Err()
 }
 
 // Has checks if key exists.
-func (c *Client) Has(ctx context.Context, key string) (bool, error) {
+func (c *RedisClient) Has(ctx context.Context, key string) (bool, error) {
 	n, err := (*redis.Client)(c).Exists(ctx, key).Result()
 
 	if err != nil {
@@ -56,7 +56,7 @@ func (c *Client) Has(ctx context.Context, key string) (bool, error) {
 }
 
 // Pull retrieves and deletes a key atomically.
-func (c *Client) Pull(ctx context.Context, key string) (v any, e error) {
+func (c *RedisClient) Pull(ctx context.Context, key string) (v any, e error) {
 	encoded, err := (*redis.Client)(c).GetDel(ctx, key).Result()
 
 	if errors.Is(err, redis.Nil) {
@@ -75,22 +75,22 @@ func (c *Client) Pull(ctx context.Context, key string) (v any, e error) {
 }
 
 // Forever stores a value indefinitely.
-func (c *Client) Forever(ctx context.Context, key string, value any) error {
+func (c *RedisClient) Forever(ctx context.Context, key string, value any) error {
 	return c.Put(ctx, key, value, 0)
 }
 
 // Increment increases a key's integer value by 'by'.
-func (c *Client) Increment(ctx context.Context, key string, by int64) (int64, error) {
+func (c *RedisClient) Increment(ctx context.Context, key string, by int64) (int64, error) {
 	return (*redis.Client)(c).IncrBy(ctx, key, by).Result()
 }
 
 // Decrement decreases a key's integer value by 'by'.
-func (c *Client) Decrement(ctx context.Context, key string, by int64) (int64, error) {
+func (c *RedisClient) Decrement(ctx context.Context, key string, by int64) (int64, error) {
 	return (*redis.Client)(c).DecrBy(ctx, key, by).Result()
 }
 
 // Remember gets or computes and caches a value with TTL.
-func (c *Client) Remember(ctx context.Context, key string, ttl time.Duration, compute func() (any, error)) (any, error) {
+func (c *RedisClient) Remember(ctx context.Context, key string, ttl time.Duration, compute func() (any, error)) (any, error) {
 	val, err := c.Get(ctx, key)
 
 	if err == nil {
@@ -115,6 +115,6 @@ func (c *Client) Remember(ctx context.Context, key string, ttl time.Duration, co
 }
 
 // RememberForever caches a computed value indefinitely.
-func (c *Client) RememberForever(ctx context.Context, key string, compute func() (any, error)) (any, error) {
+func (c *RedisClient) RememberForever(ctx context.Context, key string, compute func() (any, error)) (any, error) {
 	return c.Remember(ctx, key, 0, compute)
 }

framework/crypto/aes/encrypter.go framework/crypto/aes.goframework/crypto/aes/encrypter.go renamed to framework/crypto/aes.go

@@ -1,4 +1,4 @@
-package aes
+package crypto
 
 import (
 	"crypto/aes"
@@ -8,25 +8,25 @@ import (
 	"io"
 )
 
-type Encrypter struct {
+type AES struct {
 	key []byte
 }
 
-var ErrMissmatchedNonceSize = errors.New("missmatched nonce size")
+var ErrMissmatchedAESNonceSize = errors.New("missmatched nonce size")
 
-// NewEncrypter creates a new AES encrypter with the provided key.
+// NewAES creates a new AES encrypter with the provided key.
 // Key should be 16, 24, or 32 bytes for AES-128, AES-192, or AES-256.
-func NewEncrypter(key []byte) (*Encrypter, error) {
+func NewAES(key []byte) (*AES, error) {
 	if len(key) != 16 && len(key) != 24 && len(key) != 32 {
 		return nil, aes.KeySizeError(len(key))
 	}
 
-	return &Encrypter{key: key}, nil
+	return &AES{key: key}, nil
 }
 
 // Encrypt encrypts the plaintext using AES-GCM.
 // Returns ciphertext with nonce prepended.
-func (e *Encrypter) Encrypt(value []byte) ([]byte, error) {
+func (e *AES) Encrypt(value []byte) ([]byte, error) {
 	block, err := aes.NewCipher(e.key)
 
 	if err != nil {
@@ -51,7 +51,7 @@ func (e *Encrypter) Encrypt(value []byte) ([]byte, error) {
 
 // Decrypt decrypts the ciphertext using AES-GCM.
 // Expects nonce to be prepended to ciphertext.
-func (e *Encrypter) Decrypt(value []byte) ([]byte, error) {
+func (e *AES) Decrypt(value []byte) ([]byte, error) {
 	block, err := aes.NewCipher(e.key)
 
 	if err != nil {
@@ -67,7 +67,7 @@ func (e *Encrypter) Decrypt(value []byte) ([]byte, error) {
 	nonceSize := gcm.NonceSize()
 
 	if len(value) < nonceSize {
-		return nil, ErrMissmatchedNonceSize
+		return nil, ErrMissmatchedAESNonceSize
 	}
 
 	nonce, ciphertext := value[:nonceSize], value[nonceSize:]

framework/crypto/aes/encrypter_test.go framework/crypto/aes_test.goframework/crypto/aes/encrypter_test.go renamed to framework/crypto/aes_test.go

@@ -1,22 +1,22 @@
-package aes_test
+package crypto_test
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"github.com/studiolambda/cosmos/framework/crypto/aes"
+	"github.com/studiolambda/cosmos/framework/crypto"
 )
 
-func TestItCanCreateEncrypter(t *testing.T) {
+func TestItCanCreateAESEncrypter(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	_, err := aes.NewEncrypter(key)
+	_, err := crypto.NewAES(key)
 
 	require.NoError(t, err)
 }
 
-func TestItCanEncrypt(t *testing.T) {
+func TestItCanEncryptAES(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	e, err := aes.NewEncrypter(key)
+	e, err := crypto.NewAES(key)
 
 	require.NoError(t, err)
 
@@ -26,9 +26,9 @@ func TestItCanEncrypt(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestItCanDecrypt(t *testing.T) {
+func TestItCanDecryptAES(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	e, _ := aes.NewEncrypter(key)
+	e, _ := crypto.NewAES(key)
 	plain := []byte("Hello, World!")
 	cypher, _ := e.Encrypt(plain)
 	res, err := e.Decrypt(cypher)

framework/crypto/chacha20/encrypter.go framework/crypto/chacha20.goframework/crypto/chacha20/encrypter.go renamed to framework/crypto/chacha20.go

@@ -1,4 +1,4 @@
-package chacha20
+package crypto
 
 import (
 	"crypto/cipher"
@@ -9,27 +9,27 @@ import (
 	"golang.org/x/crypto/chacha20poly1305"
 )
 
-type Encrypter struct {
+type ChaCha20 struct {
 	aead cipher.AEAD
 }
 
-var ErrMissmatchedNonceSize = errors.New("missmatched nonce size")
+var ErrMissmatchedChaCha20NonceSize = errors.New("missmatched nonce size")
 
-// NewEncrypter creates a new ChaCha20-Poly1305 encrypter.
+// NewChaCha20 creates a new ChaCha20-Poly1305 encrypter.
 // Key must be exactly 32 bytes.
-func NewEncrypter(key []byte) (*Encrypter, error) {
+func NewChaCha20(key []byte) (*ChaCha20, error) {
 	aead, err := chacha20poly1305.New(key)
 
 	if err != nil {
 		return nil, err
 	}
 
-	return &Encrypter{aead: aead}, nil
+	return &ChaCha20{aead: aead}, nil
 }
 
 // Encrypt encrypts the plaintext using ChaCha20-Poly1305.
 // Returns ciphertext with nonce prepended.
-func (e *Encrypter) Encrypt(value []byte) ([]byte, error) {
+func (e *ChaCha20) Encrypt(value []byte) ([]byte, error) {
 	nonce := make([]byte, e.aead.NonceSize())
 
 	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
@@ -42,11 +42,11 @@ func (e *Encrypter) Encrypt(value []byte) ([]byte, error) {
 
 // Decrypt decrypts the ciphertext using ChaCha20-Poly1305.
 // Expects nonce to be prepended to ciphertext.
-func (e *Encrypter) Decrypt(value []byte) ([]byte, error) {
+func (e *ChaCha20) Decrypt(value []byte) ([]byte, error) {
 	nonceSize := e.aead.NonceSize()
 
 	if len(value) < nonceSize {
-		return nil, ErrMissmatchedNonceSize
+		return nil, ErrMissmatchedChaCha20NonceSize
 	}
 
 	nonce, ciphertext := value[:nonceSize], value[nonceSize:]

…mework/crypto/chacha20/encrypter_test.go framework/crypto/chacha20_test.goframework/crypto/chacha20/encrypter_test.go renamed to framework/crypto/chacha20_test.go framework/crypto/chacha20/encrypter_test.go renamed to framework/crypto/chacha20_test.go

@@ -1,22 +1,22 @@
-package chacha20_test
+package crypto_test
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"github.com/studiolambda/cosmos/framework/crypto/chacha20"
+	"github.com/studiolambda/cosmos/framework/crypto"
 )
 
-func TestItCanCreateEncrypter(t *testing.T) {
+func TestItCanCreateChaCha20Encrypter(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	_, err := chacha20.NewEncrypter(key)
+	_, err := crypto.NewChaCha20(key)
 
 	require.NoError(t, err)
 }
 
-func TestItCanEncrypt(t *testing.T) {
+func TestItCanEncryptChaCha20(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	e, err := chacha20.NewEncrypter(key)
+	e, err := crypto.NewChaCha20(key)
 
 	require.NoError(t, err)
 
@@ -26,9 +26,9 @@ func TestItCanEncrypt(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestItCanDecrypt(t *testing.T) {
+func TestItCanDecryptChaCha20(t *testing.T) {
 	key := []byte("12345678901234567890123456789012")
-	e, _ := chacha20.NewEncrypter(key)
+	e, _ := crypto.NewChaCha20(key)
 	plain := []byte("Hello, World!")
 	cypher, _ := e.Encrypt(plain)
 	res, err := e.Decrypt(cypher)