@yolo-croket-dev/core 1.7.25-slowquery.8 → 1.7.25

package/functions/abort/abort-context.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/**
+ * AbortSignal을 AsyncLocalStorage를 통해 전역적으로 관리하는 컨텍스트
+ */
+export declare class AbortContext {
+    private static asyncLocalStorage;
+    /**
+     * AbortSignal과 함께 컨텍스트를 실행
+     * @param abortSignal 중단 신호
+     * @param requestId 요청 ID (디버깅용)
+     * @param callback 실행할 콜백 함수
+     * @returns 실행 결과
+     */
+    static run<T>(abortSignal: AbortSignal, requestId: string, callback: () => T): T;
+    /**
+     * 현재 컨텍스트의 AbortSignal을 가져옴
+     * @returns 현재 AbortSignal 또는 null
+     */
+    static getCurrentAbortSignal(): AbortSignal | null;
+    /**
+     * 현재 컨텍스트의 요청 ID를 가져옴
+     * @returns 현재 요청 ID 또는 null
+     */
+    static getCurrentRequestId(): string | null;
+    /**
+     * 현재 컨텍스트 정보를 가져옴
+     * @returns 현재 컨텍스트 또는 null
+     */
+    static getCurrentContext(): {
+        abortSignal: AbortSignal;
+        requestId: string;
+    } | null;
+}

package/functions/abort/abort-context.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortContext = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * AbortSignal을 AsyncLocalStorage를 통해 전역적으로 관리하는 컨텍스트
+ */
+class AbortContext {
+    /**
+     * AbortSignal과 함께 컨텍스트를 실행
+     * @param abortSignal 중단 신호
+     * @param requestId 요청 ID (디버깅용)
+     * @param callback 실행할 콜백 함수
+     * @returns 실행 결과
+     */
+    static run(abortSignal, requestId, callback) {
+        return this.asyncLocalStorage.run({
+            abortSignal,
+            requestId,
+        }, callback);
+    }
+    /**
+     * 현재 컨텍스트의 AbortSignal을 가져옴
+     * @returns 현재 AbortSignal 또는 null
+     */
+    static getCurrentAbortSignal() {
+        const context = this.asyncLocalStorage.getStore();
+        return (context === null || context === void 0 ? void 0 : context.abortSignal) || null;
+    }
+    /**
+     * 현재 컨텍스트의 요청 ID를 가져옴
+     * @returns 현재 요청 ID 또는 null
+     */
+    static getCurrentRequestId() {
+        const context = this.asyncLocalStorage.getStore();
+        return (context === null || context === void 0 ? void 0 : context.requestId) || null;
+    }
+    /**
+     * 현재 컨텍스트 정보를 가져옴
+     * @returns 현재 컨텍스트 또는 null
+     */
+    static getCurrentContext() {
+        return this.asyncLocalStorage.getStore() || null;
+    }
+}
+exports.AbortContext = AbortContext;
+AbortContext.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();

package/functions/abort/abort.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 현재 컨텍스트의 AbortSignal을 가져오는 전역 함수
+ * @returns 현재 AbortSignal 또는 null
+ */
+export declare function getCurrentAbortSignal(): AbortSignal | null;
+/**
+ * 현재 AbortSignal이 중단되었는지 확인
+ * @returns 중단 여부
+ */
+export declare function isAborted(): boolean;
+/**
+ * AbortSignal이 중단되었을 때 에러를 던지는 함수
+ * @param message 에러 메시지
+ * @throws 중단된 경우 에러 발생
+ */
+export declare function throwIfAborted(message?: string): void;
+/**
+ * AbortSignal을 감지하여 중단 가능한 Promise를 생성
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function withAbortSignal<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+/**
+ * AbortSignal을 감지하여 중단 가능한 delay
+ * @param ms 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function delayWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * AbortSignal을 감지하여 중단 가능한 setTimeout
+ * @param callback 실행할 콜백 함수
+ * @param delay 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 타이머 ID
+ */
+export declare function setTimeoutWithAbort(callback: () => void, delay: number, abortSignal?: AbortSignal): NodeJS.Timeout;
+/**
+ * AbortSignal을 감지하여 중단 가능한 반복 작업
+ * @param task 반복할 작업 함수
+ * @param interval 반복 간격 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function repeatWithAbort(task: () => Promise<void> | void, interval: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * 이벤트 기반으로 중단 가능한 Promise 실행
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function withAbortSignalEventBased<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T>;

package/functions/abort/abort.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAbortSignalEventBased = exports.repeatWithAbort = exports.setTimeoutWithAbort = exports.delayWithAbort = exports.withAbortSignal = exports.throwIfAborted = exports.isAborted = exports.getCurrentAbortSignal = void 0;
+const abort_context_1 = require("./abort-context");
+/**
+ * 현재 컨텍스트의 AbortSignal을 가져오는 전역 함수
+ * @returns 현재 AbortSignal 또는 null
+ */
+function getCurrentAbortSignal() {
+    return abort_context_1.AbortContext.getCurrentAbortSignal();
+}
+exports.getCurrentAbortSignal = getCurrentAbortSignal;
+/**
+ * 현재 AbortSignal이 중단되었는지 확인
+ * @returns 중단 여부
+ */
+function isAborted() {
+    var _a;
+    const signal = getCurrentAbortSignal();
+    return (_a = signal === null || signal === void 0 ? void 0 : signal.aborted) !== null && _a !== void 0 ? _a : false;
+}
+exports.isAborted = isAborted;
+/**
+ * AbortSignal이 중단되었을 때 에러를 던지는 함수
+ * @param message 에러 메시지
+ * @throws 중단된 경우 에러 발생
+ */
+function throwIfAborted(message = '작업이 중단되었습니다') {
+    if (isAborted()) {
+        throw new Error(`REQUEST_ABORTED: ${message}`);
+    }
+}
+exports.throwIfAborted = throwIfAborted;
+/**
+ * AbortSignal을 감지하여 중단 가능한 Promise를 생성
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function withAbortSignal(promise, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+        // 원본 Promise 처리
+        promise
+            .then((result) => {
+            signal.removeEventListener('abort', abortHandler);
+            resolve(result);
+        })
+            .catch((error) => {
+            signal.removeEventListener('abort', abortHandler);
+            reject(error);
+        });
+    });
+}
+exports.withAbortSignal = withAbortSignal;
+/**
+ * AbortSignal을 감지하여 중단 가능한 delay
+ * @param ms 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function delayWithAbort(ms, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    return new Promise((resolve, reject) => {
+        if (!signal) {
+            setTimeout(resolve, ms);
+            return;
+        }
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        const timerId = setTimeout(() => {
+            if (!signal.aborted) {
+                resolve();
+            }
+        }, ms);
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            clearTimeout(timerId);
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+exports.delayWithAbort = delayWithAbort;
+/**
+ * AbortSignal을 감지하여 중단 가능한 setTimeout
+ * @param callback 실행할 콜백 함수
+ * @param delay 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 타이머 ID
+ */
+function setTimeoutWithAbort(callback, delay, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return setTimeout(callback, delay);
+    }
+    // 이미 중단된 경우
+    if (signal.aborted) {
+        throw new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다');
+    }
+    const timerId = setTimeout(() => {
+        if (!signal.aborted) {
+            callback();
+        }
+    }, delay);
+    // 중단 이벤트 리스너 등록
+    const abortHandler = () => {
+        clearTimeout(timerId);
+    };
+    signal.addEventListener('abort', abortHandler, { once: true });
+    return timerId;
+}
+exports.setTimeoutWithAbort = setTimeoutWithAbort;
+/**
+ * AbortSignal을 감지하여 중단 가능한 반복 작업
+ * @param task 반복할 작업 함수
+ * @param interval 반복 간격 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function repeatWithAbort(task, interval, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    return new Promise((resolve, reject) => {
+        if (!signal) {
+            // abortSignal이 없으면 일반적인 반복 실행
+            const runTask = async () => {
+                try {
+                    await task();
+                    setTimeout(runTask, interval);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            runTask();
+            return;
+        }
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        const runTask = async () => {
+            if (signal.aborted) {
+                reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+                return;
+            }
+            try {
+                await task();
+                if (!signal.aborted) {
+                    setTimeout(runTask, interval);
+                }
+                else {
+                    reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+        runTask();
+    });
+}
+exports.repeatWithAbort = repeatWithAbort;
+/**
+ * 이벤트 기반으로 중단 가능한 Promise 실행
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function withAbortSignalEventBased(promise, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        let isCompleted = false;
+        // abort 이벤트 리스너 (즉시 반응)
+        const abortHandler = () => {
+            if (!isCompleted) {
+                isCompleted = true;
+                reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+            }
+        };
+        // 이벤트 리스너 등록
+        signal.addEventListener('abort', abortHandler, { once: true });
+        // 원본 Promise 처리
+        promise
+            .then((result) => {
+            if (!isCompleted) {
+                isCompleted = true;
+                signal.removeEventListener('abort', abortHandler);
+                resolve(result);
+            }
+        })
+            .catch((error) => {
+            if (!isCompleted) {
+                isCompleted = true;
+                signal.removeEventListener('abort', abortHandler);
+                reject(error);
+            }
+        });
+    });
+}
+exports.withAbortSignalEventBased = withAbortSignalEventBased;

package/functions/abort/enhanced-promise-patch.d.ts

@@ -0,0 +1,17 @@
+declare global {
+    var Promise: PromiseConstructor;
+}
+export declare class EnhancedPromisePatch {
+    private static isPatched;
+    private static originalPromise;
+    private static originalSetTimeout;
+    static patch(): void;
+    private static patchPromise;
+    private static patchSetTimeout;
+    static unpatch(): void;
+    /**
+     * 현재 패치 상태 확인
+     * @returns 패치 여부
+     */
+    static getPatchStatus(): boolean;
+}

package/functions/abort/enhanced-promise-patch.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedPromisePatch = void 0;
+const abort_1 = require("./abort");
+class EnhancedPromisePatch {
+    static patch() {
+        if (this.isPatched) {
+            return;
+        }
+        this.patchPromise();
+        this.patchSetTimeout();
+        this.isPatched = true;
+    }
+    static patchPromise() {
+        this.originalPromise = global.Promise;
+        // Promise 생성자 패치
+        global.Promise = new Proxy(global.Promise, {
+            construct(target, args) {
+                const abortSignal = (0, abort_1.getCurrentAbortSignal)();
+                if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                    return Promise.reject(new Error('REQUEST_ABORTED: Promise가 중단되었습니다'));
+                }
+                // target은 Promise 생성자이므로, new 연산자와 함께 사용해야 하며, args는 [executor] 형태의 튜플임을 명시합니다.
+                const promise = Reflect.construct(target, args);
+                if (!abortSignal) {
+                    return promise;
+                }
+                // Promise 체인에 중단 확인 추가
+                return promise.then((result) => {
+                    if (abortSignal.aborted) {
+                        throw new Error('REQUEST_ABORTED: Promise 실행 중 중단되었습니다');
+                    }
+                    return result;
+                }, (error) => {
+                    if (abortSignal.aborted) {
+                        throw new Error('REQUEST_ABORTED: Promise 실행 중 중단되었습니다');
+                    }
+                    throw error;
+                });
+            },
+        });
+        // Promise.resolve 패치
+        const originalResolve = global.Promise.resolve;
+        global.Promise.resolve = (value) => {
+            const abortSignal = (0, abort_1.getCurrentAbortSignal)();
+            if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                return Promise.reject(new Error('REQUEST_ABORTED: Promise.resolve가 중단되었습니다'));
+            }
+            const promise = originalResolve.call(global.Promise, value);
+            if (!abortSignal) {
+                return promise;
+            }
+            return promise.then((result) => {
+                if (abortSignal.aborted) {
+                    throw new Error('REQUEST_ABORTED: Promise.resolve 실행 중 중단되었습니다');
+                }
+                return result;
+            }, (error) => {
+                if (abortSignal.aborted) {
+                    throw new Error('REQUEST_ABORTED: Promise.resolve 실행 중 중단되었습니다');
+                }
+                throw error;
+            });
+        };
+        // Promise.reject 패치
+        const originalReject = global.Promise.reject;
+        global.Promise.reject = (reason) => {
+            const abortSignal = (0, abort_1.getCurrentAbortSignal)();
+            if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                return Promise.reject(new Error('REQUEST_ABORTED: Promise.reject가 중단되었습니다'));
+            }
+            return originalReject.call(global.Promise, reason);
+        };
+    }
+    static patchSetTimeout() {
+        this.originalSetTimeout = global.setTimeout;
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        global.setTimeout = (callback, delay, ...args) => {
+            const abortSignal = (0, abort_1.getCurrentAbortSignal)();
+            if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                throw new Error('REQUEST_ABORTED: setTimeout이 중단되었습니다');
+            }
+            const timerId = this.originalSetTimeout(() => {
+                if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                    throw new Error('REQUEST_ABORTED: setTimeout 콜백이 중단되었습니다');
+                }
+                callback(...args);
+            }, delay);
+            if (abortSignal) {
+                const abortHandler = () => {
+                    clearTimeout(timerId);
+                };
+                abortSignal.addEventListener('abort', abortHandler, { once: true });
+            }
+            return timerId;
+        };
+    }
+    static unpatch() {
+        if (!this.isPatched) {
+            return;
+        }
+        global.Promise = this.originalPromise;
+        global.setTimeout = this.originalSetTimeout;
+        this.isPatched = false;
+    }
+    /**
+     * 현재 패치 상태 확인
+     * @returns 패치 여부
+     */
+    static getPatchStatus() {
+        return this.isPatched;
+    }
+}
+exports.EnhancedPromisePatch = EnhancedPromisePatch;
+EnhancedPromisePatch.isPatched = false;

package/functions/abort/index.d.ts

@@ -0,0 +1,3 @@
+export * from './abort';
+export * from './abort-context';
+export * from './enhanced-promise-patch';

package/functions/abort/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abort"), exports);
+__exportStar(require("./abort-context"), exports);
+__exportStar(require("./enhanced-promise-patch"), exports);

package/functions/index.d.ts

@@ -4,3 +4,4 @@ export * from './amqp-publish.function';
 export * from './rewrite-file-value.function';
 export * from './amqp-call-manager.function';
 export * from './extract-redis-url.function';
+export * from './abort';

package/functions/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./amqp-publish.function"), exports);
 __exportStar(require("./rewrite-file-value.function"), exports);
 __exportStar(require("./amqp-call-manager.function"), exports);
 __exportStar(require("./extract-redis-url.function"), exports);
+__exportStar(require("./abort"), exports);

package/interceptors/logging-service.interceptor.js

@@ -188,7 +188,7 @@ let LoggingServiceInterceptor = class LoggingServiceInterceptor {
         }));
     }
 };
-LoggingServiceInterceptor = __decorate([
+exports.LoggingServiceInterceptor = LoggingServiceInterceptor;
+exports.LoggingServiceInterceptor = LoggingServiceInterceptor = __decorate([
     (0, common_1.Injectable)()
 ], LoggingServiceInterceptor);
-exports.LoggingServiceInterceptor = LoggingServiceInterceptor;

package/interceptors/rpc.interceptor.d.ts

@@ -5,6 +5,8 @@ import { GracefulShutdownService } from '../modules/graceful-shutdown/graceful-s
 export declare class RPCInterceptor implements NestInterceptor {
     private readonly reflector;
     private readonly gracefulShutdownService;
+    protected readonly DEFAULT_TIMEOUT: number;
+    protected readonly DEFAULT_TIMEOUT_MESSAGE = "\uC694\uCCAD\uC774 \uD0C0\uC784\uC544\uC6C3\uB418\uC5C8\uC2B5\uB2C8\uB2E4.";
     constructor(reflector: Reflector, gracefulShutdownService: GracefulShutdownService);
     private maxLengthOverShorten;
     /** 메시지가 재전송되었을때에, 재시도 Count가 명시되어 있지 않을때에 처리 할지 여부를 결정하는 함수 */

package/interceptors/rpc.interceptor.js

@@ -44,11 +44,9 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
 const amqplib_1 = __importDefault(require("amqplib"));
-// import Logger from '@yolo-croket-dev/logger';
 const functions_1 = require("../functions");
 const exceptions_1 = require("../exceptions");
 const graceful_shutdown_service_1 = require("../modules/graceful-shutdown/graceful-shutdown.service");
-// const logger = Logger.createLogger('RPCInterceptor');
 const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 // const MAX_CUT_LENGTH = 500;
 const MAX_LENGTH = 300;
@@ -56,6 +54,8 @@ let RPCInterceptor = class RPCInterceptor {
     constructor(reflector, gracefulShutdownService) {
         this.reflector = reflector;
         this.gracefulShutdownService = gracefulShutdownService;
+        this.DEFAULT_TIMEOUT = 1000 * 60 * 29; // 29분 타임아웃
+        this.DEFAULT_TIMEOUT_MESSAGE = '요청이 타임아웃되었습니다.';
     }
     maxLengthOverShorten(data) {
         if (typeof data !== 'string') {
@@ -146,48 +146,12 @@ let RPCInterceptor = class RPCInterceptor {
         }
         return obj;
     }
-    // private keyCutter(data: string) {
-    //   try {
-    //     if (data) {
-    //       data = JSON.parse(data);
-    //     } else {
-    //       return data;
-    //     }
-    //   } catch (err) {
-    //     return data;
-    //   }
-    //   for (const key of Object.keys(data)) {
-    //     const type = typeof data[key as any];
-    //     if (type === 'string') {
-    //       if (data[key as any].length > MAX_CUT_LENGTH) {
-    //         (data[key as any] as any) = `${data[key as any].slice(0, MAX_CUT_LENGTH)}...`;
-    //       }
-    //     } else if (type === 'object') {
-    //       if (data[key as any] === null) {
-    //         (data[key as any] as any) = null;
-    //       } else {
-    //         (data[key as any] as any) = this.keyCutter(data[key as any]);
-    //       }
-    //     }
-    //   }
-    //   return data;
-    // }
     async intercept(context, next) {
         var _a, _b, _c, _d, _e;
         const options = this.reflector.get('rpcInterceptorScope', context.getHandler());
         const args = context.getArgs();
         const arg = args[0];
         const rmq = args[1];
-        // 메시지에서 AbortController 가져오기
-        const abortController = rmq.args[0].abortController;
-        //  const messageId = (rmq as any).messageId;
-        //  if (!abortController) {
-        //    // AbortController가 없으면 기본 처리
-        //    return next.handle().pipe(
-        //      timeout(1000 * 60 * 29),
-        //      // ... 기존 로직
-        //    );
-        //  }
         const channel = rmq.getChannelRef();
         const message = rmq.getMessage();
         const now = Date.now();
@@ -204,6 +168,7 @@ let RPCInterceptor = class RPCInterceptor {
             correlationId,
             isMessageAck: false,
         };
+        const abortController = new AbortController();
         /** consume 메시지 전부 cancel */
         if (this.gracefulShutdownService.isApplicationExit) {
             msaLogger.debug('RPCInterceptor isApplicationExit called', { traceId: 'IS_APPLICATION_EXIT' });
@@ -264,13 +229,6 @@ let RPCInterceptor = class RPCInterceptor {
                 errMessage,
                 errAction,
             };
-            // const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
-            // if (isTimeoutError) {
-            //   channel.nack(message, false, true);
-            //   message.properties.replyTo = undefined; /** replyTo가 존재하면 sendToQueue가 호출되므로, 삭제해주기 */
-            //   execInterceptor.isMessageAck = true;
-            //   return EMPTY;
-            // }
             if (!Number.isNaN(staticRetryCount)
                 && staticRetryCount
                 && err.isRetry !== false) {
@@ -303,11 +261,6 @@ let RPCInterceptor = class RPCInterceptor {
             const messageContent = message.content.toString();
             /** 파일 객체 처리 */
             (0, functions_1.reWriteFileValue)((_a = messageContent === null || messageContent === void 0 ? void 0 : messageContent.data) === null || _a === void 0 ? void 0 : _a.file);
-            // logger.debug(`<= (error:${traceId}): ${JSON.stringify(sendMessage.toString())}`, {
-            //   ...logParam,
-            //   duration,
-            //   isError: true,
-            // });
             if (!noAck && !isAck) {
                 channel.ack(message);
                 execInterceptor.isMessageAck = true;
@@ -336,45 +289,20 @@ let RPCInterceptor = class RPCInterceptor {
                 return new rxjs_1.Observable();
             }
         }
-        if (content.pattern === 'UPLOAD_FILE') {
-            if (content.data.payload.file) {
-                content.data.payload.file = `${content.data.payload.file.slice(0, 30)}...`;
-            }
-            // logger.debug(`=> (${traceId}): ${JSON.stringify(this.keyCutter(JSON.stringify(content)))}`);
-        }
-        else {
-            // logger.debug(`=> (${traceId}): ${JSON.stringify(this.keyCutter(JSON.stringify(content)))}`);
-        }
         this.gracefulShutdownService.pushActiveInterceptors(execInterceptor);
         // eslint-disable-next-line consistent-return
-        return next
+        return functions_1.AbortContext.run(abortController.signal, execInterceptor.traceId, () => next
             .handle()
-            .pipe((0, operators_1.switchMap)((val) => {
-            console.log('switchMap called', val);
-            if (abortController === null || abortController === void 0 ? void 0 : abortController.signal.aborted) {
-                console.log('RPC Interceptor: Service execution aborted');
-                return (0, rxjs_1.throwError)(() => new Error('Service execution aborted'));
-            }
-            // // AbortController를 컨텍스트에 주입
-            // const request = context.switchToRpc().getData();
-            // if (request && typeof request === 'object') {
-            //   (request as any).abortController = abortController;
-            //   (request as any).abortSignal = abortController?.signal;
-            // }
-            return (0, rxjs_1.of)(val);
-        }), 
-        // timeout(1000 * 60 * 29), // 30분 타임아웃
-        (0, operators_1.timeout)(1000 * 3), // 30분 타임아웃
-        (0, operators_1.tap)({
+            .pipe((0, operators_1.timeout)({
+            each: this.DEFAULT_TIMEOUT,
+            with: () => {
+                msaLogger.error('RPCInterceptor timeout 발생', { traceId: execInterceptor.traceId }, { message: this.DEFAULT_TIMEOUT_MESSAGE });
+                abortController.abort();
+                return (0, rxjs_1.throwError)(() => new exceptions_1.InternalServerError('TIMEOUT_ERROR', this.DEFAULT_TIMEOUT_MESSAGE));
+            },
+        }), (0, operators_1.tap)({
             next: async (val) => {
-                console.log('RPC Interceptor next called');
                 val.isError = false;
-                // const duration = Date.now() - now;
-                // logger.debug(`<= (success:${traceId}): ${val.message}`, {
-                //   ...logParam,
-                //   duration,
-                //   isError: val.isError,
-                // });
                 /** 만약 응답데이터중 isRequeue가 true라면, 다시 재처리 하도록 함 */
                 if (val.data && val.data.isRequeue) {
                     channel.nack(message, false, true);
@@ -391,12 +319,8 @@ let RPCInterceptor = class RPCInterceptor {
         // eslint-disable-next-line consistent-return
         (0, operators_1.catchError)(async (err) => {
             // timeout 에러 처리
-            const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
+            const isTimeoutError = err instanceof Error && (err.name === 'TimeoutError' || err.message === this.DEFAULT_TIMEOUT_MESSAGE);
             if (isTimeoutError) {
-                if (abortController) {
-                    abortController.abort();
-                    throw new Error('Message aborted due to timeout');
-                }
                 msaLogger.error('[타임 아웃] 메시지 재전송 처리', { traceId: execInterceptor.traceId }, {
                     error: {
                         message: err.message,
@@ -426,12 +350,13 @@ let RPCInterceptor = class RPCInterceptor {
             }
         }), (0, operators_1.finalize)(() => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-        }));
+            abortController.abort();
+        })));
     }
 };
-RPCInterceptor = __decorate([
+exports.RPCInterceptor = RPCInterceptor;
+exports.RPCInterceptor = RPCInterceptor = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [core_1.Reflector,
         graceful_shutdown_service_1.GracefulShutdownService])
 ], RPCInterceptor);
-exports.RPCInterceptor = RPCInterceptor;

package/interfaces/exception.js

@@ -18,9 +18,10 @@ var ErrActionTypeEnum;
     ErrActionTypeEnum["LEGACY_SHOW_TOAST"] = "LEGACY_SHOW_TOAST";
     ErrActionTypeEnum["FORCE_UPDATE"] = "FORCE_UPDATE";
     ErrActionTypeEnum["UPDATE_ACCESS_TOKEN"] = "UPDATE_ACCESS_TOKEN";
-})(ErrActionTypeEnum = exports.ErrActionTypeEnum || (exports.ErrActionTypeEnum = {}));
+})(ErrActionTypeEnum || (exports.ErrActionTypeEnum = ErrActionTypeEnum = {}));
 class ErrAction {
 }
+exports.ErrAction = ErrAction;
 __decorate([
     (0, swagger_1.ApiProperty)({
         description: '액션 타입',
@@ -57,9 +58,9 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], ErrAction.prototype, "webViewUrl", void 0);
-exports.ErrAction = ErrAction;
 class ErrInfo {
 }
+exports.ErrInfo = ErrInfo;
 __decorate([
     (0, swagger_1.ApiProperty)({
         description: '에러 종류 식별자',
@@ -81,4 +82,3 @@ __decorate([
     }),
     __metadata("design:type", ErrAction)
 ], ErrInfo.prototype, "action", void 0);
-exports.ErrInfo = ErrInfo;

package/modules/graceful-shutdown/graceful-shutdown.module.js

@@ -25,7 +25,8 @@ let GracefulShutdownModule = class GracefulShutdownModule {
         }
     }
 };
-GracefulShutdownModule = __decorate([
+exports.GracefulShutdownModule = GracefulShutdownModule;
+exports.GracefulShutdownModule = GracefulShutdownModule = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({
         providers: [graceful_shutdown_service_1.GracefulShutdownService],
@@ -33,4 +34,3 @@ GracefulShutdownModule = __decorate([
     }),
     __metadata("design:paramtypes", [graceful_shutdown_service_1.GracefulShutdownService])
 ], GracefulShutdownModule);
-exports.GracefulShutdownModule = GracefulShutdownModule;

package/modules/graceful-shutdown/graceful-shutdown.rmq.d.ts

@@ -1,7 +1,7 @@
 import { RmqOptions, ServerRMQ } from '@nestjs/microservices';
 import { Channel } from 'amqp-connection-manager';
 import { ConsumeMessage } from 'amqplib';
-export declare type GracefulRmqOptions = RmqOptions['options'] & {
+export type GracefulRmqOptions = RmqOptions['options'] & {
     waitingEndingHandlersTimeoutMs?: number;
     waitingEndingHandlersIntervalMs?: number;
 };

package/modules/graceful-shutdown/graceful-shutdown.rmq.js

@@ -3,12 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GracefulServerRMQ = void 0;
 const microservices_1 = require("@nestjs/microservices");
 const node_util_1 = require("node:util");
-const abortable_promise_1 = require("@xuchaoqian/abortable-promise");
 const sleep = (0, node_util_1.promisify)(setTimeout);
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_TIMEOUT_MS = 5000;
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_INTERVAL_MS = 500;
-// const RMQ_DEFAULT_MESSAGE_TIMEOUT_MS = 1000 * 60 * 29; // 29분
-const RMQ_DEFAULT_MESSAGE_TIMEOUT_MS = 1000 * 2; // 2분
 class GracefulServerRMQ extends microservices_1.ServerRMQ {
     constructor(options) {
         super(options);
@@ -39,43 +36,10 @@ class GracefulServerRMQ extends microservices_1.ServerRMQ {
         }
     }
     async handleMessage(message, channel) {
-        const messageId = message.properties.messageId || message.properties.correlationId || `msg_${Date.now()}_${Math.random()}`;
-        // AbortController 생성
-        const abortController = new AbortController();
-        // 타임아웃 설정
-        setTimeout(() => {
-            console.log(`Message timeout: ${messageId}`);
-            abortController.abort(); // Abort with default reason
-        }, RMQ_DEFAULT_MESSAGE_TIMEOUT_MS);
-        console.log('timeout 설정');
         this.runningMessages += 1;
-        try {
-            // AbortController를 메시지에 추가
-            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-explicit-any
-            message.abortController = abortController;
-            // eslint-disable-next-line no-param-reassign
-            message.messageId = messageId;
-            // abort 상태 확인
-            if (abortController.signal.aborted) {
-                console.log(`Message already aborted: ${messageId}`);
-                this.runningMessages -= 1;
-                return;
-            }
-            const abortablePromise = new abortable_promise_1.AbortablePromise((0, node_util_1.promisify)(() => super.handleMessage(message, channel)), abortController.signal);
-            await abortablePromise;
-        }
-        catch (error) {
-            if (error.message.includes('Message aborted')) {
-                console.log(`Message processing aborted: ${messageId}`);
-                // abort로 인한 에러는 정상적으로 처리된 것으로 간주
-            }
-            else {
-                throw error;
-            }
-        }
-        finally {
+        return super.handleMessage(message, channel).finally(() => {
             this.runningMessages -= 1;
-        }
+        });
     }
     async close() {
         this.closing = true;

package/modules/graceful-shutdown/graceful-shutdown.service.js

@@ -137,7 +137,7 @@ let GracefulShutdownService = class GracefulShutdownService {
         });
     }
 };
-GracefulShutdownService = __decorate([
+exports.GracefulShutdownService = GracefulShutdownService;
+exports.GracefulShutdownService = GracefulShutdownService = __decorate([
     (0, common_1.Injectable)()
 ], GracefulShutdownService);
-exports.GracefulShutdownService = GracefulShutdownService;

package/modules/redis.module.js

@@ -15,10 +15,10 @@ const redisProvider = {
 };
 let RedisModule = class RedisModule {
 };
-RedisModule = __decorate([
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = __decorate([
     (0, common_1.Module)({
         providers: [redisProvider],
         exports: [redisProvider],
     })
 ], RedisModule);
-exports.RedisModule = RedisModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-croket-dev/core",
-  "version": "1.7.25-slowquery.8",
+  "version": "1.7.25",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",
@@ -15,7 +15,6 @@
   "license": "UNLICENSED",
   "dependencies": {
     "@nestjs/common": "^8.2.3",
-    "@xuchaoqian/abortable-promise": "^1.11.2",
     "@yolo-croket-dev/logger": "^1.0.15",
     "@yolo-croket-dev/msa-logger": "^3.0.4",
     "@yolo-croket-dev/redis": "^1.0.23",
@@ -27,7 +26,7 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/node": "^16.11.9",
+    "@types/node": "^24.3.1",
     "@types/randomstring": "^1.1.8",
     "@types/uuid": "^8.3.4"
   }

package/pipes/rpc-validation.pipe.js

@@ -31,8 +31,8 @@ let ValidationPipe = class ValidationPipe {
         return value;
     }
 };
-ValidationPipe = __decorate([
+exports.ValidationPipe = ValidationPipe;
+exports.ValidationPipe = ValidationPipe = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [Object])
 ], ValidationPipe);
-exports.ValidationPipe = ValidationPipe;