feat: add api

control-plane/api/internal/session/mem.go

@@ -0,0 +1,54 @@
+package session
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+// MemManager : Manager en mémoire (dev/tests), avec expiration paresseuse.
+type MemManager struct {
+	mu    sync.RWMutex
+	items map[string]entry
+	ttl   time.Duration
+}
+
+type entry struct {
+	s       Session
+	expires time.Time
+}
+
+func NewMemManager(ttl time.Duration) *MemManager {
+	return &MemManager{items: make(map[string]entry), ttl: ttl}
+}
+
+func (m *MemManager) TTL() time.Duration { return m.ttl }
+
+func (m *MemManager) Create(_ context.Context, s Session) (string, error) {
+	token, err := newToken()
+	if err != nil {
+		return "", err
+	}
+	s.CreatedAt = time.Now().UTC()
+	m.mu.Lock()
+	m.items[token] = entry{s: s, expires: time.Now().Add(m.ttl)}
+	m.mu.Unlock()
+	return token, nil
+}
+
+func (m *MemManager) Get(_ context.Context, token string) (Session, bool, error) {
+	m.mu.RLock()
+	e, ok := m.items[token]
+	m.mu.RUnlock()
+	if !ok || time.Now().After(e.expires) {
+		return Session{}, false, nil
+	}
+	return e.s, true, nil
+}
+
+func (m *MemManager) Delete(_ context.Context, token string) error {
+	m.mu.Lock()
+	delete(m.items, token)
+	m.mu.Unlock()
+	return nil
+}

control-plane/api/internal/session/redis.go

@@ -0,0 +1,65 @@
+package session
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+)
+
+const keyPrefix = "omnex:session:"
+
+// RedisManager : Manager adossé à Redis.
+type RedisManager struct {
+	rdb *redis.Client
+	ttl time.Duration
+}
+
+func NewRedisManager(rdb *redis.Client, ttl time.Duration) *RedisManager {
+	return &RedisManager{rdb: rdb, ttl: ttl}
+}
+
+func (m *RedisManager) TTL() time.Duration { return m.ttl }
+
+func (m *RedisManager) Create(ctx context.Context, s Session) (string, error) {
+	token, err := newToken()
+	if err != nil {
+		return "", err
+	}
+	s.CreatedAt = time.Now().UTC()
+	data, err := json.Marshal(s)
+	if err != nil {
+		return "", err
+	}
+	if err := m.rdb.Set(ctx, keyPrefix+token, data, m.ttl).Err(); err != nil {
+		return "", err
+	}
+	return token, nil
+}
+
+func (m *RedisManager) Get(ctx context.Context, token string) (Session, bool, error) {
+	if token == "" {
+		return Session{}, false, nil
+	}
+	data, err := m.rdb.Get(ctx, keyPrefix+token).Bytes()
+	if errors.Is(err, redis.Nil) {
+		return Session{}, false, nil
+	}
+	if err != nil {
+		return Session{}, false, err
+	}
+	var s Session
+	if err := json.Unmarshal(data, &s); err != nil {
+		return Session{}, false, err
+	}
+	return s, true, nil
+}
+
+func (m *RedisManager) Delete(ctx context.Context, token string) error {
+	if token == "" {
+		return nil
+	}
+	return m.rdb.Del(ctx, keyPrefix+token).Err()
+}

control-plane/api/internal/session/session.go

@@ -0,0 +1,41 @@
+// Package session : sessions utilisateurs stockées côté serveur dans Redis.
+// Tokens opaques aléatoires (révocables), pas de JWT.
+package session
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"time"
+)
+
+// CookieName : nom du cookie de session (httpOnly).
+const CookieName = "omnex_session"
+
+// Session : données associées à un token de session.
+type Session struct {
+	UserID    string    `json:"user_id"`
+	Role      string    `json:"role"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// Manager : cycle de vie des sessions.
+type Manager interface {
+	// Create génère un token opaque et persiste la session (TTL appliqué).
+	Create(ctx context.Context, s Session) (token string, err error)
+	// Get récupère une session par token (found=false si absente/expirée).
+	Get(ctx context.Context, token string) (s Session, found bool, err error)
+	// Delete révoque une session (logout).
+	Delete(ctx context.Context, token string) error
+	// TTL renvoie la durée de vie configurée.
+	TTL() time.Duration
+}
+
+// newToken génère un token de session cryptographiquement aléatoire (256 bits).
+func newToken() (string, error) {
+	b := make([]byte, 32)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+	return base64.RawURLEncoding.EncodeToString(b), nil
+}