@yolo-croket-dev/core 1.7.25-slowquery.29 → 1.7.25-slowquery.3

package/decorators/index.d.ts

@@ -1,3 +1,2 @@
 export * from './rpc-interceptor-scope.decorator';
 export * from './rpc-transform.decorator';
-export * from './abort-event.decorator';

package/decorators/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./rpc-interceptor-scope.decorator"), exports);
 __exportStar(require("./rpc-transform.decorator"), exports);
-__exportStar(require("./abort-event.decorator"), exports);

package/functions/index.d.ts

@@ -4,5 +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';
-export * from './abort-context';

package/functions/index.js

@@ -20,5 +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);
-__exportStar(require("./abort-context"), 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,32 +336,39 @@ 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: () => {
-                console.log('RPCInterceptor timeout 발생');
-                msaLogger.error('RPCInterceptor timeout 발생', { traceId: execInterceptor.traceId }, { message: this.DEFAULT_TIMEOUT_MESSAGE });
-                abortController.abort();
-                return (0, rxjs_1.throwError)(() => new Error(this.DEFAULT_TIMEOUT_MESSAGE));
-            },
-        }), (0, operators_1.catchError)((error) => {
-            // eslint-disable-next-line no-console
-            console.log('AbortInterceptor: 에러 발생', {
-                error: error.message,
-                isAborted: abortController.signal.aborted,
-            });
-            // abort된 경우와 일반 에러를 구분
-            if (abortController.signal.aborted) {
-                // 추가되어야 하는가?
-                return (0, rxjs_1.throwError)(() => new Error(`REQUEST_ABORTED: ${this.DEFAULT_TIMEOUT_MESSAGE}`));
-            }
-            return (0, rxjs_1.throwError)(() => error);
-        }), (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}`, {
@@ -339,9 +392,12 @@ let RPCInterceptor = class RPCInterceptor {
         // eslint-disable-next-line consistent-return
         (0, operators_1.catchError)(async (err) => {
             // timeout 에러 처리
-            console.log('RPCInterceptor catchError 발생', err);
-            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,
@@ -371,12 +427,12 @@ let RPCInterceptor = class RPCInterceptor {
             }
         }), (0, operators_1.finalize)(() => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-        })));
+        }));
     }
 };
-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;
 };

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,58 @@ 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();
+        // 타임아웃 설정
+        const timeoutId = setTimeout(() => {
+            console.log(`Message timeout: ${messageId}`);
+            abortController.abort();
+        }, RMQ_DEFAULT_MESSAGE_TIMEOUT_MS);
+        console.log('timeout 설정', timeoutId);
         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.race를 사용하여 abort와 handleMessage 경쟁
+            const handleMessagePromise = super.handleMessage(message, channel);
+            const abortPromise = new Promise((_, reject) => {
+                // 1초마다 abort 상태를 확인
+                const interval = setInterval(() => {
+                    if (abortController.signal.aborted) {
+                        reject(new Error(`Message aborted: ${messageId}`));
+                        clearInterval(interval);
+                    }
+                }, 1000);
+            });
+            // 둘 중 하나가 먼저 완료되면 그 결과를 반환
+            await Promise.race([
+                handleMessagePromise,
+                abortPromise,
+            ]);
+        }
+        catch (error) {
+            if (error.message.includes('Message aborted')) {
+                console.log(`Message processing aborted: ${messageId}`);
+                // abort로 인한 에러는 정상적으로 처리된 것으로 간주
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
             this.runningMessages -= 1;
-        });
+            clearTimeout(timeoutId);
+        }
     }
     async close() {
         this.closing = true;

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.29",
+  "version": "1.7.25-slowquery.3",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",

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/decorators/abort-event.decorator.d.ts

@@ -1,4 +0,0 @@
-/**
- * 이벤트 기반으로 AbortSignal을 감지하는 데코레이터 (Interval 없음)
- */
-export declare function AbortEvent(): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/decorators/abort-event.decorator.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbortEvent = void 0;
-// src/modules/rpc-testing/decorators/abort-event.decorator.ts
-const abort_1 = require("../functions/abort");
-/**
- * 이벤트 기반으로 AbortSignal을 감지하는 데코레이터 (Interval 없음)
- */
-function AbortEvent() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        // eslint-disable-next-line no-param-reassign
-        descriptor.value = async function (...args) {
-            const abortSignal = (0, abort_1.getCurrentAbortSignal)();
-            if (!abortSignal) {
-                return originalMethod.apply(this, args);
-            }
-            if (abortSignal.aborted) {
-                throw new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다');
-            }
-            // 중단 확인을 위한 인터벌
-            const intervalId = setInterval(() => {
-                if (abortSignal.aborted) {
-                    clearInterval(intervalId);
-                    throw new Error('REQUEST_ABORTED: 작업이 중단되었습니다');
-                }
-            }, 1000);
-            try {
-                const result = await originalMethod.apply(this, args);
-                clearInterval(intervalId);
-                return result;
-            }
-            catch (error) {
-                clearInterval(intervalId);
-                throw error;
-            }
-        };
-        return descriptor;
-    };
-}
-exports.AbortEvent = AbortEvent;

package/functions/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-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.d.ts

@@ -1,60 +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>;
-/**
- * 현재 컨텍스트 정보를 로깅하는 디버그 함수
- * @param message 로그 메시지
- */
-export declare function logAbortContext(message: string): void;
-/**
- * 이벤트 기반으로 중단 가능한 Promise 실행
- * @param promise 원본 Promise
- * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
- * @returns 중단 가능한 Promise
- */
-export declare function withAbortSignalEventBased<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T>;

package/functions/abort.js

@@ -1,246 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withAbortSignalEventBased = exports.logAbortContext = 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;
-/**
- * 현재 컨텍스트 정보를 로깅하는 디버그 함수
- * @param message 로그 메시지
- */
-function logAbortContext(message) {
-    var _a;
-    const context = abort_context_1.AbortContext.getCurrentContext();
-    // eslint-disable-next-line no-console
-    console.log(`[AbortContext] ${message}`, {
-        requestId: context === null || context === void 0 ? void 0 : context.requestId,
-        isAborted: (_a = context === null || context === void 0 ? void 0 : context.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted,
-        hasSignal: !!(context === null || context === void 0 ? void 0 : context.abortSignal),
-    });
-}
-exports.logAbortContext = logAbortContext;
-/**
- * 이벤트 기반으로 중단 가능한 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;