feat: update storage adapter (#15)

* fix: remove file storage adapter

* feat: add close method to the storage adapter

Author: amir78729

AGENTS.md

@@ -236,9 +236,12 @@ type StorageAdapter interface {
     Save(events []Event) error
     Load() ([]Event, error)
     Clear() error
+    Close() error
 }
 ```
 
+The `Close()` method is called when the client is disposed, allowing storage adapters to release resources (e.g., close database connections, Redis clients, file handles).
+
 #### Logger Adapter
 
 ```go

README.md

@@ -61,7 +61,7 @@ func main() {
         APIKey:         "your-api-key",
         Endpoint:       "https://api.example.com/events",
         HTTPAdapter:    adapters.NewNetHTTPAdapter(),
-        StorageAdapter: adapters.NewFileStorageAdapter("ripple_events.json"),
+        StorageAdapter: adapters.NewNoOpStorageAdapter(),
     })
     if err != nil {
         panic(err)
@@ -129,7 +129,7 @@ Configuration validation:
 
 ### Client Methods
 
-#### `Init() error`
+#### `Init()`
 
 Initializes the client and restores persisted events. Uses double-checked locking for thread safety. Resets the disposed state, so calling `Init()` after `Dispose()` re-enables the client.
 
@@ -253,19 +253,17 @@ client, err := ripple.NewClient(ripple.ClientConfig{
 
 | Adapter                | Capacity  | Persistence | Use Case                          |
 | ---------------------- | --------- | ----------- | --------------------------------- |
-| **FileStorageAdapter** | Unlimited | Permanent   | Default, persistent event storage |
-| **NoOpStorageAdapter** | N/A       | None        | When persistence is not needed    |
+| **NoOpStorageAdapter** | N/A       | None        | Default, no persistence           |
 
 ```go
 import "github.com/Tap30/ripple-go/adapters"
 
-// Persistent storage
-fileStorage := adapters.NewFileStorageAdapter("ripple_events.json")
-
-// No persistence
-noopStorage := adapters.NewNoOpStorageAdapter()
+// No persistence (default)
+storage := adapters.NewNoOpStorageAdapter()
 ```
 
+For custom storage implementations (e.g., file, Redis, database), implement the `StorageAdapter` interface. See [adapters/README.md](./adapters/README.md) for examples.
+
 ## Concurrency Guarantees
 
 - **Thread-Safe Flush**: Multiple concurrent `Flush()` calls are serialized via mutex

adapters/README.md

@@ -30,17 +30,14 @@ type StorageAdapter interface {
     Save(events []Event) error
     Load() ([]Event, error)
     Clear() error
+    Close() error
 }
 ```
 
-**Default Implementation:** `FileStorageAdapter`
-
-- Stores events as JSON in a file
-- Suitable for server environments
-
 **NoOp Implementation:** `NoOpStorageAdapter`
 
 - Performs no storage operations
+- Default choice for most use cases
 - Useful when persistence is not required
 
 ### LoggerAdapter
@@ -100,13 +97,107 @@ func (a *MyHTTPAdapter) SendWithContext(ctx context.Context, endpoint string, ev
 ```go
 package main
 
-import "github.com/Tap30/ripple-go/adapters"
+import (
+    "encoding/json"
+    "os"
+    "github.com/Tap30/ripple-go/adapters"
+)
+
+type FileStorage struct {
+    filepath string
+}
+
+func (f *FileStorage) Save(events []adapters.Event) error {
+    data, err := json.Marshal(events)
+    if err != nil {
+        return err
+    }
+    return os.WriteFile(f.filepath, data, 0o644)
+}
+
+func (f *FileStorage) Load() ([]adapters.Event, error) {
+    data, err := os.ReadFile(f.filepath)
+    if err != nil {
+        if os.IsNotExist(err) {
+            return []adapters.Event{}, nil
+        }
+        return nil, err
+    }
+    var events []adapters.Event
+    if err := json.Unmarshal(data, &events); err != nil {
+        return nil, err
+    }
+    return events, nil
+}
+
+func (f *FileStorage) Clear() error {
+    err := os.Remove(f.filepath)
+    if err != nil && !os.IsNotExist(err) {
+        return err
+    }
+    return nil
+}
+
+func (f *FileStorage) Close() error {
+    // No persistent connections for file storage
+    return nil
+}
+```
+
+### Example: Redis Storage Adapter
+
+```go
+package main
+
+import (
+    "context"
+    "encoding/json"
+    "github.com/Tap30/ripple-go/adapters"
+    "github.com/redis/go-redis/v9"
+)
+
+type RedisStorage struct {
+    client *redis.Client
+    key    string
+}
+
+func NewRedisStorage(addr, key string) *RedisStorage {
+    return &RedisStorage{
+        client: redis.NewClient(&redis.Options{Addr: addr}),
+        key:    key,
+    }
+}
+
+func (r *RedisStorage) Save(events []adapters.Event) error {
+    data, err := json.Marshal(events)
+    if err != nil {
+        return err
+    }
+    return r.client.Set(context.Background(), r.key, data, 0).Err()
+}
+
+func (r *RedisStorage) Load() ([]adapters.Event, error) {
+    data, err := r.client.Get(context.Background(), r.key).Result()
+    if err == redis.Nil {
+        return []adapters.Event{}, nil
+    }
+    if err != nil {
+        return nil, err
+    }
+    var events []adapters.Event
+    if err := json.Unmarshal([]byte(data), &events); err != nil {
+        return nil, err
+    }
+    return events, nil
+}
 
-type RedisStorage struct{}
+func (r *RedisStorage) Clear() error {
+    return r.client.Del(context.Background(), r.key).Err()
+}
 
-func (r *RedisStorage) Save(events []adapters.Event) error { return nil }
-func (r *RedisStorage) Load() ([]adapters.Event, error)    { return nil, nil }
-func (r *RedisStorage) Clear() error                       { return nil }
+func (r *RedisStorage) Close() error {
+    return r.client.Close()
+}
 ```
 
 ## Usage with Client
@@ -126,7 +217,7 @@ func main() {
         APIKey:         "your-api-key",
         Endpoint:       "https://api.example.com/events",
         HTTPAdapter:    adapters.NewNetHTTPAdapter(),
-        StorageAdapter: adapters.NewFileStorageAdapter("ripple_events.json"),
+        StorageAdapter: adapters.NewNoOpStorageAdapter(),
         LoggerAdapter:  adapters.NewPrintLoggerAdapter(adapters.LogLevelDebug),
     })
     if err != nil {

adapters/file_storage_adapter_test.go

@@ -23,3 +23,8 @@ func (n *NoOpStorageAdapter) Load() ([]Event, error) {
 func (n *NoOpStorageAdapter) Clear() error {
 	return nil
 }
+
+// Close does nothing and always returns nil.
+func (n *NoOpStorageAdapter) Close() error {
+	return nil
+}

adapters/noop_storage_adapter.go

@@ -43,6 +43,15 @@ func TestNoOpStorageAdapter_Clear(t *testing.T) {
 	}
 }
 
+func TestNoOpStorageAdapter_Close(t *testing.T) {
+	adapter := NewNoOpStorageAdapter()
+
+	err := adapter.Close()
+	if err != nil {
+		t.Errorf("Close should always return nil, got: %v", err)
+	}
+}
+
 func TestNoOpStorageAdapter_Interface(t *testing.T) {
 	var _ StorageAdapter = (*NoOpStorageAdapter)(nil)
 }

adapters/noop_storage_adapter_test.go

@@ -20,4 +20,10 @@ type StorageAdapter interface {
 	//
 	// Returns error if clear fails.
 	Clear() error
+
+	// Close releases any resources held by the storage adapter.
+	// Called when the client is disposed.
+	//
+	// Returns error if close fails.
+	Close() error
 }

adapters/storage_adapter.go

@@ -67,10 +67,10 @@ func TestContractCompliance(t *testing.T) {
 		client, _ := NewClient(createTestConfig())
 		clientValue := reflect.ValueOf(client)
 
-		// Init() error
+		// Init()
 		initType := clientValue.MethodByName("Init").Type()
-		if initType.NumIn() != 0 || initType.NumOut() != 1 {
-			t.Error("Init should take no parameters and return error")
+		if initType.NumIn() != 0 || initType.NumOut() != 0 {
+			t.Error("Init should take no parameters and return nothing")
 		}
 
 		// Track(string, map[string]any, map[string]any) error

contract_validation_test.go

@@ -139,6 +139,12 @@ func (d *Dispatcher) Dispose() {
 
 	d.stopTimer()
 	d.queue.Clear()
+
+	if err := d.storageAdapter.Close(); err != nil {
+		d.loggerAdapter.Error("failed to close storage adapter", map[string]any{
+			"error": err.Error(),
+		})
+	}
 }
 
 // applyQueueLimit applies the maxBufferSize limit using FIFO eviction.