Redistore

https://pkg.go.dev/github.com/boj/redistore/v2
Admin
Redistore is a Go session store backend for gorilla/sessions that uses Redis as the storage engine...
Tokens:14,362
Snippets:141
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Complete Redistore Example

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

A full example demonstrating how to initialize a redistore store with custom configurations and handle HTTP requests for setting, getting, and deleting session data.

```go
package main

import (
    "log"
    "net/http"

    "github.com/boj/redistore/v2"
    "github.com/gorilla/sessions"
)

func main() {
    // Initialize store with custom configuration
    store, err := redistore.NewStore(
        redistore.KeysFromStrings("secret-key-123"),
        redistore.WithAddress("tcp", "localhost:6379"),
        redistore.WithDB("1"),
        redistore.WithMaxLength(8192),
        redistore.WithKeyPrefix("webapp_"),
        redistore.WithDefaultMaxAge(3600), // 1 hour
    )
    if err != nil {
        log.Fatal(err)
    }
    defer store.Close()

    http.HandleFunc("/set", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        session.Values["user"] = "john_doe"
        session.Values["authenticated"] = true
        sessions.Save(r, w)
        w.Write([]byte("Session saved!"))
    })

    http.HandleFunc("/get", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        user := session.Values["user"]
        if user != nil {
            w.Write([]byte("User: " + user.(string)))
        } else {
            w.Write([]byte("No user in session"))
        }
    })

    http.HandleFunc("/delete", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        session.Options.MaxAge = -1
        sessions.Save(r, w)
        w.Write([]byte("Session deleted!"))
    })

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}


```

--------------------------------

### Quick Start Implementation

Source: https://pkg.go.dev/github.com/boj/redistore/v2

A complete example demonstrating how to initialize the store and use it within an HTTP handler.

```go
package main

import (
    "log"
    "net/http"

    "github.com/boj/redistore/v2"
    "github.com/gorilla/sessions"
)

func main() {
    // Create a new store with options
    store, err := redistore.NewStore(
        redistore.KeysFromStrings("secret-key"),
        redistore.WithAddress("tcp", ":6379"),
    )
    if err != nil {
        panic(err)
    }
    defer store.Close()

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // Get a session
        session, err := store.Get(r, "session-key")
        if err != nil {
            log.Println(err.Error())
            return
        }

        // Set a value
        session.Values["foo"] = "bar"

        // Save session
        if err = sessions.Save(r, w); err != nil {
            log.Fatalf("Error saving session: %v", err)
        }
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Initialize RediStore with Custom Configuration

Source: https://pkg.go.dev/github.com/boj/redistore/v2

A complete example demonstrating store initialization and basic session CRUD operations.

```go
package main

import (
    "log"
    "net/http"

    "github.com/boj/redistore/v2"
    "github.com/gorilla/sessions"
)

func main() {
    // Initialize store with custom configuration
    store, err := redistore.NewStore(
        redistore.KeysFromStrings("secret-key-123"),
        redistore.WithAddress("tcp", "localhost:6379"),
        redistore.WithDB("1"),
        redistore.WithMaxLength(8192),
        redistore.WithKeyPrefix("webapp_"),
        redistore.WithDefaultMaxAge(3600), // 1 hour
    )
    if err != nil {
        log.Fatal(err)
    }
    defer store.Close()

    http.HandleFunc("/set", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        session.Values["user"] = "john_doe"
        session.Values["authenticated"] = true
        sessions.Save(r, w)
        w.Write([]byte("Session saved!"))
    })

    http.HandleFunc("/get", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        user := session.Values["user"]
        if user != nil {
            w.Write([]byte("User: " + user.(string)))
        } else {
            w.Write([]byte("No user in session"))
        }
    })

    http.HandleFunc("/delete", func(w http.ResponseWriter, r *http.Request) {
        session, _ := store.Get(r, "my-session")
        session.Options.MaxAge = -1
        sessions.Save(r, w)
        w.Write([]byte("Session deleted!"))
    })

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### NewStore Basic Usage Example

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Demonstrates basic usage of NewStore with a single secret key and connection via address.

```go
// Basic usage with single key (using helper function)
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### NewStore Usage without Helper Functions

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Example of initializing RediStore by directly providing key pairs as a byte slice, without using helper functions like KeysFromStrings.

```go
// Without helper functions (direct slice)
store, err := NewStore(
    [][]byte{[]byte("secret-key")},
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### NewStore Usage Examples

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Various ways to initialize a RediStore, including key rotation, custom serializers, and URL-based connections.

```go
// Basic usage with single key (using helper function)
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)

// Using Keys() with byte slices
store, err := NewStore(
    Keys(
        []byte("authentication-key"), // 32 or 64 bytes
        []byte("encryption-key"),     // 16, 24, or 32 bytes
    ),
    WithAddress("tcp", ":6379"),
)

// With key rotation (old keys for decoding only)
store, err := NewStore(
    KeysFromStrings(
        "new-auth-key",
        "new-encrypt-key",
        "old-auth-key",    // For decoding existing sessions
        "old-encrypt-key",
    ),
    WithAddress("tcp", "localhost:6379"),
    WithDB("1"),
)

// With multiple options
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", "localhost:6379"),
    WithDB("1"),
    WithMaxLength(8192),
    WithKeyPrefix("myapp_"),
    WithSerializer(JSONSerializer{}),
)

// Using URL
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithURL("redis://:password@localhost:6379/0"),
)

// Without helper functions (direct slice)
store, err := NewStore(
    [][]byte{[]byte("secret-key")},
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Install Redistore v1 (Legacy)

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Use this command to install the legacy v1 of redistore.

```bash
go get github.com/boj/redistore@v1
```

--------------------------------

### Run Test Suite

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Instructions for running the test suite, including starting Redis, running tests, and generating coverage reports.

```bash
# Start Redis (required)
redis-server

# Run tests
go test -v

# With coverage
go test -v -coverprofile=coverage.out
go tool cover -html=coverage.out

```

--------------------------------

### Install Redistore v2

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Use this command to install the latest recommended version of redistore.

```bash
go get github.com/boj/redistore/v2
```

--------------------------------

### Install redistore

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Commands to install the current or legacy versions of the package.

```bash
go get github.com/boj/redistore/v2
```

```bash
go get github.com/boj/redistore@v1
```

--------------------------------

### Handle Configuration Errors

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Example of handling errors when multiple conflicting connection options are provided.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithURL("redis://localhost"), // ❌ Error: multiple connection options
)
if err != nil {
    // Error: "only one connection option can be specified"
    log.Fatal(err)
}
```

--------------------------------

### RediStore Get Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

The Get method retrieves a session for a given name and adds it to the registry. It is analogous to gorilla/sessions FilesystemStore.Get().

```go
func (s *RediStore) Get(r *http.Request, name string) (*sessions.Session, error)
```

--------------------------------

### Handle Connection Errors

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Example of handling errors when the Redis connection fails.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", "invalid:9999"),
)
if err != nil {
    // Error: "failed to connect to Redis: ..."
    log.Fatal(err)
}
```

--------------------------------

### Get - Get Session

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Retrieves a session for the given name from Redis.

```APIDOC
## GET /Get

### Description
Gets a session for the given name after adding it to the registry. See gorilla/sessions FilesystemStore.Get().

### Method
GET

### Endpoint
/Get

### Parameters
#### Path Parameters
None

#### Query Parameters
- **name** (string) - The name of the session to retrieve.

#### Request Body
None

### Request Example
```go
session, err := store.Get(r, "my_session_name")
```

### Response
#### Success Response (200)
- **session** (*sessions.Session) - The retrieved session.
- **error** (error) - An error if the session could not be retrieved.

#### Response Example
```json
{
  "session": {
    "ID": "some-session-id",
    "Values": {
      "user": "john_doe"
    },
    "Options": {
      "MaxAge": 86400,
      "HTTPOnly": true,
      "Secure": false,
      "Domain": "",
      "Path": "/",
      "SameSite": 0
    }
  },
  "error": null
}
```
```

--------------------------------

### Get Session Values

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Retrieve values from a session by their keys. Always check if the retrieved value is nil before type assertion.

```go
session, _ := store.Get(r, "session-key")
username := session.Values["username"]
if username != nil {
    fmt.Println(username.(string))
}

```

--------------------------------

### Migrate from v1 to v2

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Comparison of store initialization between v1 and v2.

```go
// v1
store, err := redistore.NewRediStore(10, "tcp", ":6379", "", "", []byte("key"))

// v2
store, err := redistore.NewStore(
    []byte("key"),
    redistore.WithAddress("tcp", ":6379"),
)
```

--------------------------------

### NewStore Usage with URL

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Shows how to initialize a RediStore using a Redis connection URL.

```go
// Using URL
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithURL("redis://:password@localhost:6379/0"),
)
```

--------------------------------

### Configure Store Post-Initialization

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Modify store settings after the initial creation.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
)

// Modify after creation
store.SetMaxLength(16384)
store.SetKeyPrefix("app2_")
store.SetSerializer(redistore.JSONSerializer{})
store.SetMaxAge(86400 * 7) // 7 days
```

--------------------------------

### Migrate from Redistore v1 to v2

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Compare the initialization syntax for redistore v1 and v2. v2 uses a more idiomatic option pattern for configuration.

```go
// v1
store, err := redistore.NewRediStore(10, "tcp", ":6379", "", "", []byte("key"))

// v2
store, err := redistore.NewStore(
    []byte("key"),
    redistore.WithAddress("tcp", ":6379"),
)

```

--------------------------------

### NewStore Usage with Keys()

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Shows how to use NewStore with byte slices for authentication and encryption keys.

```go
// Using Keys() with byte slices
store, err := NewStore(
    Keys(
        []byte("authentication-key"), // 32 or 64 bytes
        []byte("encryption-key"),     // 16, 24, or 32 bytes
    ),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Initialize RediStore with String Keys

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Create a new RediStore instance using string keys. Useful for development and testing, but use caution with sensitive keys in production.

```go
// Single key
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)

// Multiple keys for rotation
store, err := NewStore(
    KeysFromStrings(
        "new-auth-key",
        "new-encrypt-key",
        "old-auth-key",
        "old-encrypt-key",
    ),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### NewStore Usage with Multiple Options

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Demonstrates configuring a RediStore with various options including address, database, max length, key prefix, and serializer.

```go
// With multiple options
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", "localhost:6379"),
    WithDB("1"),
    WithMaxLength(8192),
    WithKeyPrefix("myapp_"),
    WithSerializer(JSONSerializer{}),
)
```

--------------------------------

### Initialize RediStore with Keys

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Create a new RediStore instance using byte slice keys for authentication and encryption.

```go
store, err := NewStore(
    Keys([]byte("auth-key"), []byte("encrypt-key")),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Post-Initialization Configuration

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Modify store settings like MaxLength, KeyPrefix, Serializer, and MaxAge after the store has been created. This allows for dynamic configuration changes.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
)

// Modify after creation
store.SetMaxLength(16384)
store.SetKeyPrefix("app2_")
store.SetSerializer(redistore.JSONSerializer{})
store.SetMaxAge(86400 * 7) // 7 days

```

--------------------------------

### NewStore Constructor Signature

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Initializes a new RediStore instance with required key pairs and configuration options.

```go
func NewStore(keyPairs [][]byte, opts ...Option) (*RediStore, error)
```

--------------------------------

### NewStore Usage with Key Rotation

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Illustrates creating a RediStore with key rotation, where old keys are used for decoding existing sessions.

```go
// With key rotation (old keys for decoding only)
store, err := NewStore(
    KeysFromStrings(
        "new-auth-key",
        "new-encrypt-key",
        "old-auth-key",    // For decoding existing sessions
        "old-encrypt-key",
    ),
    WithAddress("tcp", "localhost:6379"),
    WithDB("1"),
)
```

--------------------------------

### Handle Configuration Errors

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Catch configuration errors during store initialization, such as specifying multiple connection options. Ensure only one connection method is used.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithURL("redis://localhost"), // ❌ Error: multiple connection options
)
if err != nil {
    // Error: "only one connection option can be specified"
    log.Fatal(err)
}

```

--------------------------------

### Redis Store with Authentication

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a redistore session store with authentication credentials for Redis.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
    redistore.WithAuth("username", "password"),
)
```

--------------------------------

### Configure Redis Connection

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Various methods for initializing the store connection, including authentication, database selection, and URL strings.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
)
```

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
    redistore.WithAuth("username", "password"),
)
```

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
    redistore.WithDB("5"), // Use database 5
)
```

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithURL("redis://:password@localhost:6379/0"),
)
```

--------------------------------

### RediStore Lifecycle and Session Methods

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Methods for managing the store connection and session lifecycle.

```go
func (s *RediStore) Close() error
```

```go
func (s *RediStore) Delete(
	r *http.Request,
	w http.ResponseWriter,
	session *sessions.Session,
) error
```

```go
func (s *RediStore) Get(r *http.Request, name string) (*sessions.Session, error)
```

```go
func (s *RediStore) New(r *http.Request, name string) (*sessions.Session, error)
```

```go
func (s *RediStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error
```

--------------------------------

### Create RediStore with Multiple String Keys for Rotation

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a new RediStore with multiple keys as strings, intended for key rotation. This is convenient for testing but less secure for production than using byte slices.

```go
// Multiple keys for rotation
store, err := NewStore(
    KeysFromStrings(
        "new-auth-key",
        "new-encrypt-key",
        "old-auth-key",
        "old-encrypt-key",
    ),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Basic Connection to Redis Store

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a new redistore session store with a secret key and connects to Redis on the default address.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
)
```

--------------------------------

### Key Rotation with String Keys

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Use KeysFromStrings to provide new and old authentication and encryption keys. The first pair is used for new sessions, while all pairs are tried for decoding existing sessions.

```go
// Keys are provided in pairs: authentication key, encryption key
// The first pair is used for encoding new sessions
// All pairs are tried for decoding existing sessions
store, err := redistore.NewStore(
    redistore.KeysFromStrings(
        "new-authentication-key", // 32 or 64 bytes recommended
        "new-encryption-key",     // 16, 24, or 32 bytes for AES
        "old-authentication-key", // Keep for existing sessions
        "old-encryption-key",     // Keep for existing sessions
    ),
    redistore.WithAddress("tcp", "localhost:6379"),
)

```

--------------------------------

### Run Test Suite

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Commands to run tests and generate coverage reports.

```bash
# Start Redis (required)
redis-server

# Run tests
go test -v

# With coverage
go test -v -coverprofile=coverage.out
go tool cover -html=coverage.out
```

--------------------------------

### Advanced Store Configuration

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Customizing store behavior such as session size, key prefixes, TTL, and serialization.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
    redistore.WithMaxLength(8192),          // Max session size: 8KB
    redistore.WithKeyPrefix("myapp_"),      // Key prefix
    redistore.WithDefaultMaxAge(3600),      // Default TTL: 1 hour
    redistore.WithSerializer(redistore.JSONSerializer{}), // JSON serializer
)
```

--------------------------------

### Redis Store using Redis URL

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a redistore session store by providing a Redis connection URL, which can include authentication and database selection.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithURL("redis://:password@localhost:6379/0"),
)
```

--------------------------------

### Redis Store with Specific Database

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a redistore session store and specifies which Redis database to use.

```go
store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithAddress("tcp", "localhost:6379"),
    redistore.WithDB("5"), // Use database 5
)
```

--------------------------------

### redistore.NewStore Configuration

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a new Redis session store with various configuration options for connection, authentication, and session management.

```APIDOC
## Configuration Options

### Connection Options (Required - Choose ONE)
- **WithPool(pool)** - Use a custom Redis connection pool
- **WithAddress(network, address)** - Connect via network and address (e.g., "tcp", ":6379")
- **WithURL(url)** - Connect via Redis URL (e.g., "redis://localhost:6379/0")

### Authentication Options
- **WithAuth(username, password)** - Set username and password
- **WithPassword(password)** - Set password only

### Redis Configuration
- **WithDB(db)** - Database index ("0"-"15")
- **WithDBNum(dbNum)** - Database index as integer
- **WithPoolSize(size)** - Connection pool size
- **WithIdleTimeout(timeout)** - Connection idle timeout

### Store Configuration
- **WithMaxLength(length)** - Max session size in bytes (0 = unlimited)
- **WithKeyPrefix(prefix)** - Redis key prefix
- **WithDefaultMaxAge(age)** - Default TTL in seconds
- **WithSerializer(s)** - Session serializer
- **WithSessionOptions(opts)** - Full gorilla/sessions options
- **WithPath(path)** - Cookie path
- **WithMaxAge(age)** - Cookie MaxAge
```

--------------------------------

### Key Rotation with Byte Slices

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

For production, use Keys with byte slices loaded from secure storage. This is recommended for managing sensitive keys.

```go
// Using Keys() with byte slices for production
authKey, _ := loadKeyFromSecureStorage("auth-key")
encryptKey, _ := loadKeyFromSecureStorage("encrypt-key")
store, err := redistore.NewStore(
    redistore.Keys(authKey, encryptKey),
    redistore.WithAddress("tcp", "localhost:6379"),
)

```

--------------------------------

### Manage Session Values

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Set and retrieve values from a session store instance.

```go
session, _ := store.Get(r, "session-key")
session.Values["username"] = "john"
session.Values["role"] = "admin"
sessions.Save(r, w)
```

```go
session, _ := store.Get(r, "session-key")
username := session.Values["username"]
if username != nil {
    fmt.Println(username.(string))
}
```

--------------------------------

### Redistore with Gob Serializer

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initialize a redistore store using the default GobSerializer. This is suitable for complex Go types and is efficient for binary data.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    // GobSerializer is the default, no need to specify
)


```

--------------------------------

### Configure Default Session Options

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the default session options for fine-grained control over cookie behavior.

```go
func WithSessionOptions(opts *sessions.Options) Option
```

--------------------------------

### Create RediStore with Single String Key

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initializes a new RediStore with a single secret key provided as a string. Suitable for development and testing. For production, use byte slices from secure storage.

```go
// Single key
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Configure Redis Database Index (String)

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the Redis database index to use. Accepts a string representation of a number between 0 and 15. Defaults to '0' if empty.

```go
func WithDB(db string) Option
```

--------------------------------

### NewStore

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Creates a new RediStore instance with the specified key pairs and configuration options.

```APIDOC
## func NewStore

### Description
Creates a new RediStore with the given options. At least one connection option is required.

### Parameters
#### Arguments
- **keyPairs** ([][]byte) - Required - One or more key pairs for cookie encryption and authentication. Each key should be 16, 24, or 32 bytes.
- **opts** (...Option) - Required - Configuration options including connection, authentication, and store settings.

### Request Example
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)
```

--------------------------------

### Configure Session Serializers

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Choose between the default Gob serializer or the JSON serializer for session data.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    // GobSerializer is the default, no need to specify
)
```

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithSerializer(redistore.JSONSerializer{}),
)
```

--------------------------------

### RediStore Configuration Methods

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Methods to configure the behavior of the RediStore session store.

```APIDOC
## SetKeyPrefix

### Description
Sets the key prefix for all keys used in the RediStore to avoid collisions.

### Parameters
- **p** (string) - Required - The prefix string to be used for keys.

## SetMaxAge

### Description
Restricts the maximum age, in seconds, of the session record in both the database and the browser.

### Parameters
- **v** (int) - Required - Maximum age in seconds. Set to 0 for no restriction.

## SetMaxLength

### Description
Sets the maximum length of new sessions. If set to 0, there is no limit.

### Parameters
- **l** (int) - Required - Maximum length in bytes. Default is 4096.

## SetSerializer

### Description
Sets the session serializer responsible for encoding and decoding session data.

### Parameters
- **ss** (SessionSerializer) - Required - The implementation of the SessionSerializer interface.
```

--------------------------------

### Configure Redis Database Index (Integer)

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the Redis database index using an integer. Equivalent to WithDB(strconv.Itoa(dbNum)).

```go
func WithDBNum(dbNum int) Option
```

--------------------------------

### Use Custom Redis Pool

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Integrating a custom redigo pool for connection management.

```go
import "github.com/gomodule/redigo/redis"

pool := &redis.Pool{
    MaxIdle:     100,
    IdleTimeout: 5 * time.Minute,
    Dial: func() (redis.Conn, error) {
        return redis.Dial("tcp", "localhost:6379")
    },
}

store, err := redistore.NewStore(
    redistore.KeysFromStrings("secret-key"),
    redistore.WithPool(pool),
)
```

--------------------------------

### RediStore New Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

The New method creates a new session for a given name without adding it to the registry. It is analogous to gorilla/sessions FilesystemStore.New().

```go
func (s *RediStore) New(r *http.Request, name string) (*sessions.Session, error)
```

--------------------------------

### Configure Redis Authentication

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the username and password for Redis authentication. Both can be empty if not required.

```go
func WithAuth(username, password string) Option
```

--------------------------------

### Implement Custom Session Serializer

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Define a custom serializer by implementing the SessionSerializer interface and passing it to the store configuration.

```go
type SessionSerializer interface {
    Serialize(ss *sessions.Session) ([]byte, error)
    Deserialize(d []byte, ss *sessions.Session) error
}

type MySerializer struct{}

func (s MySerializer) Serialize(ss *sessions.Session) ([]byte, error) {
    // Your implementation
}

func (s MySerializer) Deserialize(d []byte, ss *sessions.Session) error {
    // Your implementation
}

// Use it
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithSerializer(MySerializer{}),
)
```

--------------------------------

### Redistore with JSON Serializer

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Initialize a redistore store using the JSONSerializer. This serializer provides human-readable and cross-language compatible session data.

```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithSerializer(redistore.JSONSerializer{}),
)


```

--------------------------------

### Configure Key Rotation

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Use key pairs to support rotation without invalidating existing sessions. The first pair encodes new sessions, while all pairs are checked for decoding.

```go
// Keys are provided in pairs: authentication key, encryption key
// The first pair is used for encoding new sessions
// All pairs are tried for decoding existing sessions
store, err := redistore.NewStore(
    redistore.KeysFromStrings(
        "new-authentication-key", // 32 or 64 bytes recommended
        "new-encryption-key",     // 16, 24, or 32 bytes for AES
        "old-authentication-key", // Keep for existing sessions
        "old-encryption-key",     // Keep for existing sessions
    ),
    redistore.WithAddress("tcp", "localhost:6379"),
)

// Using Keys() with byte slices for production
authKey, _ := loadKeyFromSecureStorage("auth-key")
encryptKey, _ := loadKeyFromSecureStorage("encrypt-key")
store, err := redistore.NewStore(
    redistore.Keys(authKey, encryptKey),
    redistore.WithAddress("tcp", "localhost:6379"),
)
```

--------------------------------

### Configure Redis database index

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Sets the Redis database index using a string or integer.

```go
func WithDB(db string) Option
```

```go
func WithDBNum(dbNum int) Option
```

--------------------------------

### RediStore Configuration Options

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Functional options for configuring a RediStore instance.

```APIDOC
## RediStore Configuration Options

### Description
Functions used to configure a RediStore instance. These options are passed to the store constructor.

### Available Options
- **WithAddress(network, address string)** - Connect to Redis using network and address.
- **WithAuth(username, password string)** - Set Redis authentication credentials.
- **WithDB(db string)** - Set Redis database index (0-15).
- **WithDBNum(dbNum int)** - Set Redis database index using an integer.
- **WithDefaultMaxAge(age int)** - Set default TTL in seconds for sessions.
- **WithIdleTimeout(timeout time.Duration)** - Set idle timeout for connections in the pool.
- **WithKeyPrefix(prefix string)** - Set prefix for all Redis keys.
- **WithMaxAge(age int)** - Set MaxAge for session cookies in seconds.
- **WithMaxLength(length int)** - Set maximum size of session data in bytes.
- **WithPassword(password string)** - Set password for Redis authentication.
- **WithPath(path string)** - Set cookie path for sessions.
- **WithPool(pool *redis.Pool)** - Use a custom Redis connection pool.
- **WithPoolSize(size int)** - Set maximum number of idle connections.
- **WithSerializer(serializer SessionSerializer)** - Set the session serializer (e.g., JSONSerializer).
- **WithSessionOptions(opts *sessions.Options)** - Set default session options.
- **WithURL(url string)** - Connect to Redis using a connection URL.
```

--------------------------------

### Configure Default Session Max Age

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the default TTL in seconds for sessions when session.Options.MaxAge is 0. Defaults to 1200 seconds.

```go
func WithDefaultMaxAge(age int) Option
```

--------------------------------

### Configure Session Cookie Path

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the cookie path for sessions. Defaults to '/'. Modifies session options.

```go
func WithPath(path string) Option
```

--------------------------------

### Configure Redis Key Prefix

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the prefix for all Redis keys used by this store. Defaults to 'session_'. Useful for avoiding key collisions.

```go
func WithKeyPrefix(prefix string) Option
```

--------------------------------

### Set Session Values

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Set key-value pairs within a session. Ensure the session is saved after modifications.

```go
session, _ := store.Get(r, "session-key")
session.Values["username"] = "john"
session.Values["role"] = "admin"
sessions.Save(r, w)

```

--------------------------------

### Configure RediStore Connection URL

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Configures RediStore to connect to Redis using a URL. Mutually exclusive with WithPool and WithAddress.

```go
func WithURL(url string) Option
```

```go
WithURL("redis://localhost:6379/0")
```

```go
WithURL("redis://:password@localhost:6379/1")
```

--------------------------------

### Session Serializers

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Configuring different serializers for session data storage.

```APIDOC
## Serializers

### Gob Serializer (Default)
Uses Go's `encoding/gob` package. Efficient binary format, suitable for complex Go types.

### JSON Serializer
Uses `encoding/json` package. Human-readable, cross-language compatible.

### Usage Example
```go
store, err := redistore.NewStore(
    [][]byte{[]byte("secret-key")},
    redistore.WithAddress("tcp", ":6379"),
    redistore.WithSerializer(redistore.JSONSerializer{}),
)
```
```

--------------------------------

### Configure RediStore with Custom Redis Pool

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Configures RediStore to use a custom Redis connection pool. Mutually exclusive with WithAddress and WithURL.

```go
func WithPool(pool *redis.Pool) Option
```

--------------------------------

### KeysFromStrings Function

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Generates key pairs from strings, useful for development and testing.

```APIDOC
## KeysFromStrings Function

### Description
KeysFromStrings creates a key pairs slice from strings. This is the most convenient way to provide keys for development and testing.

Warning: For production use with sensitive keys, consider using Keys() with byte slices loaded from secure storage instead of hardcoded strings.

### Function Signature
```go
func KeysFromStrings(keys ...string) [][]byte
```

### Example Usage
```go
// Single key
store, err := NewStore(
    KeysFromStrings("secret-key"),
    WithAddress("tcp", ":6379"),
)

// Multiple keys for rotation
store, err := NewStore(
    KeysFromStrings(
        "new-auth-key",
        "new-encrypt-key",
        "old-auth-key",
        "old-encrypt-key",
    ),
    WithAddress("tcp", ":6379"),
)
```
```

--------------------------------

### Handle Flash Messages

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Add, retrieve, and clear flash messages within a session.

```go
// Add flash message
session.AddFlash("Welcome back!")
sessions.Save(r, w)

// Retrieve and clear flash messages
flashes := session.Flashes()
for _, flash := range flashes {
    fmt.Println(flash)
}
sessions.Save(r, w) // Save to clear flashes
```

--------------------------------

### Set RediStore Key Prefix

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the prefix for all keys in the RediStore to prevent collisions.

```go
func (s *RediStore) SetKeyPrefix(p string)
```

--------------------------------

### Configure Connection Pool Size

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the maximum number of idle connections in the pool. Defaults to 10. Only applies when using WithAddress or WithURL.

```go
func WithPoolSize(size int) Option
```

--------------------------------

### Configure Connection Idle Timeout

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the idle timeout for connections in the pool. Defaults to 240 seconds. Only applies when using WithAddress or WithURL.

```go
func WithIdleTimeout(timeout time.Duration) Option
```

--------------------------------

### RediStore Methods

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Methods for managing session lifecycles including retrieval, saving, and deletion.

```APIDOC
## Get
Returns a session for the given name after adding it to the registry.

## New
Returns a session for the given name without adding it to the registry.

## Save
Adds a single session to the response.

## Delete
Removes the session from redis and sets the cookie to expire. Note: This method is deprecated; use session.Options.MaxAge = -1 and call Save instead.

## Close
Closes the underlying redis.Pool.
```

--------------------------------

### New - Create New Session

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Creates a new session for the given name without adding it to the registry.

```APIDOC
## POST /New

### Description
Creates a new session for the given name without adding it to the registry. See gorilla/sessions FilesystemStore.New().

### Method
POST

### Endpoint
/New

### Parameters
#### Path Parameters
None

#### Query Parameters
- **name** (string) - The name of the session to create.

#### Request Body
None

### Request Example
```go
session, err := store.New(r, "my_new_session_name")
```

### Response
#### Success Response (200)
- **session** (*sessions.Session) - The newly created session.
- **error** (error) - An error if the session could not be created.

#### Response Example
```json
{
  "session": {
    "ID": "",
    "Values": {},
    "Options": {
      "MaxAge": 2592000,
      "HTTPOnly": true,
      "Secure": false,
      "Domain": "",
      "Path": "/",
      "SameSite": 0
    }
  },
  "error": null
}
```
```

--------------------------------

### Keys Function

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Generates key pairs from byte slices for secure session management.

```APIDOC
## Keys Function

### Description
Keys creates a key pairs slice from individual byte slices. This is a convenience function to simplify the creation of key pairs without having to write [][]byte{...}.

### Function Signature
```go
func Keys(keys ...[]byte) [][]byte
```

### Example Usage
```go
store, err := NewStore(
    Keys([]byte("auth-key"), []byte("encrypt-key")),
    WithAddress("tcp", ":6379"),
)
```
```

--------------------------------

### Configure Redis Password Only

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets only the password for Redis authentication. A convenience function for instances without a username.

```go
func WithPassword(password string) Option
```

--------------------------------

### Configure Session Serializer

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the session serializer. Defaults to GobSerializer. JSONSerializer or custom implementations can also be used.

```go
func WithSerializer(serializer SessionSerializer) Option
```

--------------------------------

### Option Functions

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Functions to configure RediStore options.

```APIDOC
## Option Functions

### Description
These functions provide a way to configure the `RediStore` when creating a new instance. They are used with the `NewStore` constructor.

### Available Options:

- **WithAddress(network, address string) Option**
  Configures the network and address for the Redis connection.

- **WithAuth(username, password string) Option**
  Sets the username and password for Redis authentication.

- **WithDB(db string) Option**
  Selects the Redis database to use.

- **WithDBNum(dbNum int) Option**
  Selects the Redis database by its number.

- **WithDefaultMaxAge(age int) Option**
  Sets the default maximum age for sessions.

- **WithIdleTimeout(timeout time.Duration) Option**
  Configures the idle timeout for Redis connections.

- **WithKeyPrefix(prefix string) Option**
  Sets a prefix for all keys stored in Redis.

- **WithMaxAge(age int) Option**
  Sets the maximum age for sessions.

- **WithMaxLength(length int) Option**
  Sets the maximum length for session data.

- **WithPassword(password string) Option**
  Sets the password for Redis authentication.

- **WithPath(path string) Option**
  Sets the path for session cookies (if applicable).

- **WithPool(pool *redis.Pool) Option**
  Provides a pre-configured Redis connection pool.

- **WithPoolSize(size int) Option**
  Sets the size of the Redis connection pool.

- **WithSerializer(serializer SessionSerializer) Option**
  Specifies the serializer to use for session data (e.g., GobSerializer, JSONSerializer).

- **WithSessionOptions(opts *sessions.Options) Option**
  Allows setting advanced session options.

- **WithURL(url string) Option**
  Configures the Redis connection using a URL string.
```

--------------------------------

### Option Type Definition

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Defines the function type for configuring a RediStore.

```go
type Option func(*storeConfig) error
```

--------------------------------

### Configure Maximum Session Data Length

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the maximum size of session data in bytes. Defaults to 4096 bytes. Set to 0 for no limit (use with caution).

```go
func WithMaxLength(length int) Option
```

--------------------------------

### GobSerializer Serialize Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Serializes session values into a byte slice using Gob encoding. Returns the byte slice and an error if serialization fails.

```go
func (s GobSerializer) Serialize(ss *sessions.Session) ([]byte, error)
```

--------------------------------

### SetKeyPrefix

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Sets a prefix for all keys used by RediStore. This is helpful for isolating sessions when multiple applications share a single Redis instance.

```APIDOC
## SetKeyPrefix

### Description
Sets the key prefix for all keys used in the RediStore. This is useful to avoid key name collisions when using a single Redis instance for multiple applications.

### Method
`func (*RediStore) SetKeyPrefix(p string)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Configure RediStore Connection Address

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Configures RediStore to connect to Redis using a specified network and address. Mutually exclusive with WithPool and WithURL.

```go
func WithAddress(network, address string) Option
```

```go
WithAddress("tcp", "localhost:6379")
```

```go
WithAddress("unix", "/tmp/redis.sock")
```

--------------------------------

### Configure Session Cookie Max Age

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Sets the MaxAge for session cookies in seconds. Defaults to 30 days. Modifies session options.

```go
func WithMaxAge(age int) Option
```

--------------------------------

### Add and Retrieve Flash Messages

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Add temporary flash messages to the session and retrieve them. Flash messages are cleared after retrieval. Remember to save the session to clear them.

```go
// Add flash message
session.AddFlash("Welcome back!")
sessions.Save(r, w)

// Retrieve and clear flash messages
flashes := session.Flashes()
for _, flash := range flashes {
    fmt.Println(flash)
}
sessions.Save(r, w) // Save to clear flashes

```

--------------------------------

### GobSerializer Serialize

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Encodes session values into a byte slice using gob encoding.

```APIDOC
## func (GobSerializer) Serialize

### Description
Encodes the session values using gob encoding and returns the serialized byte slice.

### Parameters
- **ss** (*sessions.Session) - Required - A pointer to the session to be serialized.

### Response
- **data** ([]byte) - The serialized session values.
- **error** (error) - Returns an error if the encoding process encounters an issue.
```

--------------------------------

### JSONSerializer Serialize Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Serializes session values into a JSON-encoded byte slice. Returns an error if session keys are not strings.

```go
func (s JSONSerializer) Serialize(ss *sessions.Session) ([]byte, error)
```

--------------------------------

### Key Rotation

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Supports encryption key rotation to change keys without invalidating existing sessions by providing key pairs.

```APIDOC
## Key Rotation

### Description
Allows changing keys without invalidating existing sessions. Keys are provided in pairs (authentication key, encryption key). The first pair is used for encoding new sessions, while all pairs are tried for decoding existing sessions.

### Key Sizes
- **Authentication key**: 32 or 64 bytes (HMAC)
- **Encryption key**: 16 (AES-128), 24 (AES-192), or 32 bytes (AES-256)

### Helper Functions
- **KeysFromStrings(keys ...string)** - Simplest way to provide keys from strings
- **Keys(keys ...[]byte)** - For keys already as byte slices
```

--------------------------------

### Set RediStore Serializer

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Configures the serializer used for encoding and decoding session data.

```go
func (s *RediStore) SetSerializer(ss SessionSerializer)
```

--------------------------------

### JSONSerializer Methods

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Methods for serializing and deserializing session data using JSON format.

```APIDOC
## JSONSerializer.Serialize

### Description
Converts the session's values into a JSON-encoded byte slice.

### Parameters
- **ss** (pointer) - Required - A pointer to the session to be serialized.

### Response
- **[]byte** - A byte slice containing the JSON-encoded session values.
- **error** - Returns an error if serialization fails or if any session keys are not strings.

## JSONSerializer.Deserialize

### Description
Attempts to deserialize a byte slice into the session's Values map.

### Parameters
- **d** ([]byte) - Required - A byte slice containing the serialized session data.
- **ss** (pointer) - Required - A pointer to the sessions.Session where the data will be stored.

### Response
- **error** - Returns an error if the deserialization process fails.
```

--------------------------------

### JSONSerializer Deserialize Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Deserializes a byte slice into a session's Values map. Returns an error if deserialization fails.

```go
func (s JSONSerializer) Deserialize(d []byte, ss *sessions.Session) error
```

--------------------------------

### Define SessionSerializer Interface

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Interface for implementing custom session data serialization and deserialization.

```go
type SessionSerializer interface {
	Deserialize(d []byte, ss *sessions.Session) error
	Serialize(ss *sessions.Session) ([]byte, error)
}
```

--------------------------------

### GobSerializer Deserialize Method

Source: https://pkg.go.dev/github.com/boj/redistore/v2%40v2.0.1

Deserializes a byte slice into a session object using Gob encoding. Ensure the session object is properly initialized before calling.

```go
func (s GobSerializer) Deserialize(d []byte, ss *sessions.Session) error
```

--------------------------------

### Set RediStore Max Age

Source: https://pkg.go.dev/github.com/boj/redistore/v2

Configures the maximum age of session records in seconds for both database and browser.

```go
func (s *RediStore) SetMaxAge(v int)
```
Tokens:
Raw