@yolo-croket-dev/core 1.7.31 → 1.7.32-slowquery.1

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 export declare class AbortContext {
     private static asyncLocalStorage;
+    private static contextCounter;
     static run<T>(abortSignal: AbortSignal, requestId: string, callback: () => T): T;
     static getCurrentAbortSignal(): AbortSignal | null;
     static getCurrentRequestId(): string | null;

package/functions/abort/abort-context.js

@@ -7,7 +7,8 @@ class AbortContext {
         const currentContext = this.asyncLocalStorage.getStore();
         const newContext = {
             abortSignal,
-            requestId,
+            // eslint-disable-next-line no-plusplus
+            requestId: `ctx_${++this.contextCounter}_${Date.now()}`,
             createdAt: Date.now(),
             parentContext: currentContext || undefined,
         };
@@ -57,3 +58,4 @@ class AbortContext {
 }
 exports.AbortContext = AbortContext;
 AbortContext.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+AbortContext.contextCounter = 0;

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

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

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

@@ -8,41 +8,145 @@ class ContextPromisePatch {
             return;
         }
         this.originalPromise = global.Promise;
-        // Promise 생성자 패치 - 컨텍스트가 있을 때만 동작
+        this.patchPromise();
+        this.patchSetTimeout();
+        this.isPatched = true;
+    }
+    static patchPromise() {
+        // 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가 중단되었습니다'));
+                const contextId = currentContext.requestId;
+                // 이미 중단된 경우
+                if (abortSignal.aborted) {
+                    return Promise.reject(new Error(`REQUEST_ABORTED: Promise가 중단되었습니다 (${contextId})`));
                 }
-                // eslint-disable-next-line new-cap
                 const promise = Reflect.construct(target, args);
-                // 컨텍스트가 있는 경우에만 중단 확인 추가
+                // Promise 체인에 자동으로 중단 확인 추가
                 return promise.then((result) => {
+                    // 컨텍스트가 여전히 유효한지 확인
+                    const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
+                    if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
+                        // 컨텍스트가 변경되었으면 원본 결과 반환
+                        return result;
+                    }
                     if (abortSignal.aborted) {
-                        throw new Error('REQUEST_ABORTED: Promise 실행 중 중단되었습니다');
+                        throw new Error(`REQUEST_ABORTED: Promise 실행 중 중단되었습니다 (${contextId})`);
                     }
                     return result;
                 }, (error) => {
+                    // 컨텍스트가 여전히 유효한지 확인
+                    const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
+                    if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
+                        // 컨텍스트가 변경되었으면 원본 에러 반환
+                        throw error;
+                    }
                     if (abortSignal.aborted) {
-                        throw new Error('REQUEST_ABORTED: Promise 실행 중 중단되었습니다');
+                        throw new Error(`REQUEST_ABORTED: Promise 실행 중 중단되었습니다 (${contextId})`);
                     }
                     throw error;
                 });
             },
         });
-        this.isPatched = true;
+        // Promise.resolve 패치
+        const originalResolve = global.Promise.resolve;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        global.Promise.resolve = (value) => {
+            const currentContext = abort_context_1.AbortContext.getCurrentContext();
+            if (!currentContext) {
+                return originalResolve.call(global.Promise, value);
+            }
+            const abortSignal = currentContext.abortSignal;
+            const contextId = currentContext.requestId;
+            if (abortSignal.aborted) {
+                return Promise.reject(new Error(`REQUEST_ABORTED: Promise.resolve가 중단되었습니다 (${contextId})`));
+            }
+            const promise = originalResolve.call(global.Promise, value);
+            return promise.then((result) => {
+                const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
+                if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
+                    return result;
+                }
+                if (abortSignal.aborted) {
+                    throw new Error(`REQUEST_ABORTED: Promise.resolve 실행 중 중단되었습니다 (${contextId})`);
+                }
+                return result;
+            }, (error) => {
+                const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
+                if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
+                    throw error;
+                }
+                if (abortSignal.aborted) {
+                    throw new Error(`REQUEST_ABORTED: Promise.resolve 실행 중 중단되었습니다 (${contextId})`);
+                }
+                throw error;
+            });
+        };
+        // Promise.reject 패치
+        const originalReject = global.Promise.reject;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        global.Promise.reject = (reason) => {
+            const currentContext = abort_context_1.AbortContext.getCurrentContext();
+            if (!currentContext) {
+                return originalReject.call(global.Promise, reason);
+            }
+            const abortSignal = currentContext.abortSignal;
+            if (abortSignal.aborted) {
+                return Promise.reject(new Error(`REQUEST_ABORTED: Promise.reject가 중단되었습니다 (${currentContext.requestId})`));
+            }
+            return originalReject.call(global.Promise, reason);
+        };
+    }
+    static patchSetTimeout() {
+        this.originalSetTimeout = global.setTimeout;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        global.setTimeout = (callback, delay, ...args) => {
+            const currentContext = abort_context_1.AbortContext.getCurrentContext();
+            if (!currentContext) {
+                return this.originalSetTimeout(callback, delay, ...args);
+            }
+            const abortSignal = currentContext.abortSignal;
+            const contextId = currentContext.requestId;
+            if (abortSignal.aborted) {
+                throw new Error(`REQUEST_ABORTED: setTimeout이 중단되었습니다 (${contextId})`);
+            }
+            const wrappedCallback = () => {
+                // 컨텍스트가 여전히 유효한지 확인
+                const currentContextCheck = abort_context_1.AbortContext.getCurrentContext();
+                if (!currentContextCheck || currentContextCheck.requestId !== contextId) {
+                    // 컨텍스트가 변경되었으면 원본 콜백 실행
+                    // eslint-disable-next-line prefer-spread
+                    callback.apply(null, args);
+                    return;
+                }
+                if (abortSignal.aborted) {
+                    throw new Error(`REQUEST_ABORTED: setTimeout 콜백이 중단되었습니다 (${contextId})`);
+                }
+                // eslint-disable-next-line prefer-spread
+                callback.apply(null, args);
+            };
+            const timerId = this.originalSetTimeout(wrappedCallback, delay, ...args);
+            // 중단 이벤트 리스너 등록
+            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;
     }
 }

package/package.json

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