@dooboostore/simple-boot-http-server 1.0.24 → 1.0.26

package/src/proxy/TopicProtocolApiServiceProxy.ts

@@ -1,7 +1,7 @@
-import { getSim, Sim } from '@dooboostore/simple-boot';
+import { getSim, sim, SimConfig } from '@dooboostore/simple-boot';
 import { HttpHeaders } from '../codes/HttpHeaders';
 import { ApiService } from '@dooboostore/simple-boot';
-import { RandomUtils } from '@dooboostore/core';
+import { ConstructorType, RandomUtils } from '@dooboostore/core';
 import { HttpFetcherTarget } from '@dooboostore/core';
 
 export type TopicProtocolConfig<TBody = unknown> = {
@@ -26,303 +26,288 @@ type TopicProtocolRequest<TBody = unknown> = {
 type FileEntry = { id: string; file: Blob; filename?: string };
 type MixedPart = { headers: Record<string, string>; body: Uint8Array };
 
-@Sim
-export class TopicProtocolApiServiceProxy<T extends object> implements ProxyHandler<T> {
-  constructor(private apiService: ApiService) {}
+// ── Helpers (module-level, mirrors SymbolIntentApiServiceProxy pattern) ──────
 
-  private static isFileValue(value: unknown): value is File | Blob | ArrayBuffer | Uint8Array {
-    if (typeof File !== 'undefined' && value instanceof File) {
-      return true;
-    }
-    if (typeof Blob !== 'undefined' && value instanceof Blob) {
-      return true;
-    }
-    if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
-      return true;
-    }
-    if (typeof Uint8Array !== 'undefined' && value instanceof Uint8Array) {
-      return true;
-    }
-    return false;
-  }
+const isFileValue = (value: unknown): value is File | Blob | ArrayBuffer | Uint8Array => {
+  if (typeof File !== 'undefined' && value instanceof File) return true;
+  if (typeof Blob !== 'undefined' && value instanceof Blob) return true;
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) return true;
+  if (typeof Uint8Array !== 'undefined' && value instanceof Uint8Array) return true;
+  return false;
+};
 
-  private static toFileEntry(value: File | Blob | ArrayBuffer | Uint8Array, id: string): FileEntry | undefined {
-    if (typeof Blob === 'undefined') {
-      return undefined;
-    }
-    if (typeof File !== 'undefined' && value instanceof File) {
-      const blob = new Blob([value], { type: value.type });
-      return { id, file: blob, filename: value.name };
-    }
-    if (value instanceof Blob) {
-      return { id, file: value };
-    }
-    const view = value instanceof Uint8Array ? value : new Uint8Array(value);
-    const safe = value instanceof Uint8Array ? new Uint8Array(value) : new Uint8Array(view);
-    const blob = new Blob([safe]);
-    return { id, file: blob };
+const toFileEntry = (value: File | Blob | ArrayBuffer | Uint8Array, id: string): FileEntry | undefined => {
+  if (typeof Blob === 'undefined') return undefined;
+  if (typeof File !== 'undefined' && value instanceof File) {
+    return { id, file: new Blob([value], { type: value.type }), filename: value.name };
   }
+  if (value instanceof Blob) return { id, file: value };
+  const safe = value instanceof Uint8Array ? new Uint8Array(value) : new Uint8Array(value);
+  return { id, file: new Blob([safe]) };
+};
 
-  private static buildRequest<TBody>(target: string, body?: TBody, type: TopicProtocolType = 'intent') {
-    const fileEntries: FileEntry[] = [];
-    let fileIndex = 0;
+const buildRequest = <TBody>(target: string, body?: TBody, type: TopicProtocolType = 'intent') => {
+  const fileEntries: FileEntry[] = [];
+  let fileIndex = 0;
 
-    const registerFile = (value: File | Blob | ArrayBuffer | Uint8Array): string | undefined => {
-      const id = `f${++fileIndex}`;
-      const entry = TopicProtocolApiServiceProxy.toFileEntry(value, id);
-      if (entry) {
-        fileEntries.push(entry);
-        return id;
-      }
-      return undefined;
-    };
-
-    const replaceFiles = (value: unknown): unknown => {
-      if (TopicProtocolApiServiceProxy.isFileValue(value)) {
-        const id = registerFile(value);
-        if (id) {
-          return { $file: id };
-        }
-        return value;
-      }
-      if (Array.isArray(value)) {
-        return value.map(item => replaceFiles(item));
-      }
-      if (value && typeof value === 'object') {
-        const result: Record<string, unknown> = {};
-        Object.keys(value).forEach(key => {
-          result[key] = replaceFiles((value as Record<string, unknown>)[key]);
-        });
-        return result;
-      }
-      return value;
-    };
-
-    const payload = replaceFiles(body);
-    const request: TopicProtocolRequest<TBody> = {
-      type,
-      target,
-      requestUUID: RandomUtils.uuid4(),
-      body: payload as TBody,
-      files: fileEntries.length > 0 ? fileEntries.map(entry => ({ id: entry.id })) : undefined
-    };
-
-    return { request, fileEntries };
-  }
+  const registerFile = (value: File | Blob | ArrayBuffer | Uint8Array): string | undefined => {
+    const id = `f${++fileIndex}`;
+    const entry = toFileEntry(value, id);
+    if (entry) { fileEntries.push(entry); return id; }
+    return undefined;
+  };
 
-  private static async parseMultipartMixed(response: Response) {
-    const contentType = response.headers.get('Content-Type') ?? '';
-    const boundaryMatch = contentType.match(/boundary=([^;]+)/i);
-    if (!boundaryMatch) {
-      return undefined;
+  const replaceFiles = (value: unknown): unknown => {
+    if (isFileValue(value)) {
+      const id = registerFile(value);
+      return id ? { $file: id } : value;
     }
-    const boundary = boundaryMatch[1].replace(/^"|"$/g, '');
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    const boundaryBytes = new TextEncoder().encode(`--${boundary}`);
-    const endBoundaryBytes = new TextEncoder().encode(`--${boundary}--`);
-    const separator = new TextEncoder().encode('\r\n\r\n');
-
-    const indexOf = (source: Uint8Array, needle: Uint8Array, from = 0) => {
-      for (let i = from; i <= source.length - needle.length; i++) {
-        let matched = true;
-        for (let j = 0; j < needle.length; j++) {
-          if (source[i + j] !== needle[j]) {
-            matched = false;
-            break;
-          }
-        }
-        if (matched) {
-          return i;
-        }
-      }
-      return -1;
-    };
-
-    const parts: MixedPart[] = [];
-    let cursor = indexOf(buffer, boundaryBytes, 0);
-    while (cursor !== -1) {
-      const nextBoundary = indexOf(buffer, boundaryBytes, cursor + boundaryBytes.length);
-      const endBoundary = indexOf(buffer, endBoundaryBytes, cursor + boundaryBytes.length);
-      const isFinal = endBoundary !== -1 && (endBoundary < nextBoundary || nextBoundary === -1);
-      const partStart = cursor + boundaryBytes.length;
-      if (isFinal) {
-        break;
-      }
-      let headerStart = partStart;
-      if (buffer[headerStart] === 13 && buffer[headerStart + 1] === 10) {
-        headerStart += 2;
-      }
-      const headerEnd = indexOf(buffer, separator, headerStart);
-      if (headerEnd === -1) {
-        break;
-      }
-      const headerText = new TextDecoder().decode(buffer.slice(headerStart, headerEnd));
-      const headers: Record<string, string> = {};
-      headerText.split('\r\n').forEach(line => {
-        const idx = line.indexOf(':');
-        if (idx > -1) {
-          const key = line.slice(0, idx).trim().toLowerCase();
-          headers[key] = line.slice(idx + 1).trim();
-        }
+    if (Array.isArray(value)) return value.map(item => replaceFiles(item));
+    if (value && typeof value === 'object') {
+      const result: Record<string, unknown> = {};
+      Object.keys(value).forEach(key => {
+        result[key] = replaceFiles((value as Record<string, unknown>)[key]);
       });
-      const bodyStart = headerEnd + separator.length;
-      const bodyEnd = nextBoundary === -1 ? buffer.length : nextBoundary - 2;
-      const body = buffer.slice(bodyStart, bodyEnd);
-      parts.push({ headers, body });
-      cursor = nextBoundary;
+      return result;
     }
+    return value;
+  };
 
-    return { boundary, parts };
-  }
+  const payload = replaceFiles(body);
+  const request: TopicProtocolRequest<TBody> = {
+    type,
+    target,
+    requestUUID: RandomUtils.uuid4(),
+    body: payload as TBody,
+    files: fileEntries.length > 0 ? fileEntries.map(e => ({ id: e.id })) : undefined,
+  };
 
-  private static parseDispositionFilename(disposition?: string) {
-    if (!disposition) {
-      return undefined;
-    }
-    const match = disposition.match(/filename=\"?([^\";]+)\"?/i);
-    return match ? match[1] : undefined;
-  }
+  return { request, fileEntries };
+};
 
-  private static parseDispositionName(disposition?: string) {
-    if (!disposition) {
-      return undefined;
-    }
-    const match = disposition.match(/name=\"?([^\";]+)\"?/i);
-    return match ? match[1] : undefined;
-  }
+const parseDispositionName = (disposition?: string) => {
+  const match = disposition?.match(/name=\"?([^\";]+)\"?/i);
+  return match ? match[1] : undefined;
+};
+
+const parseDispositionFilename = (disposition?: string) => {
+  const match = disposition?.match(/filename=\"?([^\";]+)\"?/i);
+  return match ? match[1] : undefined;
+};
 
-  private static replaceFileRefs(value: unknown, fileMap: Map<string, { name?: string; mime?: string; size: number; buffer: ArrayBuffer }>) {
-    if (value && typeof value === 'object' && '$file' in value) {
-      const fileKey = (value as { $file?: unknown }).$file;
-      if (typeof fileKey === 'string') {
-        const file = fileMap.get(fileKey);
-        if (file) {
-          return file;
-        }
+const parseMultipartMixed = async (response: Response) => {
+  const contentType = response.headers.get('Content-Type') ?? '';
+  const boundaryMatch = contentType.match(/boundary=([^;]+)/i);
+  if (!boundaryMatch) return undefined;
+
+  const boundary = boundaryMatch[1].replace(/^"|"$/g, '');
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const boundaryBytes = new TextEncoder().encode(`--${boundary}`);
+  const endBoundaryBytes = new TextEncoder().encode(`--${boundary}--`);
+  const separator = new TextEncoder().encode('\r\n\r\n');
+
+  const indexOf = (source: Uint8Array, needle: Uint8Array, from = 0) => {
+    for (let i = from; i <= source.length - needle.length; i++) {
+      let matched = true;
+      for (let j = 0; j < needle.length; j++) {
+        if (source[i + j] !== needle[j]) { matched = false; break; }
       }
+      if (matched) return i;
     }
-    if (Array.isArray(value)) {
-      return value.map(item => TopicProtocolApiServiceProxy.replaceFileRefs(item, fileMap));
-    }
-    if (value && typeof value === 'object') {
-      const result: Record<string, unknown> = {};
-      Object.keys(value).forEach(key => {
-        result[key] = TopicProtocolApiServiceProxy.replaceFileRefs((value as Record<string, unknown>)[key], fileMap);
-      });
-      return result;
+    return -1;
+  };
+
+  const parts: MixedPart[] = [];
+  let cursor = indexOf(buffer, boundaryBytes, 0);
+
+  while (cursor !== -1) {
+    const nextBoundary = indexOf(buffer, boundaryBytes, cursor + boundaryBytes.length);
+    const endBoundary  = indexOf(buffer, endBoundaryBytes, cursor + boundaryBytes.length);
+    const isFinal = endBoundary !== -1 && (endBoundary < nextBoundary || nextBoundary === -1);
+    const partStart = cursor + boundaryBytes.length;
+    if (isFinal) break;
+
+    let headerStart = partStart;
+    if (buffer[headerStart] === 13 && buffer[headerStart + 1] === 10) headerStart += 2;
+
+    const headerEnd = indexOf(buffer, separator, headerStart);
+    if (headerEnd === -1) break;
+
+    const headerText = new TextDecoder().decode(buffer.slice(headerStart, headerEnd));
+    const headers: Record<string, string> = {};
+    headerText.split('\r\n').forEach(line => {
+      const idx = line.indexOf(':');
+      if (idx > -1) headers[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
+    });
+
+    const bodyStart = headerEnd + separator.length;
+    const bodyEnd   = nextBoundary === -1 ? buffer.length : nextBoundary - 2;
+    parts.push({ headers, body: buffer.slice(bodyStart, bodyEnd) });
+    cursor = nextBoundary;
+  }
+
+  return { boundary, parts };
+};
+
+const replaceFileRefs = (
+  value: unknown,
+  fileMap: Map<string, { name?: string; mime?: string; size: number; buffer: ArrayBuffer }>,
+): unknown => {
+  if (value && typeof value === 'object' && '$file' in value) {
+    const fileKey = (value as { $file?: unknown }).$file;
+    if (typeof fileKey === 'string') {
+      const file = fileMap.get(fileKey);
+      if (file) return file;
     }
-    return value;
   }
+  if (Array.isArray(value)) return value.map(item => replaceFileRefs(item, fileMap));
+  if (value && typeof value === 'object') {
+    const result: Record<string, unknown> = {};
+    Object.keys(value).forEach(key => {
+      result[key] = replaceFileRefs((value as Record<string, unknown>)[key], fileMap);
+    });
+    return result;
+  }
+  return value;
+};
 
-  private static normalizeResponse(value: unknown) {
-    if (value && typeof value === 'object' && 'state' in value && 'body' in value) {
-      const typed = value as { state?: string; body?: unknown };
-      if (typed.state === 'error') {
-        const message = typeof typed.body === 'object' && typed.body && 'message' in typed.body ? String((typed.body as { message?: unknown }).message) : 'TopicProtocol error';
-        throw new Error(message);
-      }
-      return typed.body;
+const normalizeResponse = (value: unknown): unknown => {
+  if (value && typeof value === 'object' && 'state' in value && 'body' in value) {
+    const typed = value as { state?: string; body?: unknown };
+    if (typed.state === 'error') {
+      const message = typeof typed.body === 'object' && typed.body && 'message' in typed.body
+        ? String((typed.body as { message?: unknown }).message)
+        : 'TopicProtocol error';
+      throw new Error(message);
     }
-    return value;
+    return typed.body;
   }
+  return value;
+};
+
+// ── createHandler (module-level export, same as SymbolIntentApiServiceProxy) ─
+
+export const createTopicHandler = <T extends object>(apiService: ApiService): ProxyHandler<T> => {
+  return {
+    get(target: T, prop: string | symbol, receiver: unknown): unknown {
+      if (prop === '_SimpleBoot_origin') return target;
+
+      const simConfig = getSim(target);
+      const value = Reflect.get(target, prop, receiver);
+
+      if (typeof value === 'function' && simConfig?.symbol) {
+        return function (...args: unknown[]) {
+          const f = value as Function;
+
+          const p = (userConfig?: TopicProtocolConfig) => {
+            const symbolValue = Array.isArray(simConfig.symbol) ? simConfig.symbol[0] : simConfig.symbol;
+            const symbolName  = (symbolValue as Symbol | undefined)?.description ?? String(symbolValue ?? simConfig.symbol);
+            const targetPath  = `Symbol.for(${symbolName}):/${String(prop)}`;
+
+            const { request, fileEntries } = buildRequest(targetPath, userConfig?.body, userConfig?.type ?? 'intent');
+
+            const formData = new FormData();
+            formData.append('body', JSON.stringify(request));
+            fileEntries.forEach(entry => {
+              if (entry.filename) formData.append(entry.id, entry.file, entry.filename);
+              else                formData.append(entry.id, entry.file);
+            });
 
-  static createHandler<T extends object>(apiService: ApiService): ProxyHandler<T> {
-    return {
-      get(target: T, prop: string | symbol, receiver: unknown): unknown {
-        const simConfig = getSim(target);
-        const value = Reflect.get(target, prop, receiver);
-        if (typeof value === 'function' && simConfig?.symbol) {
-          return function (...args: unknown[]) {
-            const f = value as Function;
-            const p = (userConfig?: TopicProtocolConfig) => {
-              const symbolValue = Array.isArray(simConfig.symbol) ? simConfig.symbol[0] : simConfig.symbol;
-              const symbolName = (symbolValue as Symbol | undefined)?.description ?? String(symbolValue ?? simConfig.symbol);
-              const targetPath = `Symbol.for(${symbolName}):/${String(prop)}`;
-              const { request, fileEntries } = TopicProtocolApiServiceProxy.buildRequest(targetPath, userConfig?.body, userConfig?.type ?? 'intent');
-              const formData = new FormData();
-              formData.append('body', JSON.stringify(request));
-              fileEntries.forEach(entry => {
-                if (entry.filename) {
-                  formData.append(entry.id, entry.file, entry.filename);
-                } else {
-                  formData.append(entry.id, entry.file);
-                }
-              });
-
-              const headers = {
-                ...(userConfig?.headers ?? {}),
-                [HttpHeaders.XSimpleBootHttpTopicProtocol]: 'topic'
-              };
-
-              const endpoint = userConfig?.endpoint ?? '/';
-              return apiService.post({
-                target: endpoint,
-                config: {
-                  responseTransform: userConfig?.bypassTransform
-                    ? 'response'
-                    : userConfig?.transformText
-                      ? 'text'
-                      : async (response: Response) => {
-                          const contentType = response.headers.get('Content-Type') ?? '';
-                          if (contentType.toLowerCase().includes('multipart/mixed')) {
-                            const parsed = await TopicProtocolApiServiceProxy.parseMultipartMixed(response);
-                            if (!parsed) {
-                              return undefined;
+            const headers: Record<string, string> = {
+              ...(userConfig?.headers as Record<string, string> ?? {}),
+              [HttpHeaders.XSimpleBootHttpTopicProtocol]: 'topic',
+            };
+
+            const endpoint = userConfig?.endpoint ?? '/';
+
+            return (apiService as any).post({
+              target: endpoint,
+              config: {
+                responseTransform: userConfig?.bypassTransform
+                  ? 'response'
+                  : userConfig?.transformText
+                    ? 'text'
+                    : async (response: Response) => {
+                        const ct = response.headers.get('Content-Type') ?? '';
+                        if (ct.toLowerCase().includes('multipart/mixed')) {
+                          const parsed = await parseMultipartMixed(response);
+                          if (!parsed) return undefined;
+
+                          const fileMap = new Map<string, { name?: string; mime?: string; size: number; buffer: ArrayBuffer }>();
+                          let jsonBody: unknown = undefined;
+
+                          parsed.parts.forEach(part => {
+                            const partType   = part.headers['content-type'] ?? '';
+                            const disposition = part.headers['content-disposition'];
+                            const name = parseDispositionName(disposition);
+
+                            if (partType.includes('application/json')) {
+                              const text = new TextDecoder().decode(part.body);
+                              jsonBody = text ? JSON.parse(text) : undefined;
+                              return;
                             }
-                            const fileMap = new Map<string, { name?: string; mime?: string; size: number; buffer: ArrayBuffer }>();
-                            let jsonBody: unknown = undefined;
-                            parsed.parts.forEach(part => {
-                              const partType = part.headers['content-type'] ?? '';
-                              const disposition = part.headers['content-disposition'];
-                              const name = TopicProtocolApiServiceProxy.parseDispositionName(disposition);
-                              if (partType.includes('application/json')) {
-                                const text = new TextDecoder().decode(part.body);
-                                jsonBody = text ? JSON.parse(text) : undefined;
-                                return;
-                              }
-                              const filename = TopicProtocolApiServiceProxy.parseDispositionFilename(disposition);
-                              if (name) {
-                                const view = part.body;
-                                const safe = new Uint8Array(view.byteLength);
-                                safe.set(view);
-                                fileMap.set(name, {
-                                  name: filename,
-                                  mime: partType || 'application/octet-stream',
-                                  size: view.byteLength,
-                                  buffer: safe.buffer
-                                });
-                              }
-                            });
-                            if (jsonBody) {
-                              const replaced = TopicProtocolApiServiceProxy.replaceFileRefs(jsonBody, fileMap);
-                              return TopicProtocolApiServiceProxy.normalizeResponse(replaced);
+                            if (name) {
+                              const filename = parseDispositionFilename(disposition);
+                              const safe = new Uint8Array(part.body.byteLength);
+                              safe.set(part.body);
+                              fileMap.set(name, {
+                                name: filename,
+                                mime: partType || 'application/octet-stream',
+                                size: part.body.byteLength,
+                                buffer: safe.buffer,
+                              });
                             }
-                            return undefined;
-                          }
-                          const text = await response.text();
-                          const parsed = text ? JSON.parse(text) : undefined;
-                          return TopicProtocolApiServiceProxy.normalizeResponse(parsed);
-                        },
-                  transformText: userConfig?.transformText,
-                  config: userConfig?.config,
-                  fetch: {
-                    credentials: 'include',
-                    headers,
-                    body: formData
-                  }
-                } as any
-              });
-            };
-            args.push(p);
-            return Reflect.apply(f, target, args);
+                          });
+
+                          if (jsonBody) return normalizeResponse(replaceFileRefs(jsonBody, fileMap));
+                          return undefined;
+                        }
+
+                        const text   = await response.text();
+                        const parsed = text ? JSON.parse(text) : undefined;
+                        return normalizeResponse(parsed);
+                      },
+                transformText: userConfig?.transformText,
+                config: userConfig?.config,
+                fetch: {
+                  credentials: 'include',
+                  headers,
+                  body: formData,
+                },
+              } as any,
+            });
           };
-        }
-        return value;
+
+          args.push(p);
+          return Reflect.apply(f, target, args);
+        };
       }
-    };
-  }
 
-  get(target: T, prop: string | symbol, receiver: unknown): unknown {
-    return TopicProtocolApiServiceProxy.createHandler<T>(this.apiService).get!(target, prop, receiver);
+      return Reflect.get(target, prop, receiver);
+    },
+
+    apply(target: T, thisArg: unknown, argArray: unknown[]): unknown {
+      console.log('TopicProtocolApiServiceProxy apply');
+      return Reflect.apply(target as any, thisArg, argArray as any[]);
+    },
+  };
+};
+
+// ── Default factory export (same shape as SymbolIntentApiServiceProxy) ───────
+
+export default (config?: SimConfig): ConstructorType<any> => {
+  @sim(config)
+  class TopicProtocolApiServiceProxy<T extends object> implements ProxyHandler<T> {
+    constructor(private apiService: ApiService) {}
+
+    get(target: T, prop: string | symbol, receiver: unknown): unknown {
+      return createTopicHandler<T>(this.apiService).get!(target, prop, receiver);
+    }
+
+    apply(target: T, thisArg: unknown, argArray: unknown[]): unknown {
+      return createTopicHandler<T>(this.apiService).apply!(target, thisArg, argArray as any[]);
+    }
   }
-}
+
+  return TopicProtocolApiServiceProxy;
+};

package/src/websocket/WebSocketClient.ts

@@ -1,6 +1,7 @@
 import {RandomUtils} from '@dooboostore/core';
 import {TopicRequest, TopicResponse, TopicServerEventRequest, TopicServerEventResponse, TopicServerEventUnSubscribeRequest, TopicSubscribeRequest, TopicType, TopicUnsubscribeRequest} from './WebSocketManager';
-import {MessageOperator, Observable, Subject} from '@dooboostore/core';
+import {Observable, Subject} from '@dooboostore/core';
+import { filter } from '@dooboostore/core/message/operators';
 
 export * from '@dooboostore/core';
 
@@ -565,7 +566,7 @@ export class WebSocketClient {
           const value: TopicRequest = { type: option?.type, uuid, requestUUID, body: body };
           self.sendMessage(value);
         }
-        return topicSubject.pipe(MessageOperator.filter(data => data && data.requestUUID === requestUUID));
+        return topicSubject.pipe(filter(data => data && data.requestUUID === requestUUID));
       },
       onUnsubscribe: (callback: OnUnsubscribeCallback) => {
         onUnsubscribes.push(callback);

package/README.MD

@@ -1,62 +0,0 @@
-# @dooboostore/simple-boot-http-server
-
-[![NPM version](https://img.shields.io/npm/v/@dooboostore/simple-boot-http-server.svg?style=flat-square)](https://www.npmjs.com/package/@dooboostore/simple-boot-http-server)
-[![Build and Test](https://github.com/dooboostore-develop/packages/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/dooboostore-develop/packages/actions/workflows/main.yaml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-
-**Full Documentation:** [https://dooboostore-develop.github.io/@dooboostore/simple-boot-http-server](https://dooboostore-develop.github.io/@dooboostore/simple-boot-http-server)
-
-A lightweight and powerful HTTP web server framework for Node.js, built on `@dooboostore/simple-boot`.
-
----
-
-## Features
-
--   **Declarative Routing**: Use decorators like `@Router`, `@Route`, `@GET`, `@POST`, etc., to map URL paths and HTTP methods directly to your controller methods.
--   **Middleware via Filters**: Intercept the request-response cycle with `Filter` classes to implement cross-cutting concerns like logging, authentication, and CORS.
--   **Lifecycle Endpoints**: Hook into the request lifecycle with `EndPoint` classes that run on request start, close, or error.
--   **Integrated Exception Handling**: Leverage `@simple-boot`'s AOP capabilities to create robust global error handlers.
--   **Built-in Session Management**: Easily manage user sessions with a built-in session manager and customizable storage.
--   **HTTPS and HTTP/2 Support**: Secure your server with HTTPS and HTTP/2 configuration.
--   **WebSocket Topics + Events**: Topic-based subscribe/request/response with server events.
--   **WebSocket Binary File Transfer**: Send/receive files inside regular message payloads (JSON + binary framing).
--   **WebSocket Auto Reconnect**: Automatic reconnect and re-subscribe with configurable retry.
-
-## Quick Start
-
-```bash
-npx @dooboostore/create-simple-boot-http-server my-server
-cd my-server
-npm start
-```
-
-## Security Hardening
-
-- Enforce TLS in production: configure HTTPS (or terminate TLS at a trusted reverse proxy) and redirect HTTP to HTTPS.
-- Keep session cookies hardened: use `httpOnly`, `secure`, `sameSite`, short expiration, and explicit `domain/path` when required.
-- Protect WebSocket endpoints: validate origin, authenticate at connect/subscribe time, and authorize per topic.
-- Validate all inputs: apply strict validation for route params, query/body payloads, and uploaded files (type/size/path).
-- Avoid sensitive data leakage: never return stack traces, internal file paths, raw SQL errors, or secrets in responses/logs.
-- Configure CORS minimally: allow only required origins/methods/headers, avoid wildcard credentials.
-- Add rate limiting and timeout guards: mitigate brute force and resource-exhaustion attacks.
-- Rotate secrets/keys regularly and load them from environment or a secret manager (never hardcode in source).
-- Keep dependencies updated and scan regularly for CVEs.
-
-### Minimal Production Checklist
-
-- `HTTPS` enabled end-to-end
-- Session cookie options set (`httpOnly`, `secure`, `sameSite`)
-- CORS restricted to trusted origins
-- Request/WS auth + authorization enforced
-- Upload size/type limits configured
-- Error responses sanitized
-
-## Learn More
-
-The detailed API documentation, including all decorators and usage examples, is available on our documentation website.
-
-- WebSocket Guide: [document/websocket/README.md](document/websocket/README.md)
-
-## License
-
-This package is licensed under the [MIT License](https://opensource.org/licenses/MIT).