redis-wizard 0.0.1

package/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Redis Wizard 설정
+ */
+export interface RedisWizardConfig {
+    /** 테이블/스코프 프리픽스 (예: "draft:applications") */
+    table: string;
+    /** 기본 캐시 만료 시간(초), 지정하지 않으면 만료 시간 없음 */
+    cacheExpired?: number;
+}
+/**
+ * Redis Wizard 인스턴스 인터페이스
+ */
+export interface RedisWizard<T = any> {
+    /**
+     * 키에 해당하는 값을 조회합니다.
+     * @param key - 조회할 키 (table 프리픽스는 자동 추가)
+     * @returns 값이 존재하면 파싱된 객체, 없으면 null
+     */
+    read(key: string): Promise<T | null>;
+    /**
+     * 키-값 쌍을 저장합니다.
+     * @param key - 저장할 키 (table 프리픽스는 자동 추가)
+     * @param value - 저장할 값 (객체는 자동 직렬화)
+     * @param expireSeconds - 만료 시간(초), 지정하지 않으면 config.cacheExpired 사용
+     */
+    create(key: string, value: T, expireSeconds?: number): Promise<void>;
+    /**
+     * 키의 값을 부분 업데이트합니다.
+     * @param key - 업데이트할 키 (table 프리픽스는 자동 추가)
+     * @param partial - 업데이트할 부분 값
+     * @param expireSeconds - 만료 시간(초), 지정하지 않으면 config.cacheExpired 사용
+     * @returns 업데이트된 값, 키가 존재하지 않으면 null
+     */
+    update(key: string, partial: Partial<T>, expireSeconds?: number): Promise<T | null>;
+    /**
+     * 키를 삭제합니다.
+     * @param key - 삭제할 키 (table 프리픽스는 자동 추가)
+     * @returns 삭제 성공 여부
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * 키의 존재 여부를 확인합니다.
+     * @param key - 확인할 키 (table 프리픽스는 자동 추가)
+     * @returns 키가 존재하면 true
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * 키의 만료 시간을 설정합니다.
+     * @param key - 만료 시간을 설정할 키 (table 프리픽스는 자동 추가)
+     * @param seconds - 만료 시간(초), 지정하지 않으면 config.cacheExpired 사용
+     * @returns 설정 성공 여부
+     */
+    setExpire(key: string, seconds?: number): Promise<boolean>;
+    /**
+     * 키의 남은 만료 시간을 조회합니다.
+     * @param key - 조회할 키 (table 프리픽스는 자동 추가)
+     * @returns 남은 만료 시간(초), 만료 시간이 없으면 null
+     */
+    getTtl(key: string): Promise<number | null>;
+}
+/**
+ * Redis Wizard 인스턴스를 생성합니다.
+ *
+ * @example
+ * ```typescript
+ * interface Application {
+ *   id: string;
+ *   title: string;
+ *   status: 'draft' | 'published';
+ * }
+ *
+ * const redis = createRedis<Application>({
+ *   table: "draft:applications",
+ *   cacheExpired: 10000,
+ * });
+ *
+ * await redis.create("app-123", { id: "app-123", title: "My App", status: "draft" });
+ * const app = await redis.read("app-123");
+ * await redis.update("app-123", { status: "published" });
+ * await redis.delete("app-123");
+ * ```
+ *
+ * @param config - Redis Wizard 설정
+ * @returns Redis Wizard 인스턴스
+ */
+export declare function createRedis<T = any>(config: RedisWizardConfig): RedisWizard<T>;
+export { disconnect } from "./services/config";
+export { getRedisClient } from "./services/config";

package/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRedisClient = exports.disconnect = void 0;
+exports.createRedis = createRedis;
+const read_1 = require("./services/read");
+const create_1 = require("./services/create");
+const update_1 = require("./services/update");
+const delete_1 = require("./services/delete");
+const exists_1 = require("./services/exists");
+const setExpire_1 = require("./services/setExpire");
+const getTtl_1 = require("./services/getTtl");
+/**
+ * Redis Wizard 인스턴스를 생성합니다.
+ *
+ * @example
+ * ```typescript
+ * interface Application {
+ *   id: string;
+ *   title: string;
+ *   status: 'draft' | 'published';
+ * }
+ *
+ * const redis = createRedis<Application>({
+ *   table: "draft:applications",
+ *   cacheExpired: 10000,
+ * });
+ *
+ * await redis.create("app-123", { id: "app-123", title: "My App", status: "draft" });
+ * const app = await redis.read("app-123");
+ * await redis.update("app-123", { status: "published" });
+ * await redis.delete("app-123");
+ * ```
+ *
+ * @param config - Redis Wizard 설정
+ * @returns Redis Wizard 인스턴스
+ */
+function createRedis(config) {
+    const { table, cacheExpired } = config;
+    return {
+        async read(key) {
+            return await (0, read_1.read)(table, key);
+        },
+        async create(key, value, expireSeconds) {
+            await (0, create_1.create)(table, key, value, expireSeconds ?? cacheExpired);
+        },
+        async update(key, partial, expireSeconds) {
+            return await (0, update_1.update)(table, key, partial, expireSeconds ?? cacheExpired);
+        },
+        async delete(key) {
+            return await (0, delete_1.deleteKey)(table, key);
+        },
+        async exists(key) {
+            return await (0, exists_1.exists)(table, key);
+        },
+        async setExpire(key, seconds) {
+            const expireSeconds = seconds ?? cacheExpired;
+            if (expireSeconds === undefined) {
+                throw new Error("만료 시간을 지정해야 합니다. createRedis의 cacheExpired 설정 또는 seconds 파라미터를 제공하세요.");
+            }
+            return await (0, setExpire_1.setExpire)(table, key, expireSeconds);
+        },
+        async getTtl(key) {
+            return await (0, getTtl_1.getTtl)(table, key);
+        },
+    };
+}
+// Redis 연결 관리 함수 export
+var config_1 = require("./services/config");
+Object.defineProperty(exports, "disconnect", { enumerable: true, get: function () { return config_1.disconnect; } });
+var config_2 = require("./services/config");
+Object.defineProperty(exports, "getRedisClient", { enumerable: true, get: function () { return config_2.getRedisClient; } });

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "redis-wizard",
+  "description": "A modern TypeScript-based Redis database utility package that provides an enhanced wrapper around the redis library, offering simplified database operations with elegant chainable queries.",
+  "version": "0.0.1",
+  "main": "index.js",
+  "scripts": {},
+  "author": "park-minhyeong",
+  "license": "MIT",
+  "dependencies": {
+    "redis": "^5.10.0",
+    "nodemon": "^3.1.10",
+    "tspec": "^0.1.116"
+  },
+  "devDependencies": {}
+}

package/services/config.d.ts

@@ -0,0 +1,41 @@
+import { type RedisClientType } from "redis";
+/**
+ * Redis 연결 풀 설정
+ */
+export interface RedisPoolConfig {
+    /** 연결 타임아웃 (밀리초), 기본값: 10000 */
+    connectTimeout?: number;
+    /** 연결 유지 활성화 여부, 기본값: true */
+    keepAlive?: boolean;
+    /** 연결 유지 초기 지연 시간 (밀리초), 기본값: 0 */
+    keepAliveInitialDelay?: number;
+    /** 재연결 전략: false(재연결 안함), number(밀리초 지연), function(재연결 전략 함수) */
+    reconnectStrategy?: false | number | ((retries: number) => number | Error);
+    /** 지연 연결 (true면 connect() 호출 시 연결), 기본값: false */
+    lazyConnect?: boolean;
+    /** 최대 재연결 시도 횟수, 기본값: 10 */
+    maxRetriesPerRequest?: number;
+}
+/**
+ * Redis 클라이언트가 연결되어 있는지 확인합니다.
+ * 연결되어 있지 않으면 자동으로 연결을 시도합니다.
+ *
+ * @param {RedisPoolConfig} [poolConfig] - 연결 풀 설정 (선택사항, 초기화 시에만 적용)
+ * @returns {Promise<RedisClientType>} 연결된 Redis 클라이언트
+ * @throws {Error} Redis 클라이언트가 초기화되지 않았거나 연결에 실패한 경우
+ */
+export declare const getRedisClient: (poolConfig?: RedisPoolConfig) => Promise<RedisClientType>;
+/**
+ * Redis 연결 풀 설정을 업데이트합니다.
+ * 이미 연결된 경우에는 재연결이 필요할 수 있습니다.
+ *
+ * @param {RedisPoolConfig} poolConfig - 새로운 연결 풀 설정
+ * @returns {Promise<void>}
+ */
+export declare const configurePool: (poolConfig: RedisPoolConfig) => Promise<void>;
+/**
+ * Redis 연결을 종료합니다.
+ *
+ * @returns {Promise<void>}
+ */
+export declare const disconnect: () => Promise<void>;

package/services/config.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disconnect = exports.configurePool = exports.getRedisClient = void 0;
+const redis_1 = require("redis");
+/**
+ * Redis 클라이언트 인스턴스
+ * @private
+ */
+let redisClient = null;
+/**
+ * Redis 연결 상태
+ * @private
+ */
+let isConnected = false;
+/**
+ * 환경 변수에서 연결 풀 설정을 읽어옵니다.
+ * @returns {RedisPoolConfig} 연결 풀 설정
+ */
+const getPoolConfigFromEnv = () => {
+    const config = {};
+    if (process.env.REDIS_CONNECT_TIMEOUT) {
+        config.connectTimeout = parseInt(process.env.REDIS_CONNECT_TIMEOUT, 10);
+    }
+    if (process.env.REDIS_KEEP_ALIVE !== undefined) {
+        config.keepAlive = process.env.REDIS_KEEP_ALIVE === "true";
+    }
+    if (process.env.REDIS_KEEP_ALIVE_DELAY) {
+        config.keepAliveInitialDelay = parseInt(process.env.REDIS_KEEP_ALIVE_DELAY, 10);
+    }
+    if (process.env.REDIS_LAZY_CONNECT === "true") {
+        config.lazyConnect = true;
+    }
+    if (process.env.REDIS_MAX_RETRIES) {
+        config.maxRetriesPerRequest = parseInt(process.env.REDIS_MAX_RETRIES, 10);
+    }
+    return config;
+};
+/**
+ * Redis 클라이언트를 초기화하고 연결합니다.
+ * 환경 변수 REDIS_URL이 설정되어 있으면 해당 URL을 사용하고,
+ * 없으면 기본값 'redis://localhost:6379'를 사용합니다.
+ * 연결 풀 설정은 환경 변수 또는 poolConfig 파라미터로 지정할 수 있습니다.
+ *
+ * @param {RedisPoolConfig} [poolConfig] - 연결 풀 설정 (선택사항)
+ * @throws {Error} Redis 연결에 실패한 경우
+ */
+const initializeRedis = async (poolConfig) => {
+    const redisUrl = process.env.REDIS_PORT ? `redis://localhost:${process.env.REDIS_PORT}` : process.env.REDIS_URL;
+    if (!redisUrl) {
+        const error = new Error("Redis configuration error: REDIS_URL or REDIS_PORT environment variable is not set");
+        console.error("[Redis Config] Initialization failed:", error.message);
+        throw error;
+    }
+    if (redisClient && isConnected) {
+        console.log("[Redis Config] Client already connected, skipping initialization");
+        return;
+    }
+    // 환경 변수에서 연결 풀 설정 읽기
+    const envPoolConfig = getPoolConfigFromEnv();
+    // 파라미터와 환경 변수 설정 병합 (파라미터 우선)
+    const finalPoolConfig = {
+        connectTimeout: 10000,
+        keepAlive: true,
+        keepAliveInitialDelay: 0,
+        lazyConnect: false,
+        maxRetriesPerRequest: 10,
+        ...envPoolConfig,
+        ...poolConfig,
+    };
+    const socketConfig = {
+        connectTimeout: finalPoolConfig.connectTimeout,
+    };
+    if (finalPoolConfig.keepAlive !== undefined) {
+        socketConfig.keepAlive = finalPoolConfig.keepAlive;
+    }
+    if (finalPoolConfig.keepAliveInitialDelay !== undefined) {
+        socketConfig.keepAliveInitialDelay = finalPoolConfig.keepAliveInitialDelay;
+    }
+    if (finalPoolConfig.reconnectStrategy !== undefined) {
+        socketConfig.reconnectStrategy = finalPoolConfig.reconnectStrategy;
+    }
+    else {
+        socketConfig.reconnectStrategy = (retries) => {
+            if (retries > 10) {
+                return new Error("Too many reconnection attempts");
+            }
+            return Math.min(retries * 100, 3000);
+        };
+    }
+    const clientOptions = {
+        url: redisUrl,
+        socket: socketConfig,
+        ...(finalPoolConfig.lazyConnect !== undefined && { lazyConnect: finalPoolConfig.lazyConnect }),
+        ...(finalPoolConfig.maxRetriesPerRequest !== undefined && { maxRetriesPerRequest: finalPoolConfig.maxRetriesPerRequest }),
+    };
+    console.log(`[Redis Config] Initializing Redis client with URL: ${redisUrl.replace(/:[^:@]+@/, ":****@")}`, {
+        poolConfig: {
+            connectTimeout: finalPoolConfig.connectTimeout,
+            keepAlive: finalPoolConfig.keepAlive,
+            keepAliveInitialDelay: finalPoolConfig.keepAliveInitialDelay,
+            lazyConnect: finalPoolConfig.lazyConnect,
+            maxRetriesPerRequest: finalPoolConfig.maxRetriesPerRequest,
+        },
+    });
+    redisClient = (0, redis_1.createClient)(clientOptions);
+    redisClient.on("error", (err) => {
+        console.error("[Redis Config] Connection error occurred:", {
+            message: err.message,
+            stack: err.stack,
+            timestamp: new Date().toISOString(),
+        });
+        isConnected = false;
+    });
+    redisClient.on("connect", () => {
+        console.log("[Redis Config] Connecting to Redis server...");
+    });
+    redisClient.on("ready", () => {
+        console.log("[Redis Config] Redis client connected and ready", {
+            url: redisUrl.replace(/:[^:@]+@/, ":****@"),
+            timestamp: new Date().toISOString(),
+        });
+        isConnected = true;
+    });
+    redisClient.on("reconnecting", () => {
+        console.warn("[Redis Config] Attempting to reconnect to Redis server...", {
+            timestamp: new Date().toISOString(),
+        });
+        isConnected = false;
+    });
+    redisClient.on("end", () => {
+        console.log("[Redis Config] Redis connection ended", {
+            timestamp: new Date().toISOString(),
+        });
+        isConnected = false;
+    });
+    try {
+        console.log("[Redis Config] Establishing connection...");
+        await redisClient.connect();
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("[Redis Config] Failed to connect to Redis:", {
+            message: errorMessage,
+            url: redisUrl.replace(/:[^:@]+@/, ":****@"),
+            timestamp: new Date().toISOString(),
+        });
+        throw error;
+    }
+};
+/**
+ * Redis 클라이언트가 연결되어 있는지 확인합니다.
+ * 연결되어 있지 않으면 자동으로 연결을 시도합니다.
+ *
+ * @param {RedisPoolConfig} [poolConfig] - 연결 풀 설정 (선택사항, 초기화 시에만 적용)
+ * @returns {Promise<RedisClientType>} 연결된 Redis 클라이언트
+ * @throws {Error} Redis 클라이언트가 초기화되지 않았거나 연결에 실패한 경우
+ */
+const getRedisClient = async (poolConfig) => {
+    if (!redisClient || !isConnected) {
+        console.log("[Redis Config] Client not available, initializing...");
+        await initializeRedis(poolConfig);
+    }
+    if (!redisClient) {
+        const error = new Error("Redis client initialization failed: client is null after initialization attempt");
+        console.error("[Redis Config]", error.message);
+        throw error;
+    }
+    return redisClient;
+};
+exports.getRedisClient = getRedisClient;
+/**
+ * Redis 연결 풀 설정을 업데이트합니다.
+ * 이미 연결된 경우에는 재연결이 필요할 수 있습니다.
+ *
+ * @param {RedisPoolConfig} poolConfig - 새로운 연결 풀 설정
+ * @returns {Promise<void>}
+ */
+const configurePool = async (poolConfig) => {
+    if (redisClient && isConnected) {
+        console.warn("[Redis Config] Pool configuration change requires reconnection. Disconnecting current client...");
+        await (0, exports.disconnect)();
+    }
+    await initializeRedis(poolConfig);
+};
+exports.configurePool = configurePool;
+/**
+ * Redis 연결을 종료합니다.
+ *
+ * @returns {Promise<void>}
+ */
+const disconnect = async () => {
+    if (redisClient && isConnected) {
+        console.log("[Redis Config] Disconnecting Redis client...");
+        try {
+            await redisClient.quit();
+            console.log("[Redis Config] Redis client disconnected successfully", {
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.error("[Redis Config] Error during disconnection:", {
+                message: error instanceof Error ? error.message : String(error),
+                timestamp: new Date().toISOString(),
+            });
+            throw error;
+        }
+        isConnected = false;
+        redisClient = null;
+    }
+    else {
+        console.log("[Redis Config] No active connection to disconnect");
+    }
+};
+exports.disconnect = disconnect;
+// 애플리케이션 시작 시 Redis 연결 초기화
+initializeRedis().catch((error) => {
+    console.error("[Redis Config] Failed to initialize Redis on application startup:", {
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+        timestamp: new Date().toISOString(),
+    });
+});

package/services/create.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Redis에 키-값 쌍을 저장합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ * 값은 자동으로 JSON 문자열로 직렬화됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 저장할 키 (프리픽스 제외)
+ * @param {T} value - 저장할 값 (객체는 자동 직렬화)
+ * @param {number} [expireSeconds] - 만료 시간(초), 지정하지 않으면 기본값 사용
+ * @returns {Promise<void>}
+ * @throws {Error} Redis 저장 중 오류가 발생한 경우
+ */
+export declare const create: <T = any>(table: string, key: string, value: T, expireSeconds?: number) => Promise<void>;

package/services/create.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에 키-값 쌍을 저장합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ * 값은 자동으로 JSON 문자열로 직렬화됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 저장할 키 (프리픽스 제외)
+ * @param {T} value - 저장할 값 (객체는 자동 직렬화)
+ * @param {number} [expireSeconds] - 만료 시간(초), 지정하지 않으면 기본값 사용
+ * @returns {Promise<void>}
+ * @throws {Error} Redis 저장 중 오류가 발생한 경우
+ */
+const create = async (table, key, value, expireSeconds) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    try {
+        if (expireSeconds !== undefined) {
+            await client.setEx(fullKey, expireSeconds, serialized);
+        }
+        else {
+            await client.set(fullKey, serialized);
+        }
+    }
+    catch (error) {
+        console.error(`Redis SET 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.create = create;

package/services/delete.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Redis에서 키를 삭제합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 삭제할 키 (프리픽스 제외)
+ * @returns {Promise<boolean>} 삭제 성공 여부 (키가 존재했으면 true, 없었으면 false)
+ * @throws {Error} Redis 삭제 중 오류가 발생한 경우
+ */
+export declare const deleteKey: (table: string, key: string) => Promise<boolean>;

package/services/delete.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteKey = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에서 키를 삭제합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 삭제할 키 (프리픽스 제외)
+ * @returns {Promise<boolean>} 삭제 성공 여부 (키가 존재했으면 true, 없었으면 false)
+ * @throws {Error} Redis 삭제 중 오류가 발생한 경우
+ */
+const deleteKey = async (table, key) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    try {
+        const result = await client.del(fullKey);
+        return result > 0;
+    }
+    catch (error) {
+        console.error(`Redis DEL 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.deleteKey = deleteKey;

package/services/exists.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Redis에서 키의 존재 여부를 확인합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 확인할 키 (프리픽스 제외)
+ * @returns {Promise<boolean>} 키가 존재하면 true, 없으면 false
+ * @throws {Error} Redis 확인 중 오류가 발생한 경우
+ */
+export declare const exists: (table: string, key: string) => Promise<boolean>;

package/services/exists.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에서 키의 존재 여부를 확인합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 확인할 키 (프리픽스 제외)
+ * @returns {Promise<boolean>} 키가 존재하면 true, 없으면 false
+ * @throws {Error} Redis 확인 중 오류가 발생한 경우
+ */
+const exists = async (table, key) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    try {
+        const result = await client.exists(fullKey);
+        return result > 0;
+    }
+    catch (error) {
+        console.error(`Redis EXISTS 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.exists = exists;

package/services/getTtl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Redis에서 키의 남은 만료 시간을 조회합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 조회할 키 (프리픽스 제외)
+ * @returns {Promise<number | null>} 남은 만료 시간(초), 만료 시간이 없으면 null
+ * @throws {Error} Redis 만료 시간 조회 중 오류가 발생한 경우
+ */
+export declare const getTtl: (table: string, key: string) => Promise<number | null>;

package/services/getTtl.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTtl = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에서 키의 남은 만료 시간을 조회합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 조회할 키 (프리픽스 제외)
+ * @returns {Promise<number | null>} 남은 만료 시간(초), 만료 시간이 없으면 null
+ * @throws {Error} Redis 만료 시간 조회 중 오류가 발생한 경우
+ */
+const getTtl = async (table, key) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    try {
+        const ttl = await client.ttl(fullKey);
+        return ttl >= 0 ? ttl : null;
+    }
+    catch (error) {
+        console.error(`Redis TTL 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.getTtl = getTtl;

package/services/read.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Redis에서 키에 해당하는 값을 조회합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ * 값이 JSON 문자열인 경우 자동으로 파싱하여 반환합니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 조회할 키 (프리픽스 제외)
+ * @returns {Promise<T | null>} 키에 해당하는 값, 존재하지 않으면 null
+ * @throws {Error} Redis 조회 중 오류가 발생한 경우
+ */
+export declare const read: <T = any>(table: string, key: string) => Promise<T | null>;

package/services/read.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.read = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에서 키에 해당하는 값을 조회합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ * 값이 JSON 문자열인 경우 자동으로 파싱하여 반환합니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 조회할 키 (프리픽스 제외)
+ * @returns {Promise<T | null>} 키에 해당하는 값, 존재하지 않으면 null
+ * @throws {Error} Redis 조회 중 오류가 발생한 경우
+ */
+const read = async (table, key) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    try {
+        const value = await client.get(fullKey);
+        if (value === null) {
+            console.log(`Redis GET: key=${fullKey}, value=null`);
+            return null;
+        }
+        // JSON 문자열인지 확인하고 파싱 시도
+        if (typeof value === "string") {
+            const trimmedValue = value.trim();
+            // JSON 형식인지 간단히 확인 (시작이 { 또는 [)
+            if ((trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) ||
+                (trimmedValue.startsWith("[") && trimmedValue.endsWith("]"))) {
+                try {
+                    const parsed = JSON.parse(value);
+                    console.log(`Redis GET: key=${fullKey}, parsed successfully`);
+                    return parsed;
+                }
+                catch (parseError) {
+                    // JSON 파싱 실패 시 원래 문자열 반환
+                    console.log(`Redis GET: key=${fullKey}, JSON parse failed, returning string`);
+                    return value;
+                }
+            }
+        }
+        console.log(`Redis GET: key=${fullKey}, returning raw value`);
+        return value;
+    }
+    catch (error) {
+        console.error(`Redis GET 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.read = read;

package/services/setExpire.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Redis에서 키의 만료 시간을 설정합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 만료 시간을 설정할 키 (프리픽스 제외)
+ * @param {number} seconds - 만료 시간(초)
+ * @returns {Promise<boolean>} 설정 성공 여부
+ * @throws {Error} Redis 만료 시간 설정 중 오류가 발생한 경우
+ */
+export declare const setExpire: (table: string, key: string, seconds: number) => Promise<boolean>;

package/services/setExpire.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setExpire = void 0;
+const config_1 = require("./config");
+/**
+ * Redis에서 키의 만료 시간을 설정합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 만료 시간을 설정할 키 (프리픽스 제외)
+ * @param {number} seconds - 만료 시간(초)
+ * @returns {Promise<boolean>} 설정 성공 여부
+ * @throws {Error} Redis 만료 시간 설정 중 오류가 발생한 경우
+ */
+const setExpire = async (table, key, seconds) => {
+    const client = await (0, config_1.getRedisClient)();
+    const fullKey = `${table}:${key}`;
+    try {
+        const result = await client.expire(fullKey, seconds);
+        return Boolean(result);
+    }
+    catch (error) {
+        console.error(`Redis EXPIRE 오류 (key: ${fullKey}):`, error);
+        throw error;
+    }
+};
+exports.setExpire = setExpire;

package/services/update.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Redis에서 키의 값을 부분 업데이트합니다.
+ * 기존 값을 읽어와서 병합한 후 저장합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 업데이트할 키 (프리픽스 제외)
+ * @param {Partial<T>} partial - 업데이트할 부분 값
+ * @param {number} [expireSeconds] - 만료 시간(초), 지정하지 않으면 기본값 사용
+ * @returns {Promise<T | null>} 업데이트된 값, 키가 존재하지 않으면 null
+ * @throws {Error} Redis 업데이트 중 오류가 발생한 경우
+ */
+export declare const update: <T = any>(table: string, key: string, partial: Partial<T>, expireSeconds?: number) => Promise<T | null>;

package/services/update.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = void 0;
+const read_1 = require("./read");
+const create_1 = require("./create");
+/**
+ * Redis에서 키의 값을 부분 업데이트합니다.
+ * 기존 값을 읽어와서 병합한 후 저장합니다.
+ * 키는 자동으로 table 프리픽스가 추가됩니다.
+ *
+ * @param {string} table - 테이블/스코프 프리픽스
+ * @param {string} key - 업데이트할 키 (프리픽스 제외)
+ * @param {Partial<T>} partial - 업데이트할 부분 값
+ * @param {number} [expireSeconds] - 만료 시간(초), 지정하지 않으면 기본값 사용
+ * @returns {Promise<T | null>} 업데이트된 값, 키가 존재하지 않으면 null
+ * @throws {Error} Redis 업데이트 중 오류가 발생한 경우
+ */
+const update = async (table, key, partial, expireSeconds) => {
+    // 기존 값 조회
+    const existing = await (0, read_1.read)(table, key);
+    if (existing === null) {
+        return null;
+    }
+    // 기존 값과 병합
+    const updated = { ...existing, ...partial };
+    // 저장
+    await (0, create_1.create)(table, key, updated, expireSeconds);
+    return updated;
+};
+exports.update = update;

package/version.txt

@@ -0,0 +1 @@
+0.0.1