@dooboostore/simple-boot-http-server 1.0.27 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dooboostore/simple-boot-http-server",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -98,11 +98,11 @@
     "mime-types": "^2.1.34",
     "node-gzip": "^1.1.2",
     "ws": "^8.18.3",
-    "@dooboostore/core": "1.0.32",
-    "@dooboostore/core-node": "1.0.13",
-    "@dooboostore/core-web": "1.0.13",
-    "@dooboostore/simple-boot": "1.0.57",
-    "@dooboostore/dom-render": "1.0.114"
+    "@dooboostore/core": "1.0.33",
+    "@dooboostore/core-node": "1.0.14",
+    "@dooboostore/dom-render": "1.0.115",
+    "@dooboostore/core-web": "1.0.14",
+    "@dooboostore/simple-boot": "1.0.58"
   },
   "scripts": {
     "clean": "rm -rf dist",
@@ -121,6 +121,6 @@
     "publish:npm": "pnpm run build && cp package.json package.json.back && pnpm pack && TARBALL_NAME=$(ls dooboostore-simple-boot-http-server-*.tgz | head -n 1) && tar -xzf \"$TARBALL_NAME\" -C . --strip-components=1 package/package.json && rm \"$TARBALL_NAME\" && (pnpm publish --no-git-checks || true) && cp package.json.back package.json && rm -rf package.json.back  ",
     "ts:clean": "find . -name '*.js' -o -name '*.map' -o -name '*.d.ts' | xargs rm -f",
     "typecheck": "tsc --noEmit",
-    "test": "echo test"
+    "test": "node --import ./test/register-loader.mjs --test --test-force-exit test/index.test.ts"
   }
 }

package/src/SimpleBootHttpServer.ts

@@ -13,7 +13,7 @@ import {Filter} from './filters/Filter';
 import {ExceptionHandlerSituationType, targetExceptionHandler} from '@dooboostore/simple-boot';
 import {getInject, SituationTypeContainer, SituationTypeContainers} from '@dooboostore/simple-boot';
 import {EndPoint} from './endpoints/EndPoint';
-import {ReflectUtils} from '@dooboostore/core';
+import {ReflectUtils, ValidUtils} from '@dooboostore/core';
 import {ReqFormUrlBody} from './models/datas/body/ReqFormUrlBody';
 import {ReqJsonBody} from './models/datas/body/ReqJsonBody';
 import {ReqHeader} from './models/datas/ReqHeader';
@@ -140,6 +140,13 @@ export class SimpleBootHttpServer extends SimpleApplication {
       otherStorage.set(RequestResponse, rr);
       otherStorage.set(IncomingMessage, req);
       otherStorage.set(ServerResponse, res);
+      // 클라이언트가 응답 완료 전에 끊으면 abort. 핸들러는 파라미터 타입 AbortSignal 로 주입받아
+      // fetch/timers/events.once 등에 넘기면 대기 중이어도 바로 풀린다 (제너레이터 스트림의 이벤트 대기 누수 방지)
+      const abortController = new AbortController();
+      res.once('close', () => {
+        if (!res.writableFinished) abortController.abort();
+      });
+      otherStorage.set(AbortSignal, abortController.signal);
       try {
         transactionManager?.try();
         if (this.option.requestEndPoints) {
@@ -327,12 +334,21 @@ export class SimpleBootHttpServer extends SimpleApplication {
                   ...
                */
               const resConfig = it.config?.res;
-              if (resConfig?.manual === true) {
+              if (resConfig === 'manual') {
                 // 핸들러가 ServerResponse를 직접 주입받아 스스로 write/end를 제어한다 (예: SSE 스트리밍)
+              } else if (ValidUtils.isGenerator(data) || ValidUtils.isAsyncGenerator(data)) {
+                // 제너레이터 리턴: 헤더 먼저 보내고, yield 된 값을 하나씩 바로 body 로 흘려보낸다 (예: SSE)
+                const headers = resConfig?.header ?? {};
+                if (resConfig?.contentType) {
+                  headers[HttpHeaders.ContentType] = resConfig.contentType;
+                }
+                rr.resSetHeaders(headers);
+                rr.resSetStatusCode(resConfig?.status ?? HttpStatus.Ok);
+                await rr.resStream(data);
               } else {
                 if (it.config?.resolver) {
                   const execute = typeof it.config.resolver === 'function' ? this.simstanceManager.getOrNewSim({target: it.config.resolver}) : it.config.resolver;
-                  data = await execute?.resolve?.(data, rr);
+                  data = await execute?.resolve?.(data, rr, resConfig);
                 }
                 const status = resConfig?.status ?? HttpStatus.Ok;
                 const headers = resConfig?.header ?? {};

package/src/decorators/MethodMapping.ts

@@ -6,241 +6,233 @@ import { Mimes } from '../codes/Mimes';
 import { HttpMethod } from '../codes/HttpMethod';
 
 export enum UrlMappingSituationType {
-    REQ_JSON_BODY = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY',
-    REQ_PATH_DATA = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_PATH_DATA',
-    // REQ_URL_SEARCH_PARAMS = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_URL_SEARCH_PARAMS',
-    REQ_URL_SEARCH_PARAMS_OBJ = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_URL_SEARCH_PARAMS_OBJ',
-    REQ_FORM_URL_BODY = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY'
-}
-export type MappingConfig = {
-    method: HttpMethod | string,
-    description?: {
-        name?: string;
-        detail?: string;
-    };
+  REQ_JSON_BODY = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY',
+  REQ_PATH_DATA = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_PATH_DATA',
+  // REQ_URL_SEARCH_PARAMS = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_URL_SEARCH_PARAMS',
+  REQ_URL_SEARCH_PARAMS_OBJ = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_URL_SEARCH_PARAMS_OBJ',
+  REQ_FORM_URL_BODY = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY'
+}
+export type RequestMappingConfig = {
+  method: HttpMethod | string;
+  description?: {
+    name?: string;
+    detail?: string;
+  };
 
-    req?: {
-        contentType?: (Mimes|string)[];
-        accept?: (Mimes|string)[];
-    };
-
-    res?:
-        | {
-              status?: number;
-              header?: {[key: string]: string};
-              contentType?: Mimes | string;
-              manual?: false;
-          }
-        /**
-         * manual: true — 리턴값을 이용한 자동 status/header/body 처리(및 resolver 호출)를 건너뛴다.
-         * SSE 등 핸들러가 ServerResponse를 직접 주입받아 writeHead/write/end를 스스로 제어하는 경우 사용.
-         */
-        | { manual: true };
-    resolver?: Resolver|ConstructorType<Resolver>;
-}
-export type SaveMappingConfig = {propertyKey: string | symbol; config: MappingConfig}
+  req?: {
+    contentType?: (Mimes | string)[];
+    accept?: (Mimes | string)[];
+  };
+};
+export type ResponseMappingConfig = {
+  status?: number;
+  header?: { [key: string]: string };
+  contentType?: Mimes | string;
+};
+export type MappingConfig = (RequestMappingConfig & { res?: ResponseMappingConfig; resolver?: Resolver | ConstructorType<Resolver> }) | (RequestMappingConfig & { res: 'manual' });
+export type SaveMappingConfig = { propertyKey: string | symbol; config: MappingConfig };
 const MappingMetadataKey = Symbol.for('simple-boot-http-server:mapping-metadata');
 // const GETSMappingMetadataKey = Symbol('GET_METHODS');
 // const GETMappingMetadataKey = Symbol('GET_METHOD');
 
 const process = (config: MappingConfig, target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-    const saveMappingConfigs = (ReflectUtils.getMetadata(MappingMetadataKey, target.constructor) ?? []) as SaveMappingConfig[];
-    saveMappingConfigs.push({propertyKey, config});
-    ReflectUtils.defineMetadata(MappingMetadataKey, saveMappingConfigs, target.constructor);
-    ReflectUtils.defineMetadata(MappingMetadataKey, config, target, propertyKey);
-}
+  const saveMappingConfigs = (ReflectUtils.getMetadata(MappingMetadataKey, target.constructor) ?? []) as SaveMappingConfig[];
+  saveMappingConfigs.push({ propertyKey, config });
+  ReflectUtils.defineMetadata(MappingMetadataKey, saveMappingConfigs, target.constructor);
+  ReflectUtils.defineMetadata(MappingMetadataKey, config, target, propertyKey);
+};
 export function UrlMapping(config: MappingConfig): ReflectMethod;
 export function UrlMapping(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function UrlMapping(configOrtarget?: MappingConfig | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.GET}, configOrtarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            process(configOrtarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.GET }, configOrtarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      process(configOrtarget, target, propertyKey, descriptor);
+    };
+  }
 }
 export const getUrlMapping = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return ReflectUtils.getMetadata(MappingMetadataKey, target, propertyKey);
-}
+  return ReflectUtils.getMetadata(MappingMetadataKey, target, propertyKey);
+};
 
 export const getUrlMappings = (target: any): SaveMappingConfig[] => {
-    if (target !== null && undefined !== target && typeof target === 'object') {
-        target = target.constructor;
-    }
-    return ReflectUtils.getMetadata(MappingMetadataKey, target);
-}
+  if (target !== null && undefined !== target && typeof target === 'object') {
+    target = target.constructor;
+  }
+  return ReflectUtils.getMetadata(MappingMetadataKey, target);
+};
 export function GET(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function GET(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function GET(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.GET}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.GET;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.GET }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.GET;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getGET = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getGETS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.GET);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.GET);
+};
 export function POST(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function POST(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function POST(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.POST}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.POST;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.POST }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.POST;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getPOST = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getPOSTS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.POST);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.POST);
+};
 export function DELETE(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function DELETE(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function DELETE(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.DELETE}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.DELETE;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.DELETE }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.DELETE;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getDELETE = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getDELETES = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.DELETE);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.DELETE);
+};
 export function PUT(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function PUT(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function PUT(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.PUT}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.PUT;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.PUT }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.PUT;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getPUT = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getPUTS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.PUT);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.PUT);
+};
 export function PATCH(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function PATCH(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function PATCH(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.PATCH}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.PATCH;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.PATCH }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.PATCH;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getPATCH = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getPATCHS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.PATCH);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.PATCH);
+};
 export function OPTIONS(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function OPTIONS(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function OPTIONS(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.OPTIONS}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.OPTIONS;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.OPTIONS }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.OPTIONS;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getOPTIONS = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getOPTIONSS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.OPTIONS);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.OPTIONS);
+};
 export function HEAD(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function HEAD(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function HEAD(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.HEAD}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.HEAD;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.HEAD }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.HEAD;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getHEAD = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getHEADS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.HEAD);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.HEAD);
+};
 export function TRACE(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function TRACE(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function TRACE(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.TRACE}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.TRACE;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.TRACE }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.TRACE;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getTRACE = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getTRACES = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.TRACE);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.TRACE);
+};
 export function CONNECT(config: Omit<MappingConfig, 'method'>): ReflectMethod;
 export function CONNECT(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
 export function CONNECT(configOrTarget?: Omit<MappingConfig, 'method'> | any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor): ReflectMethod | void {
-    if (propertyKey && descriptor) {
-        process({method: HttpMethod.CONNECT}, configOrTarget, propertyKey, descriptor);
-    } else {
-        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-            configOrTarget.method = HttpMethod.CONNECT;
-            process(configOrTarget, target, propertyKey, descriptor);
-        }
-    }
+  if (propertyKey && descriptor) {
+    process({ method: HttpMethod.CONNECT }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+      configOrTarget.method = HttpMethod.CONNECT;
+      process(configOrTarget, target, propertyKey, descriptor);
+    };
+  }
 }
 
 export const getCONNECT = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
-    return getUrlMapping(target, propertyKey);
-}
+  return getUrlMapping(target, propertyKey);
+};
 export const getCONNECTS = (target: any): SaveMappingConfig[] => {
-    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.CONNECT);
-}
+  return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.CONNECT);
+};
 
 // Aliases for lowercase
 export const urlMapping = UrlMapping;

package/src/models/RequestResponse.ts

@@ -11,6 +11,7 @@ import { ReqHeader } from './datas/ReqHeader';
 import { ReqMultipartFormBody } from './datas/body/ReqMultipartFormBody';
 import { HttpStatus } from '../codes/HttpStatus';
 import { gzip } from 'node-gzip';
+import { createGzip, constants as zlibConstants } from 'zlib';
 import { SessionManager } from '../session/SessionManager';
 import { HttpServerOption } from '../option/HttpServerOption';
 import { Blob } from 'node:buffer';
@@ -557,6 +558,55 @@ export class RequestResponse {
     this.res.end();
   }
 
+  /**
+   * 헤더를 즉시 보내고, source 가 내놓는 값을 하나씩 바로 body 에 쓴 뒤 end.
+   * (SSE / 스트리밍 응답용. resWrite 는 버퍼링 후 resEnd 에서 한 번에 보내므로 스트리밍 불가)
+   * - 문자열/Buffer 는 그대로, 그 외는 JSON.stringify
+   * - Accept-Encoding 에 gzip 이 있으면 gzip 스트림으로 압축하고, 청크마다 Z_SYNC_FLUSH 로 바로 내보낸다
+   *   (flush 없이 쓰면 zlib 내부 버퍼에 모였다가 늦게 나가서 SSE 실시간성이 깨짐)
+   * - 클라이언트가 끊으면 source.return() 으로 제너레이터를 종료시켜 finally 가 돌게 한다
+   */
+  async resStream(source: Iterable<any> | AsyncIterable<any>) {
+    const res = this.res;
+    const gz = this.reqHeaderFirst(HttpHeaders.AcceptEncoding)?.includes('gzip') ? createGzip() : undefined;
+    if (gz) {
+      res.setHeader(HttpHeaders.ContentEncoding, 'gzip');
+      res.removeHeader(HttpHeaders.ContentLength);
+      gz.pipe(res);
+    }
+    const out = gz ?? res;
+    res.flushHeaders();
+    let closed = false;
+    const onClose = () => {
+      closed = true;
+      (source as any).return?.();
+    };
+    res.once('close', onClose);
+    try {
+      for await (const chunk of source) {
+        if (closed) break;
+        const data = typeof chunk === 'string' || Buffer.isBuffer(chunk) ? chunk : JSON.stringify(chunk);
+        const ok = out.write(data);
+        gz?.flush(zlibConstants.Z_SYNC_FLUSH);
+        // backpressure: 버퍼가 차면 drain(또는 연결 종료)까지 대기
+        if (!ok) await new Promise(resolve => { out.once('drain', resolve); res.once('close', resolve); });
+      }
+    } catch (e) {
+      // 클라이언트가 끊긴 뒤의 에러(AbortSignal 로 대기를 푼 AbortError 등)는 받을 상대가 없으니 삼킨다
+      if (!closed) throw e;
+    } finally {
+      res.off('close', onClose);
+      if (closed) {
+        gz?.destroy();
+      } else if (!res.writableEnded) {
+        // gzip 이면 gz.end() → pipe 가 res.end() 까지 해준다. 끝까지 흘려보낸 뒤 리턴
+        const finished = new Promise(resolve => { res.once('finish', resolve); res.once('close', resolve); });
+        out.end();
+        await finished;
+      }
+    }
+  }
+
   resIsDone() {
     return this.res.finished || this.res.writableEnded || this.res.headersSent;
   }

package/src/proxy/RequestResponseInjectProxy.ts

@@ -0,0 +1,30 @@
+import { RequestResponse } from '../models/RequestResponse';
+
+/**
+ * SSR 인프로세스 렌더용 sim 래퍼.
+ *
+ * 클라이언트는 SymbolIntentApiServiceProxy 가 HTTP 로 호출하며 IntentSchemeFilter 가
+ * intent.data 마지막에 rr(RequestResponse) 을 붙여 백서비스의 data 인자로 전달한다.
+ * 반면 SSR 은 페이지가 sim 을 인프로세스로 직접 호출(`svc.method(request)`)하므로 rr 이 없다.
+ *
+ * 이 프록시는 그 공백을 메운다 — 메서드 호출 시 넘어온 인자 **뒤에 rr 을 붙여준다**.
+ * IntentSchemeFilter 규약과 동일하게:
+ *   - 인자 0개 → (rr)            // 본문·쿼리 없는 요청과 동일
+ *   - 인자 1개 → (request, rr)   // 일반 서비스 호출
+ *   - 인자 N개 → (...args, rr)   // 이미 data 를 넘겼으면 그건 그대로 쓰이고 rr 은 뒤에 무시됨
+ *
+ * 백서비스 메서드가 `data?: RequestResponse` 옵셔널이라 fn.length 로 arity 를 못 재므로
+ * (옵셔널은 length 에서 제외) "메서드 파라미터 수"가 아니라 "호출 인자 뒤 append" 방식을 쓴다.
+ *
+ * constructor / 비함수 프로퍼티는 감싸지 않는다 — Sim 이 it.constructor 로 타입·메타데이터를 찾기 때문.
+ * rr 이 없으면(비SSR) 인자를 그대로 흘려보낸다.
+ */
+export const injectRequestResponse = <T extends object>(sim: T, rr?: RequestResponse): T =>
+  new Proxy(sim, {
+    get(target: any, prop: string | symbol) {
+      const value = target[prop];
+      if (prop === 'constructor' || typeof value !== 'function') return value;
+      if (!rr) return value.bind(target);
+      return (...args: any[]) => value.apply(target, [...args, rr]);
+    }
+  });

package/src/proxy/SymbolIntentApiServiceProxy.ts

@@ -40,7 +40,7 @@ export  const  createHandler = <T extends object>(apiService: ApiService): Proxy
                   fetch: {
                     credentials: 'include',
                     headers: headers,
-                    body: ConvertUtils.toFormData(userConfig?.body)
+                    body: userConfig?.body ? ConvertUtils.toFormData(userConfig.body) : undefined
                   }
                 }
               });

package/src/proxy/index.ts

@@ -1,3 +1,4 @@
 export * from './SymbolIntentApiServiceProxy';
 export * from './SymbolIntentApiServiceProxyBase';
 export * from './TopicProtocolApiServiceProxy';
+export * from './RequestResponseInjectProxy';

package/src/resolvers/Resolver.ts

@@ -1,5 +1,6 @@
 import {RequestResponse} from '../models/RequestResponse';
+import { ResponseMappingConfig } from '../decorators';
 
 export interface Resolver<T = any> {
-    resolve(data: T, rr: RequestResponse): Promise<void>;
+  resolve(data: T, rr: RequestResponse, responseMappingConfig: ResponseMappingConfig): Promise<void>;
 }