effect-redis 0.0.26 → 0.0.27

package/README.md

@@ -78,7 +78,7 @@ The library is organized into several services, all of which can share a single
 | :--- | :--- | :--- |
 | `Redis` | `RedisLive` | Comprehensive Redis commands (Get, Set, Hash, List, etc.) |
 | `RedisPubSub` | `RedisPubSubLive` | Specialized Pub/Sub operations |
-| `RedisPersistence` | `RedisPersistenceLive` | Simple persistence helpers |
+| `RedisPersistence` | `RedisPersistenceLive` | **Deprecated**: Use `Redis` service instead. Will be removed soon. |
 | `RedisStream` | `RedisStreamLive` | Redis Streams operations (XADD, XREAD, XRANGE, etc.) |
 | `RedisConnection` | `RedisConnectionLive` | The underlying shared connection manager |
 
@@ -121,7 +121,9 @@ The most comprehensive service, wrapping hundreds of Redis commands.
 - `subscribe(key, options?)` -> Returns `Stream<StreamEntry>` (continuous polling)
 - `xack(key, group, ...ids)`
 
-### `RedisPersistence` Service
+### `RedisPersistence` Service (**Deprecated**)
+> **Note**: This service is being substituted by the `Redis` service and will be removed in a future version. Please migrate to the `Redis` service for all key-value operations.
+
 A simplified service for basic storage needs.
 - `setValue(key, value)`
 - `getValue(key)`
@@ -131,6 +133,116 @@ A simplified service for basic storage needs.
 
 ---
 
+## Usage Examples
+
+### 1. Automatic Reconnection & Retries
+In production, connections can drop. Use `Stream.retry` with a `Schedule` to handle this gracefully:
+
+```ts
+import { Effect, Stream, Schedule, Duration } from "effect";
+import { RedisPubSub } from "effect-redis";
+
+const program = Effect.gen(function* () {
+  const pubsub = yield* RedisPubSub;
+  const subscription = yield* pubsub.subscribe("raw-data");
+
+  const monitoringStream = subscription.pipe(
+    Stream.tap(msg => Effect.log(`Received: ${msg}`)),
+    // Retry with exponential backoff if the connection fails
+    Stream.retry(
+      Schedule.exponential(Duration.seconds(1)).pipe(
+        Schedule.intersect(Schedule.recurs(5))
+      )
+    )
+  );
+
+  yield* Stream.runDrain(monitoringStream);
+});
+```
+
+### 2. Stream Processing with Schema Validation
+Integrate with `@effect/schema` to build type-safe data pipelines:
+
+```ts
+import { Effect, Stream, Schema, pipe } from "effect";
+import { RedisPubSub } from "effect-redis";
+
+const TradeSchema = Schema.Struct({
+  symbol: Schema.String,
+  price: Schema.Number,
+});
+
+const program = Effect.gen(function* () {
+  const pubsub = yield* RedisPubSub;
+  const trades = yield* pubsub.subscribe("trades");
+
+  yield* pipe(
+    trades,
+    Stream.map(JSON.parse),
+    Stream.mapEffect(data => 
+      Schema.decodeUnknown(TradeSchema)(data).pipe(
+        Effect.tapError(err => Effect.logWarning(`Invalid trade: ${err}`)),
+        Effect.option // Filter out invalid entries
+      )
+    ),
+    Stream.filterMap(opt => opt),
+    Stream.tap(trade => Effect.log(`Valid trade: ${trade.symbol} @ ${trade.price}`)),
+    Stream.runDrain
+  );
+});
+```
+
+### 3. Custom Commands & Transactions
+Escalate to the raw `node-redis` client for features not natively wrapped:
+
+```ts
+import { Effect } from "effect";
+import { Redis } from "effect-redis";
+
+const program = Effect.gen(function* () {
+  const redis = yield* Redis;
+
+  // Execute a transaction using the raw client
+  const results = yield* redis.use((client) =>
+    client
+      .multi()
+      .set("key1", "val1")
+      .set("key2", "val2")
+      .exec()
+  );
+
+  yield* Effect.log(`Transaction results: ${JSON.stringify(results)}`);
+});
+```
+
+### 4. Continuous Redis Stream Polling
+Use `RedisStream.subscribe` for continuous polling. You can track the last seen ID to ensure continuity across restarts:
+
+```ts
+import { Effect, Stream } from "effect";
+import { RedisStream } from "effect-redis";
+
+const program = Effect.gen(function* () {
+  const redisStream = yield* RedisStream;
+
+  // Track the last seen ID in a Ref for continuity
+  const lastId = yield* Effect.makeRef("$"); 
+
+  const events = redisStream.subscribe("app-events", {
+    id: yield* lastId.get,
+    block: 5000 // Wait up to 5s if idle
+  }).pipe(
+    Stream.tap(entry => lastId.set(String(entry.id)))
+  );
+
+  yield* Stream.runForEach(events, entry => 
+    Effect.log(`Event ID: ${entry.id}, Data: ${JSON.stringify(entry.message)}`)
+  );
+});
+```
+
+---
+
 ## Error Model
 
 Every operation can fail with a `RedisError`, which is a union of specific error types:
@@ -148,14 +260,3 @@ const program = Redis.pipe(
   )
 );
 ```
-
----
-
-## Separate CLI Tool
-
-Looking for a CLI tool to monitor Redis? Check out [@ceschiatti/redistail](https://www.npmjs.com/package/@ceschiatti/redistail), which is built using this library!
-
-```bash
-npx @ceschiatti/redistail --help
-```
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-redis",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Simple Effect wrapper for Redis.",
   "module": "dist/index.js",
   "main": "dist/index.js",