effect-redis 0.0.12 → 0.0.14

package/dist/index.js

@@ -29,4 +29,4 @@ ${this.stack.split(`
 `),endStackDef=stackDef.slice(2).join(`
 `).trim();if(!endStackDef.includes("("))endStackDef=endStackDef.replace(/at (.*)/,"at ($1)");let endStackCall=stackCall.slice(2).join(`
 `).trim();if(!endStackCall.includes("("))endStackCall=endStackCall.replace(/at (.*)/,"at ($1)");return cache=`${endStackDef}
-${endStackCall}`,cache}},opts=options.spanOptions&&"captureStackTrace"in options.spanOptions?options.spanOptions:{captureStackTrace,...options.spanOptions};return withSpan3(effect,options.spanName,opts)}var fnUntraced2=fnUntraced,ensureSuccessType=()=>(effect)=>effect,ensureErrorType=()=>(effect)=>effect,ensureRequirementsType=()=>(effect)=>effect;var exports_Layer={};__export(exports_Layer,{zipWith:()=>zipWith5,withSpan:()=>withSpan4,withParentSpan:()=>withParentSpan4,updateService:()=>updateService3,unwrapScoped:()=>unwrapScoped2,unwrapEffect:()=>unwrapEffect2,toRuntimeWithMemoMap:()=>toRuntimeWithMemoMap2,toRuntime:()=>toRuntime2,tapErrorCause:()=>tapErrorCause4,tapError:()=>tapError4,tap:()=>tap4,syncContext:()=>syncContext2,sync:()=>sync4,suspend:()=>suspend4,succeedContext:()=>succeedContext2,succeed:()=>succeed7,span:()=>span3,setVersionMismatchErrorLogLevel:()=>setVersionMismatchErrorLogLevel,setUnhandledErrorLogLevel:()=>setUnhandledErrorLogLevel,setTracerTiming:()=>setTracerTiming,setTracerEnabled:()=>setTracerEnabled,setTracer:()=>setTracer2,setScheduler:()=>setScheduler,setRequestCaching:()=>setRequestCaching,setRequestCache:()=>setRequestCache,setRequestBatching:()=>setRequestBatching,setRandom:()=>setRandom,setConfigProvider:()=>setConfigProvider2,setClock:()=>setClock,service:()=>service2,scopedDiscard:()=>scopedDiscard2,scopedContext:()=>scopedContext2,scoped:()=>scoped3,scope:()=>scope4,retry:()=>retry3,provideMerge:()=>provideMerge2,provide:()=>provide3,project:()=>project2,passthrough:()=>passthrough3,parentSpan:()=>parentSpan2,orElse:()=>orElse4,orDie:()=>orDie4,mock:()=>mock2,mergeAll:()=>mergeAll6,merge:()=>merge8,memoize:()=>memoize3,matchCause:()=>matchCause4,match:()=>match11,mapError:()=>mapError4,map:()=>map12,makeMemoMap:()=>makeMemoMap2,locallyWith:()=>locallyWith2,locallyScoped:()=>locallyScoped2,locallyEffect:()=>locallyEffect2,locally:()=>locally2,launch:()=>launch2,isLayer:()=>isLayer2,isFresh:()=>isFresh2,function:()=>fromFunction2,fresh:()=>fresh2,flatten:()=>flatten8,flatMap:()=>flatMap11,fiberRefLocallyScopedWith:()=>fiberRefLocallyScopedWith3,failSync:()=>failSync4,failCauseSync:()=>failCauseSync4,failCause:()=>failCause6,fail:()=>fail7,extendScope:()=>extendScope2,empty:()=>empty28,effectDiscard:()=>effectDiscard,effectContext:()=>effectContext,effect:()=>effect,discard:()=>discard2,dieSync:()=>dieSync4,die:()=>die6,context:()=>context4,catchAllCause:()=>catchAllCause4,catchAll:()=>catchAll4,buildWithScope:()=>buildWithScope2,buildWithMemoMap:()=>buildWithMemoMap2,build:()=>build2,annotateSpans:()=>annotateSpans4,annotateLogs:()=>annotateLogs4,MemoMapTypeId:()=>MemoMapTypeId2,LayerTypeId:()=>LayerTypeId2,CurrentMemoMap:()=>CurrentMemoMap2});var setConfigProvider=(configProvider)=>scopedDiscard(withConfigProviderScoped(configProvider)),parentSpan=(span2)=>succeedContext(make5(spanTag,span2)),span2=(name,options)=>{return options=addSpanStackTrace(options),scoped(spanTag,options?.onEnd?tap(makeSpanScoped(name,options),(span3)=>addFinalizer((exit3)=>options.onEnd(span3,exit3))):makeSpanScoped(name,options))},setTracer=(tracer3)=>scopedDiscard(withTracerScoped(tracer3));var LayerTypeId2=LayerTypeId,MemoMapTypeId2=MemoMapTypeId,CurrentMemoMap2=CurrentMemoMap,isLayer2=isLayer,isFresh2=isFresh,annotateLogs4=annotateLogs2,annotateSpans4=annotateSpans2,build2=build,buildWithScope2=buildWithScope,catchAll4=catchAll2,catchAllCause4=catchAllCause2,context4=context2,die6=die4,dieSync4=dieSync2,discard2=discard,effect=fromEffect2,effectDiscard=fromEffectDiscard,effectContext=fromEffectContext,empty28=empty27,extendScope2=extendScope,fail7=fail4,failSync4=failSync2,failCause6=failCause3,failCauseSync4=failCauseSync2,flatMap11=flatMap9,flatten8=flatten6,fresh2=fresh,mock2=mock,fromFunction2=fromFunction;var launch2=launch,map12=map9,mapError4=mapError2,match11=match9,matchCause4=matchCause2,memoize3=memoize2,merge8=merge6,mergeAll6=mergeAll4,orDie4=orDie2,orElse4=orElse2,passthrough3=passthrough,project2=project,locallyEffect2=locallyEffect,locally2=fiberRefLocally2,locallyWith2=fiberRefLocallyWith2,locallyScoped2=fiberRefLocallyScoped2,fiberRefLocallyScopedWith3=fiberRefLocallyScopedWith2,retry3=retry,scope4=scope2,scoped3=scoped,scopedDiscard2=scopedDiscard,scopedContext2=scopedContext,service2=service,succeed7=succeed4,succeedContext2=succeedContext,suspend4=suspend2,sync4=sync2,syncContext2=syncContext,tap4=tap2,tapError4=tapError2,tapErrorCause4=tapErrorCause2,toRuntime2=toRuntime,toRuntimeWithMemoMap2=toRuntimeWithMemoMap,provide3=provide,provideMerge2=provideMerge,zipWith5=zipWith3,unwrapEffect2=unwrapEffect,unwrapScoped2=unwrapScoped,setClock=(clock3)=>scopedDiscard2(fiberRefLocallyScopedWith(currentServices,add2(clockTag,clock3))),setConfigProvider2=setConfigProvider,parentSpan2=parentSpan,setRandom=(random4)=>scopedDiscard2(fiberRefLocallyScopedWith(currentServices,add2(randomTag,random4))),setRequestBatching=(requestBatching)=>scopedDiscard2(fiberRefLocallyScoped(currentRequestBatching,requestBatching)),setRequestCaching=(requestCaching)=>scopedDiscard2(fiberRefLocallyScoped(currentCacheEnabled,requestCaching)),setRequestCache=(cache)=>scopedDiscard2(isEffect(cache)?flatMap7(cache,(x)=>fiberRefLocallyScoped(currentCache,x)):fiberRefLocallyScoped(currentCache,cache)),setScheduler=(scheduler)=>scopedDiscard2(fiberRefLocallyScoped(currentScheduler,scheduler)),span3=span2,setTracer2=setTracer,setTracerEnabled=(enabled2)=>scopedDiscard2(fiberRefLocallyScoped(currentTracerEnabled,enabled2)),setTracerTiming=(enabled2)=>scopedDiscard2(fiberRefLocallyScoped(currentTracerTimingEnabled,enabled2)),setUnhandledErrorLogLevel=(level)=>scopedDiscard2(fiberRefLocallyScoped(currentUnhandledErrorLogLevel,level)),setVersionMismatchErrorLogLevel=(level)=>scopedDiscard2(fiberRefLocallyScoped(currentVersionMismatchErrorLogLevel,level)),withSpan4=withSpan2,withParentSpan4=withParentSpan2,makeMemoMap2=makeMemoMap,buildWithMemoMap2=buildWithMemoMap,updateService3=dual(3,(layer,tag,f)=>provide3(layer,map12(context4(),(c)=>add2(c,tag,f(unsafeGet3(c,tag))))));var import_redis=__toESM(require_dist2(),1);class RedisError extends exports_Data.TaggedError("RedisError"){}class RedisConnectionOptions extends exports_Context.Tag("RedisConnectionOptions")(){}class Redis extends exports_Context.Tag("Redis")(){}class RedisPubSub extends exports_Context.Tag("RedisPubSub")(){}class RedisPersistence extends exports_Context.Tag("RedisPersistence")(){}class RedisStream extends exports_Context.Tag("RedisStream")(){}var redisClientEffect=exports_Effect.gen(function*(){let{options}=yield*RedisConnectionOptions;return yield*exports_Effect.acquireRelease(exports_Effect.tryPromise({try:()=>import_redis.createClient(options).connect().then((r)=>{return console.log("Connected to Redis"),r.on("error",(e)=>{console.log("Redis error(on error):",e.message),r.destroy()}),r.on("end",()=>{console.log("Connection to Redis ended")}),r}),catch:(e)=>new RedisError({cause:e,message:"Error while connecting to Redis"})}),(client)=>client.isReady?exports_Effect.tryPromise({try:async()=>{console.log("Cleaning up Redis connection"),await client.quit()},catch:(e)=>new RedisError({cause:e,message:"Error while closing Redis connection"})}).pipe(exports_Effect.catchAll(()=>exports_Effect.void)):exports_Effect.void)}),bootstrapRedisServiceEffect=exports_Effect.gen(function*(){let client=yield*redisClientEffect;return Redis.of({use:(fn2)=>exports_Effect.gen(function*(){let result=yield*exports_Effect.try({try:()=>fn2(client),catch:(e)=>new RedisError({cause:e,message:"Synchronous error in `Redis.use`"})});if(result instanceof Promise)return yield*exports_Effect.tryPromise({try:()=>result,catch:(e)=>new RedisError({cause:e,message:"Asynchronous error in `Redis.use`"})});return result})})}),bootstrapRedisPersistenceServiceEffect=exports_Effect.gen(function*(){let client=yield*redisClientEffect;return RedisPersistence.of({setValue:(key,value)=>exports_Effect.tryPromise({try:()=>client.set(key,value),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.setValue`"})}),getValue:(key)=>exports_Effect.tryPromise({try:()=>client.get(key),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.getValue`"})}),del:(key)=>exports_Effect.tryPromise({try:()=>client.del(key),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.del`"})}),exists:(key)=>exports_Effect.tryPromise({try:async()=>{return await client.exists(key)===1},catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.exists`"})}),sAdd:(key,members)=>exports_Effect.tryPromise({try:()=>client.sAdd(key,members),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.sAdd`"})})})}),bootstrapRedisPubSubServiceEffect=exports_Effect.gen(function*(){let clientPublish=yield*redisClientEffect,clientSubscribe=yield*redisClientEffect;return RedisPubSub.of({publish:(channel,message)=>exports_Effect.tryPromise({try:()=>clientPublish.publish(channel,message),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.publish`"})}),subscribe:(channel,handler)=>exports_Effect.tryPromise({try:()=>clientSubscribe.subscribe(channel,handler),catch:(e)=>new RedisError({cause:e,message:"Error in `Redis.subscribe`"})})})}),bootstrapRedisStreamServiceEffect=exports_Effect.gen(function*(){let clientProducer=yield*redisClientEffect,clientConsumer=yield*redisClientEffect;return RedisStream.of({xadd:(key,id,message)=>exports_Effect.tryPromise({try:async()=>{return await clientProducer.xAdd(key,id,message)},catch:(e)=>new RedisError({cause:e,message:"Error in `RedisStream.xadd`"})}),xread:(key,id,block,count)=>exports_Effect.tryPromise({try:async()=>{let options={};if(block!==void 0)options.BLOCK=block;if(count!==void 0)options.COUNT=count;let streams=[{key,id}],result=await clientConsumer.xRead(streams,options);if(!result)return[];if(!Array.isArray(result))return[];return result.flatMap((stream)=>{if(stream&&typeof stream==="object"&&"messages"in stream&&Array.isArray(stream.messages))return stream.messages.map((msg)=>{if(msg&&typeof msg==="object"&&"id"in msg)return{id:String(msg.id),message:msg.message};return{id:"",message:{}}});return[]})},catch:(e)=>new RedisError({cause:e,message:"Error in `RedisStream.xread`"})}),xrange:(key,start3,end3,count)=>exports_Effect.tryPromise({try:async()=>{let options={};if(count!==void 0)options.COUNT=count;return(await clientConsumer.xRange(key,start3,end3,options)).map((msg)=>({id:msg.id,message:msg.message}))},catch:(e)=>new RedisError({cause:e,message:"Error in `RedisStream.xrange`"})})})}),RedisConnectionOptionsLive=(options)=>exports_Layer.succeed(RedisConnectionOptions,RedisConnectionOptions.of({options})),RedisLive=exports_Layer.scoped(Redis,bootstrapRedisServiceEffect),RedisPubSubLive=exports_Layer.scoped(RedisPubSub,bootstrapRedisPubSubServiceEffect),RedisPersistenceLive=exports_Layer.scoped(RedisPersistence,bootstrapRedisPersistenceServiceEffect),RedisStreamLive=exports_Layer.scoped(RedisStream,bootstrapRedisStreamServiceEffect);export{RedisStreamLive,RedisStream,RedisPubSubLive,RedisPubSub,RedisPersistenceLive,RedisPersistence,RedisLive,RedisError,RedisConnectionOptionsLive,RedisConnectionOptions,Redis};
+${endStackCall}`,cache}},opts=options.spanOptions&&"captureStackTrace"in options.spanOptions?options.spanOptions:{captureStackTrace,...options.spanOptions};return withSpan3(effect,options.spanName,opts)}var fnUntraced2=fnUntraced,ensureSuccessType=()=>(effect)=>effect,ensureErrorType=()=>(effect)=>effect,ensureRequirementsType=()=>(effect)=>effect;var exports_Layer={};__export(exports_Layer,{zipWith:()=>zipWith5,withSpan:()=>withSpan4,withParentSpan:()=>withParentSpan4,updateService:()=>updateService3,unwrapScoped:()=>unwrapScoped2,unwrapEffect:()=>unwrapEffect2,toRuntimeWithMemoMap:()=>toRuntimeWithMemoMap2,toRuntime:()=>toRuntime2,tapErrorCause:()=>tapErrorCause4,tapError:()=>tapError4,tap:()=>tap4,syncContext:()=>syncContext2,sync:()=>sync4,suspend:()=>suspend4,succeedContext:()=>succeedContext2,succeed:()=>succeed7,span:()=>span3,setVersionMismatchErrorLogLevel:()=>setVersionMismatchErrorLogLevel,setUnhandledErrorLogLevel:()=>setUnhandledErrorLogLevel,setTracerTiming:()=>setTracerTiming,setTracerEnabled:()=>setTracerEnabled,setTracer:()=>setTracer2,setScheduler:()=>setScheduler,setRequestCaching:()=>setRequestCaching,setRequestCache:()=>setRequestCache,setRequestBatching:()=>setRequestBatching,setRandom:()=>setRandom,setConfigProvider:()=>setConfigProvider2,setClock:()=>setClock,service:()=>service2,scopedDiscard:()=>scopedDiscard2,scopedContext:()=>scopedContext2,scoped:()=>scoped3,scope:()=>scope4,retry:()=>retry3,provideMerge:()=>provideMerge2,provide:()=>provide3,project:()=>project2,passthrough:()=>passthrough3,parentSpan:()=>parentSpan2,orElse:()=>orElse4,orDie:()=>orDie4,mock:()=>mock2,mergeAll:()=>mergeAll6,merge:()=>merge8,memoize:()=>memoize3,matchCause:()=>matchCause4,match:()=>match11,mapError:()=>mapError4,map:()=>map12,makeMemoMap:()=>makeMemoMap2,locallyWith:()=>locallyWith2,locallyScoped:()=>locallyScoped2,locallyEffect:()=>locallyEffect2,locally:()=>locally2,launch:()=>launch2,isLayer:()=>isLayer2,isFresh:()=>isFresh2,function:()=>fromFunction2,fresh:()=>fresh2,flatten:()=>flatten8,flatMap:()=>flatMap11,fiberRefLocallyScopedWith:()=>fiberRefLocallyScopedWith3,failSync:()=>failSync4,failCauseSync:()=>failCauseSync4,failCause:()=>failCause6,fail:()=>fail7,extendScope:()=>extendScope2,empty:()=>empty28,effectDiscard:()=>effectDiscard,effectContext:()=>effectContext,effect:()=>effect,discard:()=>discard2,dieSync:()=>dieSync4,die:()=>die6,context:()=>context4,catchAllCause:()=>catchAllCause4,catchAll:()=>catchAll4,buildWithScope:()=>buildWithScope2,buildWithMemoMap:()=>buildWithMemoMap2,build:()=>build2,annotateSpans:()=>annotateSpans4,annotateLogs:()=>annotateLogs4,MemoMapTypeId:()=>MemoMapTypeId2,LayerTypeId:()=>LayerTypeId2,CurrentMemoMap:()=>CurrentMemoMap2});var setConfigProvider=(configProvider)=>scopedDiscard(withConfigProviderScoped(configProvider)),parentSpan=(span2)=>succeedContext(make5(spanTag,span2)),span2=(name,options)=>{return options=addSpanStackTrace(options),scoped(spanTag,options?.onEnd?tap(makeSpanScoped(name,options),(span3)=>addFinalizer((exit3)=>options.onEnd(span3,exit3))):makeSpanScoped(name,options))},setTracer=(tracer3)=>scopedDiscard(withTracerScoped(tracer3));var LayerTypeId2=LayerTypeId,MemoMapTypeId2=MemoMapTypeId,CurrentMemoMap2=CurrentMemoMap,isLayer2=isLayer,isFresh2=isFresh,annotateLogs4=annotateLogs2,annotateSpans4=annotateSpans2,build2=build,buildWithScope2=buildWithScope,catchAll4=catchAll2,catchAllCause4=catchAllCause2,context4=context2,die6=die4,dieSync4=dieSync2,discard2=discard,effect=fromEffect2,effectDiscard=fromEffectDiscard,effectContext=fromEffectContext,empty28=empty27,extendScope2=extendScope,fail7=fail4,failSync4=failSync2,failCause6=failCause3,failCauseSync4=failCauseSync2,flatMap11=flatMap9,flatten8=flatten6,fresh2=fresh,mock2=mock,fromFunction2=fromFunction;var launch2=launch,map12=map9,mapError4=mapError2,match11=match9,matchCause4=matchCause2,memoize3=memoize2,merge8=merge6,mergeAll6=mergeAll4,orDie4=orDie2,orElse4=orElse2,passthrough3=passthrough,project2=project,locallyEffect2=locallyEffect,locally2=fiberRefLocally2,locallyWith2=fiberRefLocallyWith2,locallyScoped2=fiberRefLocallyScoped2,fiberRefLocallyScopedWith3=fiberRefLocallyScopedWith2,retry3=retry,scope4=scope2,scoped3=scoped,scopedDiscard2=scopedDiscard,scopedContext2=scopedContext,service2=service,succeed7=succeed4,succeedContext2=succeedContext,suspend4=suspend2,sync4=sync2,syncContext2=syncContext,tap4=tap2,tapError4=tapError2,tapErrorCause4=tapErrorCause2,toRuntime2=toRuntime,toRuntimeWithMemoMap2=toRuntimeWithMemoMap,provide3=provide,provideMerge2=provideMerge,zipWith5=zipWith3,unwrapEffect2=unwrapEffect,unwrapScoped2=unwrapScoped,setClock=(clock3)=>scopedDiscard2(fiberRefLocallyScopedWith(currentServices,add2(clockTag,clock3))),setConfigProvider2=setConfigProvider,parentSpan2=parentSpan,setRandom=(random4)=>scopedDiscard2(fiberRefLocallyScopedWith(currentServices,add2(randomTag,random4))),setRequestBatching=(requestBatching)=>scopedDiscard2(fiberRefLocallyScoped(currentRequestBatching,requestBatching)),setRequestCaching=(requestCaching)=>scopedDiscard2(fiberRefLocallyScoped(currentCacheEnabled,requestCaching)),setRequestCache=(cache)=>scopedDiscard2(isEffect(cache)?flatMap7(cache,(x)=>fiberRefLocallyScoped(currentCache,x)):fiberRefLocallyScoped(currentCache,cache)),setScheduler=(scheduler)=>scopedDiscard2(fiberRefLocallyScoped(currentScheduler,scheduler)),span3=span2,setTracer2=setTracer,setTracerEnabled=(enabled2)=>scopedDiscard2(fiberRefLocallyScoped(currentTracerEnabled,enabled2)),setTracerTiming=(enabled2)=>scopedDiscard2(fiberRefLocallyScoped(currentTracerTimingEnabled,enabled2)),setUnhandledErrorLogLevel=(level)=>scopedDiscard2(fiberRefLocallyScoped(currentUnhandledErrorLogLevel,level)),setVersionMismatchErrorLogLevel=(level)=>scopedDiscard2(fiberRefLocallyScoped(currentVersionMismatchErrorLogLevel,level)),withSpan4=withSpan2,withParentSpan4=withParentSpan2,makeMemoMap2=makeMemoMap,buildWithMemoMap2=buildWithMemoMap,updateService3=dual(3,(layer,tag,f)=>provide3(layer,map12(context4(),(c)=>add2(c,tag,f(unsafeGet3(c,tag))))));var import_redis=__toESM(require_dist2(),1);class RedisConnectionError extends exports_Data.TaggedError("RedisConnectionError"){}class RedisCommandError extends exports_Data.TaggedError("RedisCommandError"){}class RedisGeneralError extends exports_Data.TaggedError("RedisGeneralError"){}class RedisConnectionOptions extends exports_Context.Tag("RedisConnectionOptions")(){}class Redis extends exports_Context.Tag("Redis")(){}class RedisPubSub extends exports_Context.Tag("RedisPubSub")(){}class RedisPersistence extends exports_Context.Tag("RedisPersistence")(){}class RedisStream extends exports_Context.Tag("RedisStream")(){}var redisClientEffect=exports_Effect.gen(function*(){let{options,createClient:createClientFromContext}=yield*RedisConnectionOptions,create=createClientFromContext??import_redis.createClient;return yield*exports_Effect.acquireRelease(exports_Effect.tryPromise({try:()=>create(options).connect().then((r)=>{return console.log("Connected to Redis"),r.on("error",(e)=>{console.log("Redis error(on error):",e.message),r.destroy()}),r.on("end",()=>{console.log("Connection to Redis ended")}),r}),catch:(e)=>new RedisConnectionError({cause:e,message:"Error while connecting to Redis"})}),(client,_exit)=>exports_Effect.tryPromise(()=>{return console.log("Cleaning up Redis connection"),client.close()}).pipe(exports_Effect.catchAll(()=>exports_Effect.void)))}),toRedisError=(error)=>{let message=error instanceof Error?error.message:String(error);if(error instanceof Error){let maybeErrno=error,code=typeof maybeErrno.code==="string"?maybeErrno.code:void 0;if(code!==void 0&&new Set(["ECONNREFUSED","ETIMEDOUT","ECONNRESET","EPIPE","ENOTFOUND","ENETUNREACH","EHOSTUNREACH","EAI_AGAIN"]).has(code)||message.toLowerCase().includes("socket")||message.toLowerCase().includes("connect")||message.toLowerCase().includes("connection"))return new RedisConnectionError({cause:error,message});if(["WRONGTYPE","NOAUTH","WRONGPASS","NOPERM","READONLY","MOVED","ASK","NOSCRIPT","BUSY","ERR"].some((marker)=>message.startsWith(marker)))return new RedisCommandError({cause:error,message,command:"Unknown"})}return new RedisGeneralError({cause:error,message})},bootstrapRedisServiceEffect=exports_Effect.gen(function*(){let client=yield*redisClientEffect;return Redis.of({use:(fn2)=>exports_Effect.gen(function*(){let result=yield*exports_Effect.try({try:()=>fn2(client),catch:(e)=>new RedisCommandError({cause:e,message:"Synchronous error in `Redis.use`",command:"Unknown"})});if(result instanceof Promise)return yield*exports_Effect.tryPromise({try:()=>result,catch:(e)=>new RedisCommandError({cause:e,message:"Asynchronous error in `Redis.use`",command:"Unknown"})});return result}),get:(key)=>exports_Effect.tryPromise({try:()=>client.get(key),catch:toRedisError}),set:(key,value,options)=>exports_Effect.tryPromise({try:()=>{if(!options)return client.set(key,value);let setOptions={};if(options.expiration)setOptions[options.expiration.mode]=options.expiration.time;if(options.condition)setOptions[options.condition]=!0;if(options.get)setOptions.GET=!0;return Object.keys(setOptions).length>0?client.set(key,value,setOptions):client.set(key,value)},catch:toRedisError}),del:(...keys3)=>exports_Effect.tryPromise({try:()=>client.del(keys3),catch:toRedisError}),exists:(...keys3)=>exports_Effect.tryPromise({try:()=>client.exists(keys3),catch:toRedisError}),expire:(key,seconds2)=>exports_Effect.tryPromise({try:()=>client.expire(key,seconds2),catch:toRedisError}),ttl:(key)=>exports_Effect.tryPromise({try:()=>client.ttl(key),catch:toRedisError}),pexpire:(key,milliseconds)=>exports_Effect.tryPromise({try:()=>client.pExpire(key,milliseconds),catch:toRedisError}),pttl:(key)=>exports_Effect.tryPromise({try:()=>client.pTTL(key),catch:toRedisError}),hset:(key,field,value)=>exports_Effect.tryPromise({try:()=>client.hSet(key,field,value),catch:toRedisError}),hget:(key,field)=>exports_Effect.tryPromise({try:()=>client.hGet(key,field),catch:toRedisError}),hgetall:(key)=>exports_Effect.tryPromise({try:()=>client.hGetAll(key),catch:toRedisError}),hdel:(key,...fields)=>exports_Effect.tryPromise({try:()=>client.hDel(key,fields),catch:toRedisError}),hexists:(key,field)=>exports_Effect.tryPromise({try:async()=>await client.hExists(key,field)===1,catch:toRedisError}),hkeys:(key)=>exports_Effect.tryPromise({try:()=>client.hKeys(key),catch:toRedisError}),hvals:(key)=>exports_Effect.tryPromise({try:()=>client.hVals(key),catch:toRedisError}),hlen:(key)=>exports_Effect.tryPromise({try:()=>client.hLen(key),catch:toRedisError}),lpush:(key,...values3)=>exports_Effect.tryPromise({try:()=>client.lPush(key,values3),catch:toRedisError}),rpush:(key,...values3)=>exports_Effect.tryPromise({try:()=>client.rPush(key,values3),catch:toRedisError}),lpop:(key,count)=>exports_Effect.tryPromise({try:async()=>{if(count!==void 0)return client.lPopCount(key,count);return client.lPop(key)},catch:toRedisError}),rpop:(key,count)=>exports_Effect.tryPromise({try:async()=>{if(count!==void 0)return client.rPopCount(key,count);return client.rPop(key)},catch:toRedisError}),lrange:(key,start3,stop)=>exports_Effect.tryPromise({try:()=>client.lRange(key,start3,stop),catch:toRedisError}),llen:(key)=>exports_Effect.tryPromise({try:()=>client.lLen(key),catch:toRedisError}),lrem:(key,count,element)=>exports_Effect.tryPromise({try:()=>client.lRem(key,count,element),catch:toRedisError}),sadd:(key,...members)=>exports_Effect.tryPromise({try:()=>client.sAdd(key,members),catch:toRedisError}),srem:(key,...members)=>exports_Effect.tryPromise({try:()=>client.sRem(key,members),catch:toRedisError}),sismember:(key,member)=>exports_Effect.tryPromise({try:async()=>await client.sIsMember(key,member)===1,catch:toRedisError}),smembers:(key)=>exports_Effect.tryPromise({try:()=>client.sMembers(key),catch:toRedisError}),scard:(key)=>exports_Effect.tryPromise({try:()=>client.sCard(key),catch:toRedisError}),zadd:(key,score,member,...rest)=>{let members=[{score,value:member}];for(let i=0;i<rest.length;i+=2)members.push({score:rest[i],value:rest[i+1]});return exports_Effect.tryPromise({try:()=>client.zAdd(key,members),catch:toRedisError})},zrange:(key,start3,stop,withScores)=>exports_Effect.tryPromise({try:async()=>{if(withScores)return client.zRangeWithScores(key,start3,stop);return client.zRange(key,start3,stop)},catch:toRedisError}),zrangebyscore:(key,min3,max5,withScores)=>exports_Effect.tryPromise({try:async()=>{if(withScores)return client.zRangeByScoreWithScores(key,min3,max5);return client.zRangeByScore(key,min3,max5)},catch:toRedisError}),zscore:(key,member)=>exports_Effect.tryPromise({try:()=>client.zScore(key,member),catch:toRedisError}),zrem:(key,...members)=>exports_Effect.tryPromise({try:()=>client.zRem(key,members),catch:toRedisError}),zcard:(key)=>exports_Effect.tryPromise({try:()=>client.zCard(key),catch:toRedisError}),incr:(key)=>exports_Effect.tryPromise({try:()=>client.incr(key),catch:toRedisError}),decr:(key)=>exports_Effect.tryPromise({try:()=>client.decr(key),catch:toRedisError}),incrby:(key,increment)=>exports_Effect.tryPromise({try:()=>client.incrBy(key,increment),catch:toRedisError}),decrby:(key,decrement)=>exports_Effect.tryPromise({try:()=>client.decrBy(key,decrement),catch:toRedisError}),scan:(options)=>exports_Effect.tryPromise({try:async()=>{let scanOptions={};if(options?.match)scanOptions.MATCH=options.match;if(options?.count)scanOptions.COUNT=options.count;if(options?.type)scanOptions.TYPE=options.type;let result=await client.scan(String(options?.cursor??"0"),scanOptions);return{cursor:String(result.cursor),keys:result.keys}},catch:toRedisError}),flushdb:()=>exports_Effect.tryPromise({try:async()=>{return await client.flushDb(),"OK"},catch:toRedisError}),flushall:()=>exports_Effect.tryPromise({try:async()=>{return await client.flushAll(),"OK"},catch:toRedisError}),dbsize:()=>exports_Effect.tryPromise({try:()=>client.dbSize(),catch:toRedisError}),ping:(message)=>exports_Effect.tryPromise({try:async()=>{return await(message?client.ping(message):client.ping())},catch:toRedisError}),execute:(command,...args2)=>exports_Effect.tryPromise({try:()=>client.sendCommand([command,...args2.map((a)=>String(a))]),catch:toRedisError}),multi:(commands)=>exports_Effect.tryPromise({try:async()=>{let multi=client.multi();for(let[cmd,...args2]of commands)multi.addCommand([cmd,...args2.map((a)=>String(a))]);return multi.exec()},catch:toRedisError}),quit:()=>exports_Effect.tryPromise({try:async()=>{return await client.quit(),"OK"},catch:toRedisError}),disconnect:()=>exports_Effect.tryPromise({try:()=>client.disconnect(),catch:toRedisError})})}),bootstrapRedisPersistenceServiceEffect=exports_Effect.gen(function*(){let client=yield*redisClientEffect;return RedisPersistence.of({setValue:(key,value)=>exports_Effect.tryPromise({try:()=>client.set(key,value),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.setValue`",command:"SET"})}),getValue:(key)=>exports_Effect.tryPromise({try:()=>client.get(key),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.getValue`",command:"GET"})}),del:(key)=>exports_Effect.tryPromise({try:()=>client.del(key),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.del`",command:"DEL"})}),exists:(key)=>exports_Effect.tryPromise({try:async()=>{return await client.exists(key)===1},catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.exists`",command:"EXISTS"})}),sAdd:(key,members)=>exports_Effect.tryPromise({try:()=>client.sAdd(key,members),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.sAdd`",command:"SADD"})})})}),bootstrapRedisPubSubServiceEffect=exports_Effect.gen(function*(){let clientPublish=yield*redisClientEffect,clientSubscribe=yield*redisClientEffect;return RedisPubSub.of({publish:(channel,message)=>exports_Effect.tryPromise({try:()=>clientPublish.publish(channel,message),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.publish`",command:"PUBLISH"})}),subscribe:(channel,handler)=>exports_Effect.tryPromise({try:()=>clientSubscribe.subscribe(channel,handler),catch:(e)=>new RedisCommandError({cause:e,message:"Error in `Redis.subscribe`",command:"SUBSCRIBE"})})})}),bootstrapRedisStreamServiceEffect=exports_Effect.gen(function*(){let clientProducer=yield*redisClientEffect,clientConsumer=yield*redisClientEffect;return RedisStream.of({xadd:(key,id,message)=>exports_Effect.tryPromise({try:async()=>{return await clientProducer.xAdd(key,id,message)},catch:(e)=>new RedisCommandError({cause:e,message:"Error in `RedisStream.xadd`",command:"XADD"})}),xread:(key,id,block,count)=>exports_Effect.tryPromise({try:async()=>{let options={};if(block!==void 0)options.BLOCK=block;if(count!==void 0)options.COUNT=count;let streams=[{key,id}],result=await clientConsumer.xRead(streams,options);if(!result)return[];if(!Array.isArray(result))return[];return result.flatMap((stream)=>{if(stream&&typeof stream==="object"&&"messages"in stream&&Array.isArray(stream.messages))return stream.messages.map((msg)=>{if(msg&&typeof msg==="object"&&"id"in msg)return{id:String(msg.id),message:msg.message};return{id:"",message:{}}});return[]})},catch:(e)=>new RedisCommandError({cause:e,message:"Error in `RedisStream.xread`",command:"XREAD"})}),xrange:(key,start3,end3,count)=>exports_Effect.tryPromise({try:async()=>{let options={};if(count!==void 0)options.COUNT=count;return(await clientConsumer.xRange(key,start3,end3,options)).map((msg)=>({id:msg.id,message:msg.message}))},catch:(e)=>new RedisCommandError({cause:e,message:"Error in `RedisStream.xrange`",command:"XRANGE"})})})}),RedisConnectionOptionsLive=(options,createClientOverride)=>exports_Layer.succeed(RedisConnectionOptions,RedisConnectionOptions.of({options,createClient:createClientOverride})),RedisLive=exports_Layer.scoped(Redis,bootstrapRedisServiceEffect),RedisPubSubLive=exports_Layer.scoped(RedisPubSub,bootstrapRedisPubSubServiceEffect),RedisPersistenceLive=exports_Layer.scoped(RedisPersistence,bootstrapRedisPersistenceServiceEffect),RedisStreamLive=exports_Layer.scoped(RedisStream,bootstrapRedisStreamServiceEffect);export{toRedisError,RedisStreamLive,RedisStream,RedisPubSubLive,RedisPubSub,RedisPersistenceLive,RedisPersistence,RedisLive,RedisConnectionOptionsLive,RedisConnectionOptions,Redis};

package/dist/redis.d.ts

@@ -1,13 +1,6 @@
 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;
-}> {
-}
+import type { KeyOptions, RedisError, RedisHashValue, RedisListValue, RedisSetMember, RedisValue, ScanOptions, ScanResult } from './types';
 interface RedisConnectionOptionsShape {
     options?: Parameters<typeof createClient>[0];
 }
@@ -15,7 +8,201 @@ declare const RedisConnectionOptions_base: Context.TagClass<RedisConnectionOptio
 declare class RedisConnectionOptions extends RedisConnectionOptions_base {
 }
 interface RedisShape {
-    use: <T>(fn: (client: ReturnType<typeof createClient>) => T) => Effect.Effect<Awaited<T>, RedisError, never>;
+    readonly use: <T>(fn: (client: ReturnType<typeof createClient>) => 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) => Effect.Effect<string | string[] | null, RedisError>;
+    /**
+     * List operations - Pop value from right of list
+     */
+    readonly rpop: (key: string, count?: number) => 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) => 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) => 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) => 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) => 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>;
 }
 declare const Redis_base: Context.TagClass<Redis, "Redis", RedisShape>;
 declare class Redis extends Redis_base {

package/dist/src/index.d.ts

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

package/dist/src/redis.d.ts

@@ -0,0 +1,257 @@
+import { Context, Effect, Layer } from 'effect';
+import { type RedisArgument, createClient } from 'redis';
+import type { KeyOptions, RedisError, RedisHashValue, RedisListValue, RedisSetMember, RedisValue, ScanOptions, ScanResult } from './types';
+interface RedisConnectionOptionsShape {
+    options?: Parameters<typeof createClient>[0];
+    createClient?: (options?: Parameters<typeof createClient>[0]) => ReturnType<typeof createClient>;
+}
+declare const RedisConnectionOptions_base: Context.TagClass<RedisConnectionOptions, "RedisConnectionOptions", RedisConnectionOptionsShape>;
+declare class RedisConnectionOptions extends RedisConnectionOptions_base {
+}
+interface RedisShape {
+    readonly use: <T>(fn: (client: ReturnType<typeof createClient>) => 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) => Effect.Effect<string | string[] | null, RedisError>;
+    /**
+     * List operations - Pop value from right of list
+     */
+    readonly rpop: (key: string, count?: number) => 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) => 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) => 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) => 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) => 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>;
+}
+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>;
+    getValue: (key: string) => Effect.Effect<string | null, RedisError, never>;
+    del: (key: string) => Effect.Effect<number, RedisError, never>;
+    exists: (key: string) => Effect.Effect<boolean, 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 {
+}
+export interface StreamEntry {
+    id: RedisArgument;
+    message: Record<string, string>;
+}
+interface RedisStreamShape {
+    xadd: (key: RedisArgument, // Stream key name
+    id: RedisArgument | '*', // Entry ID or '*' for auto-generation
+    message: Record<string, RedisArgument>) => Effect.Effect<string, RedisError, never>;
+    xread: (key: RedisArgument, // Stream key to read from
+    id: RedisArgument, // Start reading from this ID ('$' for new entries only)
+    block?: number, // Block in milliseconds (0 for indefinite wait)
+    count?: number) => Effect.Effect<StreamEntry[], RedisError, never>;
+    xrange: (key: RedisArgument, // Stream key name
+    start: RedisArgument, // Start ID ('-' for earliest available)
+    end: RedisArgument, // End ID ('+' 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 {
+}
+/**
+ * Helper function to convert Redis errors to Effect errors
+ */
+export declare const toRedisError: (error: unknown) => RedisError;
+declare const RedisConnectionOptionsLive: (options?: Parameters<typeof createClient>[0], createClientOverride?: (options?: Parameters<typeof createClient>[0]) => ReturnType<typeof createClient>) => Layer.Layer<RedisConnectionOptions, never, never>;
+declare const RedisLive: Layer.Layer<Redis, RedisError, RedisConnectionOptions>;
+declare const RedisPubSubLive: Layer.Layer<RedisPubSub, RedisError, RedisConnectionOptions>;
+declare const RedisPersistenceLive: Layer.Layer<RedisPersistence, RedisError, RedisConnectionOptions>;
+declare const RedisStreamLive: Layer.Layer<RedisStream, RedisError, RedisConnectionOptions>;
+export { Redis, RedisConnectionOptions, RedisConnectionOptionsLive, RedisLive, RedisPersistence, RedisPersistenceLive, RedisPubSub, RedisPubSubLive, RedisStream, RedisStreamLive, };

package/dist/src/types.d.ts

@@ -0,0 +1,93 @@
+/** biome-ignore-all lint/correctness/noUnusedVariables: <explanation */
+/** biome-ignore-all lint/suspicious/noEmptyInterface: <explanation */
+/**
+ * Common Redis value types
+ */
+export type RedisValue = string | number | Buffer;
+/**
+ * Redis hash field types
+ */
+export type RedisHashValue = string | number | Buffer | Record<string, string | number | Buffer>;
+/**
+ * Redis set member types
+ */
+export type RedisSetMember = string | Buffer;
+/**
+ * Redis sorted set member with score
+ */
+export interface SortedSetMember {
+    member: string;
+    score: number;
+}
+/**
+ * Redis list value types
+ */
+export type RedisListValue = string | number | Buffer;
+/**
+ * Redis key with optional options
+ */
+export interface KeyOptions {
+    readonly expiration?: {
+        mode: 'EX' | 'PX' | 'EXAT' | 'PXAT';
+        time: number;
+    };
+    readonly condition?: 'NX' | 'XX';
+    readonly get?: boolean;
+}
+export type ScanOptions = {
+    readonly cursor?: string;
+    readonly match?: string;
+    readonly count?: number;
+    readonly type?: string;
+};
+export type ScanResult = {
+    readonly cursor: string;
+    readonly keys: ReadonlyArray<string>;
+};
+/**
+ * Get options
+ */
+export interface GetOptions {
+    readonly ex?: number;
+    readonly px?: number;
+    readonly exat?: number;
+    readonly pxat?: number;
+    readonly persist?: boolean;
+}
+/**
+ * Set range result
+ */
+export interface SetRangeResult {
+    readonly previousValue: string | null;
+    readonly length: number;
+}
+declare const RedisConnectionError_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: "RedisConnectionError";
+} & Readonly<A>;
+/*****************************************************************
+ * Error Types
+ *****************************************************************/
+export declare class RedisConnectionError extends RedisConnectionError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+}
+declare const RedisCommandError_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: "RedisCommandError";
+} & Readonly<A>;
+export declare class RedisCommandError extends RedisCommandError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+    readonly command: string;
+}> {
+}
+declare const RedisGeneralError_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: "RedisGeneralError";
+} & Readonly<A>;
+export declare class RedisGeneralError extends RedisGeneralError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+}
+export type RedisError = RedisConnectionError | RedisCommandError | RedisGeneralError;
+export {};

package/dist/test/Dummy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/redis.layer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/toRedisError.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,93 @@
+/** biome-ignore-all lint/correctness/noUnusedVariables: <explanation */
+/** biome-ignore-all lint/suspicious/noEmptyInterface: <explanation */
+/**
+ * Common Redis value types
+ */
+export type RedisValue = string | number | Buffer;
+/**
+ * Redis hash field types
+ */
+export type RedisHashValue = string | number | Buffer | Record<string, string | number | Buffer>;
+/**
+ * Redis set member types
+ */
+export type RedisSetMember = string | Buffer;
+/**
+ * Redis sorted set member with score
+ */
+export interface SortedSetMember {
+    member: string;
+    score: number;
+}
+/**
+ * Redis list value types
+ */
+export type RedisListValue = string | number | Buffer;
+/**
+ * Redis key with optional options
+ */
+export interface KeyOptions {
+    readonly expiration?: {
+        mode: 'EX' | 'PX' | 'EXAT' | 'PXAT';
+        time: number;
+    };
+    readonly condition?: 'NX' | 'XX';
+    readonly get?: boolean;
+}
+export type ScanOptions = {
+    readonly cursor?: string;
+    readonly match?: string;
+    readonly count?: number;
+    readonly type?: string;
+};
+export type ScanResult = {
+    readonly cursor: string;
+    readonly keys: ReadonlyArray<string>;
+};
+/**
+ * Get options
+ */
+export interface GetOptions {
+    readonly ex?: number;
+    readonly px?: number;
+    readonly exat?: number;
+    readonly pxat?: number;
+    readonly persist?: boolean;
+}
+/**
+ * Set range result
+ */
+export interface SetRangeResult {
+    readonly previousValue: string | null;
+    readonly length: number;
+}
+declare const RedisConnectionError_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: "RedisConnectionError";
+} & Readonly<A>;
+/*****************************************************************
+ * Error Types
+ *****************************************************************/
+export declare class RedisConnectionError extends RedisConnectionError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+}
+declare const RedisCommandError_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: "RedisCommandError";
+} & Readonly<A>;
+export declare class RedisCommandError extends RedisCommandError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+    readonly command: string;
+}> {
+}
+declare const RedisGeneralError_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: "RedisGeneralError";
+} & Readonly<A>;
+export declare class RedisGeneralError extends RedisGeneralError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+}
+export type RedisError = RedisConnectionError | RedisCommandError | RedisGeneralError;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-redis",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Simple Effect wrapper for Redis.",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -21,11 +21,13 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.8",
+    "@effect/language-service": "^0.62.5",
+    "@effect/vitest": "^0.27.0",
     "@types/bun": "latest",
     "vitest": "^4.0.14"
   },
   "peerDependencies": {
-    "effect": "^3.17.1",
+    "effect": "^3.19.9",
     "redis": "^5.1.0",
     "typescript": "^5"
   },