@uploadista/kv-store-ioredis 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @uploadista/kv-store-ioredis@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/kv-stores/ioredis
+> tsc -b
+

package/.turbo/turbo-check.log

@@ -0,0 +1,5 @@
+
+> @uploadista/kv-store-ioredis@ check /Users/denislaboureyras/Documents/uploadista/dev/uploadista/packages/uploadista/kv-stores/ioredis
+> biome check --write ./src
+
+Checked 2 files in 53ms. No fixes applied.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 uploadista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,576 @@
+# @uploadista/kv-store-ioredis
+
+IORedis-backed key-value store for Uploadista. Provides advanced Redis features including clustering, Sentinel support, and connection pooling.
+
+## Overview
+
+The IORedis KV store uses the `ioredis` library, offering:
+
+- **Advanced Clustering**: Built-in Redis cluster support with auto-discovery
+- **Sentinel Support**: Automatic failover with Redis Sentinel
+- **Connection Pooling**: Efficient connection management
+- **Lua Scripting**: Support for atomic multi-step operations
+- **Cluster-Ready**: Production-grade cluster operations
+- **Better Error Handling**: More granular retry and connection strategies
+
+Compared to the standard Redis client, IORedis is optimized for complex deployments and high-availability setups.
+
+## Installation
+
+```bash
+npm install @uploadista/kv-store-ioredis ioredis
+# or
+pnpm add @uploadista/kv-store-ioredis ioredis
+```
+
+### Prerequisites
+
+- Node.js 18+
+- Redis 5.0+ or Redis cluster
+- Optional: Redis Sentinel for automatic failover
+
+## Quick Start
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+import { Effect } from "effect";
+
+// Create IORedis instance
+const redis = new Redis({
+  host: "localhost",
+  port: 6379,
+});
+
+// Use the KV store layer
+const program = Effect.gen(function* () {
+  // The ioRedisKvStore is automatically available
+});
+
+Effect.runSync(
+  program.pipe(
+    Effect.provide(ioRedisKvStore({ redis }))
+  )
+);
+```
+
+## Features
+
+- ✅ **Redis Clustering**: Built-in support for Redis clusters
+- ✅ **Sentinel Support**: Automatic master failover detection
+- ✅ **Connection Pooling**: Efficient resource management
+- ✅ **Cluster Replica Reads**: Distribute read load across replicas
+- ✅ **Auto-Reconnect**: Robust connection recovery
+- ✅ **Pub/Sub Support**: Integration with event systems
+- ✅ **Lua Scripting**: Advanced atomic operations
+- ✅ **Type Safe**: Full TypeScript support
+
+## API Reference
+
+### Main Exports
+
+#### `ioRedisKvStore(config: IoRedisKvStoreConfig): Layer<BaseKvStoreService>`
+
+Creates an Effect layer providing the `BaseKvStoreService` backed by IORedis.
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+
+const redis = new Redis({ host: "localhost", port: 6379 });
+
+const layer = ioRedisKvStore({ redis });
+```
+
+**Configuration**:
+
+```typescript
+type IoRedisKvStoreConfig = {
+  redis: Redis; // Connected IORedis instance
+};
+```
+
+#### `makeIoRedisBaseKvStore(config: IoRedisKvStoreConfig): BaseKvStore`
+
+Factory function for creating a KV store with an existing IORedis instance.
+
+```typescript
+import { makeIoRedisBaseKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+
+const redis = new Redis();
+const store = makeIoRedisBaseKvStore({ redis });
+```
+
+### Available Operations
+
+The IORedis store implements the `BaseKvStore` interface:
+
+#### `get(key: string): Effect<string | null>`
+
+Retrieve a value by key.
+
+```typescript
+const program = Effect.gen(function* () {
+  const value = yield* store.get("upload:123");
+});
+```
+
+#### `set(key: string, value: string): Effect<void>`
+
+Store a string value.
+
+```typescript
+const program = Effect.gen(function* () {
+  yield* store.set("upload:123", JSON.stringify(data));
+});
+```
+
+#### `delete(key: string): Effect<void>`
+
+Remove a key.
+
+```typescript
+const program = Effect.gen(function* () {
+  yield* store.delete("upload:123");
+});
+```
+
+#### `list(keyPrefix: string): Effect<string[]>`
+
+List keys matching a prefix using SCAN (cluster-aware).
+
+```typescript
+const program = Effect.gen(function* () {
+  const keys = yield* store.list("upload:");
+});
+```
+
+## Configuration
+
+### Single Instance
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+
+const redis = new Redis({
+  host: "localhost",
+  port: 6379,
+  password: process.env.REDIS_PASSWORD,
+  db: 0,
+  retryStrategy: (times: number) => Math.min(times * 50, 2000),
+});
+
+const layer = ioRedisKvStore({ redis });
+```
+
+### Redis Cluster
+
+With automatic cluster discovery:
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+
+const redis = new Redis.Cluster(
+  [
+    { host: "node1", port: 6379 },
+    { host: "node2", port: 6379 },
+    { host: "node3", port: 6379 },
+  ],
+  {
+    dnsLookup: (address, callback) => callback(null, address),
+    redisOptions: {
+      password: process.env.REDIS_PASSWORD,
+    },
+  }
+);
+
+const layer = ioRedisKvStore({ redis: redis as any });
+```
+
+### Redis Sentinel
+
+For high availability with automatic failover:
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+
+const redis = new Redis({
+  sentinels: [
+    { host: "sentinel1", port: 26379 },
+    { host: "sentinel2", port: 26379 },
+    { host: "sentinel3", port: 26379 },
+  ],
+  name: "mymaster",
+  sentinelPassword: process.env.SENTINEL_PASSWORD,
+  password: process.env.REDIS_PASSWORD,
+  sentinelRetryStrategy: (times: number) => {
+    const delay = Math.min(times * 10, 1000);
+    return delay;
+  },
+});
+
+const layer = ioRedisKvStore({ redis });
+```
+
+### Replica Reads
+
+Distribute read load across replicas:
+
+```typescript
+import Redis from "ioredis";
+
+const redis = new Redis.Cluster(
+  [
+    { host: "master", port: 6379 },
+    { host: "replica1", port: 6379 },
+    { host: "replica2", port: 6379 },
+  ],
+  {
+    enableReadyCheck: true,
+    enableOfflineQueue: true,
+    scaleReads: "slave", // Read from replicas
+  }
+);
+```
+
+## Examples
+
+### Example 1: Distributed Server with Clustering
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import { uploadServer } from "@uploadista/server";
+import Redis from "ioredis";
+import { Effect } from "effect";
+
+// Cluster configuration
+const redis = new Redis.Cluster(
+  [
+    { host: "redis1", port: 6379 },
+    { host: "redis2", port: 6379 },
+    { host: "redis3", port: 6379 },
+  ],
+  {
+    redisOptions: {
+      password: process.env.REDIS_PASSWORD,
+    },
+  }
+);
+
+const program = Effect.gen(function* () {
+  const server = yield* uploadServer;
+
+  // Handle uploads across cluster
+  const upload = yield* server.createUpload(
+    { filename: "large-file.zip", size: 104857600 },
+    "client:123"
+  );
+
+  console.log(`Upload created: ${upload.id}`);
+});
+
+Effect.runSync(
+  program.pipe(
+    Effect.provide(ioRedisKvStore({ redis: redis as any }))
+  )
+);
+```
+
+### Example 2: Sentinel-Based High Availability
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+import { Effect } from "effect";
+
+const redis = new Redis({
+  sentinels: [
+    { host: "sentinel1", port: 26379 },
+    { host: "sentinel2", port: 26379 },
+    { host: "sentinel3", port: 26379 },
+  ],
+  name: "uploadista-master",
+  password: process.env.REDIS_PASSWORD,
+});
+
+// Automatic failover is handled by IORedis
+const store = ioRedisKvStore({ redis });
+
+const program = Effect.gen(function* () {
+  // Operations automatically route through Sentinel
+  // If master fails, Sentinel promotes replica automatically
+  const result = yield* Effect.tryPromise({
+    try: async () => redis.ping(),
+    catch: (e) => e as Error,
+  });
+
+  console.log(`Redis status: ${result}`);
+});
+```
+
+### Example 3: Connection Pool Optimization
+
+```typescript
+import { ioRedisKvStore } from "@uploadista/kv-store-ioredis";
+import Redis from "ioredis";
+import { Effect } from "effect";
+
+const redis = new Redis({
+  host: "localhost",
+  port: 6379,
+  maxRetriesPerRequest: 3,
+  enableReadyCheck: true,
+  enableOfflineQueue: true,
+  connectTimeout: 10000,
+  retryStrategy: (times: number) => {
+    const delay = Math.min(times * 50, 2000);
+    if (times > 10) {
+      return null; // Stop retrying
+    }
+    return delay;
+  },
+  reconnectOnError: (err: Error) => {
+    // Reconnect on all errors except AUTH errors
+    if (err.message.includes("WRONGPASS")) {
+      return false;
+    }
+    return true;
+  },
+});
+
+const program = Effect.gen(function* () {
+  // Connection pool is managed automatically
+  const store = ioRedisKvStore({ redis });
+  // Use store...
+});
+```
+
+## Performance Tuning
+
+### Cluster Mode Optimization
+
+```typescript
+const redis = new Redis.Cluster(
+  [
+    { host: "node1", port: 6379 },
+    { host: "node2", port: 6379 },
+    { host: "node3", port: 6379 },
+  ],
+  {
+    // Optimize cluster operations
+    maxRedirections: 16,        // Cluster redirects
+    retryDelayOnFailover: 100,  // Wait before retry
+    retryDelayOnClusterDown: 300, // Cluster down delay
+    dnsLookup: (address, callback) => {
+      // Implement custom DNS if needed
+      callback(null, address);
+    },
+  }
+);
+```
+
+### Connection Settings
+
+```typescript
+const redis = new Redis({
+  // Performance tuning
+  lazyConnect: false,           // Connect immediately
+  enableReadyCheck: false,      // Skip ready check for speed
+  enableOfflineQueue: true,     // Queue commands when offline
+  maxRetriesPerRequest: 3,      // Limit retries
+  socketConnectTimeout: 5000,   // Socket timeout
+  socketKeepAlive: 30000,       // Keep-alive
+});
+```
+
+## Scaling Patterns
+
+### Single Instance with Replica
+
+```
+Write Operations ──→ Master ──→ Replicates to ──→ Replica 1
+Read Operations  ─────────────────────────────→ Replica 2
+```
+
+### Redis Cluster
+
+```
+Client A ──→ Node 1 (Hash slots 0-5460)
+Client B ──→ Node 2 (Hash slots 5461-10922)
+Client C ──→ Node 3 (Hash slots 10923-16383)
+```
+
+### Sentinel Setup
+
+```
+Sentinel 1 ┐
+Sentinel 2 ├─→ Monitors ──→ Master ──→ Replica
+Sentinel 3 ┘         ↓
+                  Promotes on failure
+```
+
+## Advanced Features
+
+### Lua Scripting
+
+For atomic operations:
+
+```typescript
+import Redis from "ioredis";
+
+const redis = new Redis();
+
+// Atomic increment with limit
+const script = `
+  local val = redis.call('get', KEYS[1])
+  val = (val or 0) + 1
+  if val > tonumber(ARGV[1]) then
+    return 0
+  end
+  redis.call('set', KEYS[1], val)
+  return val
+`;
+
+const result = await redis.eval(script, 1, "counter", 100);
+```
+
+### Pub/Sub for Events
+
+```typescript
+import Redis from "ioredis";
+
+const redis = new Redis();
+const subscriber = new Redis();
+
+subscriber.on("message", (channel, message) => {
+  console.log(`${channel}: ${message}`);
+});
+
+subscriber.subscribe("upload-events");
+
+// Publish from main instance
+redis.publish("upload-events", JSON.stringify({
+  type: "upload-complete",
+  uploadId: "abc123",
+}));
+```
+
+## Deployment
+
+### Docker Compose with Cluster
+
+```yaml
+version: "3"
+services:
+  app:
+    environment:
+      REDIS_CLUSTER_NODES: redis1:6379,redis2:6379,redis3:6379
+  redis1:
+    image: redis:7-alpine
+    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf
+  redis2:
+    image: redis:7-alpine
+    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf
+  redis3:
+    image: redis:7-alpine
+    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf
+```
+
+### Kubernetes Deployment
+
+```yaml
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: redis-cluster
+spec:
+  serviceName: redis-cluster
+  replicas: 3
+  selector:
+    matchLabels:
+      app: redis
+  template:
+    metadata:
+      labels:
+        app: redis
+    spec:
+      containers:
+      - name: redis
+        image: redis:7-alpine
+        ports:
+        - containerPort: 6379
+        - containerPort: 16379
+```
+
+## Related Packages
+
+- [@uploadista/core](../../core) - Core types
+- [@uploadista/kv-store-redis](../redis) - Standard Redis client
+- [@uploadista/kv-store-memory](../memory) - For development
+- [@uploadista/event-broadcaster-ioredis](../../event-emitters/event-broadcaster-ioredis) - Event broadcasting
+- [@uploadista/server](../../servers/server) - Upload server
+
+## Troubleshooting
+
+### Cluster Connection Issues
+
+```
+Error: Failed to refresh slots cache
+```
+
+Solutions:
+1. Verify cluster nodes are accessible
+2. Check cluster configuration: `redis-cli -c cluster info`
+3. Ensure password matches across all nodes
+
+```bash
+redis-cli -c cluster nodes
+# Should show all nodes as connected
+```
+
+### Sentinel Detection Failed
+
+```
+Error: Cannot find master from Sentinel
+```
+
+Solutions:
+1. Verify Sentinel is running
+2. Check Sentinel configuration: `redis-cli -p 26379 SENTINEL MASTERS`
+3. Verify master name matches configuration
+
+```bash
+redis-cli -p 26379
+> SENTINEL get-master-addr-by-name uploadista-master
+```
+
+### High Memory Usage
+
+Monitor cluster memory:
+
+```bash
+redis-cli -c info memory | grep used_memory
+```
+
+Implement cleanup:
+
+```typescript
+// Set TTL on session keys
+await redis.setex("session:user123", 3600, sessionData);
+```
+
+## License
+
+See [LICENSE](../../../LICENSE) in the main repository.
+
+## See Also
+
+- [KV Stores Comparison Guide](../KV_STORES_COMPARISON.md) - Compare IORedis with other options
+- [Server Setup Guide](../../../SERVER_SETUP.md) - IORedis in production
+- [ioredis Documentation](https://github.com/luin/ioredis) - Official ioredis docs
+- [Redis Cluster Guide](https://redis.io/topics/cluster-tutorial) - Redis clustering
+- [Redis Sentinel Guide](https://redis.io/topics/sentinel) - High availability

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./io-redis-kv-store";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./io-redis-kv-store";

package/dist/io-redis-kv-store.d.ts

@@ -0,0 +1,9 @@
+import { type BaseKvStore, BaseKvStoreService } from "@uploadista/core/types";
+import { Layer } from "effect";
+import type { Redis as IoRedis } from "ioredis";
+export type IoRedisKvStoreConfig = {
+    redis: IoRedis;
+};
+export declare function makeIoRedisBaseKvStore({ redis, }: IoRedisKvStoreConfig): BaseKvStore;
+export declare const ioRedisKvStore: (config: IoRedisKvStoreConfig) => Layer.Layer<BaseKvStoreService, never, never>;
+//# sourceMappingURL=io-redis-kv-store.d.ts.map

package/dist/io-redis-kv-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io-redis-kv-store.d.ts","sourceRoot":"","sources":["../src/io-redis-kv-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,KAAK,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAGF,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,GACN,EAAE,oBAAoB,GAAG,WAAW,CA4CpC;AAGD,eAAO,MAAM,cAAc,GAAI,QAAQ,oBAAoB,kDACQ,CAAC"}

package/dist/io-redis-kv-store.js

@@ -0,0 +1,37 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { BaseKvStoreService } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+// Base IORedis KV store that stores raw strings
+export function makeIoRedisBaseKvStore({ redis, }) {
+    return {
+        get: (key) => Effect.tryPromise({
+            try: () => redis.get(key),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }),
+        set: (key, value) => Effect.tryPromise({
+            try: () => redis.set(key, value),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }).pipe(Effect.asVoid),
+        delete: (key) => Effect.tryPromise({
+            try: () => redis.del(key),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }).pipe(Effect.asVoid),
+        list: (keyPrefix) => Effect.gen(function* (_) {
+            const keys = new Set();
+            let cursor = "0";
+            do {
+                const [next, batch] = yield* _(Effect.tryPromise({
+                    try: () => redis.scan(cursor, "MATCH", `${keyPrefix}*`, "COUNT", "20"),
+                    catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+                }));
+                cursor = next;
+                for (const key of batch) {
+                    keys.add(key.replace(keyPrefix, ""));
+                }
+            } while (cursor !== "0");
+            return Array.from(keys);
+        }),
+    };
+}
+// Base store layer
+export const ioRedisKvStore = (config) => Layer.succeed(BaseKvStoreService, makeIoRedisBaseKvStore(config));

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@uploadista/kv-store-ioredis",
+  "type": "module",
+  "version": "0.0.3",
+  "description": "Redis KV store for Uploadista",
+  "license": "MIT",
+  "author": "Uploadista",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "ioredis": "5.8.1",
+    "effect": "3.18.4",
+    "@uploadista/core": "0.0.3"
+  },
+  "devDependencies": {
+    "@uploadista/typescript-config": "0.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "format": "biome format --write ./src",
+    "lint": "biome lint --write ./src",
+    "check": "biome check --write ./src"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./io-redis-kv-store";

package/src/io-redis-kv-store.ts

@@ -0,0 +1,61 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { type BaseKvStore, BaseKvStoreService } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+import type { Redis as IoRedis } from "ioredis";
+
+export type IoRedisKvStoreConfig = {
+  redis: IoRedis;
+};
+
+// Base IORedis KV store that stores raw strings
+export function makeIoRedisBaseKvStore({
+  redis,
+}: IoRedisKvStoreConfig): BaseKvStore {
+  return {
+    get: (key: string) =>
+      Effect.tryPromise({
+        try: () => redis.get(key),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }),
+
+    set: (key: string, value: string) =>
+      Effect.tryPromise({
+        try: () => redis.set(key, value),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }).pipe(Effect.asVoid),
+
+    delete: (key: string) =>
+      Effect.tryPromise({
+        try: () => redis.del(key),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }).pipe(Effect.asVoid),
+
+    list: (keyPrefix: string) =>
+      Effect.gen(function* (_) {
+        const keys = new Set<string>();
+        let cursor = "0";
+
+        do {
+          const [next, batch] = yield* _(
+            Effect.tryPromise({
+              try: () =>
+                redis.scan(cursor, "MATCH", `${keyPrefix}*`, "COUNT", "20"),
+              catch: (cause) =>
+                UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+            }),
+          );
+
+          cursor = next;
+          for (const key of batch) {
+            keys.add(key.replace(keyPrefix, ""));
+          }
+        } while (cursor !== "0");
+
+        return Array.from(keys);
+      }),
+  };
+}
+
+// Base store layer
+export const ioRedisKvStore = (config: IoRedisKvStoreConfig) =>
+  Layer.succeed(BaseKvStoreService, makeIoRedisBaseKvStore(config));

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@uploadista/typescript-config/server.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "typeRoots": ["../../../../node_modules/@types"]
+  },
+  "include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/io-redis-kv-store.ts"],"version":"5.9.3"}