From 6124ae0335c8165198c62df8a2d491811b150f5a Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 09:07:06 +0200 Subject: [PATCH 01/15] feat(http-e2e-tests): add SuccessfulMiddleware and UnsuccessfulMiddleware implementations --- .../middlewares/SuccessfulMiddleware.ts | 13 +++++++++ .../middlewares/UnsuccessfulMiddleware.ts | 28 +++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts new file mode 100644 index 000000000..67f16dc7a --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts @@ -0,0 +1,13 @@ +import { Middleware } from '@inversifyjs/http-core'; +import { injectable } from 'inversify'; + +@injectable() +export class SuccessfulMiddleware implements Middleware { + public async execute( + _request: unknown, + _response: unknown, + next: () => void | Promise, + ): Promise { + await next(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts new file mode 100644 index 000000000..80369b902 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts @@ -0,0 +1,28 @@ +import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; +import { injectable } from 'inversify'; + +@injectable() +export class UnsuccessfulMiddleware + implements Middleware +{ + public async execute( + _request: unknown, + response: { + send?: () => unknown; + text?: () => unknown; + status: (code: number) => void; + }, + _next: unknown, + ): Promise { + response.status(HttpStatusCode.FORBIDDEN); + if (response.send !== undefined) { + response.send(); + } + + if (response.text !== undefined) { + response.text(); + } + + return undefined; + } +} From cb3556f213e8fa90d0bca1224247f9633a251089 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 09:07:43 +0200 Subject: [PATCH 02/15] feat(http-e2e-tests): add controllers for warrior CRUD operations with successful and unsuccessful middleware --- .../WarriorsDeleteSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsDeleteUnsuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsGetSuccessfulGuardController.ts | 10 ++++++++++ .../WarriorsGetSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsGetUnsuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsOptionsSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsOptionsUnsuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPatchSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPatchUnsuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPostSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPostUnsuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPutSuccessfulMiddlewareController.ts | 10 ++++++++++ .../WarriorsPutUnsuccessfulMiddlewareController.ts | 10 ++++++++++ 13 files changed, 130 insertions(+) create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..ddcec0872 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..b805b54d7 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts new file mode 100644 index 000000000..26dd4546e --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsGetSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..26dd4546e --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsGetSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..f189b53bf --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsGetUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..c11df973f --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..3ff62c4ee --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..ee549c408 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPatchSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..3bfcbd59a --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPatchUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..4973ee2cf --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPostSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..198cb5d43 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPostUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts new file mode 100644 index 000000000..860ad099b --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPutSuccessfulMiddlewareController { + @applyMiddleware(SuccessfulMiddleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts new file mode 100644 index 000000000..f9ff05e0a --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +@controller('/warriors') +export class WarriorsPutUnsuccessfulMiddlewareController { + @applyMiddleware(UnsuccessfulMiddleware) + @PUT() + public async putWarrior(): Promise {} +} From e068742d12dfff840f4daa5dd2ef6501c773cfde Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 09:08:48 +0200 Subject: [PATCH 03/15] feat(http-e2e-tests): implement givenDefinitions for middleware controllers --- .../step-definitions/givenDefinitions.ts | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts new file mode 100644 index 000000000..f5df614be --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts @@ -0,0 +1,109 @@ +import { Given } from '@cucumber/cucumber'; +import { Container } from 'inversify'; + +import { defaultAlias } from '../../../common/models/defaultAlias'; +import { InversifyHttpWorld } from '../../../common/models/InversifyHttpWorld'; +import { getContainerOrFail } from '../../../container/calculations/getContainerOrFail'; +import { HttpMethod } from '../../../http/models/HttpMethod'; +import { WarriorsDeleteSuccessfulMiddlewareController } from '../controllers/WarriorsDeleteSuccessfulMiddlewareController'; +import { WarriorsDeleteUnsuccessfulMiddlewareController } from '../controllers/WarriorsDeleteUnsuccessfulMiddlewareController'; +import { WarriorsGetSuccessfulMiddlewareController } from '../controllers/WarriorsGetSuccessfulMiddlewareController'; +import { WarriorsGetUnsuccessfulMiddlewareController } from '../controllers/WarriorsGetUnsuccessfulMiddlewareController'; +import { WarriorsOptionsSuccessfulMiddlewareController } from '../controllers/WarriorsOptionsSuccessfulMiddlewareController'; +import { WarriorsOptionsUnsuccessfulMiddlewareController } from '../controllers/WarriorsOptionsUnsuccessfulMiddlewareController'; +import { WarriorsPatchSuccessfulMiddlewareController } from '../controllers/WarriorsPatchSuccessfulMiddlewareController'; +import { WarriorsPatchUnsuccessfulMiddlewareController } from '../controllers/WarriorsPatchUnsuccessfulMiddlewareController'; +import { WarriorsPostSuccessfulMiddlewareController } from '../controllers/WarriorsPostSuccessfulMiddlewareController'; +import { WarriorsPostUnsuccessfulMiddlewareController } from '../controllers/WarriorsPostUnsuccessfulMiddlewareController'; +import { WarriorsPutSuccessfulMiddlewareController } from '../controllers/WarriorsPutSuccessfulMiddlewareController'; +import { WarriorsPutUnsuccessfulMiddlewareController } from '../controllers/WarriorsPutUnsuccessfulMiddlewareController'; +import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; +import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; + +function getMethodWarriorSuccessfulMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteSuccessfulMiddlewareController; + case HttpMethod.get: + return WarriorsGetSuccessfulMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsSuccessfulMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchSuccessfulMiddlewareController; + case HttpMethod.post: + return WarriorsPostSuccessfulMiddlewareController; + case HttpMethod.put: + return WarriorsPutSuccessfulMiddlewareController; + } +} + +function getMethodWarriorUnsuccessfulMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteUnsuccessfulMiddlewareController; + case HttpMethod.get: + return WarriorsGetUnsuccessfulMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsUnsuccessfulMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchUnsuccessfulMiddlewareController; + case HttpMethod.post: + return WarriorsPostUnsuccessfulMiddlewareController; + case HttpMethod.put: + return WarriorsPutUnsuccessfulMiddlewareController; + } +} + +function givenWarriorSuccessfulMiddlewareControllerForContainer( + this: InversifyHttpWorld, + method: HttpMethod, + containerAlias?: string, +): void { + const parsedContainerAlias: string = containerAlias ?? defaultAlias; + const container: Container = + getContainerOrFail.bind(this)(parsedContainerAlias); + + const controller: NewableFunction = + getMethodWarriorSuccessfulMiddlewareController(method); + + container.bind(SuccessfulMiddleware).toSelf().inSingletonScope(); + container.bind(controller).toSelf().inSingletonScope(); +} + +function givenWarriorUnsuccessfulMiddlewareControllerForContainer( + this: InversifyHttpWorld, + method: HttpMethod, + containerAlias?: string, +): void { + const parsedContainerAlias: string = containerAlias ?? defaultAlias; + const container: Container = + getContainerOrFail.bind(this)(parsedContainerAlias); + + const controller: NewableFunction = + getMethodWarriorUnsuccessfulMiddlewareController(method); + + container.bind(UnsuccessfulMiddleware).toSelf().inSingletonScope(); + container.bind(controller).toSelf().inSingletonScope(); +} + +Given( + 'a warrior controller with SuccessfulMiddleware for "{httpMethod}" method', + function (this: InversifyHttpWorld, httpMethod: HttpMethod): void { + givenWarriorSuccessfulMiddlewareControllerForContainer.bind(this)( + httpMethod, + ); + }, +); + +Given( + 'a warrior controller with UnsuccessfulMiddleware for "{httpMethod}" method', + function (this: InversifyHttpWorld, httpMethod: HttpMethod): void { + givenWarriorUnsuccessfulMiddlewareControllerForContainer.bind(this)( + httpMethod, + ); + }, +); From efa5332364dc89cd342022cfa21eeb40c197cce1 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 09:09:25 +0200 Subject: [PATCH 04/15] feat(http-e2e-tests): add middleware feature for successful and unsuccessful request processing --- .../e2e-tests/features/middleware.feature | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 packages/http/tools/e2e-tests/features/middleware.feature diff --git a/packages/http/tools/e2e-tests/features/middleware.feature b/packages/http/tools/e2e-tests/features/middleware.feature new file mode 100644 index 000000000..856e3829d --- /dev/null +++ b/packages/http/tools/e2e-tests/features/middleware.feature @@ -0,0 +1,76 @@ +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 + And a server from container + And a warriors HTTP request + When the request is send + Then the response status code is Ok-ish + + 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 + And a server from container + And a warriors HTTP request + When the request is send + Then the response status code is FORBIDDEN + + 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" | From 2ccb7333d599fe272cdf3f25da7ac55c0e5f5cce Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 16:23:50 +0200 Subject: [PATCH 05/15] fix(http-core): change TResult type from void to any for better flexibility --- .../http/libraries/core/src/http/middleware/model/Middleware.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/http/libraries/core/src/http/middleware/model/Middleware.ts b/packages/http/libraries/core/src/http/middleware/model/Middleware.ts index 278123530..fbca807cd 100644 --- a/packages/http/libraries/core/src/http/middleware/model/Middleware.ts +++ b/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, From b6cea3b878f6815dd06ca3272f446377356550b6 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 16:25:40 +0200 Subject: [PATCH 06/15] fix(http-e2e-tests): return response.text() in UnsuccessfulMiddleware for proper response handling --- .../warrior/middleware/middlewares/UnsuccessfulMiddleware.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts index 80369b902..42b872ec2 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts @@ -3,7 +3,7 @@ import { injectable } from 'inversify'; @injectable() export class UnsuccessfulMiddleware - implements Middleware + implements Middleware { public async execute( _request: unknown, @@ -20,7 +20,7 @@ export class UnsuccessfulMiddleware } if (response.text !== undefined) { - response.text(); + return response.text(); } return undefined; From 8b484d94ffecb9fa6c7d6576f1ca363830158865 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 26 Apr 2025 16:31:33 +0200 Subject: [PATCH 07/15] refactor(http-e2e-tests): remove WarriorsGetSuccessfulGuardController as part of middleware cleanup --- .../WarriorsGetSuccessfulGuardController.ts | 10 ---------- 1 file changed, 10 deletions(-) delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts deleted file mode 100644 index 26dd4546e..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulGuardController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsGetSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @GET() - public async getWarrior(): Promise {} -} From b7f02a2052eeaa3dc64d99e88cb4f897f4094ad1 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Thu, 1 May 2025 14:15:08 +0200 Subject: [PATCH 08/15] feat(http-e2e-tests): add new middleware implementations for Express, Fastify, and Hono --- .../middlewares/SuccessfulMiddleware.ts | 13 --------- .../middlewares/UnsuccessfulMiddleware.ts | 28 ------------------- .../express/SuccessfulExpressMiddleware.ts | 16 +++++++++++ .../express/UnsuccessfulExpressMiddleware.ts | 16 +++++++++++ .../express4/SuccessfulExpressV4Middleware.ts | 16 +++++++++++ .../UnsuccessfulExpressV4Middleware.ts | 16 +++++++++++ .../fastify/SuccessfulFastifyMiddleware.ts | 17 +++++++++++ .../fastify/UnsuccessfulFastifyMiddleware.ts | 17 +++++++++++ .../hono/SuccessfulHonoMiddleware.ts | 16 +++++++++++ .../hono/UnsuccessfulHonoMiddleware.ts | 18 ++++++++++++ 10 files changed, 132 insertions(+), 41 deletions(-) delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/UnsuccessfulExpressMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/UnsuccessfulExpressV4Middleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/UnsuccessfulFastifyMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/UnsuccessfulHonoMiddleware.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts deleted file mode 100644 index 67f16dc7a..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/SuccessfulMiddleware.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { Middleware } from '@inversifyjs/http-core'; -import { injectable } from 'inversify'; - -@injectable() -export class SuccessfulMiddleware implements Middleware { - public async execute( - _request: unknown, - _response: unknown, - next: () => void | Promise, - ): Promise { - await next(); - } -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts deleted file mode 100644 index 42b872ec2..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/UnsuccessfulMiddleware.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; -import { injectable } from 'inversify'; - -@injectable() -export class UnsuccessfulMiddleware - implements Middleware -{ - public async execute( - _request: unknown, - response: { - send?: () => unknown; - text?: () => unknown; - status: (code: number) => void; - }, - _next: unknown, - ): Promise { - response.status(HttpStatusCode.FORBIDDEN); - if (response.send !== undefined) { - response.send(); - } - - if (response.text !== undefined) { - return response.text(); - } - - return undefined; - } -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts new file mode 100644 index 000000000..11f65fc28 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts @@ -0,0 +1,16 @@ +import { Middleware } from '@inversifyjs/http-core'; +import { NextFunction, Request, Response } from 'express'; +import { injectable } from 'inversify'; + +@injectable() +export class SuccessfulExpressMiddleware + implements Middleware +{ + public async execute( + _request: Request, + _response: Response, + next: NextFunction, + ): Promise { + next(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/UnsuccessfulExpressMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/UnsuccessfulExpressMiddleware.ts new file mode 100644 index 000000000..8917b760a --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/UnsuccessfulExpressMiddleware.ts @@ -0,0 +1,16 @@ +import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; +import { NextFunction, Request, Response } from 'express'; +import { injectable } from 'inversify'; + +@injectable() +export class UnsuccessfulExpressMiddleware + implements Middleware +{ + public async execute( + _request: Request, + response: Response, + _next: NextFunction, + ): Promise { + response.status(HttpStatusCode.FORBIDDEN).send(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts new file mode 100644 index 000000000..9929b0fa6 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts @@ -0,0 +1,16 @@ +import { Middleware } from '@inversifyjs/http-core'; +import { NextFunction, Request, Response } from 'express4'; +import { injectable } from 'inversify'; + +@injectable() +export class SuccessfulExpressV4Middleware + implements Middleware +{ + public async execute( + _request: Request, + _response: Response, + next: NextFunction, + ): Promise { + next(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/UnsuccessfulExpressV4Middleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/UnsuccessfulExpressV4Middleware.ts new file mode 100644 index 000000000..224e0df16 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/UnsuccessfulExpressV4Middleware.ts @@ -0,0 +1,16 @@ +import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; +import { NextFunction, Request, Response } from 'express4'; +import { injectable } from 'inversify'; + +@injectable() +export class UnsuccessfulExpressV4Middleware + implements Middleware +{ + public async execute( + _request: Request, + response: Response, + _next: NextFunction, + ): Promise { + response.status(HttpStatusCode.FORBIDDEN).send(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts new file mode 100644 index 000000000..a98fde0c1 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts @@ -0,0 +1,17 @@ +import { Middleware } from '@inversifyjs/http-core'; +import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify'; +import { injectable } from 'inversify'; + +@injectable() +export class SuccessfulFastifyMiddleware + implements + Middleware +{ + public async execute( + _request: FastifyRequest, + _response: FastifyReply, + next: HookHandlerDoneFunction, + ): Promise { + next(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/UnsuccessfulFastifyMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/UnsuccessfulFastifyMiddleware.ts new file mode 100644 index 000000000..bb53a7050 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/UnsuccessfulFastifyMiddleware.ts @@ -0,0 +1,17 @@ +import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; +import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify'; +import { injectable } from 'inversify'; + +@injectable() +export class UnsuccessfulFastifyMiddleware + implements + Middleware +{ + public async execute( + _request: FastifyRequest, + response: FastifyReply, + _next: HookHandlerDoneFunction, + ): Promise { + response.status(HttpStatusCode.FORBIDDEN).send(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts new file mode 100644 index 000000000..1f13839f1 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts @@ -0,0 +1,16 @@ +import { Middleware } from '@inversifyjs/http-core'; +import { Context, HonoRequest, Next } from 'hono'; +import { injectable } from 'inversify'; + +@injectable() +export class SuccessfulHonoMiddleware + implements Middleware +{ + public async execute( + _request: HonoRequest, + _response: Context, + next: Next, + ): Promise { + await next(); + } +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/UnsuccessfulHonoMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/UnsuccessfulHonoMiddleware.ts new file mode 100644 index 000000000..dc33d8f86 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/UnsuccessfulHonoMiddleware.ts @@ -0,0 +1,18 @@ +import { HttpStatusCode, Middleware } from '@inversifyjs/http-core'; +import { Context, HonoRequest, Next } from 'hono'; +import { injectable } from 'inversify'; + +@injectable() +export class UnsuccessfulHonoMiddleware + implements Middleware +{ + public async execute( + _request: HonoRequest, + response: Context, + _next: Next, + ): Promise { + response.status(HttpStatusCode.FORBIDDEN); + + return response.json(undefined); + } +} From 732e07dc2c232263279b0181e5280f704e15b51a Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Thu, 1 May 2025 14:15:59 +0200 Subject: [PATCH 09/15] feat(http-e2e-tests): add new middleware controller implementations for Express, Fastify, and Hono --- .../WarriorsDeleteSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsDeleteUnsuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsGetSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsGetUnsuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsOptionsSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsOptionsUnsuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPatchSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPatchUnsuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPostSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPostUnsuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPutSuccessfulMiddlewareController.ts | 10 ---------- .../WarriorsPutUnsuccessfulMiddlewareController.ts | 10 ---------- ...riorsDeleteSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...orsDeleteUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...WarriorsGetSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...rriorsGetUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...iorsOptionsSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...rsOptionsUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...rriorsPatchSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...iorsPatchUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...arriorsPostSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...riorsPostUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...WarriorsPutSuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...rriorsPutUnsuccessfulExpressMiddlewareController.ts | 10 ++++++++++ ...orsDeleteSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...sDeleteUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...rriorsGetSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...iorsGetUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...rsOptionsSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...OptionsUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...iorsPatchSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...rsPatchUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...riorsPostSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...orsPostUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...rriorsPutSuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...iorsPutUnsuccessfulExpressV4MiddlewareController.ts | 10 ++++++++++ ...riorsDeleteSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...orsDeleteUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...WarriorsGetSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...rriorsGetUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...iorsOptionsSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...rsOptionsUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...rriorsPatchSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...iorsPatchUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...arriorsPostSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...riorsPostUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...WarriorsPutSuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...rriorsPutUnsuccessfulFastifyMiddlewareController.ts | 10 ++++++++++ ...WarriorsDeleteSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ ...rriorsDeleteUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsGetSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsGetUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ ...arriorsOptionsSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ ...riorsOptionsUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsPatchSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ ...arriorsPatchUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsPostSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ ...WarriorsPostUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsPutSuccessfulHonoMiddlewareController.ts | 10 ++++++++++ .../WarriorsPutUnsuccessfulHonoMiddlewareController.ts | 10 ++++++++++ 60 files changed, 480 insertions(+), 120 deletions(-) delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts delete mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutSuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutSuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutSuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutSuccessfulHonoMiddlewareController.ts create mode 100644 packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts deleted file mode 100644 index ddcec0872..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsDeleteSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @DELETE() - public async deleteWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts deleted file mode 100644 index b805b54d7..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsDeleteUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsDeleteUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @DELETE() - public async deleteWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts deleted file mode 100644 index 26dd4546e..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsGetSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @GET() - public async getWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts deleted file mode 100644 index f189b53bf..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsGetUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsGetUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @GET() - public async getWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts deleted file mode 100644 index c11df973f..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsOptionsSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @OPTIONS() - public async optionsWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts deleted file mode 100644 index 3ff62c4ee..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsOptionsUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsOptionsUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @OPTIONS() - public async optionsWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts deleted file mode 100644 index ee549c408..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPatchSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @PATCH() - public async patchWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts deleted file mode 100644 index 3bfcbd59a..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPatchUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPatchUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @PATCH() - public async patchWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts deleted file mode 100644 index 4973ee2cf..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPostSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @POST() - public async postWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts deleted file mode 100644 index 198cb5d43..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPostUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPostUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @POST() - public async postWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts deleted file mode 100644 index 860ad099b..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutSuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; - -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPutSuccessfulMiddlewareController { - @applyMiddleware(SuccessfulMiddleware) - @PUT() - public async putWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts deleted file mode 100644 index f9ff05e0a..000000000 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/WarriorsPutUnsuccessfulMiddlewareController.ts +++ /dev/null @@ -1,10 +0,0 @@ -import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; - -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -@controller('/warriors') -export class WarriorsPutUnsuccessfulMiddlewareController { - @applyMiddleware(UnsuccessfulMiddleware) - @PUT() - public async putWarrior(): Promise {} -} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..8c0a0a787 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..6b4610d4a --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..c703aab6a --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..08d2d2afe --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsGetUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..2bfa38813 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..d550baef6 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..db8f77bae --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..4e27b0b08 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsPatchUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..d838bb646 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..db08e362f --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsPostUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutSuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutSuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..5783cc704 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts new file mode 100644 index 000000000..206c883e7 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressMiddleware } from '../../middlewares/express/UnsuccessfulExpressMiddleware'; + +@controller('/warriors') +export class WarriorsPutUnsuccessfulExpressMiddlewareController { + @applyMiddleware(UnsuccessfulExpressMiddleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..a4348d9fe --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..5e6de2d10 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsDeleteUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..245a38bd7 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..f9fd1f901 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsGetUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..34e82a0c5 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..10ebefece --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsOptionsUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..105018a3f --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..8d36df792 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsPatchUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..47e14666c --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..4813bf0fa --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsPostUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutSuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutSuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..4c920f973 --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts new file mode 100644 index 000000000..b9531876d --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { UnsuccessfulExpressV4Middleware } from '../../middlewares/express4/UnsuccessfulExpressV4Middleware'; + +@controller('/warriors') +export class WarriorsPutUnsuccessfulExpressV4MiddlewareController { + @applyMiddleware(UnsuccessfulExpressV4Middleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..a474d51ce --- /dev/null +++ b/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 {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..6522a1c55 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..88555da59 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetSuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsGetSuccessfulFastifyMiddlewareController { + @applyMiddleware(SuccessfulFastifyMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..025cab390 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsGetUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..0c2bb3b59 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsSuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsSuccessfulFastifyMiddlewareController { + @applyMiddleware(SuccessfulFastifyMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..4575e48b9 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..03c4ba6d0 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchSuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPatchSuccessfulFastifyMiddlewareController { + @applyMiddleware(SuccessfulFastifyMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..22ce4d64b --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPatchUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..5d32efe20 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostSuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPostSuccessfulFastifyMiddlewareController { + @applyMiddleware(SuccessfulFastifyMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..b2b1a4ef3 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPostUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutSuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutSuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..f6dd60f73 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutSuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPutSuccessfulFastifyMiddlewareController { + @applyMiddleware(SuccessfulFastifyMiddleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts new file mode 100644 index 000000000..6ce1fc963 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; + +@controller('/warriors') +export class WarriorsPutUnsuccessfulFastifyMiddlewareController { + @applyMiddleware(UnsuccessfulFastifyMiddleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..39f4e3ad0 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..971abb127 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsDeleteUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @DELETE() + public async deleteWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..97f788d6f --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsGetSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..0b5d6a217 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsGetUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @GET() + public async getWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..f59a8df88 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..36cf3be98 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsOptionsUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @OPTIONS() + public async optionsWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..77e26be7e --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPatchSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..541d3b885 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPatchUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @PATCH() + public async patchWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..ae1cb89c6 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPostSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..e1bf80e25 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPostUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @POST() + public async postWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutSuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutSuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..91a0941bf --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutSuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPutSuccessfulHonoMiddlewareController { + @applyMiddleware(SuccessfulHonoMiddleware) + @PUT() + public async putWarrior(): Promise {} +} diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts new file mode 100644 index 000000000..6ae578d04 --- /dev/null +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts @@ -0,0 +1,10 @@ +import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; + +import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; + +@controller('/warriors') +export class WarriorsPutUnsuccessfulHonoMiddlewareController { + @applyMiddleware(UnsuccessfulHonoMiddleware) + @PUT() + public async putWarrior(): Promise {} +} From 0af807e9ad4c17f296412acaac016d4f257e01a4 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Thu, 1 May 2025 14:18:43 +0200 Subject: [PATCH 10/15] feat(http-e2e-tests): implement successful and unsuccessful middleware controllers given definitions --- .../step-definitions/givenDefinitions.ts | 323 ++++++++++++++++-- 1 file changed, 286 insertions(+), 37 deletions(-) diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts index f5df614be..046e976d8 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts @@ -5,105 +5,354 @@ import { defaultAlias } from '../../../common/models/defaultAlias'; import { InversifyHttpWorld } from '../../../common/models/InversifyHttpWorld'; import { getContainerOrFail } from '../../../container/calculations/getContainerOrFail'; import { HttpMethod } from '../../../http/models/HttpMethod'; -import { WarriorsDeleteSuccessfulMiddlewareController } from '../controllers/WarriorsDeleteSuccessfulMiddlewareController'; -import { WarriorsDeleteUnsuccessfulMiddlewareController } from '../controllers/WarriorsDeleteUnsuccessfulMiddlewareController'; -import { WarriorsGetSuccessfulMiddlewareController } from '../controllers/WarriorsGetSuccessfulMiddlewareController'; -import { WarriorsGetUnsuccessfulMiddlewareController } from '../controllers/WarriorsGetUnsuccessfulMiddlewareController'; -import { WarriorsOptionsSuccessfulMiddlewareController } from '../controllers/WarriorsOptionsSuccessfulMiddlewareController'; -import { WarriorsOptionsUnsuccessfulMiddlewareController } from '../controllers/WarriorsOptionsUnsuccessfulMiddlewareController'; -import { WarriorsPatchSuccessfulMiddlewareController } from '../controllers/WarriorsPatchSuccessfulMiddlewareController'; -import { WarriorsPatchUnsuccessfulMiddlewareController } from '../controllers/WarriorsPatchUnsuccessfulMiddlewareController'; -import { WarriorsPostSuccessfulMiddlewareController } from '../controllers/WarriorsPostSuccessfulMiddlewareController'; -import { WarriorsPostUnsuccessfulMiddlewareController } from '../controllers/WarriorsPostUnsuccessfulMiddlewareController'; -import { WarriorsPutSuccessfulMiddlewareController } from '../controllers/WarriorsPutSuccessfulMiddlewareController'; -import { WarriorsPutUnsuccessfulMiddlewareController } from '../controllers/WarriorsPutUnsuccessfulMiddlewareController'; -import { SuccessfulMiddleware } from '../middlewares/SuccessfulMiddleware'; -import { UnsuccessfulMiddleware } from '../middlewares/UnsuccessfulMiddleware'; - -function getMethodWarriorSuccessfulMiddlewareController( +import { ServerKind } from '../../../server/models/ServerKind'; +import { WarriorsDeleteSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsDeleteSuccessfulExpressMiddlewareController'; +import { WarriorsDeleteUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController'; +import { WarriorsGetSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsGetSuccessfulExpressMiddlewareController'; +import { WarriorsGetUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController'; +import { WarriorsOptionsSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsOptionsSuccessfulExpressMiddlewareController'; +import { WarriorsOptionsUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController'; +import { WarriorsPatchSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPatchSuccessfulExpressMiddlewareController'; +import { WarriorsPatchUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController'; +import { WarriorsPostSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPostSuccessfulExpressMiddlewareController'; +import { WarriorsPostUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController'; +import { WarriorsPutSuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPutSuccessfulExpressMiddlewareController'; +import { WarriorsPutUnsuccessfulExpressMiddlewareController } from '../controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController'; +import { WarriorsDeleteSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsDeleteSuccessfulExpressV4MiddlewareController'; +import { WarriorsDeleteUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsGetSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsGetSuccessfulExpressV4MiddlewareController'; +import { WarriorsGetUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsOptionsSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsOptionsSuccessfulExpressV4MiddlewareController'; +import { WarriorsOptionsUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsPatchSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPatchSuccessfulExpressV4MiddlewareController'; +import { WarriorsPatchUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsPostSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPostSuccessfulExpressV4MiddlewareController'; +import { WarriorsPostUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsPutSuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPutSuccessfulExpressV4MiddlewareController'; +import { WarriorsPutUnsuccessfulExpressV4MiddlewareController } from '../controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController'; +import { WarriorsDeleteSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsDeleteSuccessfulFastifyMiddlewareController'; +import { WarriorsDeleteUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController'; +import { WarriorsGetSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsGetSuccessfulFastifyMiddlewareController'; +import { WarriorsGetUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController'; +import { WarriorsOptionsSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsOptionsSuccessfulFastifyMiddlewareController'; +import { WarriorsOptionsUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController'; +import { WarriorsPatchSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPatchSuccessfulFastifyMiddlewareController'; +import { WarriorsPatchUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController'; +import { WarriorsPostSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPostSuccessfulFastifyMiddlewareController'; +import { WarriorsPostUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController'; +import { WarriorsPutSuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPutSuccessfulFastifyMiddlewareController'; +import { WarriorsPutUnsuccessfulFastifyMiddlewareController } from '../controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController'; +import { WarriorsDeleteSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsDeleteSuccessfulHonoMiddlewareController'; +import { WarriorsDeleteUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController'; +import { WarriorsGetSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsGetSuccessfulHonoMiddlewareController'; +import { WarriorsGetUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController'; +import { WarriorsOptionsSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsOptionsSuccessfulHonoMiddlewareController'; +import { WarriorsOptionsUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController'; +import { WarriorsPatchSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPatchSuccessfulHonoMiddlewareController'; +import { WarriorsPatchUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController'; +import { WarriorsPostSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPostSuccessfulHonoMiddlewareController'; +import { WarriorsPostUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController'; +import { WarriorsPutSuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPutSuccessfulHonoMiddlewareController'; +import { WarriorsPutUnsuccessfulHonoMiddlewareController } from '../controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController'; +import { SuccessfulExpressMiddleware } from '../middlewares/express/SuccessfulExpressMiddleware'; +import { UnsuccessfulExpressMiddleware } from '../middlewares/express/UnsuccessfulExpressMiddleware'; +import { SuccessfulExpressV4Middleware } from '../middlewares/express4/SuccessfulExpressV4Middleware'; +import { UnsuccessfulExpressV4Middleware } from '../middlewares/express4/UnsuccessfulExpressV4Middleware'; +import { SuccessfulFastifyMiddleware } from '../middlewares/fastify/SuccessfulFastifyMiddleware'; +import { UnsuccessfulFastifyMiddleware } from '../middlewares/fastify/UnsuccessfulFastifyMiddleware'; +import { SuccessfulHonoMiddleware } from '../middlewares/hono/SuccessfulHonoMiddleware'; +import { UnsuccessfulHonoMiddleware } from '../middlewares/hono/UnsuccessfulHonoMiddleware'; + +function getMethodWarriorSuccessfulExpressMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteSuccessfulExpressMiddlewareController; + case HttpMethod.get: + return WarriorsGetSuccessfulExpressMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsSuccessfulExpressMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchSuccessfulExpressMiddlewareController; + case HttpMethod.post: + return WarriorsPostSuccessfulExpressMiddlewareController; + case HttpMethod.put: + return WarriorsPutSuccessfulExpressMiddlewareController; + } +} + +function getMethodWarriorSuccessfulExpressV4MiddlewareController( method: HttpMethod, ): NewableFunction { switch (method) { case HttpMethod.delete: - return WarriorsDeleteSuccessfulMiddlewareController; + return WarriorsDeleteSuccessfulExpressV4MiddlewareController; case HttpMethod.get: - return WarriorsGetSuccessfulMiddlewareController; + return WarriorsGetSuccessfulExpressV4MiddlewareController; case HttpMethod.options: - return WarriorsOptionsSuccessfulMiddlewareController; + return WarriorsOptionsSuccessfulExpressV4MiddlewareController; case HttpMethod.patch: - return WarriorsPatchSuccessfulMiddlewareController; + return WarriorsPatchSuccessfulExpressV4MiddlewareController; case HttpMethod.post: - return WarriorsPostSuccessfulMiddlewareController; + return WarriorsPostSuccessfulExpressV4MiddlewareController; case HttpMethod.put: - return WarriorsPutSuccessfulMiddlewareController; + return WarriorsPutSuccessfulExpressV4MiddlewareController; } } -function getMethodWarriorUnsuccessfulMiddlewareController( +function getMethodWarriorSuccessfulFastifyMiddlewareController( method: HttpMethod, ): NewableFunction { switch (method) { case HttpMethod.delete: - return WarriorsDeleteUnsuccessfulMiddlewareController; + return WarriorsDeleteSuccessfulFastifyMiddlewareController; case HttpMethod.get: - return WarriorsGetUnsuccessfulMiddlewareController; + return WarriorsGetSuccessfulFastifyMiddlewareController; case HttpMethod.options: - return WarriorsOptionsUnsuccessfulMiddlewareController; + return WarriorsOptionsSuccessfulFastifyMiddlewareController; case HttpMethod.patch: - return WarriorsPatchUnsuccessfulMiddlewareController; + return WarriorsPatchSuccessfulFastifyMiddlewareController; case HttpMethod.post: - return WarriorsPostUnsuccessfulMiddlewareController; + return WarriorsPostSuccessfulFastifyMiddlewareController; case HttpMethod.put: - return WarriorsPutUnsuccessfulMiddlewareController; + return WarriorsPutSuccessfulFastifyMiddlewareController; + } +} + +function getMethodWarriorSuccessfulHonoMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteSuccessfulHonoMiddlewareController; + case HttpMethod.get: + return WarriorsGetSuccessfulHonoMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsSuccessfulHonoMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchSuccessfulHonoMiddlewareController; + case HttpMethod.post: + return WarriorsPostSuccessfulHonoMiddlewareController; + case HttpMethod.put: + return WarriorsPutSuccessfulHonoMiddlewareController; + } +} + +function getMethodWarriorUnsuccessfulExpressMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteUnsuccessfulExpressMiddlewareController; + case HttpMethod.get: + return WarriorsGetUnsuccessfulExpressMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsUnsuccessfulExpressMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchUnsuccessfulExpressMiddlewareController; + case HttpMethod.post: + return WarriorsPostUnsuccessfulExpressMiddlewareController; + case HttpMethod.put: + return WarriorsPutUnsuccessfulExpressMiddlewareController; + } +} + +function getMethodWarriorUnsuccessfulExpressV4MiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteUnsuccessfulExpressV4MiddlewareController; + case HttpMethod.get: + return WarriorsGetUnsuccessfulExpressV4MiddlewareController; + case HttpMethod.options: + return WarriorsOptionsUnsuccessfulExpressV4MiddlewareController; + case HttpMethod.patch: + return WarriorsPatchUnsuccessfulExpressV4MiddlewareController; + case HttpMethod.post: + return WarriorsPostUnsuccessfulExpressV4MiddlewareController; + case HttpMethod.put: + return WarriorsPutUnsuccessfulExpressV4MiddlewareController; + } +} + +function getMethodWarriorUnsuccessfulFastifyMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteUnsuccessfulFastifyMiddlewareController; + case HttpMethod.get: + return WarriorsGetUnsuccessfulFastifyMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsUnsuccessfulFastifyMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchUnsuccessfulFastifyMiddlewareController; + case HttpMethod.post: + return WarriorsPostUnsuccessfulFastifyMiddlewareController; + case HttpMethod.put: + return WarriorsPutUnsuccessfulFastifyMiddlewareController; + } +} + +function getMethodWarriorUnsuccessfulHonoMiddlewareController( + method: HttpMethod, +): NewableFunction { + switch (method) { + case HttpMethod.delete: + return WarriorsDeleteUnsuccessfulHonoMiddlewareController; + case HttpMethod.get: + return WarriorsGetUnsuccessfulHonoMiddlewareController; + case HttpMethod.options: + return WarriorsOptionsUnsuccessfulHonoMiddlewareController; + case HttpMethod.patch: + return WarriorsPatchUnsuccessfulHonoMiddlewareController; + case HttpMethod.post: + return WarriorsPostUnsuccessfulHonoMiddlewareController; + case HttpMethod.put: + return WarriorsPutUnsuccessfulHonoMiddlewareController; } } function givenWarriorSuccessfulMiddlewareControllerForContainer( this: InversifyHttpWorld, method: HttpMethod, + serverKind: ServerKind, containerAlias?: string, ): void { const parsedContainerAlias: string = containerAlias ?? defaultAlias; + const container: Container = getContainerOrFail.bind(this)(parsedContainerAlias); + let getMethodWarriorSuccessfulController: ( + method: HttpMethod, + ) => NewableFunction; + + switch (serverKind) { + case ServerKind.express: + getMethodWarriorSuccessfulController = + getMethodWarriorSuccessfulExpressMiddlewareController; + break; + case ServerKind.express4: + getMethodWarriorSuccessfulController = + getMethodWarriorSuccessfulExpressV4MiddlewareController; + break; + case ServerKind.fastify: + getMethodWarriorSuccessfulController = + getMethodWarriorSuccessfulFastifyMiddlewareController; + break; + case ServerKind.hono: + getMethodWarriorSuccessfulController = + getMethodWarriorSuccessfulHonoMiddlewareController; + break; + } + const controller: NewableFunction = - getMethodWarriorSuccessfulMiddlewareController(method); + getMethodWarriorSuccessfulController(method); - container.bind(SuccessfulMiddleware).toSelf().inSingletonScope(); + let middleware: NewableFunction; + switch (serverKind) { + case ServerKind.express: + middleware = SuccessfulExpressMiddleware; + break; + case ServerKind.express4: + middleware = SuccessfulExpressV4Middleware; + break; + case ServerKind.fastify: + middleware = SuccessfulFastifyMiddleware; + break; + case ServerKind.hono: + middleware = SuccessfulHonoMiddleware; + break; + } + + container.bind(middleware).toSelf().inSingletonScope(); container.bind(controller).toSelf().inSingletonScope(); } function givenWarriorUnsuccessfulMiddlewareControllerForContainer( this: InversifyHttpWorld, method: HttpMethod, + serverKind: ServerKind, containerAlias?: string, ): void { const parsedContainerAlias: string = containerAlias ?? defaultAlias; + const container: Container = getContainerOrFail.bind(this)(parsedContainerAlias); + let getMethodWarriorUnsuccessfulController: ( + method: HttpMethod, + ) => NewableFunction; + + switch (serverKind) { + case ServerKind.express: + getMethodWarriorUnsuccessfulController = + getMethodWarriorUnsuccessfulExpressMiddlewareController; + break; + case ServerKind.express4: + getMethodWarriorUnsuccessfulController = + getMethodWarriorUnsuccessfulExpressV4MiddlewareController; + break; + case ServerKind.fastify: + getMethodWarriorUnsuccessfulController = + getMethodWarriorUnsuccessfulFastifyMiddlewareController; + break; + case ServerKind.hono: + getMethodWarriorUnsuccessfulController = + getMethodWarriorUnsuccessfulHonoMiddlewareController; + break; + } + const controller: NewableFunction = - getMethodWarriorUnsuccessfulMiddlewareController(method); + getMethodWarriorUnsuccessfulController(method); + + let middleware: NewableFunction; + switch (serverKind) { + case ServerKind.express: + middleware = UnsuccessfulExpressMiddleware; + break; + case ServerKind.express4: + middleware = UnsuccessfulExpressV4Middleware; + break; + case ServerKind.fastify: + middleware = UnsuccessfulFastifyMiddleware; + break; + case ServerKind.hono: + middleware = UnsuccessfulHonoMiddleware; + break; + } - container.bind(UnsuccessfulMiddleware).toSelf().inSingletonScope(); + container.bind(middleware).toSelf().inSingletonScope(); container.bind(controller).toSelf().inSingletonScope(); } Given( - 'a warrior controller with SuccessfulMiddleware for "{httpMethod}" method', - function (this: InversifyHttpWorld, httpMethod: HttpMethod): void { + 'a warrior controller with SuccessfulMiddleware for "{httpMethod}" method and "{serverKind}" server', + function ( + this: InversifyHttpWorld, + httpMethod: HttpMethod, + serverKind: ServerKind, + ): void { givenWarriorSuccessfulMiddlewareControllerForContainer.bind(this)( httpMethod, + serverKind, ); }, ); Given( - 'a warrior controller with UnsuccessfulMiddleware for "{httpMethod}" method', - function (this: InversifyHttpWorld, httpMethod: HttpMethod): void { + 'a warrior controller with UnsuccessfulMiddleware for "{httpMethod}" method and "{serverKind}" server', + function ( + this: InversifyHttpWorld, + httpMethod: HttpMethod, + serverKind: ServerKind, + ): void { givenWarriorUnsuccessfulMiddlewareControllerForContainer.bind(this)( httpMethod, + serverKind, ); }, ); From 0831d5fb97e1a53b62271891dd82ed7958c41d0b Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Thu, 1 May 2025 14:19:18 +0200 Subject: [PATCH 11/15] fix(http-e2e-tests): include in successful and unsuccessful middleware scenarios --- packages/http/tools/e2e-tests/features/middleware.feature | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/http/tools/e2e-tests/features/middleware.feature b/packages/http/tools/e2e-tests/features/middleware.feature index 856e3829d..8de200f35 100644 --- a/packages/http/tools/e2e-tests/features/middleware.feature +++ b/packages/http/tools/e2e-tests/features/middleware.feature @@ -7,7 +7,7 @@ The m allows to continue or stop the request processing 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 + Given a warrior controller with SuccessfulMiddleware for method and server And a server from container And a warriors HTTP request When the request is send @@ -42,7 +42,7 @@ The m allows to continue or stop the request processing Scenario: middleware allows to stop request processing - Given a warrior controller with UnsuccessfulMiddleware for method + Given a warrior controller with UnsuccessfulMiddleware for method and server And a server from container And a warriors HTTP request When the request is send From 499380ee4699eab6f12825e1f3ec527fdf01d1eb Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 3 May 2025 13:27:40 +0200 Subject: [PATCH 12/15] refactor(http-e2e-tests): set test header at SuccessfulMiddleware --- .../middlewares/express/SuccessfulExpressMiddleware.ts | 4 +++- .../middlewares/express4/SuccessfulExpressV4Middleware.ts | 4 +++- .../middlewares/fastify/SuccessfulFastifyMiddleware.ts | 4 +++- .../middleware/middlewares/hono/SuccessfulHonoMiddleware.ts | 4 +++- 4 files changed, 12 insertions(+), 4 deletions(-) diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts index 11f65fc28..8c888d334 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express/SuccessfulExpressMiddleware.ts @@ -8,9 +8,11 @@ export class SuccessfulExpressMiddleware { public async execute( _request: Request, - _response: Response, + response: Response, next: NextFunction, ): Promise { + response.setHeader('x-test-header', 'test-value'); + next(); } } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts index 9929b0fa6..918a1a7cb 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/express4/SuccessfulExpressV4Middleware.ts @@ -8,9 +8,11 @@ export class SuccessfulExpressV4Middleware { public async execute( _request: Request, - _response: Response, + response: Response, next: NextFunction, ): Promise { + response.setHeader('x-test-header', 'test-value'); + next(); } } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts index a98fde0c1..2a0659095 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/fastify/SuccessfulFastifyMiddleware.ts @@ -9,9 +9,11 @@ export class SuccessfulFastifyMiddleware { public async execute( _request: FastifyRequest, - _response: FastifyReply, + response: FastifyReply, next: HookHandlerDoneFunction, ): Promise { + response.header('x-test-header', 'test-value'); + next(); } } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts index 1f13839f1..04db1ac3a 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/middlewares/hono/SuccessfulHonoMiddleware.ts @@ -8,9 +8,11 @@ export class SuccessfulHonoMiddleware { public async execute( _request: HonoRequest, - _response: Context, + response: Context, next: Next, ): Promise { + response.header('x-test-header', 'test-value'); + await next(); } } From 5421ac17b93809d519a12440017ba2c86b9ecb7d Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 3 May 2025 13:29:05 +0200 Subject: [PATCH 13/15] refactor(http-e2e-tests): apply SuccessfulExpressMiddleware to all UnsuccessfulMiddlewareControllers --- ...WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts | 3 ++- .../WarriorsGetUnsuccessfulExpressMiddlewareController.ts | 3 ++- ...arriorsOptionsUnsuccessfulExpressMiddlewareController.ts | 3 ++- .../WarriorsPatchUnsuccessfulExpressMiddlewareController.ts | 3 ++- .../WarriorsPostUnsuccessfulExpressMiddlewareController.ts | 3 ++- .../WarriorsPutUnsuccessfulExpressMiddlewareController.ts | 3 ++- ...rriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- .../WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- ...riorsOptionsUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- ...arriorsPatchUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- ...WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- .../WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts | 6 +++++- ...WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts | 3 ++- .../WarriorsGetUnsuccessfulFastifyMiddlewareController.ts | 3 ++- ...arriorsOptionsUnsuccessfulFastifyMiddlewareController.ts | 3 ++- .../WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts | 3 ++- .../WarriorsPostUnsuccessfulFastifyMiddlewareController.ts | 3 ++- .../WarriorsPutUnsuccessfulFastifyMiddlewareController.ts | 3 ++- .../WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts | 3 ++- .../hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts | 3 ++- .../WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts | 3 ++- .../WarriorsPatchUnsuccessfulHonoMiddlewareController.ts | 3 ++- .../WarriorsPostUnsuccessfulHonoMiddlewareController.ts | 3 ++- .../hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts | 3 ++- 24 files changed, 66 insertions(+), 24 deletions(-) diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts index 6b4610d4a..3fa370a12 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsDeleteUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @DELETE() public async deleteWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts index 08d2d2afe..9d747fac8 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsGetUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @GET() public async getWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts index d550baef6..43ab41f7d 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsOptionsUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @OPTIONS() public async optionsWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts index 4e27b0b08..c454fb626 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPatchUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @PATCH() public async patchWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts index db08e362f..94dffd95c 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPostUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @POST() public async postWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts index 206c883e7..09feb159a 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express/WarriorsPutUnsuccessfulExpressMiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressMiddleware) + @applyMiddleware(SuccessfulExpressMiddleware, UnsuccessfulExpressMiddleware) @PUT() public async putWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts index 5e6de2d10..66e2f103b 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsDeleteUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @DELETE() public async deleteWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts index f9fd1f901..659dc5db4 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsGetUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @GET() public async getWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts index 10ebefece..40f06228e 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsOptionsUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @OPTIONS() public async optionsWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts index 8d36df792..9fe5ccc71 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPatchUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @PATCH() public async patchWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts index 4813bf0fa..c83da56c8 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPostUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @POST() public async postWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts index b9531876d..ced6b3e0a 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/express4/WarriorsPutUnsuccessfulExpressV4MiddlewareController.ts @@ -1,10 +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(UnsuccessfulExpressV4Middleware) + @applyMiddleware( + SuccessfulExpressV4Middleware, + UnsuccessfulExpressV4Middleware, + ) @PUT() public async putWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts index 6522a1c55..030345c71 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsDeleteUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsDeleteUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @DELETE() public async deleteWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts index 025cab390..3a124534e 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsGetUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsGetUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @GET() public async getWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts index 4575e48b9..37979c926 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsOptionsUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsOptionsUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @OPTIONS() public async optionsWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts index 22ce4d64b..664ad8b02 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPatchUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsPatchUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @PATCH() public async patchWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts index b2b1a4ef3..5c094e94c 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPostUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsPostUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @POST() public async postWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts index 6ce1fc963..b71c0fc91 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/fastify/WarriorsPutUnsuccessfulFastifyMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; +import { SuccessfulFastifyMiddleware } from '../../middlewares/fastify/SuccessfulFastifyMiddleware'; import { UnsuccessfulFastifyMiddleware } from '../../middlewares/fastify/UnsuccessfulFastifyMiddleware'; @controller('/warriors') export class WarriorsPutUnsuccessfulFastifyMiddlewareController { - @applyMiddleware(UnsuccessfulFastifyMiddleware) + @applyMiddleware(SuccessfulFastifyMiddleware, UnsuccessfulFastifyMiddleware) @PUT() public async putWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts index 971abb127..dddbca94b 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsDeleteUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, DELETE } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsDeleteUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @DELETE() public async deleteWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts index 0b5d6a217..df314e654 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsGetUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, GET } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsGetUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @GET() public async getWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts index 36cf3be98..7ec85ff91 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsOptionsUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, OPTIONS } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsOptionsUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @OPTIONS() public async optionsWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts index 541d3b885..bcde92bb3 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPatchUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, PATCH } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsPatchUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @PATCH() public async patchWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts index e1bf80e25..373f3e3c6 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPostUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, POST } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsPostUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @POST() public async postWarrior(): Promise {} } diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts index 6ae578d04..01686358f 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/controllers/hono/WarriorsPutUnsuccessfulHonoMiddlewareController.ts @@ -1,10 +1,11 @@ import { applyMiddleware, controller, PUT } from '@inversifyjs/http-core'; +import { SuccessfulHonoMiddleware } from '../../middlewares/hono/SuccessfulHonoMiddleware'; import { UnsuccessfulHonoMiddleware } from '../../middlewares/hono/UnsuccessfulHonoMiddleware'; @controller('/warriors') export class WarriorsPutUnsuccessfulHonoMiddlewareController { - @applyMiddleware(UnsuccessfulHonoMiddleware) + @applyMiddleware(SuccessfulHonoMiddleware, UnsuccessfulHonoMiddleware) @PUT() public async putWarrior(): Promise {} } From 22846f00f266a41b6d46771d1236be2086cdb4e4 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 3 May 2025 13:30:18 +0200 Subject: [PATCH 14/15] refactor(http-e2e-tests): bind SuccessfulExpressMiddleware to all UnsuccessfulMiddlewareControllers --- .../step-definitions/givenDefinitions.ts | 31 +++++++++++++++---- 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts index 046e976d8..4f6d052e1 100644 --- a/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts +++ b/packages/http/tools/e2e-tests/src/warrior/middleware/step-definitions/givenDefinitions.ts @@ -309,23 +309,42 @@ function givenWarriorUnsuccessfulMiddlewareControllerForContainer( const controller: NewableFunction = getMethodWarriorUnsuccessfulController(method); - let middleware: NewableFunction; + let successfulMiddleware: NewableFunction; + switch (serverKind) { case ServerKind.express: - middleware = UnsuccessfulExpressMiddleware; + successfulMiddleware = SuccessfulExpressMiddleware; break; case ServerKind.express4: - middleware = UnsuccessfulExpressV4Middleware; + successfulMiddleware = SuccessfulExpressV4Middleware; break; case ServerKind.fastify: - middleware = UnsuccessfulFastifyMiddleware; + successfulMiddleware = SuccessfulFastifyMiddleware; break; case ServerKind.hono: - middleware = UnsuccessfulHonoMiddleware; + successfulMiddleware = SuccessfulHonoMiddleware; break; } - container.bind(middleware).toSelf().inSingletonScope(); + let unsuccessfulMiddleware: NewableFunction; + + switch (serverKind) { + case ServerKind.express: + unsuccessfulMiddleware = UnsuccessfulExpressMiddleware; + break; + case ServerKind.express4: + unsuccessfulMiddleware = UnsuccessfulExpressV4Middleware; + break; + case ServerKind.fastify: + unsuccessfulMiddleware = UnsuccessfulFastifyMiddleware; + break; + case ServerKind.hono: + unsuccessfulMiddleware = UnsuccessfulHonoMiddleware; + break; + } + + container.bind(successfulMiddleware).toSelf().inSingletonScope(); + container.bind(unsuccessfulMiddleware).toSelf().inSingletonScope(); container.bind(controller).toSelf().inSingletonScope(); } From a5c5d216617c374a7a3928db625904e862fafc28 Mon Sep 17 00:00:00 2001 From: Adrianmjim Date: Sat, 3 May 2025 13:31:05 +0200 Subject: [PATCH 15/15] refactor(http-e2e-tests): add header check to middleware feature --- .../e2e-tests/features/middleware.feature | 133 +++++++++--------- 1 file changed, 67 insertions(+), 66 deletions(-) diff --git a/packages/http/tools/e2e-tests/features/middleware.feature b/packages/http/tools/e2e-tests/features/middleware.feature index 8de200f35..d5af8ea00 100644 --- a/packages/http/tools/e2e-tests/features/middleware.feature +++ b/packages/http/tools/e2e-tests/features/middleware.feature @@ -4,73 +4,74 @@ 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 + Rule: middleware allows to continue or stop the request processing - Given a warrior controller with SuccessfulMiddleware for method and server - And a server from container - And a warriors HTTP request - When the request is send - Then the response status code is Ok-ish + Scenario: middleware allows to continue request processing + Given a warrior controller with SuccessfulMiddleware for method and server + And a server from container + And a 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" | + 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 + Scenario: middleware allows to stop request processing + Given a warrior controller with UnsuccessfulMiddleware for method and server + And a server from container + And a warriors HTTP request + When the request is send + Then the response status code is FORBIDDEN + Then the response contains the correct header - Given a warrior controller with UnsuccessfulMiddleware for method and server - And a server from container - And a warriors HTTP request - When the request is send - Then the response status code is FORBIDDEN - - 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" | + 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" |