@yolo-croket-dev/core 1.7.44-slowquery.5 → 1.7.44-slowquery.6

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

@@ -7,10 +7,15 @@ export declare class ContextPromisePatch {
     private static originalClearInterval;
     private static contextTimers;
     private static timerContextMap;
+    private static contextPromises;
     /**
      * 특정 컨텍스트의 모든 타이머 정리
      */
     static clearContextTimers(contextId: string): void;
+    /**
+     * 특정 컨텍스트의 모든 Promise가 완료될 때까지 대기
+     */
+    static waitForContextPromises(contextId: string): Promise<void>;
     static patch(): void;
     private static patchPromise;
     private static patchTimeouts;

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

@@ -17,6 +17,16 @@ class ContextPromisePatch {
             this.contextTimers.delete(contextId);
         }
     }
+    /**
+     * 특정 컨텍스트의 모든 Promise가 완료될 때까지 대기
+     */
+    static async waitForContextPromises(contextId) {
+        const promises = this.contextPromises.get(contextId);
+        if (promises && promises.size > 0) {
+            // 모든 Promise가 완료될 때까지 기다림
+            await Promise.allSettled(Array.from(promises));
+        }
+    }
     static patch() {
         if (this.isPatched) {
             return;
@@ -47,8 +57,45 @@ class ContextPromisePatch {
                     return Promise.reject(new Error(`REQUEST_ABORTED: Promise가 중단되었습니다 (${contextId})`));
                 }
                 const promise = Reflect.construct(target, args);
+                // abort 이벤트 리스너 추가하여 Promise를 즉시 reject
+                const wrappedPromise = new Promise((resolve, reject) => {
+                    const checkAbort = () => {
+                        if (abortSignal.aborted) {
+                            reject(new Error(`REQUEST_ABORTED: Promise가 중단되었습니다 (${contextId})`));
+                        }
+                    };
+                    // abort 이벤트 리스너 등록
+                    abortSignal.addEventListener('abort', checkAbort);
+                    // 원본 promise가 완료될 때까지 기다림
+                    promise
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        .then((result) => {
+                        abortSignal.removeEventListener('abort', checkAbort);
+                        resolve(result);
+                    })
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        .catch((error) => {
+                        abortSignal.removeEventListener('abort', checkAbort);
+                        reject(error);
+                    });
+                    // 이미 abort된 경우
+                    if (abortSignal.aborted) {
+                        abortSignal.removeEventListener('abort', checkAbort);
+                        reject(new Error(`REQUEST_ABORTED: Promise가 중단되었습니다 (${contextId})`));
+                    }
+                });
+                // Promise 추적 추가
+                if (!ContextPromisePatch.contextPromises.has(contextId)) {
+                    ContextPromisePatch.contextPromises.set(contextId, new Set());
+                }
+                ContextPromisePatch.contextPromises.get(contextId).add(wrappedPromise);
+                // Promise 완료 시 추적에서 제거
+                wrappedPromise.finally(() => {
+                    var _a;
+                    (_a = ContextPromisePatch.contextPromises.get(contextId)) === null || _a === void 0 ? void 0 : _a.delete(wrappedPromise);
+                });
                 // Promise 체인에 자동으로 중단 확인 추가
-                return promise.then((result) => {
+                return wrappedPromise.then((result) => {
                     // 컨텍스트가 여전히 유효한지 확인
                     const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
                     if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
@@ -289,3 +336,6 @@ ContextPromisePatch.contextTimers = new Map();
 // timerId -> contextId 매핑
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ContextPromisePatch.timerContextMap = new Map();
+// 컨텍스트별 활성 Promise 추적
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ContextPromisePatch.contextPromises = new Map();

package/interceptors/rpc.interceptor.js

@@ -355,15 +355,14 @@ let RPCInterceptor = class RPCInterceptor {
                 }
             },
             error: localErrorProcessor,
-        }), (0, operators_1.finalize)(() => {
+        }), (0, operators_1.finalize)(async () => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
             // 활성 타이머를 모두 정리
             context_promise_patch_1.ContextPromisePatch.clearContextTimers(execInterceptor.traceId);
             abortController = null;
-            // disable을 충분히 지연시켜서 모든 이벤트 리스너가 완료될 때까지 기다림
-            setTimeout(() => {
-                functions_1.AbortContext.disable();
-            }, 100);
+            // 모든 Promise가 완료될 때까지 기다림
+            await context_promise_patch_1.ContextPromisePatch.waitForContextPromises(execInterceptor.traceId);
+            functions_1.AbortContext.disable();
             return rxjs_1.EMPTY;
         })));
     }

package/package.json

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