effect-redis 0.0.26 → 0.0.28

package/README.md

@@ -26,20 +26,17 @@ import {
   RedisConnectionOptionsLive,
   RedisLive,
   RedisPubSubLive,
-  RedisPersistenceLive,
   Redis,
   RedisPubSub,
-  RedisPersistence,
 } from "effect-redis";
 
 const program = Effect.gen(function* () {
   const redis = yield* Redis;
   const pubsub = yield* RedisPubSub;
-  const storage = yield* RedisPersistence;
 
   // Key-Value operations
-  yield* storage.setValue("user:42", JSON.stringify({ name: "Ada" }));
-  const val = yield* storage.getValue("user:42");
+  yield* redis.set("user:42", JSON.stringify({ name: "Ada" }));
+  const val = yield* redis.get("user:42");
 
   // Core commands
   yield* redis.set("counter", "1");
@@ -61,8 +58,7 @@ const RedisLayer = RedisConnectionOptionsLive({
   url: "redis://localhost:6379",
 }).pipe(
   Layer.provideMerge(RedisLive),
-  Layer.provideMerge(RedisPubSubLive),
-  Layer.provideMerge(RedisPersistenceLive)
+  Layer.provideMerge(RedisPubSubLive)
 );
 
 Effect.runPromise(program.pipe(Effect.provide(RedisLayer)));
@@ -78,7 +74,6 @@ 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 |
 | `RedisStream` | `RedisStreamLive` | Redis Streams operations (XADD, XREAD, XRANGE, etc.) |
 | `RedisConnection` | `RedisConnectionLive` | The underlying shared connection manager |
 
@@ -121,13 +116,116 @@ The most comprehensive service, wrapping hundreds of Redis commands.
 - `subscribe(key, options?)` -> Returns `Stream<StreamEntry>` (continuous polling)
 - `xack(key, group, ...ids)`
 
-### `RedisPersistence` Service
-A simplified service for basic storage needs.
-- `setValue(key, value)`
-- `getValue(key)`
-- `del(key)`
-- `exists(key)`
-- `sAdd(key, members)`
+
+---
+
+## 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)}`)
+  );
+});
+```
 
 ---
 
@@ -148,14 +246,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
-```
-