effect-redis 0.0.7 → 0.0.9

package/dist/src/redis.d.ts

@@ -30,6 +30,7 @@ declare class RedisPubSub extends RedisPubSub_base {
 }
 interface RedisPersistenceShape {
     setValue: (key: string, value: string) => Effect.Effect<void, RedisError, never>;
+    sAdd: (key: string, members: string[]) => Effect.Effect<void, RedisError, never>;
 }
 declare const RedisPersistence_base: Context.TagClass<RedisPersistence, "RedisPersistence", RedisPersistenceShape>;
 declare class RedisPersistence extends RedisPersistence_base {

package/package.json

@@ -1,31 +1,31 @@
-{
-  "name": "effect-redis",
-  "version": "0.0.7",
-  "description": "Simple Effect wrapper for Redis.",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "files": ["dist", "src", "README.md"],
-  "scripts": {
-    "build:main": "bun build --minify-syntax --minify-whitespace ./src/index.ts --outdir ./dist --target node --format esm",
-    "build:types": "bun tsc --emitDeclarationOnly --outDir dist",
-    "build": "bun run build:main && bun run build:types",
-    "prepublishOnly": "bun run build",
-    "test": "bun test",
-    "format": "biome format --write ./src",
-    "lint": "biome lint ."
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "effect": "^3.16.2",
-    "redis": "^5.1.0",
-    "typescript": "^5"
-  },
-  "dependencies": {
-    "@effect/platform-bun": "^0.69.2"
-  }
-}
+{
+  "name": "effect-redis",
+  "version": "0.0.9",
+  "description": "Simple Effect wrapper for Redis.",
+  "module": "dist/index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": ["dist", "src", "README.md"],
+  "scripts": {
+    "build:main": "bun build --minify-syntax --minify-whitespace ./src/index.ts --outdir ./dist --target node --format esm",
+    "build:types": "bun tsc --emitDeclarationOnly --outDir dist",
+    "build": "bun run build:main && bun run build:types",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "format": "biome format --write ./src",
+    "lint": "biome lint ."
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "effect": "^3.16.2",
+    "redis": "^5.1.0",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@effect/platform-bun": "^0.69.2"
+  }
+}

package/src/redis.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, Layer } from 'effect';
+import { Context, Data, Effect, Layer, type Scope } from 'effect';
 import { type RedisArgument, createClient } from 'redis';
 
 export class RedisError extends Data.TaggedError('RedisError')<{
@@ -52,6 +52,10 @@ interface RedisPersistenceShape {
     key: string,
     value: string,
   ) => Effect.Effect<void, RedisError, never>;
+  sAdd: (
+    key: string,
+    members: string[],
+  ) => Effect.Effect<void, RedisError, never>;
 }
 
 class RedisPersistence extends Context.Tag('RedisPersistence')<
@@ -96,7 +100,11 @@ class RedisStream extends Context.Tag('RedisStream')<
 >() {}
 
 // Common code for redis client creation
-const redisClientEffect = Effect.gen(function* () {
+const redisClientEffect: Effect.Effect<
+  ReturnType<typeof createClient>,
+  RedisError,
+  Scope.Scope | RedisConnectionOptions
+> = Effect.gen(function* () {
   const { options } = yield* RedisConnectionOptions;
 
   return yield* Effect.acquireRelease(
@@ -131,7 +139,7 @@ const redisClientEffect = Effect.gen(function* () {
 });
 
 const bootstrapRedisServiceEffect = Effect.gen(function* () {
-  const client = yield* redisClientEffect;
+  const client: ReturnType<typeof createClient> = yield* redisClientEffect;
   return Redis.of({
     use: (fn) =>
       Effect.gen(function* () {
@@ -161,7 +169,7 @@ const bootstrapRedisServiceEffect = Effect.gen(function* () {
 const RedisLive = Layer.scoped(Redis, bootstrapRedisServiceEffect);
 
 const bootstrapRedisPersistenceServiceEffect = Effect.gen(function* () {
-  const client = yield* redisClientEffect;
+  const client: ReturnType<typeof createClient> = yield* redisClientEffect;
 
   return RedisPersistence.of({
     setValue: (key, value) =>
@@ -173,6 +181,15 @@ const bootstrapRedisPersistenceServiceEffect = Effect.gen(function* () {
             message: 'Error in `Redis.setValue`',
           }),
       }),
+    sAdd: (key, members) =>
+      Effect.tryPromise({
+        try: () => client.sAdd(key, members),
+        catch: (e) =>
+          new RedisError({
+            cause: e,
+            message: 'Error in `Redis.sAdd`',
+          }),
+      }),
   });
 });
 
@@ -182,8 +199,10 @@ const RedisPersistenceLive = Layer.scoped(
 );
 
 const bootstrapRedisPubSubServiceEffect = Effect.gen(function* () {
-  const clientPublish = yield* redisClientEffect;
-  const clientSubscribe = yield* redisClientEffect;
+  const clientPublish: ReturnType<typeof createClient> =
+    yield* redisClientEffect;
+  const clientSubscribe: ReturnType<typeof createClient> =
+    yield* redisClientEffect;
 
   return RedisPubSub.of({
     publish: (channel, message) =>

package/dist/index.d.ts

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

package/dist/redis.d.ts

@@ -1,40 +0,0 @@
-import { Context, Effect, Layer } from 'effect';
-import { 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 {
-}
-declare const RedisLive: Layer.Layer<Redis, RedisError, RedisConnectionOptions>;
-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 {
-}
-declare const RedisPersistenceLive: Layer.Layer<RedisPersistence, RedisError, RedisConnectionOptions>;
-declare const RedisPubSubLive: Layer.Layer<RedisPubSub, RedisError, RedisConnectionOptions>;
-export { RedisPersistence, RedisPubSub, RedisConnectionOptions, Redis, RedisPersistenceLive, RedisPubSubLive, RedisConnectionOptionsLive, RedisLive, };