@shware/security 2.5.3 → 3.0.0

package/dist/session/redis.cjs

@@ -1,328 +1,279 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/session/redis.ts
-var redis_exports = {};
-__export(redis_exports, {
-  RedisIndexedSessionRepository: () => RedisIndexedSessionRepository,
-  RedisKVRepository: () => RedisKVRepository
-});
-module.exports = __toCommonJS(redis_exports);
-var import_common = require("./common.cjs");
-var import_map_session = require("./map-session.cjs");
-var CREATION_TIME_KEY = "creationTime";
-var LAST_ACCESSED_TIME_KEY = "lastAccessedTime";
-var MAX_INACTIVE_INTERVAL_KEY = "maxInactiveInterval";
-var ATTRIBUTE_PREFIX = "sessionAttr:";
-var SESSION_EXPIRES_PREFIX = "expires:";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_session_common = require("./common.cjs");
+const require_session_map_session = require("./map-session.cjs");
+//#region src/session/redis.ts
+const CREATION_TIME_KEY = "creationTime";
+const LAST_ACCESSED_TIME_KEY = "lastAccessedTime";
+const MAX_INACTIVE_INTERVAL_KEY = "maxInactiveInterval";
+const ATTRIBUTE_PREFIX = "sessionAttr:";
+const SESSION_EXPIRES_PREFIX = "expires:";
 var RedisSession = class {
-  cached;
-  isNew;
-  delta = /* @__PURE__ */ new Map();
-  originalSessionId;
-  originalPrincipalName;
-  originalLastAccessTime = null;
-  constructor(cached, isNew) {
-    this.cached = cached;
-    this.isNew = isNew;
-    this.originalSessionId = cached.getId();
-    this.originalPrincipalName = (0, import_common.resolveIndexesFor)(this);
-    if (isNew) {
-      this.delta.set(CREATION_TIME_KEY, cached.getCreationTime());
-      this.delta.set(LAST_ACCESSED_TIME_KEY, cached.getLastAccessedTime());
-      this.delta.set(MAX_INACTIVE_INTERVAL_KEY, cached.getMaxInactiveInterval());
-      this.cached.getAttributeNames().forEach((name) => {
-        const value = this.cached.getAttribute(name);
-        if (value) this.delta.set(this.getSessionAttrNameKey(name), value);
-      });
-    }
-  }
-  getSessionAttrNameKey(name) {
-    return ATTRIBUTE_PREFIX + name;
-  }
-  // override
-  setLastAccessedTime(lastAccessedTime) {
-    this.cached.setLastAccessedTime(lastAccessedTime);
-    this.delta.set(LAST_ACCESSED_TIME_KEY, lastAccessedTime);
-  }
-  isExpired() {
-    return this.cached.isExpired();
-  }
-  getCreationTime() {
-    return this.cached.getCreationTime();
-  }
-  getId() {
-    return this.cached.getId();
-  }
-  changeSessionId() {
-    return this.cached.changeSessionId();
-  }
-  getLastAccessedTime() {
-    return this.cached.getLastAccessedTime();
-  }
-  setMaxInactiveInterval(interval) {
-    this.cached.setMaxInactiveInterval(interval);
-    this.delta.set(MAX_INACTIVE_INTERVAL_KEY, interval);
-  }
-  getMaxInactiveInterval() {
-    return this.cached.getMaxInactiveInterval();
-  }
-  getAttribute(name) {
-    return this.cached.getAttribute(name);
-  }
-  getAttributeNames() {
-    return this.cached.getAttributeNames();
-  }
-  setAttribute(name, value) {
-    this.cached.setAttribute(name, value);
-    this.delta.set(this.getSessionAttrNameKey(name), value);
-  }
-  removeAttribute(name) {
-    this.cached.removeAttribute(name);
-    this.delta.set(this.getSessionAttrNameKey(name), null);
-  }
+	cached;
+	isNew;
+	delta = /* @__PURE__ */ new Map();
+	originalSessionId;
+	originalPrincipalName;
+	originalLastAccessTime = null;
+	constructor(cached, isNew) {
+		this.cached = cached;
+		this.isNew = isNew;
+		this.originalSessionId = cached.getId();
+		this.originalPrincipalName = require_session_common.resolveIndexesFor(this);
+		if (isNew) {
+			this.delta.set(CREATION_TIME_KEY, cached.getCreationTime());
+			this.delta.set(LAST_ACCESSED_TIME_KEY, cached.getLastAccessedTime());
+			this.delta.set(MAX_INACTIVE_INTERVAL_KEY, cached.getMaxInactiveInterval());
+			this.cached.getAttributeNames().forEach((name) => {
+				const value = this.cached.getAttribute(name);
+				if (value) this.delta.set(this.getSessionAttrNameKey(name), value);
+			});
+		}
+	}
+	getSessionAttrNameKey(name) {
+		return ATTRIBUTE_PREFIX + name;
+	}
+	setLastAccessedTime(lastAccessedTime) {
+		this.cached.setLastAccessedTime(lastAccessedTime);
+		this.delta.set(LAST_ACCESSED_TIME_KEY, lastAccessedTime);
+	}
+	isExpired() {
+		return this.cached.isExpired();
+	}
+	getCreationTime() {
+		return this.cached.getCreationTime();
+	}
+	getId() {
+		return this.cached.getId();
+	}
+	changeSessionId() {
+		return this.cached.changeSessionId();
+	}
+	getLastAccessedTime() {
+		return this.cached.getLastAccessedTime();
+	}
+	setMaxInactiveInterval(interval) {
+		this.cached.setMaxInactiveInterval(interval);
+		this.delta.set(MAX_INACTIVE_INTERVAL_KEY, interval);
+	}
+	getMaxInactiveInterval() {
+		return this.cached.getMaxInactiveInterval();
+	}
+	getAttribute(name) {
+		return this.cached.getAttribute(name);
+	}
+	getAttributeNames() {
+		return this.cached.getAttributeNames();
+	}
+	setAttribute(name, value) {
+		this.cached.setAttribute(name, value);
+		this.delta.set(this.getSessionAttrNameKey(name), value);
+	}
+	removeAttribute(name) {
+		this.cached.removeAttribute(name);
+		this.delta.set(this.getSessionAttrNameKey(name), null);
+	}
 };
 var SortedSetRedisSessionExpirationStore = class {
-  redis;
-  namespace;
-  expirationsKey;
-  constructor(redis, namespace) {
-    this.redis = redis;
-    this.namespace = namespace;
-    this.expirationsKey = `${this.namespace}:sessions:expirations`;
-  }
-  getSessionKey(sessionId) {
-    return `${this.namespace}:sessions:${sessionId}`;
-  }
-  async save(session) {
-    const expirationInMillis = session.getLastAccessedTime() + session.getMaxInactiveInterval() * 1e3;
-    await this.redis.zadd(this.expirationsKey, expirationInMillis, session.getId());
-  }
-  async remove(sessionId) {
-    await this.redis.zrem(this.expirationsKey, sessionId);
-  }
-  async rename(session) {
-    if (session.originalSessionId === null || session.originalSessionId === session.getId()) return;
-    await this.remove(session.originalSessionId);
-    await this.save(session);
-  }
-  async cleanupExpiredSessions(cleanupCount = 100) {
-    const key = this.expirationsKey;
-    const score = Date.now();
-    const sessionIds = await this.redis.zrevrangebyscore(key, score, 0, "LIMIT", 0, cleanupCount);
-    if (sessionIds.length === 0) return;
-    for (const sessionId of sessionIds) {
-      const sessionKey = this.getSessionKey(sessionId);
-      await this.redis.exists(sessionKey);
-    }
-  }
+	redis;
+	namespace;
+	expirationsKey;
+	constructor(redis, namespace) {
+		this.redis = redis;
+		this.namespace = namespace;
+		this.expirationsKey = `${this.namespace}:sessions:expirations`;
+	}
+	getSessionKey(sessionId) {
+		return `${this.namespace}:sessions:${sessionId}`;
+	}
+	async save(session) {
+		const expirationInMillis = session.getLastAccessedTime() + session.getMaxInactiveInterval() * 1e3;
+		await this.redis.zadd(this.expirationsKey, expirationInMillis, session.getId());
+	}
+	async remove(sessionId) {
+		await this.redis.zrem(this.expirationsKey, sessionId);
+	}
+	async rename(session) {
+		if (session.originalSessionId === null || session.originalSessionId === session.getId()) return;
+		await this.remove(session.originalSessionId);
+		await this.save(session);
+	}
+	async cleanupExpiredSessions(cleanupCount = 100) {
+		const key = this.expirationsKey;
+		const score = Date.now();
+		const sessionIds = await this.redis.zrevrangebyscore(key, score, 0, "LIMIT", 0, cleanupCount);
+		if (sessionIds.length === 0) return;
+		for (const sessionId of sessionIds) {
+			const sessionKey = this.getSessionKey(sessionId);
+			await this.redis.exists(sessionKey);
+		}
+	}
 };
 var RedisIndexedSessionRepository = class {
-  redis;
-  namespace;
-  expirationStore;
-  defaultMaxInactiveInterval = 1800;
-  constructor(redis, namespace = "spring:session") {
-    this.redis = redis;
-    this.namespace = namespace;
-    this.expirationStore = new SortedSetRedisSessionExpirationStore(redis, namespace);
-  }
-  setDefaultMaxInactiveInterval(interval) {
-    this.defaultMaxInactiveInterval = interval;
-  }
-  getSessionKey(sessionId) {
-    return `${this.namespace}:sessions:${sessionId}`;
-  }
-  getExpiredKey(sessionId) {
-    return `${this.namespace}:sessions:expires:${sessionId}`;
-  }
-  getSessionAttrNameKey(name) {
-    return ATTRIBUTE_PREFIX + name;
-  }
-  getPrincipalKey(principalName) {
-    return `${this.namespace}:index:${import_common.PRINCIPAL_NAME_INDEX_NAME}:${principalName}`;
-  }
-  async getSession(id, allowExpired) {
-    const key = this.getSessionKey(id);
-    const entries = await this.redis.hgetall(key);
-    if (!entries || Object.keys(entries).length === 0) return null;
-    const loaded = new import_map_session.MapSession(id);
-    if (!entries.creationTime) throw new Error("creationTime attribute not found");
-    if (!entries.lastAccessedTime) throw new Error("lastAccessedTime attribute not found");
-    if (!entries.maxInactiveInterval) throw new Error("maxInactiveInterval attribute not found");
-    loaded.setCreationTime(Number(entries.creationTime));
-    loaded.setLastAccessedTime(Number(entries.lastAccessedTime));
-    loaded.setMaxInactiveInterval(Number(entries.maxInactiveInterval));
-    for (const [key2, value] of Object.entries(entries)) {
-      if (key2.startsWith(ATTRIBUTE_PREFIX)) {
-        loaded.setAttribute(key2.slice(ATTRIBUTE_PREFIX.length), value);
-      }
-    }
-    if (!allowExpired && loaded.isExpired()) return null;
-    const result = new RedisSession(loaded, false);
-    result.originalLastAccessTime = loaded.getLastAccessedTime();
-    return result;
-  }
-  async saveDelta(session) {
-    if (session.delta.size === 0) return;
-    const sessionId = session.getId();
-    const delta = /* @__PURE__ */ new Map();
-    const removes = [];
-    session.delta.forEach((value, key) => {
-      if (value !== null) delta.set(key, value);
-      else removes.push(key);
-    });
-    if (delta.size !== 0) {
-      await this.redis.hset(this.getSessionKey(sessionId), delta);
-    }
-    if (removes.length !== 0) {
-      await this.redis.hdel(this.getSessionKey(sessionId), ...removes);
-    }
-    const principalSessionKey = this.getSessionAttrNameKey(import_common.PRINCIPAL_NAME_INDEX_NAME);
-    const securityPrincipalSessionKey = this.getSessionAttrNameKey(import_common.SPRING_SECURITY_CONTEXT);
-    if (session.delta.has(principalSessionKey) || session.delta.has(securityPrincipalSessionKey)) {
-      if (session.originalPrincipalName !== null) {
-        const originalPrincipalRedisKey = this.getPrincipalKey(session.originalPrincipalName);
-        await this.redis.srem(originalPrincipalRedisKey, sessionId);
-      }
-      const principal = (0, import_common.resolveIndexesFor)(session);
-      session.originalPrincipalName = principal;
-      if (principal !== null) {
-        const principalRedisKey = this.getPrincipalKey(principal);
-        await this.redis.sadd(principalRedisKey, sessionId);
-      }
-    }
-    if (session.isNew) {
-      session.isNew = false;
-    }
-    const sessionExpireInSeconds = session.getMaxInactiveInterval();
-    const keyToExpire = SESSION_EXPIRES_PREFIX + session.getId();
-    const sessionKey = this.getSessionKey(keyToExpire);
-    if (sessionExpireInSeconds < 0) {
-      await this.redis.append(sessionKey, "");
-      await this.redis.persist(sessionKey);
-      await this.redis.persist(this.getSessionKey(session.getId()));
-    } else if (sessionExpireInSeconds === 0) {
-      await this.redis.del(sessionKey);
-    } else {
-      await this.redis.append(sessionKey, "");
-      await this.redis.expire(sessionKey, sessionExpireInSeconds);
-    }
-    if (sessionExpireInSeconds > 0) {
-      const fiveMinutesAfterExpires = sessionExpireInSeconds + 5 * 60;
-      await this.redis.expire(this.getSessionKey(session.getId()), fiveMinutesAfterExpires);
-    }
-    await this.expirationStore.save(session);
-    session.delta.clear();
-  }
-  async saveChangeSessionId(session) {
-    const sessionId = session.getId();
-    if (sessionId === session.originalSessionId) return;
-    if (!session.isNew) {
-      const originalSessionIdKey = this.getSessionKey(session.originalSessionId);
-      const sessionIdKey = this.getSessionKey(sessionId);
-      const originalExpiredKey = this.getExpiredKey(session.originalSessionId);
-      const expiredKey = this.getExpiredKey(sessionId);
-      await this.redis.rename(originalSessionIdKey, sessionIdKey);
-      await this.redis.rename(originalExpiredKey, expiredKey);
-      if (session.originalPrincipalName !== null) {
-        const originalPrincipalRedisKey = this.getPrincipalKey(session.originalPrincipalName);
-        await this.redis.srem(originalPrincipalRedisKey, session.originalSessionId);
-        await this.redis.sadd(originalPrincipalRedisKey, sessionId);
-      }
-      await this.expirationStore.rename(session);
-    }
-    session.originalSessionId = sessionId;
-  }
-  // override
-  createSession() {
-    const cached = new import_map_session.MapSession();
-    cached.setMaxInactiveInterval(this.defaultMaxInactiveInterval);
-    return new RedisSession(cached, true);
-  }
-  async save(session) {
-    await this.saveChangeSessionId(session);
-    await this.saveDelta(session);
-  }
-  async findById(sessionId) {
-    return this.getSession(sessionId, false);
-  }
-  async deleteById(sessionId) {
-    const session = await this.getSession(sessionId, true);
-    if (!session) return;
-    const principal = (0, import_common.resolveIndexesFor)(session);
-    if (principal !== null) {
-      await this.redis.srem(this.getPrincipalKey(principal), sessionId);
-    }
-    await this.expirationStore.remove(sessionId);
-    const expiredKey = this.getExpiredKey(sessionId);
-    await this.redis.del(expiredKey);
-    session.setMaxInactiveInterval(0);
-    await this.save(session);
-  }
-  async findByIndexNameAndIndexValue(indexName, indexValue) {
-    if (indexName !== import_common.PRINCIPAL_NAME_INDEX_NAME) {
-      return /* @__PURE__ */ new Map();
-    }
-    const principalKey = this.getPrincipalKey(indexValue);
-    const sessionIds = await this.redis.smembers(principalKey);
-    if (!sessionIds || sessionIds.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    const sessions = /* @__PURE__ */ new Map();
-    for (const sessionId of sessionIds) {
-      const session = await this.findById(sessionId);
-      if (session !== null) {
-        sessions.set(sessionId, session);
-      }
-    }
-    return sessions;
-  }
-  async findByPrincipalName(principalName) {
-    return this.findByIndexNameAndIndexValue(import_common.PRINCIPAL_NAME_INDEX_NAME, principalName);
-  }
-  async cleanupExpiredSessions(cleanupCount) {
-    await this.expirationStore.cleanupExpiredSessions(cleanupCount);
-  }
+	redis;
+	namespace;
+	expirationStore;
+	defaultMaxInactiveInterval = 1800;
+	constructor(redis, namespace = "spring:session") {
+		this.redis = redis;
+		this.namespace = namespace;
+		this.expirationStore = new SortedSetRedisSessionExpirationStore(redis, namespace);
+	}
+	setDefaultMaxInactiveInterval(interval) {
+		this.defaultMaxInactiveInterval = interval;
+	}
+	getSessionKey(sessionId) {
+		return `${this.namespace}:sessions:${sessionId}`;
+	}
+	getExpiredKey(sessionId) {
+		return `${this.namespace}:sessions:expires:${sessionId}`;
+	}
+	getSessionAttrNameKey(name) {
+		return ATTRIBUTE_PREFIX + name;
+	}
+	getPrincipalKey(principalName) {
+		return `${this.namespace}:index:${require_session_common.PRINCIPAL_NAME_INDEX_NAME}:${principalName}`;
+	}
+	async getSession(id, allowExpired) {
+		const key = this.getSessionKey(id);
+		const entries = await this.redis.hgetall(key);
+		if (!entries || Object.keys(entries).length === 0) return null;
+		const loaded = new require_session_map_session.MapSession(id);
+		if (!entries.creationTime) throw new Error("creationTime attribute not found");
+		if (!entries.lastAccessedTime) throw new Error("lastAccessedTime attribute not found");
+		if (!entries.maxInactiveInterval) throw new Error("maxInactiveInterval attribute not found");
+		loaded.setCreationTime(Number(entries.creationTime));
+		loaded.setLastAccessedTime(Number(entries.lastAccessedTime));
+		loaded.setMaxInactiveInterval(Number(entries.maxInactiveInterval));
+		for (const [key, value] of Object.entries(entries)) if (key.startsWith(ATTRIBUTE_PREFIX)) loaded.setAttribute(key.slice(12), value);
+		if (!allowExpired && loaded.isExpired()) return null;
+		const result = new RedisSession(loaded, false);
+		result.originalLastAccessTime = loaded.getLastAccessedTime();
+		return result;
+	}
+	async saveDelta(session) {
+		if (session.delta.size === 0) return;
+		const sessionId = session.getId();
+		const delta = /* @__PURE__ */ new Map();
+		const removes = [];
+		session.delta.forEach((value, key) => {
+			if (value !== null) delta.set(key, value);
+			else removes.push(key);
+		});
+		if (delta.size !== 0) await this.redis.hset(this.getSessionKey(sessionId), delta);
+		if (removes.length !== 0) await this.redis.hdel(this.getSessionKey(sessionId), ...removes);
+		const principalSessionKey = this.getSessionAttrNameKey(require_session_common.PRINCIPAL_NAME_INDEX_NAME);
+		const securityPrincipalSessionKey = this.getSessionAttrNameKey(require_session_common.SPRING_SECURITY_CONTEXT);
+		if (session.delta.has(principalSessionKey) || session.delta.has(securityPrincipalSessionKey)) {
+			if (session.originalPrincipalName !== null) {
+				const originalPrincipalRedisKey = this.getPrincipalKey(session.originalPrincipalName);
+				await this.redis.srem(originalPrincipalRedisKey, sessionId);
+			}
+			const principal = require_session_common.resolveIndexesFor(session);
+			session.originalPrincipalName = principal;
+			if (principal !== null) {
+				const principalRedisKey = this.getPrincipalKey(principal);
+				await this.redis.sadd(principalRedisKey, sessionId);
+			}
+		}
+		if (session.isNew) session.isNew = false;
+		const sessionExpireInSeconds = session.getMaxInactiveInterval();
+		const keyToExpire = SESSION_EXPIRES_PREFIX + session.getId();
+		const sessionKey = this.getSessionKey(keyToExpire);
+		if (sessionExpireInSeconds < 0) {
+			await this.redis.append(sessionKey, "");
+			await this.redis.persist(sessionKey);
+			await this.redis.persist(this.getSessionKey(session.getId()));
+		} else if (sessionExpireInSeconds === 0) await this.redis.del(sessionKey);
+		else {
+			await this.redis.append(sessionKey, "");
+			await this.redis.expire(sessionKey, sessionExpireInSeconds);
+		}
+		if (sessionExpireInSeconds > 0) {
+			const fiveMinutesAfterExpires = sessionExpireInSeconds + 300;
+			await this.redis.expire(this.getSessionKey(session.getId()), fiveMinutesAfterExpires);
+		}
+		await this.expirationStore.save(session);
+		session.delta.clear();
+	}
+	async saveChangeSessionId(session) {
+		const sessionId = session.getId();
+		if (sessionId === session.originalSessionId) return;
+		if (!session.isNew) {
+			const originalSessionIdKey = this.getSessionKey(session.originalSessionId);
+			const sessionIdKey = this.getSessionKey(sessionId);
+			const originalExpiredKey = this.getExpiredKey(session.originalSessionId);
+			const expiredKey = this.getExpiredKey(sessionId);
+			await this.redis.rename(originalSessionIdKey, sessionIdKey);
+			await this.redis.rename(originalExpiredKey, expiredKey);
+			if (session.originalPrincipalName !== null) {
+				const originalPrincipalRedisKey = this.getPrincipalKey(session.originalPrincipalName);
+				await this.redis.srem(originalPrincipalRedisKey, session.originalSessionId);
+				await this.redis.sadd(originalPrincipalRedisKey, sessionId);
+			}
+			await this.expirationStore.rename(session);
+		}
+		session.originalSessionId = sessionId;
+	}
+	createSession() {
+		const cached = new require_session_map_session.MapSession();
+		cached.setMaxInactiveInterval(this.defaultMaxInactiveInterval);
+		return new RedisSession(cached, true);
+	}
+	async save(session) {
+		await this.saveChangeSessionId(session);
+		await this.saveDelta(session);
+	}
+	async findById(sessionId) {
+		return this.getSession(sessionId, false);
+	}
+	async deleteById(sessionId) {
+		const session = await this.getSession(sessionId, true);
+		if (!session) return;
+		const principal = require_session_common.resolveIndexesFor(session);
+		if (principal !== null) await this.redis.srem(this.getPrincipalKey(principal), sessionId);
+		await this.expirationStore.remove(sessionId);
+		const expiredKey = this.getExpiredKey(sessionId);
+		await this.redis.del(expiredKey);
+		session.setMaxInactiveInterval(0);
+		await this.save(session);
+	}
+	async findByIndexNameAndIndexValue(indexName, indexValue) {
+		if (indexName !== require_session_common.PRINCIPAL_NAME_INDEX_NAME) return /* @__PURE__ */ new Map();
+		const principalKey = this.getPrincipalKey(indexValue);
+		const sessionIds = await this.redis.smembers(principalKey);
+		if (!sessionIds || sessionIds.length === 0) return /* @__PURE__ */ new Map();
+		const sessions = /* @__PURE__ */ new Map();
+		for (const sessionId of sessionIds) {
+			const session = await this.findById(sessionId);
+			if (session !== null) sessions.set(sessionId, session);
+		}
+		return sessions;
+	}
+	async findByPrincipalName(principalName) {
+		return this.findByIndexNameAndIndexValue(require_session_common.PRINCIPAL_NAME_INDEX_NAME, principalName);
+	}
+	async cleanupExpiredSessions(cleanupCount) {
+		await this.expirationStore.cleanupExpiredSessions(cleanupCount);
+	}
 };
 var RedisKVRepository = class {
-  redis;
-  constructor(redis) {
-    this.redis = redis;
-  }
-  async setItem(key, value, expiresIn) {
-    if (expiresIn) {
-      await this.redis.set(key, value, "EX", expiresIn);
-    } else {
-      await this.redis.set(key, value);
-    }
-  }
-  async getItem(key) {
-    return await this.redis.get(key);
-  }
-  async removeItem(key) {
-    await this.redis.del(key);
-  }
+	redis;
+	constructor(redis) {
+		this.redis = redis;
+	}
+	async setItem(key, value, expiresIn) {
+		if (expiresIn) await this.redis.set(key, value, "EX", expiresIn);
+		else await this.redis.set(key, value);
+	}
+	async getItem(key) {
+		return await this.redis.get(key);
+	}
+	async removeItem(key) {
+		await this.redis.del(key);
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RedisIndexedSessionRepository,
-  RedisKVRepository
-});
+//#endregion
+exports.RedisIndexedSessionRepository = RedisIndexedSessionRepository;
+exports.RedisKVRepository = RedisKVRepository;
+
 //# sourceMappingURL=redis.cjs.map