@dooboostore/simple-boot-http-server 1.0.19 → 1.0.21

package/src/decorators/MethodMapping.ts

@@ -0,0 +1,233 @@
+import { ConstructorType } from '@dooboostore/core/types';
+import { ReflectMethod } from '@dooboostore/simple-boot/types/Types';
+import { ReflectUtils } from '@dooboostore/core/reflect/ReflectUtils';
+import { Resolver } from '../resolvers/Resolver';
+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_FORM_URL_BODY = 'SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY'
+}
+export type MappingConfig = {
+    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;
+    }
+    resolver?: Resolver|ConstructorType<Resolver>;
+}
+export type SaveMappingConfig = {propertyKey: string | symbol; config: MappingConfig}
+const MappingMetadataKey = Symbol('MappingMetadataKey');
+// 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);
+}
+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);
+        }
+    }
+}
+export const getUrlMapping = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    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);
+}
+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);
+        }
+    }
+}
+
+export const getGET = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getGETS = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getPOST = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getPOSTS = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getDELETE = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getDELETES = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getPUT = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getPUTS = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getPATCH = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getPATCHS = (target: any): SaveMappingConfig[] => {
+    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.GET);
+}
+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);
+        }
+    }
+}
+
+export const getOPTIONS = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getOPTIONSS = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getHEAD = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getHEADS = (target: any): SaveMappingConfig[] => {
+    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.GET);
+}
+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);
+        }
+    }
+}
+
+export const getTRACE = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getTRACES = (target: any): SaveMappingConfig[] => {
+    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);
+        }
+    }
+}
+
+export const getCONNECT = (target: any, propertyKey: string | symbol): MappingConfig | undefined => {
+    return getUrlMapping(target, propertyKey);
+}
+export const getCONNECTS = (target: any): SaveMappingConfig[] => {
+    return getUrlMappings(target)?.filter(it => it.config?.method.toUpperCase() === HttpMethod.CONNECT);
+}

package/src/decorators/index.ts

@@ -0,0 +1 @@
+export * from './MethodMapping';

package/src/endpoints/CrossDomainHeaderEndPoint.ts

@@ -0,0 +1,38 @@
+import {EndPoint} from './EndPoint';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+import {RequestResponse} from '../models/RequestResponse';
+import { HttpHeaders } from '../codes/HttpHeaders';
+
+export type CrossDomainHeaderEndPointConfig = {
+    accessControlAllowOrigin?: string | string[],
+    accessControlAllowMethods?: string | string[],
+    accessControlAllowHeaders?: string | string[],
+    accessControlExposeHeaders?: string | string[]
+}
+export class CrossDomainHeaderEndPoint implements EndPoint {
+    constructor(private config?: CrossDomainHeaderEndPointConfig) {
+    }
+
+    /*
+        rr.resSetHeader("Access-Control-Allow-Origin", "*")
+        rr.resSetHeader("Access-Control-Allow-Methods", "DELETE, POST, GET, OPTIONS")
+        rr.resSetHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
+     */
+    async endPoint(rr: RequestResponse, app: SimpleBootHttpServer) {
+        if (this.config?.accessControlAllowOrigin) {
+            rr.resSetHeader(HttpHeaders.AccessControlAllowOrigin, Array.isArray(this.config.accessControlAllowOrigin) ? this.config.accessControlAllowOrigin.join(', ') : this.config.accessControlAllowOrigin);
+        }
+        if (this.config?.accessControlAllowMethods) {
+            rr.resSetHeader(HttpHeaders.AccessControlAllowMethods, Array.isArray(this.config.accessControlAllowMethods) ? this.config.accessControlAllowMethods.join(', ') : this.config.accessControlAllowMethods);
+        }
+        if (this.config?.accessControlAllowHeaders) {
+            rr.resSetHeader(HttpHeaders.AccessControlAllowHeaders, Array.isArray(this.config.accessControlAllowHeaders) ? this.config.accessControlAllowHeaders.join(', ') : this.config.accessControlAllowHeaders);
+        }
+        if (this.config?.accessControlExposeHeaders) {
+            rr.resSetHeader(HttpHeaders.AccessControlExposeHeaders, Array.isArray(this.config.accessControlExposeHeaders) ? this.config.accessControlExposeHeaders.join(', ') : this.config.accessControlExposeHeaders);
+        }
+    }
+
+    async onInit(app: SimpleBootHttpServer) {
+    }
+}

package/src/endpoints/EndPoint.ts

@@ -0,0 +1,7 @@
+import {RequestResponse} from '../models/RequestResponse';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+import {OnInit} from '../lifecycle/OnInit';
+
+export interface EndPoint extends OnInit {
+    endPoint(rr: RequestResponse, app: SimpleBootHttpServer): Promise<any>;
+}

package/src/endpoints/HeaderEndPoint.ts

@@ -0,0 +1,17 @@
+import {EndPoint} from './EndPoint';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+import {RequestResponse} from '../models/RequestResponse';
+
+export class HeaderEndPoint implements EndPoint {
+    constructor(private headers?: { [key: string]: string | string[] }) {
+    }
+
+    async endPoint(rr: RequestResponse, app: SimpleBootHttpServer) {
+        if (this.headers) {
+            rr.resSetHeaders(this.headers);
+        }
+    }
+
+    async onInit(app: SimpleBootHttpServer) {
+    }
+}

package/{dist/esm/endpoints/index.d.ts → src/endpoints/index.ts}

@@ -1,4 +1,3 @@
 export * from './CrossDomainHeaderEndPoint';
 export * from './EndPoint';
 export * from './HeaderEndPoint';
-//# sourceMappingURL=index.d.ts.map

package/src/errors/BadRequestError.ts

@@ -0,0 +1,8 @@
+import {HttpError} from './HttpError';
+import {HttpStatus} from '../codes/HttpStatus';
+
+export class BadRequestError extends HttpError {
+    constructor({status = HttpStatus.BadRequest, message = 'Bad Request'}: {status?: number, message?: string} = {}) {
+        super({status, message});
+    }
+}

package/src/errors/ForbiddenError.ts

@@ -0,0 +1,8 @@
+import {HttpError} from './HttpError';
+import {HttpStatus} from '../codes/HttpStatus';
+
+export class ForbiddenError extends HttpError {
+    constructor({status = HttpStatus.Forbidden, message = 'Forbidden'}: {status?: number, message?: string} = {}) {
+        super({status, message});
+    }
+}

package/src/errors/HttpError.ts

@@ -0,0 +1,14 @@
+
+export class HttpError {
+    name: string = 'Error'
+    message: string;
+    stack?: string
+    data?: any;
+    public status: number;
+
+    constructor({status, message = 'HttpError'}: { status: number, message?: string }) {
+        // super(message);
+        this.message = message;
+        this.status = status;
+    }
+}

package/src/errors/InternalServerError.ts

@@ -0,0 +1,8 @@
+import {HttpError} from './HttpError';
+import {HttpStatus} from '../codes/HttpStatus';
+
+export class InternalServerError extends HttpError {
+    constructor({status = HttpStatus.InternalServerError, message = 'Internal Server Error'}: {status?: number, message?: string} = {}) {
+        super({status, message});
+    }
+}

package/src/errors/NotFoundError.ts

@@ -0,0 +1,8 @@
+import {HttpError} from './HttpError';
+import {HttpStatus} from '../codes/HttpStatus';
+
+export class NotFoundError extends HttpError {
+    constructor({status = HttpStatus.NotFound, message = 'Not Found'}: {status?: number, message?: string} = {}) {
+        super({status, message});
+    }
+}

package/src/errors/UnauthorizedError.ts

@@ -0,0 +1,8 @@
+import {HttpError} from './HttpError';
+import {HttpStatus} from '../codes/HttpStatus';
+
+export class UnauthorizedError extends HttpError {
+    constructor({status = HttpStatus.Unauthorized, message = 'Unauthorized'}: {status?: number, message?: string} = {}) {
+        super({status, message});
+    }
+}

package/{dist/esm/errors/index.d.ts → src/errors/index.ts}

@@ -4,4 +4,3 @@ export * from './HttpError';
 export * from './InternalServerError';
 export * from './NotFoundError';
 export * from './UnauthorizedError';
-//# sourceMappingURL=index.d.ts.map

package/src/filters/CacheFilter.ts

@@ -0,0 +1,169 @@
+import { Filter } from '../filters/Filter';
+import { HttpStatus } from '../codes/HttpStatus';
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import * as fs from 'fs';
+import * as path from 'path';
+import {  FileUtils } from '@dooboostore/core-node/file/FileUtils';
+import { ConvertUtils } from '@dooboostore/core-node/convert/ConvertUtils';
+import { RandomUtils } from '@dooboostore/core/random/RandomUtils';
+
+export type CacheFilterSessionType = { key: string, lifeTime: number, isUpdate: boolean, responseHeaders?: string[] };
+
+type CacheConfigCacheItemType = { path: string, createTime: number, lifeTime: number, responseHeader: { [key: string]: string | number | string[] } };
+
+type KeyAndConfig = { key: string, lifeTime?: number, responseHeaders?: string[] } ;
+
+export class CacheFilter implements Filter {
+  public static readonly CARRIER_KEY_NAME = '_CARRIER_CACHE_FILTER_KEY_NAME';
+  private storage = new Map<string, string | Buffer>();
+  private cacheConfig: {
+    createDate: string;
+    updateDate: string;
+    caches: { [key: string]: CacheConfigCacheItemType }
+  }
+
+  constructor(private config: {
+    config: {
+      cacheDir?: string;
+      lifeTime: number;
+      startUpClean?: boolean;
+    },
+    filter?: (rr: RequestResponse, app: SimpleBootHttpServer) => boolean;
+    key: (rr: RequestResponse, app: SimpleBootHttpServer) => KeyAndConfig;
+  }) {
+
+    if (config.config.cacheDir && config.config.startUpClean) {
+      FileUtils.deleteSync(config.config.cacheDir, {options: {recursive: true}});
+    }
+  }
+
+  async onInit(app: SimpleBootHttpServer) {
+  }
+
+  async proceedBefore({rr, app, carrier}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+    // this.key = undefined;
+    // this.lifeTime = undefined;
+    // this.isUpdate = false;
+    const filter = this.config.filter?.(rr,app);
+    if (!filter) {
+      return true;
+    }
+    if (this.config.config.cacheDir) {
+      FileUtils.mkdirSync(this.config.config.cacheDir, {recursive: true});
+    }
+    if (!this.cacheConfig && this.config.config.cacheDir) {
+      try {
+        this.cacheConfig = JSON.parse(ConvertUtils.toString(FileUtils.readSync([this.config.config.cacheDir, 'cacheConfig.json'], { option: {encoding: 'utf-8'}})));
+      } catch (e) {
+      }
+    }
+    const date = new Date().toISOString();
+    this.cacheConfig ??= {
+      createDate: date,
+      updateDate: date,
+      // accessDate: date,
+      caches: {}
+    };
+    this.cacheConfig.createDate ??= date;
+    this.cacheConfig.updateDate ??= date;
+    // this.cacheConfig.accessDate ??= date;
+    this.cacheConfig.caches ??= {};
+
+
+    const rkey = this.config.key(rr, app);
+    // console.log('--path filter', rr.reqMethod(), rr.reqUrlPathName, filter, rkey)
+    const sessionData: CacheFilterSessionType = {key: rkey.key, lifeTime: rkey.lifeTime ?? this.config.config.lifeTime, isUpdate: false, responseHeaders: rkey.responseHeaders};
+
+
+    const cache = this.cacheConfig.caches[sessionData.key];
+    if (cache) {
+      const existes = this.config.config.cacheDir ? FileUtils.existsSync(cache.path) : this.storage.has(cache.path);
+      const diffTime = Date.now() - cache.createTime;
+      if (!existes || diffTime > cache.lifeTime) {
+        delete this.cacheConfig[sessionData.key];
+        this.deleteChunk(cache.path);
+        sessionData.isUpdate = true;
+      } else {
+        rr.resSetHeaders({
+          ...cache.responseHeader,
+          cacheFilter: `true;remainTime=${cache.lifeTime - diffTime}`
+        });
+        // console.log('chunk--->',  cache.path);
+        try {
+          const chunk = this.getChunk(cache.path);
+        // console.log('chunk--->',  chunk);
+        await rr.resEnd(chunk);
+        } catch (e) {
+          console.log('--------e', e)
+        }
+      }
+    } else {
+      sessionData.isUpdate = true;
+    }
+    carrier.set(CacheFilter.CARRIER_KEY_NAME, sessionData);
+    return sessionData.isUpdate;
+  }
+
+  private deleteChunk(path: string) {
+    if (this.config.config.cacheDir && FileUtils.existsSync(path)) {
+      FileUtils.deleteFileSync(path);
+    } else if (this.storage.has(path)) {
+      this.storage.delete(path);
+    }
+  }
+
+  private getChunk(path: string) {
+    return this.config.config.cacheDir ? FileUtils.readSync(path) : this.storage.get(path);
+  }
+
+  async proceedAfter({rr, app, carrier}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+    // const data = await rr.resBodyStringData()
+    const sessionData = carrier.get(CacheFilter.CARRIER_KEY_NAME) as CacheFilterSessionType ;
+    if (sessionData && sessionData.isUpdate) {
+      try {
+        if (this.config.config.cacheDir) {
+          FileUtils.mkdirSync([this.config.config.cacheDir, 'caches'], {recursive: true});
+        }
+        const resBody = rr.resBodyData();
+        if (!resBody) {
+          return true;
+        }
+        let  p: string | undefined = undefined;
+        const destFileUUID = RandomUtils.uuid4();
+        p = this.writeChunk(destFileUUID, resBody);
+        const updateDateNow = Date.now();
+        const updateDate = new Date(updateDateNow).toISOString();
+        this.cacheConfig.createDate ??= updateDate;
+        this.cacheConfig.updateDate = updateDate;
+        const responseHeaders: {[key: string]: string | number | string[]} = {}
+        sessionData.responseHeaders?.map(it=>it.toLowerCase()).forEach(it => {
+          responseHeaders[it] = rr.resHeader(it);
+        })
+        this.cacheConfig.caches[sessionData.key] = {
+          path: p,
+          createTime: updateDateNow,
+          lifeTime: sessionData.lifeTime,
+          responseHeader: responseHeaders
+        };
+
+        if (this.config.config.cacheDir) {
+          FileUtils.write(JSON.stringify(this.cacheConfig), {path: [this.config.config.cacheDir, 'cacheConfig.json']});
+        }
+      } catch (e) {
+        console.log('---', e)
+      }
+    }
+
+    return true;
+  }
+
+  private writeChunk(destFileUUID: string, resBody: string | Buffer ) {
+    if (this.config.config.cacheDir) {
+      return FileUtils.write(resBody, {path: [this.config.config.cacheDir, 'caches', destFileUUID]});
+    } else {
+      this.storage.set(destFileUUID, resBody);
+      return destFileUUID;
+    }
+  }
+}

package/src/filters/Filter.ts

@@ -0,0 +1,10 @@
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import {RequestResponse} from '../models/RequestResponse';
+import {OnInit} from '../lifecycle/OnInit';
+
+export interface Filter extends OnInit {
+    // false  뒤로는 안흐르게 해주세요
+    // true  나를 스킵스켜주새요 (내뒤로 흐르게해주세요)
+    proceedBefore(data: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}): Promise<boolean>;
+    proceedAfter(data: {rr: RequestResponse, app: SimpleBootHttpServer, before: boolean, carrier: Map<string, any>}): Promise<boolean>;
+}

package/src/filters/HttpStatusFilter.ts

@@ -0,0 +1,24 @@
+import {Filter} from '../filters/Filter';
+import {HttpStatus} from '../codes/HttpStatus';
+import {RequestResponse} from '../models/RequestResponse';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+
+export class HttpStatusFilter implements Filter {
+
+    constructor(private httpStatus: HttpStatus | number) {
+    }
+
+    async proceedBefore({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        // res.writeHead(this.httpStatus);
+        rr.resStatusCode(this.httpStatus);
+        rr.resEnd();
+        return false;
+    }
+
+    async proceedAfter({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        return true;
+    }
+
+    async onInit(app: SimpleBootHttpServer){
+    }
+}