@onebun/core 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",

package/src/application/application.test.ts

@@ -906,6 +906,42 @@ describe('OneBunApplication', () => {
       expect(Bun.serve).toHaveBeenCalled();
     });
 
+    test('should pass default idleTimeout (120s) to Bun.serve', async () => {
+      @Module({})
+      class TestModule {}
+
+      const app = createTestApp(TestModule);
+      await app.start();
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const serveCall = (Bun.serve as any).mock.calls[0];
+      expect(serveCall[0].idleTimeout).toBe(120);
+    });
+
+    test('should pass custom idleTimeout to Bun.serve', async () => {
+      @Module({})
+      class TestModule {}
+
+      const app = createTestApp(TestModule, { idleTimeout: 60 });
+      await app.start();
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const serveCall = (Bun.serve as any).mock.calls[0];
+      expect(serveCall[0].idleTimeout).toBe(60);
+    });
+
+    test('should pass idleTimeout: 0 to disable timeout', async () => {
+      @Module({})
+      class TestModule {}
+
+      const app = createTestApp(TestModule, { idleTimeout: 0 });
+      await app.start();
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const serveCall = (Bun.serve as any).mock.calls[0];
+      expect(serveCall[0].idleTimeout).toBe(0);
+    });
+
     test('should start application with config initialization', async () => {
       @Module({})
       class TestModule {}

package/src/application/application.ts

@@ -27,16 +27,23 @@ import { makeTraceService, TraceService } from '@onebun/trace';
 
 import {
   getControllerMetadata,
+  getControllerMiddleware,
   getSseMetadata,
   type SseDecoratorOptions,
 } from '../decorators/decorators';
+import { OneBunFile, validateFile } from '../file/onebun-file';
 import {
   NotInitializedConfig,
   type IConfig,
   type OneBunAppConfig,
 } from '../module/config.interface';
 import { ConfigServiceImpl } from '../module/config.service';
-import { createSseStream } from '../module/controller';
+import {
+  createSseStream,
+  DEFAULT_IDLE_TIMEOUT,
+  DEFAULT_SSE_HEARTBEAT_MS,
+  DEFAULT_SSE_TIMEOUT,
+} from '../module/controller';
 import { OneBunModule } from '../module/module';
 import { QueueService, type QueueAdapter } from '../queue';
 import { InMemoryQueueAdapter } from '../queue/adapters/memory.adapter';
@@ -484,7 +491,7 @@ export class OneBunApplication {
 
       /**
        * Create a route handler with the full OneBun request lifecycle:
-       * tracing setup → middleware chain → executeHandler → metrics → tracing end
+       * tracing setup → per-request timeout → middleware chain → executeHandler → metrics → tracing end
        */
       function createRouteHandler(
         routeMeta: RouteMetadata,
@@ -492,10 +499,28 @@ export class OneBunApplication {
         controller: Controller,
         fullPath: string,
         method: string,
-      ): (req: OneBunRequest) => Promise<Response> {
-        return async (req) => {
+      ): (req: OneBunRequest, server: ReturnType<typeof Bun.serve>) => Promise<Response> {
+        // Determine the effective timeout for this route:
+        // SSE endpoints check @Sse({ timeout }) first, then route-level, then DEFAULT_SSE_TIMEOUT
+        // Normal endpoints use route-level timeout only (undefined = use global idleTimeout)
+        const isSse = routeMeta.handler
+          ? getSseMetadata(Object.getPrototypeOf(controller), routeMeta.handler) !== undefined
+          : false;
+        const sseDecoratorOptions = routeMeta.handler
+          ? getSseMetadata(Object.getPrototypeOf(controller), routeMeta.handler)
+          : undefined;
+        const effectiveTimeout: number | undefined = isSse
+          ? (sseDecoratorOptions?.timeout ?? routeMeta.timeout ?? DEFAULT_SSE_TIMEOUT)
+          : routeMeta.timeout;
+
+        return async (req, server) => {
           const startTime = Date.now();
 
+          // Apply per-request idle timeout if configured
+          if (effectiveTimeout !== undefined) {
+            server.timeout(req, effectiveTimeout);
+          }
+
           // Setup tracing context if available and enabled
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           let traceSpan: any = null;
@@ -700,6 +725,12 @@ export class OneBunApplication {
         };
       }
 
+      // Application-wide middleware — resolve class constructors via root module DI
+      const globalMiddlewareClasses = (this.options.middleware as Function[] | undefined) ?? [];
+      const globalMiddleware: Function[] = globalMiddlewareClasses.length > 0
+        ? (this.ensureModule().resolveMiddleware?.(globalMiddlewareClasses) ?? [])
+        : [];
+
       // Add routes from controllers
       for (const controllerClass of controllers) {
         const controllerMetadata = getControllerMetadata(controllerClass);
@@ -724,6 +755,15 @@ export class OneBunApplication {
 
         const controllerPath = controllerMetadata.path;
 
+        // Module-level middleware (already resolved bound functions)
+        const moduleMiddleware = this.ensureModule().getModuleMiddleware?.(controllerClass) ?? [];
+
+        // Controller-level middleware — resolve class constructors via root module DI
+        const ctrlMiddlewareClasses = getControllerMiddleware(controllerClass);
+        const ctrlMiddleware: Function[] = ctrlMiddlewareClasses.length > 0
+          ? (this.ensureModule().resolveMiddleware?.(ctrlMiddlewareClasses) ?? [])
+          : [];
+
         for (const route of controllerMetadata.routes) {
           // Combine: appPrefix + controllerPath + routePath
           // Normalize to ensure consistent matching (e.g., '/api/users/' -> '/api/users')
@@ -733,8 +773,26 @@ export class OneBunApplication {
             controller,
           );
 
+          // Route-level middleware — resolve class constructors via root module DI
+          const routeMiddlewareClasses = route.middleware ?? [];
+          const routeMiddleware: Function[] = routeMiddlewareClasses.length > 0
+            ? (this.ensureModule().resolveMiddleware?.(routeMiddlewareClasses) ?? [])
+            : [];
+
+          // Merge middleware: global → module → controller → route
+          const mergedMiddleware = [
+            ...globalMiddleware,
+            ...moduleMiddleware,
+            ...ctrlMiddleware,
+            ...routeMiddleware,
+          ];
+          const routeWithMergedMiddleware: RouteMetadata = {
+            ...route,
+            middleware: mergedMiddleware.length > 0 ? mergedMiddleware : undefined,
+          };
+
           // Create wrapped handler with full OneBun lifecycle (tracing, metrics, middleware)
-          const wrappedHandler = createRouteHandler(route, handler, controller, fullPath, method);
+          const wrappedHandler = createRouteHandler(routeWithMergedMiddleware, handler, controller, fullPath, method);
 
           // Add to bunRoutes grouped by path and method
           if (!bunRoutes[fullPath]) {
@@ -843,6 +901,8 @@ export class OneBunApplication {
       this.server = Bun.serve<WsClientData>({
         port: this.options.port,
         hostname: this.options.host,
+        // Idle timeout (seconds) — default 120s to support SSE and long-running requests
+        idleTimeout: this.options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT,
         // WebSocket handlers
         websocket: wsHandlers,
         // Bun routes API: all endpoints are handled here
@@ -911,6 +971,43 @@ export class OneBunApplication {
       throw error;
     }
 
+    /**
+     * Extract an OneBunFile from a JSON value.
+     * Supports two formats:
+     * - String: raw base64 data
+     * - Object: { data: string, filename?: string, mimeType?: string }
+     */
+    function extractFileFromJsonValue(value: unknown): OneBunFile | undefined {
+      if (typeof value === 'string' && value.length > 0) {
+        return OneBunFile.fromBase64(value);
+      }
+
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value as Record<string, unknown>;
+        if (typeof obj.data === 'string' && obj.data.length > 0) {
+          return OneBunFile.fromBase64(
+            obj.data,
+            typeof obj.filename === 'string' ? obj.filename : undefined,
+            typeof obj.mimeType === 'string' ? obj.mimeType : undefined,
+          );
+        }
+      }
+
+      return undefined;
+    }
+
+    /**
+     * Extract a file from a JSON body by field name
+     */
+    function extractFileFromJson(
+      jsonBody: Record<string, unknown>,
+      fieldName: string,
+    ): OneBunFile | undefined {
+      const fieldValue = jsonBody[fieldName];
+
+      return extractFileFromJsonValue(fieldValue);
+    }
+
     /**
      * Execute route handler with parameter injection and validation.
      * Path parameters come from BunRequest.params (populated by Bun routes API).
@@ -951,6 +1048,52 @@ export class OneBunApplication {
       // Sort params by index to ensure correct order
       const sortedParams = [...(route.params || [])].sort((a, b) => a.index - b.index);
 
+      // Pre-parse body for file upload params (FormData or JSON, cached for all params)
+      const needsFileData = sortedParams.some(
+        (p) =>
+          p.type === ParamType.FILE ||
+          p.type === ParamType.FILES ||
+          p.type === ParamType.FORM_FIELD,
+      );
+
+      // Validate that @Body and file decorators are not used on the same method
+      if (needsFileData) {
+        const hasBody = sortedParams.some((p) => p.type === ParamType.BODY);
+        if (hasBody) {
+          throw new Error(
+            'Cannot use @Body() together with @UploadedFile/@UploadedFiles/@FormField on the same method. ' +
+            'Both consume the request body. Use file decorators for multipart/base64 uploads.',
+          );
+        }
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let formData: any = null;
+      let jsonBody: Record<string, unknown> | null = null;
+      let isMultipart = false;
+
+      if (needsFileData) {
+        const contentType = req.headers.get('content-type') || '';
+
+        if (contentType.includes('multipart/form-data')) {
+          isMultipart = true;
+          try {
+            formData = await req.formData();
+          } catch {
+            formData = null;
+          }
+        } else if (contentType.includes('application/json')) {
+          try {
+            const parsed = await req.json();
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+              jsonBody = parsed as Record<string, unknown>;
+            }
+          } catch {
+            jsonBody = null;
+          }
+        }
+      }
+
       for (const param of sortedParams) {
         switch (param.type) {
           case ParamType.PATH:
@@ -989,6 +1132,100 @@ export class OneBunApplication {
             args[param.index] = undefined;
             break;
 
+          case ParamType.FILE: {
+            let file: OneBunFile | undefined;
+
+            if (isMultipart && formData && param.name) {
+              const entry = formData.get(param.name);
+              if (entry instanceof File) {
+                file = new OneBunFile(entry);
+              }
+            } else if (jsonBody && param.name) {
+              file = extractFileFromJson(jsonBody, param.name);
+            }
+
+            if (file && param.fileOptions) {
+              validateFile(file, param.fileOptions, param.name);
+            }
+
+            args[param.index] = file;
+            break;
+          }
+
+          case ParamType.FILES: {
+            let files: OneBunFile[] = [];
+
+            if (isMultipart && formData) {
+              if (param.name) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const entries: any[] = formData.getAll(param.name);
+                files = entries
+                  .filter((entry: unknown): entry is File => entry instanceof File)
+                  .map((f: File) => new OneBunFile(f));
+              } else {
+                // Get all files from all fields
+                for (const [, value] of formData.entries()) {
+                  if (value instanceof File) {
+                    files.push(new OneBunFile(value));
+                  }
+                }
+              }
+            } else if (jsonBody) {
+              if (param.name) {
+                const fieldValue = jsonBody[param.name];
+                if (Array.isArray(fieldValue)) {
+                  files = fieldValue
+                    .map((item) => extractFileFromJsonValue(item))
+                    .filter((f): f is OneBunFile => f !== undefined);
+                }
+              } else {
+                // Extract all file-like values from JSON
+                for (const [, value] of Object.entries(jsonBody)) {
+                  const file = extractFileFromJsonValue(value);
+                  if (file) {
+                    files.push(file);
+                  }
+                }
+              }
+            }
+
+            // Validate maxCount
+            if (param.fileOptions?.maxCount !== undefined && files.length > param.fileOptions.maxCount) {
+              throw new Error(
+                `Too many files for "${param.name || 'upload'}". Got ${files.length}, max is ${param.fileOptions.maxCount}`,
+              );
+            }
+
+            // Validate each file
+            if (param.fileOptions) {
+              for (const file of files) {
+                validateFile(file, param.fileOptions, param.name);
+              }
+            }
+
+            args[param.index] = files;
+            break;
+          }
+
+          case ParamType.FORM_FIELD: {
+            let value: string | undefined;
+
+            if (isMultipart && formData && param.name) {
+              const entry = formData.get(param.name);
+              if (typeof entry === 'string') {
+                value = entry;
+              }
+            } else if (jsonBody && param.name) {
+              const jsonValue = jsonBody[param.name];
+              if (jsonValue !== undefined && jsonValue !== null) {
+                value = String(jsonValue);
+              }
+            }
+
+            args[param.index] = value;
+            break;
+          }
+
           default:
             args[param.index] = undefined;
         }
@@ -998,6 +1235,16 @@ export class OneBunApplication {
           throw new Error(`Required parameter ${param.name || param.index} is missing`);
         }
 
+        // For FILES type, also check for empty array when required
+        if (
+          param.isRequired &&
+          param.type === ParamType.FILES &&
+          Array.isArray(args[param.index]) &&
+          (args[param.index] as unknown[]).length === 0
+        ) {
+          throw new Error(`Required parameter ${param.name || param.index} is missing`);
+        }
+
         // Apply arktype schema validation if provided
         if (param.schema && args[param.index] !== undefined) {
           try {
@@ -1170,9 +1417,14 @@ export class OneBunApplication {
 
       // Check if result is an async iterable (generator)
       if (result && typeof result === 'object' && Symbol.asyncIterator in result) {
+        // Apply default heartbeat if none specified to keep the connection alive
+        const effectiveOptions = {
+          ...options,
+          heartbeat: options.heartbeat ?? DEFAULT_SSE_HEARTBEAT_MS,
+        };
         const stream = createSseStream(
           result as AsyncIterable<unknown>,
-          options,
+          effectiveOptions,
         );
 
         return new Response(stream, {

package/src/application/multi-service-application.ts

@@ -143,6 +143,7 @@ export class MultiServiceApplication<TServices extends ServicesMap = ServicesMap
       envOverrides: { ...appOptions.envOverrides, ...serviceOptions.envOverrides },
       envSchemaExtend: serviceOptions.envSchemaExtend,
       logger: { ...appOptions.logger, ...serviceOptions.logger },
+      middleware: serviceOptions.middleware ?? appOptions.middleware,
       metrics: { ...appOptions.metrics, ...serviceOptions.metrics },
       tracing: { ...appOptions.tracing, ...serviceOptions.tracing },
     };
@@ -197,6 +198,7 @@ export class MultiServiceApplication<TServices extends ServicesMap = ServicesMap
         basePath: mergedOptions.basePath,
         // When routePrefix is true, use service name as prefix
         routePrefix: mergedOptions.routePrefix ? name : undefined,
+        middleware: mergedOptions.middleware,
         envSchema: mergedEnvSchema,
         envOptions: {
           ...this.options.envOptions,

package/src/application/multi-service.types.ts

@@ -30,7 +30,7 @@ export type TracingOptions = NonNullable<ApplicationOptions['tracing']>;
  * Any new shared options should be added to ApplicationOptions first.
  */
 export interface BaseServiceOptions
-  extends Pick<ApplicationOptions, 'host' | 'basePath' | 'metrics' | 'tracing'> {
+  extends Pick<ApplicationOptions, 'host' | 'basePath' | 'metrics' | 'tracing' | 'middleware'> {
   /**
    * Add service name as prefix to all routes.
    * When true, the service name will be used as routePrefix.