effect-redis 0.0.5 → 0.0.7

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from './redis';

package/dist/src/redis.d.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, Layer } from 'effect';
+import { type RedisArgument, createClient } from 'redis';
+declare const RedisError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RedisError";
+} & Readonly<A>;
+export declare class RedisError extends RedisError_base<{
+    cause: unknown;
+    message: string;
+}> {
+}
+interface RedisConnectionOptionsShape {
+    options?: Parameters<typeof createClient>[0];
+}
+declare const RedisConnectionOptions_base: Context.TagClass<RedisConnectionOptions, "RedisConnectionOptions", RedisConnectionOptionsShape>;
+declare class RedisConnectionOptions extends RedisConnectionOptions_base {
+}
+declare const RedisConnectionOptionsLive: (options?: Parameters<typeof createClient>[0]) => Layer.Layer<RedisConnectionOptions, never, never>;
+interface RedisShape {
+    use: <T>(fn: (client: ReturnType<typeof createClient>) => T) => Effect.Effect<Awaited<T>, RedisError, never>;
+}
+declare const Redis_base: Context.TagClass<Redis, "Redis", RedisShape>;
+declare class Redis extends Redis_base {
+}
+interface RedisPubSubShape {
+    publish: (channel: string, message: string) => Effect.Effect<void, RedisError, never>;
+    subscribe: (channel: string, handler: (message: string) => void) => Effect.Effect<void, RedisError, never>;
+}
+declare const RedisPubSub_base: Context.TagClass<RedisPubSub, "RedisPubSub", RedisPubSubShape>;
+declare class RedisPubSub extends RedisPubSub_base {
+}
+interface RedisPersistenceShape {
+    setValue: (key: string, value: string) => Effect.Effect<void, RedisError, never>;
+}
+declare const RedisPersistence_base: Context.TagClass<RedisPersistence, "RedisPersistence", RedisPersistenceShape>;
+declare class RedisPersistence extends RedisPersistence_base {
+}
+export interface StreamEntry {
+    id: RedisArgument;
+    message: Record<string, string>;
+}
+interface RedisStreamShape {
+    xadd: (key: RedisArgument, id: RedisArgument | '*', message: Record<string, RedisArgument>) => Effect.Effect<string, RedisError, never>;
+    xread: (key: RedisArgument, id: RedisArgument, // Use '$' to read only new entries from now
+    block?: number, // Block in milliseconds, 0 for indefinite
+    count?: number) => Effect.Effect<StreamEntry[], RedisError, never>;
+    xrange: (key: RedisArgument, start: RedisArgument, // '-' for earliest available
+    end: RedisArgument, // '+' for latest available
+    count?: number) => Effect.Effect<StreamEntry[], RedisError, never>;
+}
+declare const RedisStream_base: Context.TagClass<RedisStream, "RedisStream", RedisStreamShape>;
+declare class RedisStream extends RedisStream_base {
+}
+declare const RedisLive: Layer.Layer<Redis, RedisError, RedisConnectionOptions>;
+declare const RedisPersistenceLive: Layer.Layer<RedisPersistence, RedisError, RedisConnectionOptions>;
+declare const RedisPubSubLive: Layer.Layer<RedisPubSub, RedisError, RedisConnectionOptions>;
+declare const RedisStreamLive: Layer.Layer<RedisStream, RedisError, RedisConnectionOptions>;
+export { RedisPersistence, RedisPubSub, RedisConnectionOptions, Redis, RedisStream, RedisPersistenceLive, RedisPubSubLive, RedisConnectionOptionsLive, RedisLive, RedisStreamLive, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-redis",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Simple Effect wrapper for Redis.",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -21,9 +21,11 @@
     "@types/bun": "latest"
   },
   "peerDependencies": {
-    "typescript": "^5",
-    "effect": "^3.15.4",
-    "redis": "^5.1.0"
+    "effect": "^3.16.2",
+    "redis": "^5.1.0",
+    "typescript": "^5"
   },
-  "dependencies": {}
+  "dependencies": {
+    "@effect/platform-bun": "^0.69.2"
+  }
 }

package/src/redis.ts

@@ -1,5 +1,5 @@
 import { Context, Data, Effect, Layer } from 'effect';
-import { createClient } from 'redis';
+import { type RedisArgument, createClient } from 'redis';
 
 export class RedisError extends Data.TaggedError('RedisError')<{
   cause: unknown;
@@ -31,36 +31,6 @@ interface RedisShape {
 }
 class Redis extends Context.Tag('Redis')<Redis, RedisShape>() {}
 
-const bootstrapRedisEffect = Effect.gen(function* () {
-  const client = yield* redisClientEffect;
-  return Redis.of({
-    use: (fn) =>
-      Effect.gen(function* () {
-        const result = yield* Effect.try({
-          try: () => fn(client),
-          catch: (e) =>
-            new RedisError({
-              cause: e,
-              message: 'Synchronous error in `Redis.use`',
-            }),
-        });
-        if (result instanceof Promise) {
-          return yield* Effect.tryPromise({
-            try: () => result,
-            catch: (e) =>
-              new RedisError({
-                cause: e,
-                message: 'Asynchronous error in `Redis.use`',
-              }),
-          });
-        }
-        return result;
-      }),
-  });
-});
-
-const RedisLive = Layer.scoped(Redis, bootstrapRedisEffect);
-
 interface RedisPubSubShape {
   publish: (
     channel: string,
@@ -89,6 +59,43 @@ class RedisPersistence extends Context.Tag('RedisPersistence')<
   RedisPersistenceShape
 >() {}
 
+// Stream related types
+export interface StreamEntry {
+  id: RedisArgument;
+  message: Record<string, string>;
+}
+
+interface RedisStreamShape {
+  // Add an entry to a stream
+  xadd: (
+    key: RedisArgument,
+    id: RedisArgument | '*',
+    message: Record<string, RedisArgument>,
+  ) => Effect.Effect<string, RedisError, never>;
+
+  // Read from a stream with ability to block and wait for new entries
+  xread: (
+    key: RedisArgument,
+    id: RedisArgument, // Use '$' to read only new entries from now
+    block?: number, // Block in milliseconds, 0 for indefinite
+    count?: number, // Max number of entries to return
+  ) => Effect.Effect<StreamEntry[], RedisError, never>;
+
+  // Read a range of entries from a stream
+  xrange: (
+    key: RedisArgument,
+    start: RedisArgument, // '-' for earliest available
+    end: RedisArgument, // '+' for latest available
+    count?: number,
+  ) => Effect.Effect<StreamEntry[], RedisError, never>;
+}
+
+class RedisStream extends Context.Tag('RedisStream')<
+  RedisStream,
+  RedisStreamShape
+>() {}
+
+// Common code for redis client creation
 const redisClientEffect = Effect.gen(function* () {
   const { options } = yield* RedisConnectionOptions;
 
@@ -123,68 +130,222 @@ const redisClientEffect = Effect.gen(function* () {
   );
 });
 
-const bootstrapRedisPersistenceEffect = Effect.gen(function* () {
+const bootstrapRedisServiceEffect = Effect.gen(function* () {
   const client = yield* redisClientEffect;
-
-  return RedisPersistence.of({
-    setValue: (key, value) =>
+  return Redis.of({
+    use: (fn) =>
       Effect.gen(function* () {
-        return yield* Effect.tryPromise({
-          try: () => client.set(key, value),
+        const result = yield* Effect.try({
+          try: () => fn(client),
           catch: (e) =>
             new RedisError({
               cause: e,
-              message: 'Error in `Redis.setValue`',
+              message: 'Synchronous error in `Redis.use`',
             }),
         });
+        if (result instanceof Promise) {
+          return yield* Effect.tryPromise({
+            try: () => result,
+            catch: (e) =>
+              new RedisError({
+                cause: e,
+                message: 'Asynchronous error in `Redis.use`',
+              }),
+          });
+        }
+        return result;
+      }),
+  });
+});
+
+const RedisLive = Layer.scoped(Redis, bootstrapRedisServiceEffect);
+
+const bootstrapRedisPersistenceServiceEffect = Effect.gen(function* () {
+  const client = yield* redisClientEffect;
+
+  return RedisPersistence.of({
+    setValue: (key, value) =>
+      Effect.tryPromise({
+        try: () => client.set(key, value),
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `Redis.setValue`',
+          }),
       }),
   });
 });
 
 const RedisPersistenceLive = Layer.scoped(
   RedisPersistence,
-  bootstrapRedisPersistenceEffect,
+  bootstrapRedisPersistenceServiceEffect,
 );
 
-const bootstrapRedisPubSubEffect = Effect.gen(function* () {
+const bootstrapRedisPubSubServiceEffect = Effect.gen(function* () {
   const clientPublish = yield* redisClientEffect;
   const clientSubscribe = yield* redisClientEffect;
 
   return RedisPubSub.of({
     publish: (channel, message) =>
-      Effect.gen(function* () {
-        return yield* Effect.tryPromise({
-          try: () => clientPublish.publish(channel, message),
-          catch: (e) =>
-            new RedisError({
-              cause: e,
-              message: 'Error in `Redis.publish`',
-            }),
-        });
+      Effect.tryPromise({
+        try: () => clientPublish.publish(channel, message),
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `Redis.publish`',
+          }),
       }),
     subscribe: (channel, handler) =>
-      Effect.gen(function* () {
-        return yield* Effect.tryPromise({
-          try: () => clientSubscribe.subscribe(channel, handler),
-          catch: (e) =>
-            new RedisError({
-              cause: e,
-              message: 'Error in `Redis.subscribe`',
-            }),
-        });
+      Effect.tryPromise({
+        try: () => clientSubscribe.subscribe(channel, handler),
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `Redis.subscribe`',
+          }),
       }),
   });
 });
 
-const RedisPubSubLive = Layer.scoped(RedisPubSub, bootstrapRedisPubSubEffect);
+const RedisPubSubLive = Layer.scoped(
+  RedisPubSub,
+  bootstrapRedisPubSubServiceEffect,
+);
+
+// Redis Stream implementation
+const bootstrapRedisStreamServiceEffect = Effect.gen(function* () {
+  // Separate connections: one dedicated to writes (producer) and one to reads (consumer)
+  const clientProducer = yield* redisClientEffect;
+  const clientConsumer = yield* redisClientEffect;
+
+  return RedisStream.of({
+    xadd: (
+      key: RedisArgument,
+      id: RedisArgument,
+      message: Record<string, RedisArgument>,
+    ) =>
+      Effect.tryPromise({
+        try: async () => {
+          // Pass the message object directly to xAdd
+          return await clientProducer.xAdd(key, id, message);
+        },
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `RedisStream.xadd`',
+          }),
+      }),
+
+    xread: (
+      key: RedisArgument,
+      id: RedisArgument,
+      block?: number,
+      count?: number,
+    ) =>
+      Effect.tryPromise({
+        try: async () => {
+          const options: Record<string, number> = {};
+
+          if (block !== undefined) {
+            options.BLOCK = block;
+          }
+
+          if (count !== undefined) {
+            options.COUNT = count;
+          }
+
+          // Create proper XReadStream objects instead of arrays
+          const streams = [{ key, id }];
+          const result = await clientConsumer.xRead(streams, options);
+
+          if (!result) {
+            return [];
+          }
+
+          // Transform result into StreamEntry[] format
+          if (!Array.isArray(result)) {
+            return [];
+          }
+
+          return result.flatMap((stream) => {
+            // Type guard to check if stream has the expected structure
+            if (
+              stream &&
+              typeof stream === 'object' &&
+              'messages' in stream &&
+              Array.isArray(stream.messages)
+            ) {
+              return stream.messages.map((msg) => {
+                // Add type guard for msg
+                if (msg && typeof msg === 'object' && 'id' in msg) {
+                  return {
+                    id: String(msg.id), // Convert to string explicitly
+                    message: msg.message as Record<string, string>,
+                  };
+                }
+                // Return a default or handle error case
+                return {
+                  id: '',
+                  message: {} as Record<string, string>,
+                };
+              });
+            }
+
+            return [];
+          });
+        },
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `RedisStream.xread`',
+          }),
+      }),
+
+    xrange: (
+      key: RedisArgument,
+      start: RedisArgument,
+      end: RedisArgument,
+      count?: number,
+    ) =>
+      Effect.tryPromise({
+        try: async () => {
+          const options: Record<string, number> = {};
+
+          if (count !== undefined) {
+            options.COUNT = count;
+          }
+
+          const result = await clientConsumer.xRange(key, start, end, options);
+
+          // Transform result into StreamEntry[] format
+          return result.map((msg) => ({
+            id: msg.id,
+            message: msg.message as Record<string, string>,
+          }));
+        },
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `RedisStream.xrange`',
+          }),
+      }),
+  });
+});
+
+const RedisStreamLive = Layer.scoped(
+  RedisStream,
+  bootstrapRedisStreamServiceEffect,
+);
 
 export {
   RedisPersistence,
   RedisPubSub,
   RedisConnectionOptions,
   Redis,
+  RedisStream,
   RedisPersistenceLive,
   RedisPubSubLive,
   RedisConnectionOptionsLive,
   RedisLive,
+  RedisStreamLive,
 };