Add middleware e2e tests

packages/http/libraries/core/src/http/middleware/model/Middleware.ts

@@ -3,7 +3,7 @@ export interface Middleware<
   TRequest = any,
   TResponse = any,
   TNextFunction = any,
-  TResult = void,
+  TResult = any,
 > {
   execute(
     request: TRequest,

packages/http/tools/e2e-tests/features/middleware.feature

@@ -0,0 +1,77 @@
+Feature: middleware
+The m allows to continue or stop the request processing
+
+  Background: Having a container
+    Given a container
+
+  Rule: middleware allows to continue or stop the request processing
+
+    Scenario: middleware allows to continue request processing
+      Given a warrior controller with SuccessfulMiddleware for <method> method and <server_kind> server
+      And a <server_kind> server from container
+      And a <method> warriors HTTP request
+      When the request is send
+      Then the response status code is Ok-ish
+      Then the response contains the correct header
+
+      Examples:
+        | server_kind | method    |
+        | "express"   | "DELETE"  |
+        | "express"   | "GET"     |
+        | "express"   | "OPTIONS" |
+        | "express"   | "PATCH"   |
+        | "express"   | "POST"    |
+        | "express"   | "PUT"     |
+        | "express4"  | "DELETE"  |
+        | "express4"  | "GET"     |
+        | "express4"  | "OPTIONS" |
+        | "express4"  | "PATCH"   |
+        | "express4"  | "POST"    |
+        | "express4"  | "PUT"     |
+        | "fastify"   | "DELETE"  |
+        | "fastify"   | "GET"     |
+        | "fastify"   | "OPTIONS" |
+        | "fastify"   | "PATCH"   |
+        | "fastify"   | "POST"    |
+        | "fastify"   | "PUT"     |
+        | "hono"      | "DELETE"  |
+        | "hono"      | "GET"     |
+        | "hono"      | "OPTIONS" |
+        | "hono"      | "PATCH"   |
+        | "hono"      | "POST"    |
+        | "hono"      | "PUT"     |
+
+    Scenario: middleware allows to stop request processing
+      Given a warrior controller with UnsuccessfulMiddleware for <method> method and <server_kind> server
+      And a <server_kind> server from container
+      And a <method> warriors HTTP request
+      When the request is send
+      Then the response status code is FORBIDDEN
+      Then the response contains the correct header
+
+      Examples:
+        | server_kind | method    |
+        | "express"   | "DELETE"  |
+        | "express"   | "GET"     |
+        | "express"   | "OPTIONS" |
+        | "express"   | "PATCH"   |
+        | "express"   | "POST"    |
+        | "express"   | "PUT"     |
+        | "express4"  | "DELETE"  |
+        | "express4"  | "GET"     |
+        | "express4"  | "OPTIONS" |
+        | "express4"  | "PATCH"   |
+        | "express4"  | "POST"    |
+        | "express4"  | "PUT"     |
+        | "fastify"   | "DELETE"  |
+        | "fastify"   | "GET"     |
+        | "fastify"   | "OPTIONS" |
+        | "fastify"   | "PATCH"   |
+        | "fastify"   | "POST"    |
+        | "fastify"   | "PUT"     |
+        | "hono"      | "DELETE"  |
+        | "hono"      | "GET"     |
+        | "hono"      | "OPTIONS" |
+        | "hono"      | "PATCH"   |
+        | "hono"      | "POST"    |
+        | "hono"      | "PUT"     |

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsDeleteSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @DELETE()
+  public async deleteWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsDeleteUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @DELETE()
+  public async deleteWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, GET } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsGetSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @GET()
+  public async getWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, GET } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsGetUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @GET()
+  public async getWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsOptionsSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @OPTIONS()
+  public async optionsWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsOptionsUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @OPTIONS()
+  public async optionsWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPatchSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @PATCH()
+  public async patchWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPatchUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @PATCH()
+  public async patchWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, POST } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPostSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @POST()
+  public async postWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, POST } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPostUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @POST()
+  public async postWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutSuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPutSuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware)
+  @PUT()
+  public async putWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts

@@ -0,0 +1,11 @@
+import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressMiddleware } from '../../middlewares/express/SuccessfulExpressMiddleware';
+import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware';
+
+@controller('/warriors')
+export class WarriorsPutUnsuccessfulExpressMiddlewareController {
+  @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware)
+  @PUT()
+  public async putWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsDeleteSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @DELETE()
+  public async deleteWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsDeleteUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @DELETE()
+  public async deleteWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, GET } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsGetSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @GET()
+  public async getWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, GET } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsGetUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @GET()
+  public async getWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsOptionsSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @OPTIONS()
+  public async optionsWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsOptionsUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @OPTIONS()
+  public async optionsWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPatchSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @PATCH()
+  public async patchWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPatchUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @PATCH()
+  public async patchWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, POST } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPostSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @POST()
+  public async postWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, POST } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPostUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @POST()
+  public async postWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutSuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPutSuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(SuccessfulExpressV4Middleware)
+  @PUT()
+  public async putWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts

@@ -0,0 +1,14 @@
+import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core';
+
+import { SuccessfulExpressV4Middleware } from '../../middlewares/express4/SuccessfulExpressV4Middleware';
+import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware';
+
+@controller('/warriors')
+export class WarriorsPutUnsuccessfulExpressV4MiddlewareController {
+  @applyMiddleware(
+    SuccessfulExpressV4Middleware,
+    UnsuccessfulExpressV4Middleware,
+  )
+  @PUT()
+  public async putWarrior(): Promise<void> {}
+}

packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteSuccessfulFastifyMiddlewareController.ts

@@ -0,0 +1,10 @@
+import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core';
+
+import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware';
+
+@controller('/warriors')
+export class WarriorsDeleteSuccessfulFastifyMiddlewareController {
+  @applyMiddleware(SuccessfulFastifyMiddleware)
+  @DELETE()
+  public async deleteWarrior(): Promise<void> {}
+}