effect-redis 0.0.26 → 0.0.28

package/src/redis/core.ts

@@ -1,701 +1,701 @@
-import { Context, Effect, Layer, type Scope, Option } from 'effect';
-import type {
-  KeyOptions,
-  RedisHashValue,
-  RedisListValue,
-  RedisSetMember,
-  RedisValue,
-  ScanOptions,
-  ScanResult,
-} from '../types';
-import { RedisCommandError, type RedisError } from '../types';
-import {
-  redisClientEffect,
-  type RedisConnectionOptions,
-  RedisConnection,
-  RedisConnectionLive,
-} from './connection';
-import {
-  createRedisCommandWithCustomError,
-  createGenericRedisCommand,
-  type RedisClient,
-} from './helpers';
-import { toRedisError } from './errors';
-
-// Shape interface for core Redis operations
-// Provides a generic use() method for executing any Redis command
-export interface RedisShape {
-  readonly use: <T>(
-    fn: (client: RedisClient) => T,
-  ) => Effect.Effect<Awaited<T>, RedisError, never>;
-
-  /**
-   * Get value by key
-   */
-  readonly get: (key: string) => Effect.Effect<string | null, RedisError>;
-
-  /**
-   * Set value by key
-   */
-  readonly set: (
-    key: string,
-    value: RedisValue,
-    options?: KeyOptions,
-  ) => Effect.Effect<'OK' | string | null, RedisError>;
-
-  /**
-   * Delete key(s)
-   */
-  readonly del: (...keys: string[]) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Check if key exists
-   */
-  readonly exists: (...keys: string[]) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Set expiration for key
-   */
-  readonly expire: (
-    key: string,
-    seconds: number,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Set expiration for key in milliseconds
-   */
-  readonly pexpire: (
-    key: string,
-    milliseconds: number,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Get TTL for key in seconds
-   */
-  readonly ttl: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Get TTL for key in milliseconds
-   */
-  readonly pttl: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Hash operations - Set field in hash
-   */
-  readonly hset: (
-    key: string,
-    field: string,
-    value: RedisHashValue,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Hash operations - Get field from hash
-   */
-  readonly hget: (
-    key: string,
-    field: string,
-  ) => Effect.Effect<string | null, RedisError>;
-
-  /**
-   * Hash operations - Get all fields and values from hash
-   */
-  readonly hgetall: (
-    key: string,
-  ) => Effect.Effect<Record<string, string>, RedisError>;
-
-  /**
-   * Hash operations - Delete field(s) from hash
-   */
-  readonly hdel: (
-    key: string,
-    ...fields: string[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Hash operations - Check if field exists in hash
-   */
-  readonly hexists: (
-    key: string,
-    field: string,
-  ) => Effect.Effect<boolean, RedisError>;
-
-  /**
-   * Hash operations - Get all fields from hash
-   */
-  readonly hkeys: (key: string) => Effect.Effect<string[], RedisError>;
-
-  /**
-   * Hash operations - Get all values from hash
-   */
-  readonly hvals: (key: string) => Effect.Effect<string[], RedisError>;
-
-  /**
-   * Hash operations - Get number of fields in hash
-   */
-  readonly hlen: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * List operations - Push value(s) to left of list
-   */
-  readonly lpush: (
-    key: string,
-    ...values: RedisListValue[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * List operations - Push value(s) to right of list
-   */
-  readonly rpush: (
-    key: string,
-    ...values: RedisListValue[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * List operations - Pop value from left of list
-   */
-  readonly lpop: (
-    key: string,
-    count?: number | undefined,
-  ) => Effect.Effect<string | string[] | null, RedisError>;
-
-  /**
-   * List operations - Pop value from right of list
-   */
-  readonly rpop: (
-    key: string,
-    count?: number | undefined,
-  ) => Effect.Effect<string | string[] | null, RedisError>;
-
-  /**
-   * List operations - Get range of elements from list
-   */
-  readonly lrange: (
-    key: string,
-    start: number,
-    stop: number,
-  ) => Effect.Effect<string[], RedisError>;
-
-  /**
-   * List operations - Get length of list
-   */
-  readonly llen: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * List operations - Remove elements from list
-   */
-  readonly lrem: (
-    key: string,
-    count: number,
-    element: RedisListValue,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Set operations - Add member(s) to set
-   */
-  readonly sadd: (
-    key: string,
-    ...members: RedisSetMember[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Set operations - Remove member(s) from set
-   */
-  readonly srem: (
-    key: string,
-    ...members: RedisSetMember[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Set operations - Check if member is in set
-   */
-  readonly sismember: (
-    key: string,
-    member: RedisSetMember,
-  ) => Effect.Effect<boolean, RedisError>;
-
-  /**
-   * Set operations - Get all members of set
-   */
-  readonly smembers: (key: string) => Effect.Effect<string[], RedisError>;
-
-  /**
-   * Set operations - Get number of members in set
-   */
-  readonly scard: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Sorted Set operations - Add member(s) to sorted set
-   */
-  readonly zadd: (
-    key: string,
-    score: number,
-    member: string,
-    ...rest: Array<number | string>
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Sorted Set operations - Get range of members from sorted set
-   */
-  readonly zrange: (
-    key: string,
-    start: number,
-    stop: number,
-    withScores?: boolean | undefined,
-  ) => Effect.Effect<string[] | { value: string; score: number }[], RedisError>;
-
-  /**
-   * Sorted Set operations - Get range of members by score
-   */
-  readonly zrangebyscore: (
-    key: string,
-    min: number | string,
-    max: number | string,
-    withScores?: boolean | undefined,
-  ) => Effect.Effect<string[] | { value: string; score: number }[], RedisError>;
-
-  /**
-   * Sorted Set operations - Get score of member
-   */
-  readonly zscore: (
-    key: string,
-    member: string,
-  ) => Effect.Effect<number | null, RedisError>;
-
-  /**
-   * Sorted Set operations - Remove member(s) from sorted set
-   */
-  readonly zrem: (
-    key: string,
-    ...members: string[]
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Sorted Set operations - Get number of members in sorted set
-   */
-  readonly zcard: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Increment value
-   */
-  readonly incr: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Decrement value
-   */
-  readonly decr: (key: string) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Increment value by amount
-   */
-  readonly incrby: (
-    key: string,
-    increment: number,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Decrement value by amount
-   */
-  readonly decrby: (
-    key: string,
-    decrement: number,
-  ) => Effect.Effect<number, RedisError>;
-
-  /**
-   * Scan keys
-   */
-  readonly scan: (
-    options?: ScanOptions | undefined,
-  ) => Effect.Effect<ScanResult, RedisError>;
-
-  /**
-   * Flush database
-   */
-  readonly flushdb: () => Effect.Effect<'OK', RedisError>;
-
-  /**
-   * Flush all databases
-   */
-  readonly flushall: () => Effect.Effect<'OK', RedisError>;
-
-  /**
-   * Get database size
-   */
-  readonly dbsize: () => Effect.Effect<number, RedisError>;
-
-  /**
-   * Ping Redis
-   */
-  readonly ping: (
-    message?: string | undefined,
-  ) => Effect.Effect<string, RedisError>;
-
-  /**
-   * Execute raw Redis command
-   */
-  readonly execute: <A>(
-    command: string,
-    ...args: (string | number | Buffer)[]
-  ) => Effect.Effect<A, RedisError>;
-
-  /**
-   * Multi/exec transaction
-   */
-  readonly multi: (
-    commands: Array<[string, ...(string | number | Buffer)[]]>,
-  ) => Effect.Effect<unknown[], RedisError>;
-
-  /**
-   * Close connection
-   */
-  readonly quit: () => Effect.Effect<'OK', RedisError>;
-
-  /**
-   * Force close connection
-   */
-  readonly disconnect: () => Effect.Effect<void, RedisError>;
-}
-
-// Context tag for core Redis service
-// Used to access Redis client through dependency injection
-export class Redis extends Context.Tag('Redis')<Redis, RedisShape>() {}
-
-// Bootstrap effect for creating the core Redis service
-// Provides the generic use() method for executing Redis commands
-const bootstrapRedisServiceEffect: Effect.Effect<
-  RedisShape,
-  RedisError,
-  Scope.Scope | RedisConnectionOptions | RedisConnection
-> = Effect.gen(function* () {
-  // Get a managed Redis client
-  const typedClient: RedisClient = yield* Effect.serviceOption(
-    RedisConnection,
-  ).pipe(
-    Effect.flatMap((opt) =>
-      Option.isSome(opt) ? Effect.succeed(opt.value) : redisClientEffect,
-    ),
-  );
-
-  return Redis.of({
-    // Generic method to execute any Redis command with proper error handling
-    use: <T>(fn: (client: import('./helpers').RedisClient) => T) =>
-      createGenericRedisCommand(typedClient, fn) as Effect.Effect<
-        Awaited<T>,
-        RedisError,
-        never
-      >,
-
-    get: createRedisCommandWithCustomError((key: string) =>
-      typedClient.get(key),
-    ),
-
-    set: (key: string, value: RedisValue, options?: KeyOptions) =>
-      createRedisCommandWithCustomError(
-        (key: string, value: RedisValue, options?: KeyOptions) => {
-          if (!options) {
-            return typedClient.set(key, value);
-          }
-
-          const setOptions: Record<string, unknown> = {};
-
-          if (options.expiration) {
-            setOptions[options.expiration.mode] = options.expiration.time;
-          }
-
-          if (options.condition) {
-            setOptions[options.condition] = true;
-          }
-
-          if (options.get) {
-            setOptions.GET = true;
-          }
-
-          return Object.keys(setOptions).length > 0
-            ? typedClient.set(key, value, setOptions)
-            : typedClient.set(key, value);
-        },
-      )(key, value, options),
-
-    del: createRedisCommandWithCustomError((...keys: string[]) =>
-      typedClient.del(keys),
-    ),
-
-    exists: createRedisCommandWithCustomError((...keys: string[]) =>
-      typedClient.exists(keys),
-    ),
-
-    expire: createRedisCommandWithCustomError((key: string, seconds: number) =>
-      typedClient.expire(key, seconds),
-    ),
-
-    ttl: createRedisCommandWithCustomError((key: string) =>
-      typedClient.ttl(key),
-    ),
-
-    pexpire: createRedisCommandWithCustomError(
-      (key: string, milliseconds: number) =>
-        typedClient.pExpire(key, milliseconds),
-    ),
-
-    pttl: createRedisCommandWithCustomError((key: string) =>
-      typedClient.pTTL(key),
-    ),
-
-    hset: createRedisCommandWithCustomError(
-      (key: string, field: string, value: RedisHashValue) =>
-        typedClient.hSet(key, field, value as string),
-    ),
-
-    hget: createRedisCommandWithCustomError((key: string, field: string) =>
-      typedClient.hGet(key, field),
-    ),
-
-    hgetall: createRedisCommandWithCustomError((key: string) =>
-      typedClient.hGetAll(key),
-    ),
-
-    hdel: createRedisCommandWithCustomError(
-      (key: string, ...fields: string[]) => typedClient.hDel(key, fields),
-    ),
-
-    hexists: createRedisCommandWithCustomError(
-      async (key: string, field: string) =>
-        (await typedClient.hExists(key, field)) === 1,
-    ),
-
-    hkeys: createRedisCommandWithCustomError((key: string) =>
-      typedClient.hKeys(key),
-    ),
-
-    hvals: createRedisCommandWithCustomError((key: string) =>
-      typedClient.hVals(key),
-    ),
-
-    hlen: createRedisCommandWithCustomError((key: string) =>
-      typedClient.hLen(key),
-    ),
-
-    lpush: createRedisCommandWithCustomError(
-      (key: string, ...values: RedisListValue[]) =>
-        typedClient.lPush(key, values as string[]),
-    ),
-
-    rpush: createRedisCommandWithCustomError(
-      (key: string, ...values: RedisListValue[]) =>
-        typedClient.rPush(key, values as string[]),
-    ),
-
-    lpop: createRedisCommandWithCustomError(
-      async (key: string, count?: number) => {
-        if (count !== undefined) {
-          return typedClient.lPopCount(key, count);
-        }
-        return typedClient.lPop(key);
-      },
-    ) as (
-      key: string,
-      count?: number,
-    ) => Effect.Effect<string | string[] | null, RedisError>,
-
-    rpop: createRedisCommandWithCustomError(
-      async (key: string, count?: number) => {
-        if (count !== undefined) {
-          return typedClient.rPopCount(key, count);
-        }
-        return typedClient.rPop(key);
-      },
-    ) as (
-      key: string,
-      count?: number,
-    ) => Effect.Effect<string | string[] | null, RedisError>,
-
-    lrange: createRedisCommandWithCustomError(
-      (key: string, start: number, stop: number) =>
-        typedClient.lRange(key, start, stop),
-    ),
-
-    llen: createRedisCommandWithCustomError((key: string) =>
-      typedClient.lLen(key),
-    ),
-
-    lrem: createRedisCommandWithCustomError(
-      (key: string, count: number, element: RedisListValue) =>
-        typedClient.lRem(key, count, element as string),
-    ),
-
-    sadd: createRedisCommandWithCustomError(
-      (key: string, ...members: RedisSetMember[]) =>
-        typedClient.sAdd(key, members as string[]),
-    ),
-
-    srem: createRedisCommandWithCustomError(
-      (key: string, ...members: RedisSetMember[]) =>
-        typedClient.sRem(key, members as string[]),
-    ),
-
-    sismember: createRedisCommandWithCustomError(
-      async (key: string, member: RedisSetMember) =>
-        (await typedClient.sIsMember(key, member as string)) === 1,
-    ),
-
-    smembers: createRedisCommandWithCustomError((key: string) =>
-      typedClient.sMembers(key),
-    ),
-
-    scard: createRedisCommandWithCustomError((key: string) =>
-      typedClient.sCard(key),
-    ),
-
-    zadd: (
-      key: string,
-      score: number,
-      member: string,
-      ...rest: Array<number | string>
-    ) => {
-      if (rest.length % 2 !== 0) {
-        return Effect.fail(
-          new RedisCommandError({
-            cause: new Error(
-              'Invalid zadd arguments: score-member pairs required',
-            ),
-            message: 'zadd requires score-member pairs',
-            command: 'ZADD',
-          }),
-        );
-      }
-
-      const members: Array<{ score: number; value: string }> = [
-        { score, value: member },
-      ];
-      for (let i = 0; i < rest.length; i += 2) {
-        members.push({
-          score: rest[i] as number,
-          value: rest[i + 1] as string,
-        });
-      }
-
-      return Effect.tryPromise({
-        try: () => typedClient.zAdd(key, members),
-        catch: toRedisError,
-      });
-    },
-
-    zrange: createRedisCommandWithCustomError(
-      async (
-        key: string,
-        start: number,
-        stop: number,
-        withScores?: boolean,
-      ) => {
-        if (withScores) {
-          return typedClient.zRangeWithScores(key, start, stop);
-        }
-        return typedClient.zRange(key, start, stop);
-      },
-    ),
-
-    zrangebyscore: createRedisCommandWithCustomError(
-      async (
-        key: string,
-        min: number | string,
-        max: number | string,
-        withScores?: boolean,
-      ) => {
-        if (withScores) {
-          return typedClient.zRangeByScoreWithScores(key, min, max);
-        }
-        return typedClient.zRangeByScore(key, min, max);
-      },
-    ),
-
-    zscore: createRedisCommandWithCustomError((key: string, member: string) =>
-      typedClient.zScore(key, member),
-    ),
-
-    zrem: createRedisCommandWithCustomError(
-      (key: string, ...members: string[]) => typedClient.zRem(key, members),
-    ),
-
-    zcard: createRedisCommandWithCustomError((key: string) =>
-      typedClient.zCard(key),
-    ),
-
-    incr: createRedisCommandWithCustomError((key: string) =>
-      typedClient.incr(key),
-    ),
-
-    decr: createRedisCommandWithCustomError((key: string) =>
-      typedClient.decr(key),
-    ),
-
-    incrby: createRedisCommandWithCustomError(
-      (key: string, increment: number) => typedClient.incrBy(key, increment),
-    ),
-
-    decrby: createRedisCommandWithCustomError(
-      (key: string, decrement: number) => typedClient.incrBy(key, -decrement),
-    ),
-
-    scan: createRedisCommandWithCustomError(async (options?: ScanOptions) => {
-      const scanOptions: Record<string, unknown> = {};
-      if (options?.match) scanOptions.MATCH = options.match;
-      if (options?.count) scanOptions.COUNT = options.count;
-      if (options?.type) scanOptions.TYPE = options.type;
-
-      const cursor = options?.cursor ?? '0';
-      const result = await typedClient.scan(cursor, scanOptions);
-      return {
-        cursor: result.cursor.toString(),
-        keys: result.keys,
-      };
-    }),
-
-    flushdb: createRedisCommandWithCustomError(async () => {
-      await typedClient.flushDb();
-      return 'OK' as const;
-    }),
-
-    flushall: createRedisCommandWithCustomError(async () => {
-      await typedClient.flushAll();
-      return 'OK' as const;
-    }),
-
-    dbsize: createRedisCommandWithCustomError(() => typedClient.dbSize()),
-
-    ping: createRedisCommandWithCustomError(async (message?: string) => {
-      const result = await (message
-        ? typedClient.ping(message)
-        : typedClient.ping());
-      return result;
-    }),
-
-    execute: <A>(command: string, ...args: (string | number | Buffer)[]) =>
-      createRedisCommandWithCustomError(() =>
-        typedClient.sendCommand([command, ...args.map((a) => String(a))]),
-      )() as Effect.Effect<A, RedisError>,
-
-    multi: createRedisCommandWithCustomError(
-      async (commands: Array<[string, ...(string | number | Buffer)[]]>) => {
-        const multi = typedClient.multi();
-        for (const [cmd, ...args] of commands) {
-          multi.addCommand([cmd, ...args.map((a) => String(a))]);
-        }
-        return multi.exec();
-      },
-    ),
-
-    quit: createRedisCommandWithCustomError(async () => {
-      await typedClient.quit();
-      return 'OK' as const;
-    }),
-
-    disconnect: createRedisCommandWithCustomError(() =>
-      typedClient.disconnect(),
-    ),
-  });
-});
-
-// Live layer for the core Redis service
-// Creates a scoped service that manages the Redis client lifecycle
-export const RedisLive = Layer.scoped(Redis, bootstrapRedisServiceEffect).pipe(
-  Layer.provide(RedisConnectionLive),
-);
+import { Context, Effect, Layer, type Scope, Option } from 'effect';
+import type {
+  KeyOptions,
+  RedisHashValue,
+  RedisListValue,
+  RedisSetMember,
+  RedisValue,
+  ScanOptions,
+  ScanResult,
+} from '../types';
+import { RedisCommandError, type RedisError } from '../types';
+import {
+  redisClientEffect,
+  type RedisConnectionOptions,
+  RedisConnection,
+  RedisConnectionLive,
+} from './connection';
+import {
+  createRedisCommandWithCustomError,
+  createGenericRedisCommand,
+  type RedisClient,
+} from './helpers';
+import { toRedisError } from './errors';
+
+// Shape interface for core Redis operations
+// Provides a generic use() method for executing any Redis command
+export interface RedisShape {
+  readonly use: <T>(
+    fn: (client: RedisClient) => T,
+  ) => Effect.Effect<Awaited<T>, RedisError, never>;
+
+  /**
+   * Get value by key
+   */
+  readonly get: (key: string) => Effect.Effect<string | null, RedisError>;
+
+  /**
+   * Set value by key
+   */
+  readonly set: (
+    key: string,
+    value: RedisValue,
+    options?: KeyOptions,
+  ) => Effect.Effect<'OK' | string | null, RedisError>;
+
+  /**
+   * Delete key(s)
+   */
+  readonly del: (...keys: string[]) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Check if key exists
+   */
+  readonly exists: (...keys: string[]) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Set expiration for key
+   */
+  readonly expire: (
+    key: string,
+    seconds: number,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Set expiration for key in milliseconds
+   */
+  readonly pexpire: (
+    key: string,
+    milliseconds: number,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Get TTL for key in seconds
+   */
+  readonly ttl: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Get TTL for key in milliseconds
+   */
+  readonly pttl: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Hash operations - Set field in hash
+   */
+  readonly hset: (
+    key: string,
+    field: string,
+    value: RedisHashValue,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Hash operations - Get field from hash
+   */
+  readonly hget: (
+    key: string,
+    field: string,
+  ) => Effect.Effect<string | null, RedisError>;
+
+  /**
+   * Hash operations - Get all fields and values from hash
+   */
+  readonly hgetall: (
+    key: string,
+  ) => Effect.Effect<Record<string, string>, RedisError>;
+
+  /**
+   * Hash operations - Delete field(s) from hash
+   */
+  readonly hdel: (
+    key: string,
+    ...fields: string[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Hash operations - Check if field exists in hash
+   */
+  readonly hexists: (
+    key: string,
+    field: string,
+  ) => Effect.Effect<boolean, RedisError>;
+
+  /**
+   * Hash operations - Get all fields from hash
+   */
+  readonly hkeys: (key: string) => Effect.Effect<string[], RedisError>;
+
+  /**
+   * Hash operations - Get all values from hash
+   */
+  readonly hvals: (key: string) => Effect.Effect<string[], RedisError>;
+
+  /**
+   * Hash operations - Get number of fields in hash
+   */
+  readonly hlen: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * List operations - Push value(s) to left of list
+   */
+  readonly lpush: (
+    key: string,
+    ...values: RedisListValue[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * List operations - Push value(s) to right of list
+   */
+  readonly rpush: (
+    key: string,
+    ...values: RedisListValue[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * List operations - Pop value from left of list
+   */
+  readonly lpop: (
+    key: string,
+    count?: number | undefined,
+  ) => Effect.Effect<string | string[] | null, RedisError>;
+
+  /**
+   * List operations - Pop value from right of list
+   */
+  readonly rpop: (
+    key: string,
+    count?: number | undefined,
+  ) => Effect.Effect<string | string[] | null, RedisError>;
+
+  /**
+   * List operations - Get range of elements from list
+   */
+  readonly lrange: (
+    key: string,
+    start: number,
+    stop: number,
+  ) => Effect.Effect<string[], RedisError>;
+
+  /**
+   * List operations - Get length of list
+   */
+  readonly llen: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * List operations - Remove elements from list
+   */
+  readonly lrem: (
+    key: string,
+    count: number,
+    element: RedisListValue,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Set operations - Add member(s) to set
+   */
+  readonly sadd: (
+    key: string,
+    ...members: RedisSetMember[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Set operations - Remove member(s) from set
+   */
+  readonly srem: (
+    key: string,
+    ...members: RedisSetMember[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Set operations - Check if member is in set
+   */
+  readonly sismember: (
+    key: string,
+    member: RedisSetMember,
+  ) => Effect.Effect<boolean, RedisError>;
+
+  /**
+   * Set operations - Get all members of set
+   */
+  readonly smembers: (key: string) => Effect.Effect<string[], RedisError>;
+
+  /**
+   * Set operations - Get number of members in set
+   */
+  readonly scard: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Sorted Set operations - Add member(s) to sorted set
+   */
+  readonly zadd: (
+    key: string,
+    score: number,
+    member: string,
+    ...rest: Array<number | string>
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Sorted Set operations - Get range of members from sorted set
+   */
+  readonly zrange: (
+    key: string,
+    start: number,
+    stop: number,
+    withScores?: boolean | undefined,
+  ) => Effect.Effect<string[] | { value: string; score: number }[], RedisError>;
+
+  /**
+   * Sorted Set operations - Get range of members by score
+   */
+  readonly zrangebyscore: (
+    key: string,
+    min: number | string,
+    max: number | string,
+    withScores?: boolean | undefined,
+  ) => Effect.Effect<string[] | { value: string; score: number }[], RedisError>;
+
+  /**
+   * Sorted Set operations - Get score of member
+   */
+  readonly zscore: (
+    key: string,
+    member: string,
+  ) => Effect.Effect<number | null, RedisError>;
+
+  /**
+   * Sorted Set operations - Remove member(s) from sorted set
+   */
+  readonly zrem: (
+    key: string,
+    ...members: string[]
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Sorted Set operations - Get number of members in sorted set
+   */
+  readonly zcard: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Increment value
+   */
+  readonly incr: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Decrement value
+   */
+  readonly decr: (key: string) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Increment value by amount
+   */
+  readonly incrby: (
+    key: string,
+    increment: number,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Decrement value by amount
+   */
+  readonly decrby: (
+    key: string,
+    decrement: number,
+  ) => Effect.Effect<number, RedisError>;
+
+  /**
+   * Scan keys
+   */
+  readonly scan: (
+    options?: ScanOptions | undefined,
+  ) => Effect.Effect<ScanResult, RedisError>;
+
+  /**
+   * Flush database
+   */
+  readonly flushdb: () => Effect.Effect<'OK', RedisError>;
+
+  /**
+   * Flush all databases
+   */
+  readonly flushall: () => Effect.Effect<'OK', RedisError>;
+
+  /**
+   * Get database size
+   */
+  readonly dbsize: () => Effect.Effect<number, RedisError>;
+
+  /**
+   * Ping Redis
+   */
+  readonly ping: (
+    message?: string | undefined,
+  ) => Effect.Effect<string, RedisError>;
+
+  /**
+   * Execute raw Redis command
+   */
+  readonly execute: <A>(
+    command: string,
+    ...args: (string | number | Buffer)[]
+  ) => Effect.Effect<A, RedisError>;
+
+  /**
+   * Multi/exec transaction
+   */
+  readonly multi: (
+    commands: Array<[string, ...(string | number | Buffer)[]]>,
+  ) => Effect.Effect<unknown[], RedisError>;
+
+  /**
+   * Close connection
+   */
+  readonly quit: () => Effect.Effect<'OK', RedisError>;
+
+  /**
+   * Force close connection
+   */
+  readonly disconnect: () => Effect.Effect<void, RedisError>;
+}
+
+// Context tag for core Redis service
+// Used to access Redis client through dependency injection
+export class Redis extends Context.Tag('Redis')<Redis, RedisShape>() {}
+
+// Bootstrap effect for creating the core Redis service
+// Provides the generic use() method for executing Redis commands
+const bootstrapRedisServiceEffect: Effect.Effect<
+  RedisShape,
+  RedisError,
+  Scope.Scope | RedisConnectionOptions | RedisConnection
+> = Effect.gen(function* () {
+  // Get a managed Redis client
+  const typedClient: RedisClient = yield* Effect.serviceOption(
+    RedisConnection,
+  ).pipe(
+    Effect.flatMap((opt) =>
+      Option.isSome(opt) ? Effect.succeed(opt.value) : redisClientEffect,
+    ),
+  );
+
+  return Redis.of({
+    // Generic method to execute any Redis command with proper error handling
+    use: <T>(fn: (client: import('./helpers').RedisClient) => T) =>
+      createGenericRedisCommand(typedClient, fn) as Effect.Effect<
+        Awaited<T>,
+        RedisError,
+        never
+      >,
+
+    get: createRedisCommandWithCustomError((key: string) =>
+      typedClient.get(key),
+    ),
+
+    set: (key: string, value: RedisValue, options?: KeyOptions) =>
+      createRedisCommandWithCustomError(
+        (key: string, value: RedisValue, options?: KeyOptions) => {
+          if (!options) {
+            return typedClient.set(key, value);
+          }
+
+          const setOptions: Record<string, unknown> = {};
+
+          if (options.expiration) {
+            setOptions[options.expiration.mode] = options.expiration.time;
+          }
+
+          if (options.condition) {
+            setOptions[options.condition] = true;
+          }
+
+          if (options.get) {
+            setOptions.GET = true;
+          }
+
+          return Object.keys(setOptions).length > 0
+            ? typedClient.set(key, value, setOptions)
+            : typedClient.set(key, value);
+        },
+      )(key, value, options),
+
+    del: createRedisCommandWithCustomError((...keys: string[]) =>
+      typedClient.del(keys),
+    ),
+
+    exists: createRedisCommandWithCustomError((...keys: string[]) =>
+      typedClient.exists(keys),
+    ),
+
+    expire: createRedisCommandWithCustomError((key: string, seconds: number) =>
+      typedClient.expire(key, seconds),
+    ),
+
+    ttl: createRedisCommandWithCustomError((key: string) =>
+      typedClient.ttl(key),
+    ),
+
+    pexpire: createRedisCommandWithCustomError(
+      (key: string, milliseconds: number) =>
+        typedClient.pExpire(key, milliseconds),
+    ),
+
+    pttl: createRedisCommandWithCustomError((key: string) =>
+      typedClient.pTTL(key),
+    ),
+
+    hset: createRedisCommandWithCustomError(
+      (key: string, field: string, value: RedisHashValue) =>
+        typedClient.hSet(key, field, value as string),
+    ),
+
+    hget: createRedisCommandWithCustomError((key: string, field: string) =>
+      typedClient.hGet(key, field),
+    ),
+
+    hgetall: createRedisCommandWithCustomError((key: string) =>
+      typedClient.hGetAll(key),
+    ),
+
+    hdel: createRedisCommandWithCustomError(
+      (key: string, ...fields: string[]) => typedClient.hDel(key, fields),
+    ),
+
+    hexists: createRedisCommandWithCustomError(
+      async (key: string, field: string) =>
+        (await typedClient.hExists(key, field)) === 1,
+    ),
+
+    hkeys: createRedisCommandWithCustomError((key: string) =>
+      typedClient.hKeys(key),
+    ),
+
+    hvals: createRedisCommandWithCustomError((key: string) =>
+      typedClient.hVals(key),
+    ),
+
+    hlen: createRedisCommandWithCustomError((key: string) =>
+      typedClient.hLen(key),
+    ),
+
+    lpush: createRedisCommandWithCustomError(
+      (key: string, ...values: RedisListValue[]) =>
+        typedClient.lPush(key, values as string[]),
+    ),
+
+    rpush: createRedisCommandWithCustomError(
+      (key: string, ...values: RedisListValue[]) =>
+        typedClient.rPush(key, values as string[]),
+    ),
+
+    lpop: createRedisCommandWithCustomError(
+      async (key: string, count?: number) => {
+        if (count !== undefined) {
+          return typedClient.lPopCount(key, count);
+        }
+        return typedClient.lPop(key);
+      },
+    ) as (
+      key: string,
+      count?: number,
+    ) => Effect.Effect<string | string[] | null, RedisError>,
+
+    rpop: createRedisCommandWithCustomError(
+      async (key: string, count?: number) => {
+        if (count !== undefined) {
+          return typedClient.rPopCount(key, count);
+        }
+        return typedClient.rPop(key);
+      },
+    ) as (
+      key: string,
+      count?: number,
+    ) => Effect.Effect<string | string[] | null, RedisError>,
+
+    lrange: createRedisCommandWithCustomError(
+      (key: string, start: number, stop: number) =>
+        typedClient.lRange(key, start, stop),
+    ),
+
+    llen: createRedisCommandWithCustomError((key: string) =>
+      typedClient.lLen(key),
+    ),
+
+    lrem: createRedisCommandWithCustomError(
+      (key: string, count: number, element: RedisListValue) =>
+        typedClient.lRem(key, count, element as string),
+    ),
+
+    sadd: createRedisCommandWithCustomError(
+      (key: string, ...members: RedisSetMember[]) =>
+        typedClient.sAdd(key, members as string[]),
+    ),
+
+    srem: createRedisCommandWithCustomError(
+      (key: string, ...members: RedisSetMember[]) =>
+        typedClient.sRem(key, members as string[]),
+    ),
+
+    sismember: createRedisCommandWithCustomError(
+      async (key: string, member: RedisSetMember) =>
+        (await typedClient.sIsMember(key, member as string)) === 1,
+    ),
+
+    smembers: createRedisCommandWithCustomError((key: string) =>
+      typedClient.sMembers(key),
+    ),
+
+    scard: createRedisCommandWithCustomError((key: string) =>
+      typedClient.sCard(key),
+    ),
+
+    zadd: (
+      key: string,
+      score: number,
+      member: string,
+      ...rest: Array<number | string>
+    ) => {
+      if (rest.length % 2 !== 0) {
+        return Effect.fail(
+          new RedisCommandError({
+            cause: new Error(
+              'Invalid zadd arguments: score-member pairs required',
+            ),
+            message: 'zadd requires score-member pairs',
+            command: 'ZADD',
+          }),
+        );
+      }
+
+      const members: Array<{ score: number; value: string }> = [
+        { score, value: member },
+      ];
+      for (let i = 0; i < rest.length; i += 2) {
+        members.push({
+          score: rest[i] as number,
+          value: rest[i + 1] as string,
+        });
+      }
+
+      return Effect.tryPromise({
+        try: () => typedClient.zAdd(key, members),
+        catch: toRedisError,
+      });
+    },
+
+    zrange: createRedisCommandWithCustomError(
+      async (
+        key: string,
+        start: number,
+        stop: number,
+        withScores?: boolean,
+      ) => {
+        if (withScores) {
+          return typedClient.zRangeWithScores(key, start, stop);
+        }
+        return typedClient.zRange(key, start, stop);
+      },
+    ),
+
+    zrangebyscore: createRedisCommandWithCustomError(
+      async (
+        key: string,
+        min: number | string,
+        max: number | string,
+        withScores?: boolean,
+      ) => {
+        if (withScores) {
+          return typedClient.zRangeByScoreWithScores(key, min, max);
+        }
+        return typedClient.zRangeByScore(key, min, max);
+      },
+    ),
+
+    zscore: createRedisCommandWithCustomError((key: string, member: string) =>
+      typedClient.zScore(key, member),
+    ),
+
+    zrem: createRedisCommandWithCustomError(
+      (key: string, ...members: string[]) => typedClient.zRem(key, members),
+    ),
+
+    zcard: createRedisCommandWithCustomError((key: string) =>
+      typedClient.zCard(key),
+    ),
+
+    incr: createRedisCommandWithCustomError((key: string) =>
+      typedClient.incr(key),
+    ),
+
+    decr: createRedisCommandWithCustomError((key: string) =>
+      typedClient.decr(key),
+    ),
+
+    incrby: createRedisCommandWithCustomError(
+      (key: string, increment: number) => typedClient.incrBy(key, increment),
+    ),
+
+    decrby: createRedisCommandWithCustomError(
+      (key: string, decrement: number) => typedClient.incrBy(key, -decrement),
+    ),
+
+    scan: createRedisCommandWithCustomError(async (options?: ScanOptions) => {
+      const scanOptions: Record<string, unknown> = {};
+      if (options?.match) scanOptions.MATCH = options.match;
+      if (options?.count) scanOptions.COUNT = options.count;
+      if (options?.type) scanOptions.TYPE = options.type;
+
+      const cursor = options?.cursor ?? '0';
+      const result = await typedClient.scan(cursor, scanOptions);
+      return {
+        cursor: result.cursor.toString(),
+        keys: result.keys,
+      };
+    }),
+
+    flushdb: createRedisCommandWithCustomError(async () => {
+      await typedClient.flushDb();
+      return 'OK' as const;
+    }),
+
+    flushall: createRedisCommandWithCustomError(async () => {
+      await typedClient.flushAll();
+      return 'OK' as const;
+    }),
+
+    dbsize: createRedisCommandWithCustomError(() => typedClient.dbSize()),
+
+    ping: createRedisCommandWithCustomError(async (message?: string) => {
+      const result = await (message
+        ? typedClient.ping(message)
+        : typedClient.ping());
+      return result;
+    }),
+
+    execute: <A>(command: string, ...args: (string | number | Buffer)[]) =>
+      createRedisCommandWithCustomError(() =>
+        typedClient.sendCommand([command, ...args.map((a) => String(a))]),
+      )() as Effect.Effect<A, RedisError>,
+
+    multi: createRedisCommandWithCustomError(
+      async (commands: Array<[string, ...(string | number | Buffer)[]]>) => {
+        const multi = typedClient.multi();
+        for (const [cmd, ...args] of commands) {
+          multi.addCommand([cmd, ...args.map((a) => String(a))]);
+        }
+        return multi.exec();
+      },
+    ),
+
+    quit: createRedisCommandWithCustomError(async () => {
+      await typedClient.quit();
+      return 'OK' as const;
+    }),
+
+    disconnect: createRedisCommandWithCustomError(() =>
+      typedClient.disconnect(),
+    ),
+  });
+});
+
+// Live layer for the core Redis service
+// Creates a scoped service that manages the Redis client lifecycle
+export const RedisLive = Layer.scoped(Redis, bootstrapRedisServiceEffect).pipe(
+  Layer.provide(RedisConnectionLive),
+);