🔴 redis

Redis Cache Client - RESP Protocol

~450 lines ~60 function In-Memory

📖 Overview

Redis modülü, RESP (REdis Serialization Protocol) üzerinden tam özellikli Redis client sağlar. String, hash, list, set operations and pub/sub desteği sunar.

🔑 Key Features

🚀 Quick Start

import redis

// Connect
let client = redis.connect("127.0.0.1:6379")?

// String operations
client.set("user:1:name", "Alice")?
let name = client.get("user:1:name")?
io.println("Name: {}", name)

// With expiration (5 minutes)
client.setex("session:abc", 300, "user_data")?

client.close()

💡 Example: Session Management

import redis, crypto, time, json

struct SessionStore do
    redis: redis.Client
end

struct Session do
    user_id: int,
    username: str,
    created_at: time.Instant,
    data: Map[str, str]
end

function session_store_new(redis_url: str) -> Result[SessionStore, Error] do
    return Ok(SessionStore do
        redis: redis.connect(redis_url)?
    end)
end

function create_session(store: SessionStore, user_id: int, username: str) 
    -> Result[str, Error] do
    // Generate session ID
    let session_id = crypto.random_hex(32)
    
    // Create session
    let session = Session do
        user_id: user_id,
        username: username,
        created_at: time.now(),
        data: Map.new()
    end
    
    // Store in Redis (1 hour TTL)
    let key = "session:{}".formatla(session_id)
    let value = json.encode(session)
    store.redis.setex(key, 3600, value)?
    
    return Ok(session_id)
end

function get_session(store: SessionStore, session_id: str) 
    -> Result[Optional[Session], Error] do
    let key = "session:{}".formatla(session_id)
    let value = store.redis.get(key)?
    
    if value.is_none()  do
        return Ok(None)
    end
    
    let session: Session = json.decode(value.unwrap())?
    return Ok(Some(session))
end

function destroy_session(store: SessionStore, session_id: str) -> Result[None, Error] do
    let key = "session:{}".formatla(session_id)
    store.redis.del(key)?
    return Ok(None)
end

// useım
function main() do
    let store = session_store_new("127.0.0.1:6379")?
    
    // Login - create session
    let session_id = create_session(store, 123, "alice")?
    io.println("Session created: {}", session_id)
    
    // Verify session
    if session = get_session(store, session_id)?  do
        io.println("User: {} (ID: {})", session.username, session.user_id)
    end
    
    // Logout - destroy session
    destroy_session(store, session_id)?
end

💡 Example: Rate Limiting

import redis, time

function rate_limit_check(client: redis.Client, user_id: int, max_requests: int, window_secs: int) 
    -> Result[bool, Error] do
    let key = "rate_limit:{}".formatla(user_id)
    
    // Increment counter
    let count = client.incr(key)?
    
    // Set expiry on first request
    if count == 1  do
        client.expire(key, window_secs)?
    end
    
    // Check limit
    return Ok(count <= max_requests)
end

// API endpoint
function handle_request(client: redis.Client, user_id: int) -> Result[None, Error] do
    // 100 requests per minute
    if rate_limit_check(client, user_id, 100, 60)?  do
        // Process request
        io.println("Request processed")
    else do
        io.println("Rate limit exceeded")
    end
    return Ok(None)
end

📊 Data Structures

// Hash (dictionary)
client.hset("user:1", "name", "Alice")?
client.hset("user:1", "email", "alice@example.com")?
let all = client.hgetall("user:1")?

// List (queue)
client.lpush("queue:tasks", "task1")?
client.lpush("queue:tasks", "task2")?
let task = client.rpop("queue:tasks")?

// Set (unique items)
client.sadd("tags", "python")?
client.sadd("tags", "rust")?
let members = client.smembers("tags")?

🔗 Related Modules

← All Modules