@yolo-croket-dev/core 1.7.25-slowquery.39 → 1.7.25-slowquery.4

package/functions/index.d.ts

@@ -4,4 +4,3 @@ 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,4 +20,3 @@ __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 {
         }));
     }
 };
-exports.LoggingServiceInterceptor = LoggingServiceInterceptor;
-exports.LoggingServiceInterceptor = LoggingServiceInterceptor = __decorate([
+LoggingServiceInterceptor = __decorate([
     (0, common_1.Injectable)()
 ], LoggingServiceInterceptor);
+exports.LoggingServiceInterceptor = LoggingServiceInterceptor;

package/interceptors/rpc.interceptor.d.ts

@@ -5,8 +5,6 @@ import { GracefulShutdownService } from '../modules/graceful-shutdown/graceful-s
 export declare class RPCInterceptor implements NestInterceptor {
     private readonly reflector;
     private readonly gracefulShutdownService;
-    protected readonly DEFAULT_TIMEOUT = 1000;
-    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,9 +44,11 @@ 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;
@@ -54,9 +56,6 @@ let RPCInterceptor = class RPCInterceptor {
     constructor(reflector, gracefulShutdownService) {
         this.reflector = reflector;
         this.gracefulShutdownService = gracefulShutdownService;
-        this.DEFAULT_TIMEOUT = 1000; // 29분 타임아웃
-        // protected readonly DEFAULT_TIMEOUT = 1000 * 60 * 29; // 29분 타임아웃
-        this.DEFAULT_TIMEOUT_MESSAGE = '요청이 타임아웃되었습니다.';
     }
     maxLengthOverShorten(data) {
         if (typeof data !== 'string') {
@@ -147,12 +146,48 @@ 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();
@@ -169,7 +204,6 @@ 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' });
@@ -230,6 +264,13 @@ 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) {
@@ -262,6 +303,11 @@ 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;
@@ -290,20 +336,46 @@ 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 functions_1.AbortContext.run(abortController.signal, execInterceptor.traceId, () => next
+        return next
             .handle()
-            .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)({
+            .pipe(
+        // AbortController 신호 감지
+        (0, operators_1.takeUntil)(new rxjs_1.Observable(subscriber => {
+            const abortHandler = () => {
+                console.log('RPC Interceptor abortHandler called');
+                subscriber.next();
+                subscriber.complete();
+            };
+            console.log('RPC Interceptor abortHandler addEventListener');
+            abortController.signal.addEventListener('abort', abortHandler, { once: true });
+            // 정리 함수
+            return () => {
+                abortController.signal.removeEventListener('abort', abortHandler);
+            };
+        })), 
+        // timeout(1000 * 60 * 29), // 30분 타임아웃
+        (0, operators_1.timeout)(1000 * 30), // 30분 타임아웃
+        (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);
@@ -320,8 +392,12 @@ 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' || err.message === this.DEFAULT_TIMEOUT_MESSAGE);
+            const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
             if (isTimeoutError) {
+                if (abortController) {
+                    abortController.abort();
+                    throw new Error('Message aborted due to timeout');
+                }
                 msaLogger.error('[타임 아웃] 메시지 재전송 처리', { traceId: execInterceptor.traceId }, {
                     error: {
                         message: err.message,
@@ -351,13 +427,12 @@ let RPCInterceptor = class RPCInterceptor {
             }
         }), (0, operators_1.finalize)(() => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-            abortController.abort();
-        })));
+        }));
     }
 };
-exports.RPCInterceptor = RPCInterceptor;
-exports.RPCInterceptor = RPCInterceptor = __decorate([
+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,10 +18,9 @@ var ErrActionTypeEnum;
     ErrActionTypeEnum["LEGACY_SHOW_TOAST"] = "LEGACY_SHOW_TOAST";
     ErrActionTypeEnum["FORCE_UPDATE"] = "FORCE_UPDATE";
     ErrActionTypeEnum["UPDATE_ACCESS_TOKEN"] = "UPDATE_ACCESS_TOKEN";
-})(ErrActionTypeEnum || (exports.ErrActionTypeEnum = ErrActionTypeEnum = {}));
+})(ErrActionTypeEnum = exports.ErrActionTypeEnum || (exports.ErrActionTypeEnum = {}));
 class ErrAction {
 }
-exports.ErrAction = ErrAction;
 __decorate([
     (0, swagger_1.ApiProperty)({
         description: '액션 타입',
@@ -58,9 +57,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: '에러 종류 식별자',
@@ -82,3 +81,4 @@ __decorate([
     }),
     __metadata("design:type", ErrAction)
 ], ErrInfo.prototype, "action", void 0);
+exports.ErrInfo = ErrInfo;

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

@@ -25,8 +25,7 @@ let GracefulShutdownModule = class GracefulShutdownModule {
         }
     }
 };
-exports.GracefulShutdownModule = GracefulShutdownModule;
-exports.GracefulShutdownModule = GracefulShutdownModule = __decorate([
+GracefulShutdownModule = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({
         providers: [graceful_shutdown_service_1.GracefulShutdownService],
@@ -34,3 +33,4 @@ exports.GracefulShutdownModule = 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 type GracefulRmqOptions = RmqOptions['options'] & {
+export declare type GracefulRmqOptions = RmqOptions['options'] & {
     waitingEndingHandlersTimeoutMs?: number;
     waitingEndingHandlersIntervalMs?: number;
 };
@@ -17,4 +17,5 @@ export declare class GracefulServerRMQ extends ServerRMQ {
     protected waitingHandlers(): Promise<void>;
     handleMessage(message: ConsumeMessage, channel: Channel): Promise<void>;
     close(): Promise<void>;
+    private executeWithAbortSignal;
 }

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

@@ -6,6 +6,8 @@ const node_util_1 = require("node:util");
 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);
@@ -36,10 +38,43 @@ 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();
+        }, RMQ_DEFAULT_MESSAGE_TIMEOUT_MS);
+        console.log('timeout 설정');
         this.runningMessages += 1;
-        return super.handleMessage(message, channel).finally(() => {
+        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;
+            }
+            // Promise.withResolvers를 사용하여 abort signal 감지
+            await this.executeWithAbortSignal(() => super.handleMessage(message, channel), abortController);
+        }
+        catch (error) {
+            if (error.message.includes('Message aborted')) {
+                console.log(`Message processing aborted: ${messageId}`);
+                // abort로 인한 에러는 정상적으로 처리된 것으로 간주
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
             this.runningMessages -= 1;
-        });
+        }
     }
     async close() {
         this.closing = true;
@@ -55,5 +90,58 @@ class GracefulServerRMQ extends microservices_1.ServerRMQ {
         this.runningMessages = 0;
         super.close();
     }
+    // Promise.withResolvers를 사용한 abort signal 감지
+    async executeWithAbortSignal(task, abortController) {
+        // Promise.withResolvers 사용
+        const { promise, resolve, reject } = Promise.withResolvers();
+        let isAborted = false;
+        let isResolved = false;
+        // eslint-disable-next-line no-undef
+        let checkInterval = null;
+        // Abort 이벤트 리스너
+        const abortHandler = () => {
+            if (!isResolved) {
+                isAborted = true;
+                console.log('Abort signal detected');
+                if (checkInterval)
+                    clearInterval(checkInterval);
+                reject(new Error('Message aborted'));
+            }
+        };
+        // Abort signal 이벤트 리스너 등록
+        // eslint-disable-next-line no-undef
+        abortController.signal.addEventListener('abort', abortHandler, { once: true });
+        // 매우 짧은 간격으로 abort 상태 확인
+        checkInterval = setInterval(() => {
+            if (abortController.signal.aborted && !isResolved) {
+                isAborted = true;
+                clearInterval(checkInterval);
+                // eslint-disable-next-line no-undef
+                abortController.signal.removeEventListener('abort', abortHandler);
+                reject(new Error('Message aborted'));
+            }
+        }, 1); // 1ms마다 확인
+        // 원본 task 실행
+        task()
+            .then((result) => {
+            if (!isAborted && !isResolved) {
+                isResolved = true;
+                if (checkInterval)
+                    clearInterval(checkInterval);
+                abortController.signal.removeEventListener('abort', abortHandler);
+                resolve(result);
+            }
+        })
+            .catch((error) => {
+            if (!isAborted && !isResolved) {
+                isResolved = true;
+                if (checkInterval)
+                    clearInterval(checkInterval);
+                abortController.signal.removeEventListener('abort', abortHandler);
+                reject(error);
+            }
+        });
+        return promise;
+    }
 }
 exports.GracefulServerRMQ = GracefulServerRMQ;

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

@@ -137,7 +137,7 @@ let GracefulShutdownService = class GracefulShutdownService {
         });
     }
 };
-exports.GracefulShutdownService = GracefulShutdownService;
-exports.GracefulShutdownService = GracefulShutdownService = __decorate([
+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 {
 };
-exports.RedisModule = RedisModule;
-exports.RedisModule = RedisModule = __decorate([
+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.39",
+  "version": "1.7.25-slowquery.4",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",
@@ -26,7 +26,7 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/node": "^24.3.1",
+    "@types/node": "^16.11.9",
     "@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;
     }
 };
-exports.ValidationPipe = ValidationPipe;
-exports.ValidationPipe = ValidationPipe = __decorate([
+ValidationPipe = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [Object])
 ], ValidationPipe);
+exports.ValidationPipe = ValidationPipe;

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

@@ -1,33 +0,0 @@
-/// <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

@@ -1,47 +0,0 @@
-"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

@@ -1,55 +0,0 @@
-/// <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

@@ -1,231 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-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

@@ -1,115 +0,0 @@
-"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

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

package/functions/abort/index.js

@@ -1,19 +0,0 @@
-"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);