@tekir/redis 0.1.3 → 0.1.4

package/dist/index.js

@@ -1,3 +1,437 @@
-export { Redis } from './redis';
-export { RedisManager } from './manager';
-export { RedisProvider } from './provider';
+// src/redis.ts
+import { createRequire } from "node:module";
+var nodeRequire = createRequire(import.meta.url);
+
+class NodeRedisClient {
+  client;
+  messageHandlers = new Map;
+  constructor(url, options = {}) {
+    const imported = nodeRequire("ioredis");
+    const IORedis = imported.default || imported;
+    this.client = new IORedis(url, {
+      lazyConnect: true,
+      connectTimeout: options.connectionTimeout,
+      enableAutoPipelining: options.enableAutoPipelining,
+      maxRetriesPerRequest: options.maxRetries,
+      retryStrategy: options.autoReconnect === false ? null : undefined,
+      tls: options.tls === true ? {} : options.tls || undefined
+    });
+    this.client.on("message", (channel, message) => {
+      this.messageHandlers.get(channel)?.(message, channel);
+    });
+  }
+  async connect() {
+    if (this.client.status === "wait")
+      await this.client.connect();
+    else if (this.client.status !== "ready")
+      await new Promise((resolve, reject) => {
+        this.client.once("ready", resolve);
+        this.client.once("error", reject);
+      });
+  }
+  close() {
+    this.client.disconnect();
+  }
+  get connected() {
+    return this.client.status === "ready";
+  }
+  get(key) {
+    return this.client.get(key);
+  }
+  set(key, value, ...args) {
+    return this.client.set(key, value, ...args);
+  }
+  del(...keys) {
+    return this.client.del(...keys);
+  }
+  async exists(key) {
+    return await this.client.exists(key) > 0;
+  }
+  incr(key) {
+    return this.client.incr(key);
+  }
+  decr(key) {
+    return this.client.decr(key);
+  }
+  expire(key, seconds) {
+    return this.client.expire(key, seconds);
+  }
+  ttl(key) {
+    return this.client.ttl(key);
+  }
+  hget(key, field) {
+    return this.client.hget(key, field);
+  }
+  hmset(key, fields) {
+    return this.client.hmset(key, ...fields);
+  }
+  hmget(key, fields) {
+    return this.client.hmget(key, ...fields);
+  }
+  hincrby(key, field, increment) {
+    return this.client.hincrby(key, field, increment);
+  }
+  sadd(key, ...members) {
+    return this.client.sadd(key, ...members);
+  }
+  srem(key, ...members) {
+    return this.client.srem(key, ...members);
+  }
+  async sismember(key, member) {
+    return await this.client.sismember(key, member) > 0;
+  }
+  smembers(key) {
+    return this.client.smembers(key);
+  }
+  publish(channel, message) {
+    return this.client.publish(channel, message);
+  }
+  async subscribe(channel, callback) {
+    this.messageHandlers.set(channel, callback);
+    await this.client.subscribe(channel);
+  }
+  async unsubscribe(channel) {
+    if (channel)
+      this.messageHandlers.delete(channel);
+    else
+      this.messageHandlers.clear();
+    await (channel ? this.client.unsubscribe(channel) : this.client.unsubscribe());
+  }
+  send(command, args = []) {
+    return this.client.call(command, ...args);
+  }
+}
+
+class Redis {
+  client;
+  prefix;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.prefix = (config.prefix || "").replace(/:+$/, "");
+    const RedisClient = process.versions.bun ? globalThis.Bun.RedisClient : NodeRedisClient;
+    const url = config.url || process.env.REDIS_URL || "redis://localhost:6379";
+    const isTls = config.tls != null || url.startsWith("rediss://");
+    if (!isTls && false) {}
+    this.client = new RedisClient(url, {
+      connectionTimeout: config.connectionTimeout,
+      idleTimeout: config.idleTimeout,
+      autoReconnect: config.autoReconnect ?? true,
+      maxRetries: config.maxRetries ?? 10,
+      enableAutoPipelining: config.enableAutoPipelining ?? true,
+      tls: config.tls
+    });
+  }
+  key(k) {
+    return this.prefix ? `${this.prefix}:${k}` : k;
+  }
+  keyName(key) {
+    return this.key(key);
+  }
+  static maskUrl(url) {
+    return url.replace(/(\w+:\/\/)([^@/]+)@/, "$1***@");
+  }
+  async connect() {
+    await this.client.connect();
+  }
+  close() {
+    this.client.close();
+  }
+  get connected() {
+    return this.client.connected;
+  }
+  async get(key) {
+    return this.client.get(this.key(key));
+  }
+  async set(key, value) {
+    await this.client.set(this.key(key), String(value));
+  }
+  async setEx(key, value, seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0)
+      throw new Error("Redis setEx seconds must be a positive number");
+    await this.client.send("SET", [this.key(key), String(value), "EX", String(Math.floor(seconds))]);
+  }
+  async del(...keys) {
+    await this.client.del(...keys.map((k) => this.key(k)));
+  }
+  async exists(key) {
+    return this.client.exists(this.key(key));
+  }
+  async incr(key) {
+    return this.client.incr(this.key(key));
+  }
+  async decr(key) {
+    return this.client.decr(this.key(key));
+  }
+  async expire(key, seconds) {
+    await this.client.expire(this.key(key), seconds);
+  }
+  async ttl(key) {
+    return this.client.ttl(this.key(key));
+  }
+  async hget(key, field) {
+    return this.client.hget(this.key(key), field);
+  }
+  async hmset(key, fields) {
+    await this.client.hmset(this.key(key), fields);
+  }
+  async hmget(key, fields) {
+    return this.client.hmget(this.key(key), fields);
+  }
+  async hincrby(key, field, increment) {
+    return this.client.hincrby(this.key(key), field, increment);
+  }
+  async sadd(key, ...members) {
+    return this.client.sadd(this.key(key), ...members);
+  }
+  async srem(key, ...members) {
+    return this.client.srem(this.key(key), ...members);
+  }
+  async sismember(key, member) {
+    return this.client.sismember(this.key(key), member);
+  }
+  async smembers(key) {
+    return this.client.smembers(this.key(key));
+  }
+  async publish(channel, message) {
+    await this.client.publish(channel, message);
+  }
+  async subscribe(channel, callback) {
+    await this.client.subscribe(channel, callback);
+  }
+  async unsubscribe(channel) {
+    await this.client.unsubscribe(channel);
+  }
+  async send(command, args = []) {
+    return this.client.send(command, args);
+  }
+  async getJSON(key) {
+    const val = await this.get(key);
+    if (val === null)
+      return null;
+    try {
+      return JSON.parse(val);
+    } catch (e) {
+      console.warn(`[@tekir/redis] Failed to parse JSON for key "${key}": ${e.message}`);
+      return null;
+    }
+  }
+  async setJSON(key, value, expireSeconds) {
+    const payload = JSON.stringify(value);
+    if (payload === undefined)
+      throw new Error(`Redis cannot serialize undefined for key "${key}"`);
+    if (expireSeconds && expireSeconds > 0) {
+      await this.client.send("SET", [this.key(key), payload, "EX", String(Math.floor(expireSeconds))]);
+    } else {
+      await this.client.set(this.key(key), payload);
+    }
+  }
+  async remember(key, seconds, callback) {
+    const cached = await this.getJSON(key);
+    if (cached !== null)
+      return cached;
+    const lockKey = this.key(`${key}:__lock`);
+    const lockToken = crypto.randomUUID();
+    const acquired = await this.client.send("SET", [lockKey, lockToken, "NX", "EX", "10"]);
+    if (acquired == null) {
+      for (let i = 0;i < 300; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        const waited = await this.getJSON(key);
+        if (waited !== null)
+          return waited;
+      }
+      throw new Error(`Redis remember timed out waiting for lock on "${key}"`);
+    }
+    const renewScript = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('EXPIRE', KEYS[1], 10)
+end
+return 0
+`;
+    const renewTimer = setInterval(() => {
+      this.client.send("EVAL", [renewScript, "1", lockKey, lockToken]).catch(() => {});
+    }, 3000);
+    renewTimer.unref?.();
+    try {
+      const fresh = await this.getJSON(key);
+      if (fresh !== null)
+        return fresh;
+      const value = await callback();
+      await this.setJSON(key, value, seconds);
+      return value;
+    } finally {
+      clearInterval(renewTimer);
+      if (acquired != null) {
+        const releaseScript = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('DEL', KEYS[1])
+end
+return 0
+`;
+        await this.client.send("EVAL", [releaseScript, "1", lockKey, lockToken]).catch(() => {});
+      }
+    }
+  }
+  async clearPrefix() {
+    if (!this.prefix)
+      return 0;
+    const pattern = `${this.prefix}:*`;
+    let cursor = "0";
+    let deleted = 0;
+    do {
+      const [next, batch] = await this.client.send("SCAN", [cursor, "MATCH", pattern, "COUNT", "100"]);
+      cursor = next;
+      if (batch.length) {
+        await this.client.send("DEL", batch);
+        deleted += batch.length;
+      }
+    } while (cursor !== "0");
+    return deleted;
+  }
+  async flushdb() {
+    await this.send("FLUSHDB", []);
+  }
+  getClient() {
+    return this.client;
+  }
+}
+// src/manager.ts
+class RedisManager {
+  _connections = new Map;
+  _defaultName;
+  _config;
+  constructor(config = {}) {
+    this._config = config;
+    this._defaultName = config.default || "default";
+    if (!config.connections) {
+      this._connections.set(this._defaultName, new Redis(config));
+    }
+  }
+  connection(name) {
+    const connName = name || this._defaultName;
+    if (!this._connections.has(connName)) {
+      const connConfig = this._config.connections?.[connName];
+      if (!connConfig) {
+        throw new Error(`[@tekir/redis] Connection "${connName}" is not configured. ` + `Available: ${this.connectionNames.join(", ")}`);
+      }
+      this._connections.set(connName, new Redis(connConfig));
+    }
+    return this._connections.get(connName);
+  }
+  get connectionNames() {
+    if (this._config.connections)
+      return Object.keys(this._config.connections);
+    return [this._defaultName];
+  }
+  close(name) {
+    if (name) {
+      this._connections.get(name)?.close();
+      this._connections.delete(name);
+    } else {
+      for (const [, conn] of this._connections)
+        conn.close();
+      this._connections.clear();
+    }
+  }
+  get(key) {
+    return this.connection().get(key);
+  }
+  set(key, value) {
+    return this.connection().set(key, value);
+  }
+  del(...keys) {
+    return this.connection().del(...keys);
+  }
+  exists(key) {
+    return this.connection().exists(key);
+  }
+  incr(key) {
+    return this.connection().incr(key);
+  }
+  decr(key) {
+    return this.connection().decr(key);
+  }
+  expire(key, seconds) {
+    return this.connection().expire(key, seconds);
+  }
+  ttl(key) {
+    return this.connection().ttl(key);
+  }
+  hget(key, field) {
+    return this.connection().hget(key, field);
+  }
+  hmset(key, fields) {
+    return this.connection().hmset(key, fields);
+  }
+  hmget(key, fields) {
+    return this.connection().hmget(key, fields);
+  }
+  hincrby(key, field, increment) {
+    return this.connection().hincrby(key, field, increment);
+  }
+  sadd(key, ...members) {
+    return this.connection().sadd(key, ...members);
+  }
+  srem(key, ...members) {
+    return this.connection().srem(key, ...members);
+  }
+  sismember(key, member) {
+    return this.connection().sismember(key, member);
+  }
+  smembers(key) {
+    return this.connection().smembers(key);
+  }
+  publish(channel, message) {
+    return this.connection().publish(channel, message);
+  }
+  subscribe(channel, callback) {
+    return this.connection().subscribe(channel, callback);
+  }
+  unsubscribe(channel) {
+    return this.connection().unsubscribe(channel);
+  }
+  send(command, args = []) {
+    return this.connection().send(command, args);
+  }
+  keyName(key) {
+    return this.connection().keyName(key);
+  }
+  getJSON(key) {
+    return this.connection().getJSON(key);
+  }
+  setEx(key, value, seconds) {
+    return this.connection().setEx(key, value, seconds);
+  }
+  setJSON(key, value, expireSeconds) {
+    return this.connection().setJSON(key, value, expireSeconds);
+  }
+  remember(key, seconds, callback) {
+    return this.connection().remember(key, seconds, callback);
+  }
+  clearPrefix() {
+    return this.connection().clearPrefix();
+  }
+  flushdb() {
+    return this.connection().flushdb();
+  }
+  get connected() {
+    return this.connection().connected;
+  }
+  getClient() {
+    return this.connection().getClient();
+  }
+}
+// src/provider.ts
+class RedisProvider {
+  async register(app) {
+    const config = app.use("config");
+    if (!config("redis"))
+      return;
+    app.instance("redis", new RedisManager(config("redis")));
+  }
+}
+export {
+  RedisProvider,
+  RedisManager,
+  Redis
+};

package/dist/redis.d.ts

@@ -1,4 +1,32 @@
 import type { RedisConnectionConfig } from './types';
+export declare class NodeRedisClient {
+    private client;
+    private messageHandlers;
+    constructor(url: string, options?: Record<string, any>);
+    connect(): Promise<void>;
+    close(): void;
+    get connected(): boolean;
+    get(key: string): any;
+    set(key: string, value: string, ...args: Array<string | number>): any;
+    del(...keys: string[]): any;
+    exists(key: string): Promise<boolean>;
+    incr(key: string): any;
+    decr(key: string): any;
+    expire(key: string, seconds: number): any;
+    ttl(key: string): any;
+    hget(key: string, field: string): any;
+    hmset(key: string, fields: string[]): any;
+    hmget(key: string, fields: string[]): any;
+    hincrby(key: string, field: string, increment: number): any;
+    sadd(key: string, ...members: string[]): any;
+    srem(key: string, ...members: string[]): any;
+    sismember(key: string, member: string): Promise<boolean>;
+    smembers(key: string): any;
+    publish(channel: string, message: string): any;
+    subscribe(channel: string, callback: (message: string, channel: string) => void): Promise<void>;
+    unsubscribe(channel?: string): Promise<void>;
+    send(command: string, args?: string[]): any;
+}
 /**
  * Redis client wrapper around Bun's native RedisClient.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekir/redis",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Redis connection and client management",
   "author": "dev@tekir.io",
   "license": "MIT",
@@ -39,10 +39,11 @@
     }
   },
   "dependencies": {
-    "@tekir/core": "^0.1.0"
+    "@tekir/core": "^0.1.0",
+    "ioredis": "^5.8.2"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc --noEmit false",
+    "build": "bun ../../scripts/build-package.ts",
     "prepublishOnly": "bun run build"
   },
   "exports": {

package/src/redis.ts

@@ -1,4 +1,65 @@
 import type { RedisConnectionConfig } from './types'
+import { createRequire } from 'node:module'
+
+const nodeRequire = createRequire(import.meta.url)
+
+export class NodeRedisClient {
+  private client: any
+  private messageHandlers = new Map<string, (message: string, channel: string) => void>()
+
+  constructor(url: string, options: Record<string, any> = {}) {
+    const imported = nodeRequire('ioredis')
+    const IORedis = imported.default || imported
+    this.client = new IORedis(url, {
+      lazyConnect: true,
+      connectTimeout: options.connectionTimeout,
+      enableAutoPipelining: options.enableAutoPipelining,
+      maxRetriesPerRequest: options.maxRetries,
+      retryStrategy: options.autoReconnect === false ? null : undefined,
+      tls: options.tls === true ? {} : options.tls || undefined,
+    })
+    this.client.on('message', (channel: string, message: string) => {
+      this.messageHandlers.get(channel)?.(message, channel)
+    })
+  }
+
+  async connect(): Promise<void> {
+    if (this.client.status === 'wait') await this.client.connect()
+    else if (this.client.status !== 'ready') await new Promise<void>((resolve, reject) => {
+      this.client.once('ready', resolve)
+      this.client.once('error', reject)
+    })
+  }
+  close(): void { this.client.disconnect() }
+  get connected(): boolean { return this.client.status === 'ready' }
+  get(key: string) { return this.client.get(key) }
+  set(key: string, value: string, ...args: Array<string | number>) { return this.client.set(key, value, ...args) }
+  del(...keys: string[]) { return this.client.del(...keys) }
+  async exists(key: string) { return (await this.client.exists(key)) > 0 }
+  incr(key: string) { return this.client.incr(key) }
+  decr(key: string) { return this.client.decr(key) }
+  expire(key: string, seconds: number) { return this.client.expire(key, seconds) }
+  ttl(key: string) { return this.client.ttl(key) }
+  hget(key: string, field: string) { return this.client.hget(key, field) }
+  hmset(key: string, fields: string[]) { return this.client.hmset(key, ...fields) }
+  hmget(key: string, fields: string[]) { return this.client.hmget(key, ...fields) }
+  hincrby(key: string, field: string, increment: number) { return this.client.hincrby(key, field, increment) }
+  sadd(key: string, ...members: string[]) { return this.client.sadd(key, ...members) }
+  srem(key: string, ...members: string[]) { return this.client.srem(key, ...members) }
+  async sismember(key: string, member: string) { return (await this.client.sismember(key, member)) > 0 }
+  smembers(key: string) { return this.client.smembers(key) }
+  publish(channel: string, message: string) { return this.client.publish(channel, message) }
+  async subscribe(channel: string, callback: (message: string, channel: string) => void) {
+    this.messageHandlers.set(channel, callback)
+    await this.client.subscribe(channel)
+  }
+  async unsubscribe(channel?: string) {
+    if (channel) this.messageHandlers.delete(channel)
+    else this.messageHandlers.clear()
+    await (channel ? this.client.unsubscribe(channel) : this.client.unsubscribe())
+  }
+  send(command: string, args: string[] = []) { return this.client.call(command, ...args) }
+}
 
 /**
  * Redis client wrapper around Bun's native RedisClient.
@@ -25,7 +86,9 @@ export class Redis {
     this.config = config
     this.prefix = (config.prefix || '').replace(/:+$/, '')
 
-    const { RedisClient } = Bun as any
+    const RedisClient = process.versions.bun
+      ? (globalThis as any).Bun.RedisClient
+      : NodeRedisClient
     const url = config.url || process.env.REDIS_URL || 'redis://localhost:6379'
 
     // Encourage TLS in production: a plaintext redis:// connection exposes

package/dist/manager.js

@@ -1,159 +0,0 @@
-import { Redis } from './redis';
-/**
- * Manages multiple named Redis connections with lazy initialization.
- *
- * Provides proxy methods that delegate to the default connection for convenience,
- * while also allowing access to any named connection via {@link RedisManager.connection}.
- *
- * @example
- * ```ts
- * const manager = new RedisManager({
- *   default: 'cache',
- *   connections: {
- *     cache: { url: 'redis://localhost:6379/0' },
- *     session: { url: 'redis://localhost:6379/1' },
- *   },
- * })
- * await manager.set('key', 'value')               // uses 'cache'
- * await manager.connection('session').set('k', 'v') // uses 'session'
- * ```
- */
-export class RedisManager {
-    _connections = new Map();
-    _defaultName;
-    _config;
-    /**
-     * Create a new RedisManager.
-     *
-     * @param config - Redis configuration with optional named connections.
-     */
-    constructor(config = {}) {
-        this._config = config;
-        this._defaultName = config.default || 'default';
-        // If no connections map, treat the whole config as a single connection
-        if (!config.connections) {
-            this._connections.set(this._defaultName, new Redis(config));
-        }
-    }
-    /**
-     * Get a named Redis connection. The connection is lazy-initialized on first access.
-     *
-     * @param name - The connection name. Defaults to the configured default connection.
-     * @returns The {@link Redis} instance for the named connection.
-     * @throws If the named connection is not configured.
-     *
-     * @example
-     * ```ts
-     * const cache = manager.connection('cache')
-     * await cache.get('key')
-     * ```
-     */
-    connection(name) {
-        const connName = name || this._defaultName;
-        if (!this._connections.has(connName)) {
-            const connConfig = this._config.connections?.[connName];
-            if (!connConfig) {
-                throw new Error(`[@tekir/redis] Connection "${connName}" is not configured. ` +
-                    `Available: ${this.connectionNames.join(', ')}`);
-            }
-            this._connections.set(connName, new Redis(connConfig));
-        }
-        return this._connections.get(connName);
-    }
-    /**
-     * List all configured connection names.
-     *
-     * @returns An array of connection name strings.
-     *
-     * @example
-     * ```ts
-     * manager.connectionNames // ['cache', 'session']
-     * ```
-     */
-    get connectionNames() {
-        if (this._config.connections)
-            return Object.keys(this._config.connections);
-        return [this._defaultName];
-    }
-    /**
-     * Close a specific named connection, or all connections if no name is given.
-     *
-     * @param name - The connection name to close. Omit to close all connections.
-     *
-     * @example
-     * ```ts
-     * manager.close('session') // close one connection
-     * manager.close()          // close all connections
-     * ```
-     */
-    close(name) {
-        if (name) {
-            this._connections.get(name)?.close();
-            this._connections.delete(name);
-        }
-        else {
-            for (const [, conn] of this._connections)
-                conn.close();
-            this._connections.clear();
-        }
-    }
-    // ─── Proxy methods delegating to the default connection ───
-    /** @see {@link Redis.get} */
-    get(key) { return this.connection().get(key); }
-    /** @see {@link Redis.set} */
-    set(key, value) { return this.connection().set(key, value); }
-    /** @see {@link Redis.del} */
-    del(...keys) { return this.connection().del(...keys); }
-    /** @see {@link Redis.exists} */
-    exists(key) { return this.connection().exists(key); }
-    /** @see {@link Redis.incr} */
-    incr(key) { return this.connection().incr(key); }
-    /** @see {@link Redis.decr} */
-    decr(key) { return this.connection().decr(key); }
-    /** @see {@link Redis.expire} */
-    expire(key, seconds) { return this.connection().expire(key, seconds); }
-    /** @see {@link Redis.ttl} */
-    ttl(key) { return this.connection().ttl(key); }
-    /** @see {@link Redis.hget} */
-    hget(key, field) { return this.connection().hget(key, field); }
-    /** @see {@link Redis.hmset} */
-    hmset(key, fields) { return this.connection().hmset(key, fields); }
-    /** @see {@link Redis.hmget} */
-    hmget(key, fields) { return this.connection().hmget(key, fields); }
-    /** @see {@link Redis.hincrby} */
-    hincrby(key, field, increment) { return this.connection().hincrby(key, field, increment); }
-    /** @see {@link Redis.sadd} */
-    sadd(key, ...members) { return this.connection().sadd(key, ...members); }
-    /** @see {@link Redis.srem} */
-    srem(key, ...members) { return this.connection().srem(key, ...members); }
-    /** @see {@link Redis.sismember} */
-    sismember(key, member) { return this.connection().sismember(key, member); }
-    /** @see {@link Redis.smembers} */
-    smembers(key) { return this.connection().smembers(key); }
-    /** @see {@link Redis.publish} */
-    publish(channel, message) { return this.connection().publish(channel, message); }
-    /** @see {@link Redis.subscribe} */
-    subscribe(channel, callback) { return this.connection().subscribe(channel, callback); }
-    /** @see {@link Redis.unsubscribe} */
-    unsubscribe(channel) { return this.connection().unsubscribe(channel); }
-    /** @see {@link Redis.send} */
-    send(command, args = []) { return this.connection().send(command, args); }
-    /** @see {@link Redis.keyName} */
-    keyName(key) { return this.connection().keyName(key); }
-    /** @see {@link Redis.getJSON} */
-    getJSON(key) { return this.connection().getJSON(key); }
-    /** @see {@link Redis.setEx} */
-    setEx(key, value, seconds) { return this.connection().setEx(key, value, seconds); }
-    /** @see {@link Redis.setJSON} */
-    setJSON(key, value, expireSeconds) { return this.connection().setJSON(key, value, expireSeconds); }
-    /** @see {@link Redis.remember} */
-    remember(key, seconds, callback) { return this.connection().remember(key, seconds, callback); }
-    /** @see {@link Redis.clearPrefix} */
-    clearPrefix() { return this.connection().clearPrefix(); }
-    /** @see {@link Redis.flushdb} */
-    flushdb() { return this.connection().flushdb(); }
-    /** @see {@link Redis.connected} */
-    get connected() { return this.connection().connected; }
-    /** @see {@link Redis.getClient} */
-    getClient() { return this.connection().getClient(); }
-}

package/dist/provider.js

@@ -1,25 +0,0 @@
-import { RedisManager } from './manager';
-/**
- * Service provider that reads the `redis` configuration and registers
- * a {@link RedisManager} instance in the application container.
- */
-export class RedisProvider {
-    /**
-     * Register the Redis manager into the application container.
-     *
-     * @param app - The Tekir application instance.
-     * @returns A promise that resolves once registration is complete.
-     *
-     * @example
-     * ```ts
-     * // In your providers list:
-     * app.register(new RedisProvider())
-     * ```
-     */
-    async register(app) {
-        const config = app.use('config');
-        if (!config('redis'))
-            return;
-        app.instance('redis', new RedisManager(config('redis')));
-    }
-}

package/dist/redis.js

@@ -1,450 +0,0 @@
-/**
- * Redis client wrapper around Bun's native RedisClient.
- *
- * Provides a high-level API for string, hash, set, and pub/sub operations,
- * plus JSON helpers and a cache-aside `remember` method.
- *
- * @example
- * ```ts
- * const redis = new Redis({ url: 'redis://localhost:6379', prefix: 'app:' })
- * await redis.set('greeting', 'hello')
- * const val = await redis.get('greeting') // 'hello'
- * ```
- */
-export class Redis {
-    client;
-    prefix;
-    config;
-    /**
-     * @param config - Redis connection configuration.
-     */
-    constructor(config = {}) {
-        this.config = config;
-        this.prefix = (config.prefix || '').replace(/:+$/, '');
-        const { RedisClient } = Bun;
-        const url = config.url || process.env.REDIS_URL || 'redis://localhost:6379';
-        // Encourage TLS in production: a plaintext redis:// connection exposes
-        // credentials and data to network observers. Warn once instead of throwing
-        // to stay backward compatible with local/dev setups.
-        const isTls = config.tls != null || url.startsWith('rediss://');
-        if (!isTls && process.env.NODE_ENV === 'production') {
-            console.warn(`[@tekir/redis] Connecting to ${Redis.maskUrl(url)} without TLS in production. ` +
-                `Use a rediss:// URL or set tls to encrypt credentials and data in transit.`);
-        }
-        this.client = new RedisClient(url, {
-            connectionTimeout: config.connectionTimeout,
-            idleTimeout: config.idleTimeout,
-            autoReconnect: config.autoReconnect ?? true,
-            maxRetries: config.maxRetries ?? 10,
-            enableAutoPipelining: config.enableAutoPipelining ?? true,
-            tls: config.tls,
-        });
-    }
-    key(k) {
-        return this.prefix ? `${this.prefix}:${k}` : k;
-    }
-    /** Resolve the actual Redis key after applying this connection's namespace. */
-    keyName(key) { return this.key(key); }
-    /**
-     * Strip any credentials embedded in a Redis URL so it is safe to log.
-     *
-     * @param url - The connection URL, possibly containing `user:pass@host`.
-     * @returns The URL with the userinfo component masked.
-     */
-    static maskUrl(url) {
-        return url.replace(/(\w+:\/\/)([^@/]+)@/, '$1***@');
-    }
-    // ─── Connection ────────────────────────────────────────
-    /**
-     * Open the connection to the Redis server.
-     *
-     * @returns A promise that resolves once the connection is established.
-     *
-     * @example
-     * ```ts
-     * await redis.connect()
-     * ```
-     */
-    async connect() { await this.client.connect(); }
-    /**
-     * Close the connection to the Redis server.
-     */
-    close() { this.client.close(); }
-    /**
-     * Whether the client is currently connected to Redis.
-     *
-     * @returns `true` if the connection is active.
-     */
-    get connected() { return this.client.connected; }
-    // ─── String operations ────────────────────────────────
-    /**
-     * Get the value of a key.
-     *
-     * @param key - The key to retrieve.
-     * @returns The string value, or `null` if the key does not exist.
-     *
-     * @example
-     * ```ts
-     * const val = await redis.get('name') // 'Alice' | null
-     * ```
-     */
-    async get(key) { return this.client.get(this.key(key)); }
-    /**
-     * Set the value of a key.
-     *
-     * @param key - The key to set.
-     * @param value - The string or numeric value to store.
-     *
-     * @example
-     * ```ts
-     * await redis.set('counter', 42)
-     * ```
-     */
-    async set(key, value) { await this.client.set(this.key(key), String(value)); }
-    /** Atomically set a value and its expiration time. */
-    async setEx(key, value, seconds) {
-        if (!Number.isFinite(seconds) || seconds <= 0)
-            throw new Error('Redis setEx seconds must be a positive number');
-        await this.client.send('SET', [this.key(key), String(value), 'EX', String(Math.floor(seconds))]);
-    }
-    /**
-     * Delete one or more keys.
-     *
-     * @param keys - The keys to delete.
-     *
-     * @example
-     * ```ts
-     * await redis.del('key1', 'key2')
-     * ```
-     */
-    async del(...keys) { await this.client.del(...keys.map(k => this.key(k))); }
-    /**
-     * Check whether a key exists.
-     *
-     * @param key - The key to check.
-     * @returns `true` if the key exists.
-     */
-    async exists(key) { return this.client.exists(this.key(key)); }
-    /**
-     * Increment the integer value of a key by one.
-     *
-     * @param key - The key to increment.
-     * @returns The new value after incrementing.
-     */
-    async incr(key) { return this.client.incr(this.key(key)); }
-    /**
-     * Decrement the integer value of a key by one.
-     *
-     * @param key - The key to decrement.
-     * @returns The new value after decrementing.
-     */
-    async decr(key) { return this.client.decr(this.key(key)); }
-    /**
-     * Set a timeout on a key (in seconds).
-     *
-     * @param key - The key to set the expiry on.
-     * @param seconds - Time-to-live in seconds.
-     */
-    async expire(key, seconds) { await this.client.expire(this.key(key), seconds); }
-    /**
-     * Get the remaining time-to-live of a key in seconds.
-     *
-     * @param key - The key to query.
-     * @returns Remaining TTL in seconds, `-1` if no expiry is set, `-2` if the key does not exist.
-     */
-    async ttl(key) { return this.client.ttl(this.key(key)); }
-    // ─── Hash operations ──────────────────────────────────
-    /**
-     * Get the value of a single field in a hash.
-     *
-     * @param key - The hash key.
-     * @param field - The field name within the hash.
-     * @returns The field value, or `null` if the field or key does not exist.
-     */
-    async hget(key, field) { return this.client.hget(this.key(key), field); }
-    /**
-     * Set multiple field-value pairs in a hash.
-     *
-     * @param key - The hash key.
-     * @param fields - An array of alternating field names and values (e.g. `['f1', 'v1', 'f2', 'v2']`).
-     */
-    async hmset(key, fields) { await this.client.hmset(this.key(key), fields); }
-    /**
-     * Get the values of multiple fields in a hash.
-     *
-     * @param key - The hash key.
-     * @param fields - An array of field names to retrieve.
-     * @returns An array of values corresponding to the requested fields (`null` for missing fields).
-     */
-    async hmget(key, fields) { return this.client.hmget(this.key(key), fields); }
-    /**
-     * Increment a numeric field in a hash by a given amount.
-     *
-     * @param key - The hash key.
-     * @param field - The field name to increment.
-     * @param increment - The integer amount to add.
-     * @returns The new value of the field after incrementing.
-     */
-    async hincrby(key, field, increment) { return this.client.hincrby(this.key(key), field, increment); }
-    // ─── Set operations ───────────────────────────────────
-    /**
-     * Add one or more members to a set.
-     *
-     * @param key - The set key.
-     * @param members - The members to add.
-     * @returns The number of members that were added (excluding already-present members).
-     */
-    async sadd(key, ...members) { return this.client.sadd(this.key(key), ...members); }
-    /**
-     * Remove one or more members from a set.
-     *
-     * @param key - The set key.
-     * @param members - The members to remove.
-     * @returns The number of members that were removed.
-     */
-    async srem(key, ...members) { return this.client.srem(this.key(key), ...members); }
-    /**
-     * Check whether a value is a member of a set.
-     *
-     * @param key - The set key.
-     * @param member - The value to check for.
-     * @returns `true` if the member exists in the set.
-     */
-    async sismember(key, member) { return this.client.sismember(this.key(key), member); }
-    /**
-     * Get all members of a set.
-     *
-     * @param key - The set key.
-     * @returns An array of all members in the set.
-     */
-    async smembers(key) { return this.client.smembers(this.key(key)); }
-    // ─── Pub/Sub ──────────────────────────────────────────
-    /**
-     * Publish a message to a channel.
-     *
-     * @param channel - The channel name.
-     * @param message - The message string to publish.
-     */
-    async publish(channel, message) { await this.client.publish(channel, message); }
-    /**
-     * Subscribe to a channel and receive messages via a callback.
-     *
-     * The message passed to the callback is the raw string received from Redis and
-     * is NOT deserialized by this wrapper. Treat it as untrusted input: validate
-     * it and never `eval` it. If you `JSON.parse` it, wrap the parse in a
-     * try/catch to guard against poisoned payloads.
-     *
-     * @param channel - The channel name to subscribe to.
-     * @param callback - Invoked for each message received on the channel.
-     *
-     * @example
-     * ```ts
-     * await redis.subscribe('events', (msg, ch) => {
-     *   console.log(`Received on ${ch}: ${msg}`)
-     * })
-     * ```
-     */
-    async subscribe(channel, callback) {
-        await this.client.subscribe(channel, callback);
-    }
-    /**
-     * Unsubscribe from a channel, or from all channels if none is specified.
-     *
-     * @param channel - The channel to unsubscribe from. Omit to unsubscribe from all.
-     */
-    async unsubscribe(channel) { await this.client.unsubscribe(channel); }
-    // ─── Raw command ──────────────────────────────────────
-    /**
-     * Send a raw Redis command. ADVANCED / INTERNAL escape hatch.
-     *
-     * This bypasses the key prefix and every higher-level safeguard. The `command`
-     * and `args` are passed straight to Redis, so they MUST be trusted, statically
-     * known values. Never build a command name or its arguments from user input:
-     * doing so allows execution of dangerous commands (`FLUSHALL`, `CONFIG`,
-     * `EVAL`, `KEYS *`, ...) and lets callers escape the prefix namespace.
-     *
-     * @param command - A trusted, statically-known Redis command (e.g. `'PING'`, `'INFO'`).
-     * @param args - Arguments for the command. Must not contain untrusted input.
-     * @returns The raw response from Redis.
-     *
-     * @example
-     * ```ts
-     * const pong = await redis.send('PING') // 'PONG'
-     * ```
-     */
-    async send(command, args = []) { return this.client.send(command, args); }
-    // ─── JSON helpers ─────────────────────────────────────
-    /**
-     * Get a value from Redis and parse it as JSON.
-     *
-     * @param key - The key to retrieve.
-     * @returns The parsed object, or `null` if the key does not exist or parsing fails.
-     *
-     * @example
-     * ```ts
-     * const user = await redis.getJSON<{ name: string }>('user:1')
-     * ```
-     */
-    async getJSON(key) {
-        const val = await this.get(key);
-        if (val === null)
-            return null;
-        try {
-            return JSON.parse(val);
-        }
-        catch (e) {
-            // Surface corrupt/poisoned payloads instead of silently masking them as a
-            // cache miss. Returning null still preserves the previous behaviour for
-            // callers, but the warning makes the problem diagnosable.
-            console.warn(`[@tekir/redis] Failed to parse JSON for key "${key}": ${e.message}`);
-            return null;
-        }
-    }
-    /**
-     * Serialize a value as JSON and store it in Redis, with an optional TTL.
-     *
-     * @param key - The key to store the value under.
-     * @param value - The value to JSON-serialize and store.
-     * @param expireSeconds - Optional time-to-live in seconds.
-     *
-     * @example
-     * ```ts
-     * await redis.setJSON('user:1', { name: 'Alice' }, 3600)
-     * ```
-     */
-    async setJSON(key, value, expireSeconds) {
-        const payload = JSON.stringify(value);
-        if (payload === undefined)
-            throw new Error(`Redis cannot serialize undefined for key "${key}"`);
-        if (expireSeconds && expireSeconds > 0) {
-            // Atomic SET ... EX so a crash between writing the value and setting the
-            // TTL can never leave a permanent (TTL-less) key behind.
-            await this.client.send('SET', [this.key(key), payload, 'EX', String(Math.floor(expireSeconds))]);
-        }
-        else {
-            await this.client.set(this.key(key), payload);
-        }
-    }
-    /**
-     * Cache-aside helper: return the cached value if it exists, otherwise execute
-     * the callback, store the result in Redis with a TTL, and return it.
-     *
-     * @param key - The cache key.
-     * @param seconds - Time-to-live in seconds for the cached value.
-     * @param callback - Async function invoked to compute the value on a cache miss.
-     * @returns The cached or freshly computed value.
-     *
-     * On a cache miss this acquires a short-lived `SET NX` lock so that, under
-     * concurrent misses, only one caller runs `callback()` while the others wait
-     * for the freshly-populated value. This protects the backend from a stampede
-     * (thundering herd) when a hot key expires.
-     *
-     * @example
-     * ```ts
-     * const users = await redis.remember('all-users', 60, async () => {
-     *   return db.query('SELECT * FROM users')
-     * })
-     * ```
-     */
-    async remember(key, seconds, callback) {
-        const cached = await this.getJSON(key);
-        if (cached !== null)
-            return cached;
-        const lockKey = this.key(`${key}:__lock`);
-        const lockToken = crypto.randomUUID();
-        // Try to become the single flight that computes the value. SET NX EX gives
-        // a self-expiring lock so a crashed holder cannot deadlock other callers.
-        const acquired = await this.client.send('SET', [lockKey, lockToken, 'NX', 'EX', '10']);
-        if (acquired == null) {
-            // Another caller is computing it. Wait for the populated value, but do
-            // not run the callback without owning the lock: doing so would turn slow
-            // cache fills back into a stampede. A bounded timeout keeps callers from
-            // hanging forever if Redis itself is unhealthy.
-            for (let i = 0; i < 300; i++) {
-                await new Promise(r => setTimeout(r, 100));
-                const waited = await this.getJSON(key);
-                if (waited !== null)
-                    return waited;
-            }
-            throw new Error(`Redis remember timed out waiting for lock on "${key}"`);
-        }
-        const renewScript = `
-if redis.call('GET', KEYS[1]) == ARGV[1] then
-  return redis.call('EXPIRE', KEYS[1], 10)
-end
-return 0
-`;
-        const renewTimer = setInterval(() => {
-            void this.client.send('EVAL', [renewScript, '1', lockKey, lockToken]).catch(() => { });
-        }, 3000);
-        renewTimer.unref?.();
-        try {
-            // Re-check after acquiring the lock: a racing holder may have populated it.
-            const fresh = await this.getJSON(key);
-            if (fresh !== null)
-                return fresh;
-            const value = await callback();
-            await this.setJSON(key, value, seconds);
-            return value;
-        }
-        finally {
-            clearInterval(renewTimer);
-            // Only the owner may release the lock. A plain DEL lets a slow callback
-            // delete a successor's lock after its own 10s lease expired, reopening
-            // the stampede window. Waiters that never acquired it release nothing.
-            if (acquired != null) {
-                const releaseScript = `
-if redis.call('GET', KEYS[1]) == ARGV[1] then
-  return redis.call('DEL', KEYS[1])
-end
-return 0
-`;
-                await this.client.send('EVAL', [releaseScript, '1', lockKey, lockToken]).catch(() => { });
-            }
-        }
-    }
-    /**
-     * Delete every key under this connection's prefix using a non-blocking SCAN.
-     *
-     * Unlike {@link Redis.flushdb}, this is scoped: it only removes keys that
-     * belong to this logical store (`<prefix>:*`), leaving other stores that
-     * share the same Redis database (sessions, queues, ...) untouched. If no
-     * prefix is configured this deletes nothing and returns `0`, to avoid
-     * accidentally wiping the whole database.
-     *
-     * @returns The number of keys deleted.
-     */
-    async clearPrefix() {
-        if (!this.prefix)
-            return 0;
-        const pattern = `${this.prefix}:*`;
-        let cursor = '0';
-        let deleted = 0;
-        do {
-            const [next, batch] = await this.client.send('SCAN', [cursor, 'MATCH', pattern, 'COUNT', '100']);
-            cursor = next;
-            if (batch.length) {
-                await this.client.send('DEL', batch);
-                deleted += batch.length;
-            }
-        } while (cursor !== '0');
-        return deleted;
-    }
-    /**
-     * Delete ALL keys in the currently selected database. DANGEROUS.
-     *
-     * This ignores the key prefix and removes every key in the database, including
-     * data owned by other logical stores (sessions, queues, other caches) that
-     * share the same Redis database. Prefer {@link Redis.clearPrefix} to delete
-     * only this store's keys. Never expose this to user-triggered code paths.
-     *
-     * @returns A promise that resolves once the database has been flushed.
-     */
-    async flushdb() { await this.send('FLUSHDB', []); }
-    /**
-     * Get the underlying Bun `RedisClient` instance for advanced operations.
-     *
-     * @returns The raw Bun RedisClient.
-     */
-    getClient() { return this.client; }
-}

package/dist/types.js

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