@yolo-croket-dev/core 1.7.30 → 1.7.31

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

@@ -1,33 +1,19 @@
 /// <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;
+    /**
+     * 컨텍스트가 유효한지 확인
+     */
+    static isContextValid(): boolean;
+    /**
+     * 컨텍스트 디버깅 정보
+     */
+    static getDebugInfo(): any;
 }

package/functions/abort/abort-context.js

@@ -2,45 +2,57 @@
 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({
+        const currentContext = this.asyncLocalStorage.getStore();
+        const newContext = {
             abortSignal,
             requestId,
-        }, callback);
+            createdAt: Date.now(),
+            parentContext: currentContext || undefined,
+        };
+        return this.asyncLocalStorage.run(newContext, 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;
     }
+    static getCurrentContext() {
+        const context = this.asyncLocalStorage.getStore();
+        if (context) {
+            return {
+                abortSignal: context.abortSignal,
+                requestId: context.requestId,
+            };
+        }
+        return null;
+    }
     /**
-     * 현재 컨텍스트 정보를 가져옴
-     * @returns 현재 컨텍스트 또는 null
+     * 컨텍스트가 유효한지 확인
      */
-    static getCurrentContext() {
-        return this.asyncLocalStorage.getStore() || null;
+    static isContextValid() {
+        const context = this.asyncLocalStorage.getStore();
+        return !!((context === null || context === void 0 ? void 0 : context.abortSignal) && (context === null || context === void 0 ? void 0 : context.requestId));
+    }
+    /**
+     * 컨텍스트 디버깅 정보
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static getDebugInfo() {
+        var _a;
+        const context = this.asyncLocalStorage.getStore();
+        return {
+            hasContext: !!context,
+            requestId: context === null || context === void 0 ? void 0 : context.requestId,
+            hasSignal: !!(context === null || context === void 0 ? void 0 : context.abortSignal),
+            isAborted: (_a = context === null || context === void 0 ? void 0 : context.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted,
+            createdAt: context === null || context === void 0 ? void 0 : context.createdAt,
+            age: context ? Date.now() - context.createdAt : 0,
+        };
     }
 }
 exports.AbortContext = AbortContext;

package/functions/abort/abort.js

@@ -39,30 +39,38 @@ exports.throwIfAborted = throwIfAborted;
  */
 function withAbortSignal(promise, abortSignal) {
     const signal = abortSignal || getCurrentAbortSignal();
+    const currentContext = abort_context_1.AbortContext.getCurrentContext();
     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);
-        });
+        // Promise 실행 - 컨텍스트 전파 보장
+        const processPromise = async () => {
+            try {
+                const result = await promise;
+                signal.removeEventListener('abort', abortHandler);
+                resolve(result);
+            }
+            catch (error) {
+                signal.removeEventListener('abort', abortHandler);
+                reject(error);
+            }
+        };
+        // 현재 컨텍스트가 있으면 전파
+        if (currentContext) {
+            abort_context_1.AbortContext.run(currentContext.abortSignal, currentContext.requestId, processPromise);
+        }
+        else {
+            processPromise();
+        }
     });
 }
 exports.withAbortSignal = withAbortSignal;

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

@@ -0,0 +1,6 @@
+export declare class ContextPromisePatch {
+    private static originalPromise;
+    private static isPatched;
+    static patch(): void;
+    static unpatch(): void;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextPromisePatch = void 0;
+const abort_context_1 = require("./abort-context");
+class ContextPromisePatch {
+    static patch() {
+        if (this.isPatched) {
+            return;
+        }
+        this.originalPromise = global.Promise;
+        // Promise 생성자 패치 - 컨텍스트가 있을 때만 동작
+        global.Promise = new Proxy(global.Promise, {
+            construct(target, args) {
+                const currentContext = abort_context_1.AbortContext.getCurrentContext();
+                // 컨텍스트가 없으면 원본 Promise 사용
+                if (!currentContext) {
+                    return Reflect.construct(target, args);
+                }
+                const abortSignal = currentContext.abortSignal;
+                if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                    return Promise.reject(new Error('REQUEST_ABORTED: Promise가 중단되었습니다'));
+                }
+                // eslint-disable-next-line new-cap
+                const promise = Reflect.construct(target, args);
+                // 컨텍스트가 있는 경우에만 중단 확인 추가
+                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;
+                });
+            },
+        });
+        this.isPatched = true;
+    }
+    static unpatch() {
+        if (!this.isPatched) {
+            return;
+        }
+        global.Promise = this.originalPromise;
+        this.isPatched = false;
+    }
+}
+exports.ContextPromisePatch = ContextPromisePatch;
+ContextPromisePatch.isPatched = false;

package/interceptors/rpc.interceptor.d.ts

@@ -7,6 +7,7 @@ export declare class RPCInterceptor implements NestInterceptor {
     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.";
+    private static isPatched;
     constructor(reflector: Reflector, gracefulShutdownService: GracefulShutdownService);
     private maxLengthOverShorten;
     /** 메시지가 재전송되었을때에, 재시도 Count가 명시되어 있지 않을때에 처리 할지 여부를 결정하는 함수 */

package/interceptors/rpc.interceptor.js

@@ -34,6 +34,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var RPCInterceptor_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPCInterceptor = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -46,11 +47,12 @@ const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
 const amqplib_1 = __importDefault(require("amqplib"));
 const functions_1 = require("../functions");
 const exceptions_1 = require("../exceptions");
+const context_promise_patch_1 = require("../functions/abort/context-promise-patch");
 const graceful_shutdown_service_1 = require("../modules/graceful-shutdown/graceful-shutdown.service");
 const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 // const MAX_CUT_LENGTH = 500;
 const MAX_LENGTH = 300;
-let RPCInterceptor = class RPCInterceptor {
+let RPCInterceptor = RPCInterceptor_1 = class RPCInterceptor {
     constructor(reflector, gracefulShutdownService) {
         this.reflector = reflector;
         this.gracefulShutdownService = gracefulShutdownService;
@@ -274,6 +276,7 @@ let RPCInterceptor = class RPCInterceptor {
             }
             const sendMessage = Buffer.from(JSON.stringify(abstractAmqpHandlerData));
             if (!isAck) {
+                const currentContext = functions_1.AbortContext.getCurrentContext();
                 // 에러 전달
                 msaLogger.error('에러 응답 전송 처리', { traceId: execInterceptor.traceId }, {
                     error: {
@@ -285,6 +288,7 @@ let RPCInterceptor = class RPCInterceptor {
                         staticRetryCount,
                     },
                     messagePattern: method,
+                    currentContext: currentContext && currentContext.requestId ? currentContext.requestId : null,
                 });
                 channel.sendToQueue(message.properties.replyTo, sendMessage, { correlationId: message.properties.correlationId });
             }
@@ -319,6 +323,10 @@ let RPCInterceptor = class RPCInterceptor {
                 return new rxjs_1.Observable();
             }
         }
+        if (!RPCInterceptor_1.isPatched) {
+            context_promise_patch_1.ContextPromisePatch.patch();
+            RPCInterceptor_1.isPatched = true;
+        }
         this.gracefulShutdownService.pushActiveInterceptors(execInterceptor);
         // eslint-disable-next-line consistent-return
         return functions_1.AbortContext.run(abortController.signal, execInterceptor.traceId, () => next
@@ -358,7 +366,8 @@ let RPCInterceptor = class RPCInterceptor {
     }
 };
 exports.RPCInterceptor = RPCInterceptor;
-exports.RPCInterceptor = RPCInterceptor = __decorate([
+RPCInterceptor.isPatched = false;
+exports.RPCInterceptor = RPCInterceptor = RPCInterceptor_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [core_1.Reflector,
         graceful_shutdown_service_1.GracefulShutdownService])

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

@@ -1,28 +1,51 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GracefulShutdownModule = void 0;
 const common_1 = require("@nestjs/common");
+const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
 const graceful_shutdown_service_1 = require("./graceful-shutdown.service");
+const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 let GracefulShutdownModule = class GracefulShutdownModule {
     constructor(gracefulShutdownService) {
         this.gracefulShutdownService = gracefulShutdownService;
     }
     async onModuleDestroy() {
-        // GracefulShutdownService가 완료될 때까지 대기
-        while (this.gracefulShutdownService.getActiveInterceptorsCount() > 0) {
-            await new Promise(resolve => {
-                setTimeout(() => resolve(), 100);
-            });
-        }
+        // onApplicationShutdown에서 모든 activeInterceptors 완료를 기다림
+        // 이렇게 하면 onModuleDestroy가 호출되기 전에 모든 이벤트가 처리됨
+        await this.gracefulShutdownService.waitForActiveInterceptors();
+        msaLogger.info('GracefulShutdownService.onModuleDestroy: all interceptors finished, shutting down', { traceId: 'ON_MODULE_DESTROY' });
     }
 };
 exports.GracefulShutdownModule = GracefulShutdownModule;

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

@@ -18,6 +18,6 @@ export declare class GracefulShutdownService implements OnApplicationShutdown, O
     getShutdownStatus(): boolean;
     onApplicationShutdown(signal?: string): Promise<void>;
     onModuleDestroy(): Promise<void>;
-    private waitForActiveInterceptors;
+    waitForActiveInterceptors(): Promise<void>;
 }
 export {};

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

@@ -80,10 +80,6 @@ let GracefulShutdownService = class GracefulShutdownService {
         this.shutdownSignal = signal;
         this.isApplicationExit = true;
         msaLogger.debug(`GracefulShutdownService.onApplicationShutdown signal=${signal}`, { traceId: 'ON_APPLICATION_SHUTDOWN' });
-        // onApplicationShutdown에서 모든 activeInterceptors 완료를 기다림
-        // 이렇게 하면 onModuleDestroy가 호출되기 전에 모든 이벤트가 처리됨
-        await this.waitForActiveInterceptors();
-        msaLogger.info('GracefulShutdownService.onApplicationShutdown: all interceptors finished, shutting down', { traceId: 'ON_APPLICATION_SHUTDOWN' });
         // 모든 이벤트 처리 완료 후 종료
         process.exit(0);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-croket-dev/core",
-  "version": "1.7.30",
+  "version": "1.7.31",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",