Merge pull request #128 from ozeanjs/release/v0.11.0

chore(release): bump version to v0.11.0

Author: mrthiti

.husky/pre-commit

@@ -1,4 +1,5 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-bun lint-staged
+bun lint-staged
+bun run test

packages/ozean-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ozean-cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "This is the official Command-Line Interface (CLI) for the OzeanJs Framework. It helps you kickstart new projects.",
   "keywords": [
     "ozean",

packages/ozean/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ozean",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A modern, simple, and high-performance web framework for Bun, inspired by Angular's architecture.",
   "keywords": [
     "ozean",

packages/ozean/src/core/app.ts

@@ -375,11 +375,17 @@ export class App {
                 const meta = executionPlan!.paramMeta[i];
                 let val: any;
                 if (meta) {
-                  if (meta.type === 'file') val = (req as any).file;
-                  else if (meta.type === 'query')
+                  if (meta.type === 'req') {
+                    val = req;
+                  } else if (meta.type === 'file') {
+                    val = (req as any).file;
+                  } else if (meta.type === 'query') {
                     val = Object.fromEntries(url.searchParams)[meta.key];
-                  else if (meta.type === 'param') val = matched.params[meta.key];
-                  else if (meta.type === 'body') val = meta.key ? body[meta.key] : body;
+                  } else if (meta.type === 'param') {
+                    val = matched.params[meta.key];
+                  } else if (meta.type === 'body') {
+                    val = meta.key ? body[meta.key] : body;
+                  }
                 }
                 const argMeta: ArgumentMetadata = {
                   type: meta?.type,

packages/ozean/src/decorators/parameters.ts

@@ -1,5 +1,5 @@
 function createParameterDecorator(
-  type: 'query' | 'param' | 'body',
+  type: 'req' | 'query' | 'param' | 'body',
   key?: string
 ): ParameterDecorator {
   return (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => {
@@ -13,6 +13,7 @@ function createParameterDecorator(
     Reflect.defineMetadata('custom:param', existingParams, target, propertyKey);
   };
 }
+export const Req = () => createParameterDecorator('req');
 export const Query = (key: string) => createParameterDecorator('query', key);
 export const Param = (key: string) => createParameterDecorator('param', key);
 export const Body = (key?: string) => createParameterDecorator('body', key);

packages/ozean/src/index.ts

@@ -5,7 +5,7 @@ export { Module } from './decorators/module';
 export { Controller } from './decorators/controller';
 export { Get, Post, Put, Delete, Patch } from './decorators/http-methods';
 export { Injectable, Inject } from './decorators/injectable';
-export { Query, Param, Body } from './decorators/parameters';
+export { Req, Query, Param, Body } from './decorators/parameters';
 export { UseMiddleware } from './decorators/use-middleware.decorator';
 export { UsePipes } from './decorators/use-pipes.decorator';
 export { UseFilters } from './decorators/use-filters.decorator';

packages/ozean/test/e2e/middleware.e2e.test.ts

@@ -0,0 +1,161 @@
+import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
+import type { Server } from 'bun';
+import 'reflect-metadata';
+
+import {
+  App,
+  Module,
+  Controller,
+  Get,
+  Injectable,
+  type Middleware,
+  type NextFunction,
+  UseMiddleware,
+} from '../../src';
+
+const executionOrder: string[] = [];
+
+@Injectable()
+class GlobalMiddleware1 implements Middleware {
+  async use(req: Request, next: NextFunction) {
+    executionOrder.push('GlobalMiddleware1');
+    return await next();
+  }
+}
+
+@Injectable()
+class GlobalMiddleware2 implements Middleware {
+  async use(req: Request, next: NextFunction) {
+    executionOrder.push('GlobalMiddleware2');
+    return await next();
+  }
+}
+
+@Injectable()
+class ControllerMiddleware implements Middleware {
+  async use(req: Request, next: NextFunction) {
+    executionOrder.push('ControllerMiddleware');
+    return await next();
+  }
+}
+
+@Injectable()
+class RouteMiddleware implements Middleware {
+  async use(req: Request, next: NextFunction) {
+    executionOrder.push('RouteMiddleware');
+    return await next();
+  }
+}
+
+@Injectable()
+class ShortCircuitMiddleware implements Middleware {
+  async use(req: Request, next: NextFunction) {
+    return new Response('Request was short-circuited by middleware', { status: 200 });
+  }
+}
+
+@Controller('/middleware-test')
+@UseMiddleware(ControllerMiddleware)
+class TestController {
+  @Get('/all')
+  @UseMiddleware(RouteMiddleware)
+  getWithAllMiddlewares() {
+    executionOrder.push('Handler');
+    return { success: true };
+  }
+
+  @Get('/no-route-mw')
+  getWithNoRouteMiddleware() {
+    executionOrder.push('Handler');
+    return { success: true };
+  }
+
+  @Get('/short-circuit')
+  @UseMiddleware(ShortCircuitMiddleware)
+  getShortCircuited() {
+    executionOrder.push('Handler');
+    return { message: 'This should not be returned' };
+  }
+}
+
+@Module({
+  controllers: [TestController],
+  providers: [
+    GlobalMiddleware1,
+    GlobalMiddleware2,
+    ControllerMiddleware,
+    RouteMiddleware,
+    ShortCircuitMiddleware,
+  ],
+})
+class TestAppModule {}
+
+describe('Middlewares (E2E)', () => {
+  let app: App;
+  let server: Server;
+
+  beforeAll(() => {
+    app = new App(TestAppModule);
+
+    app.use(GlobalMiddleware1, GlobalMiddleware2);
+
+    server = app.listen(0);
+  });
+
+  afterAll(() => {
+    server.stop(true);
+  });
+
+  beforeEach(() => {
+    executionOrder.length = 0;
+  });
+
+  test('should execute global, controller, and route middlewares in correct order', async () => {
+    const response = await fetch(new URL('/middleware-test/all', server.url));
+
+    expect(response.status).toBe(200);
+
+    expect(executionOrder).toEqual([
+      'GlobalMiddleware1',
+      'GlobalMiddleware2',
+      'ControllerMiddleware',
+      'RouteMiddleware',
+      'Handler',
+    ]);
+  });
+
+  test('should execute only global and controller middlewares when no route middleware is present', async () => {
+    const response = await fetch(new URL('/middleware-test/no-route-mw', server.url));
+
+    expect(response.status).toBe(200);
+
+    expect(executionOrder).toEqual([
+      'GlobalMiddleware1',
+      'GlobalMiddleware2',
+      'ControllerMiddleware',
+      'Handler',
+    ]);
+  });
+
+  test('should allow a middleware to short-circuit the request chain', async () => {
+    const response = await fetch(new URL('/middleware-test/short-circuit', server.url));
+
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe('Request was short-circuited by middleware');
+
+    expect(executionOrder).not.toContain('Handler');
+    expect(executionOrder).toEqual([
+      'GlobalMiddleware1',
+      'GlobalMiddleware2',
+      'ControllerMiddleware',
+    ]);
+  });
+
+  test('should not apply middlewares to a non-existent route', async () => {
+    const response = await fetch(new URL('/not-found', server.url));
+
+    expect(response.status).toBe(404);
+
+    expect(executionOrder).toEqual([]);
+  });
+});