fix(common): Fix @useafter and @UseBefore decorators when it was used…

… twice or more on the same class or method

BREAKING CHANGE:
If you use UseBefore or UseAfter as following:
```typescript
class MyController {
  @UseBefore(Middleware1)
  @UseBefore(Middleware2)
  test(){}
}
```
You have to inverse the middlewares:
```typescript
class MyController {
  @UseBefore(Middleware2)
  @UseBefore(Middleware1)
  test(){}
}
```

The calls order was wrong in v5. v6 fix this problem.

.nycrc

@@ -28,6 +28,6 @@
   "check-coverage": true,
   "lines": 99.86,
   "statements": 99.86,
-  "functions": 99.82,
-  "branches": 88.64
+  "functions": 99.76,
+  "branches": 88.52
 }

packages/common/src/mvc/decorators/method/useAfter.spec.ts

@@ -7,32 +7,38 @@ class CustomMiddleware {
   use() {}
 }
 
+class CustomMiddleware2 {
+  use() {}
+}
+
 describe("UseAfter()", () => {
   describe("when the decorator is use on a class", () => {
     it("should add the middleware on the use stack", () => {
       // WHEN
       @UseAfter(CustomMiddleware)
+      @UseAfter(CustomMiddleware2)
       class Test {
         test() {}
       }
 
       // THEN
       const store = Store.from(Test).get("middlewares");
 
-      expect(store).to.deep.eq({useAfter: [CustomMiddleware]});
+      expect(store).to.deep.eq({useAfter: [CustomMiddleware, CustomMiddleware2]});
     });
   });
   describe("when the decorator is use on a method", () => {
     it("should add the middleware on the use stack", () => {
       // WHEN
       class Test {
         @UseAfter(CustomMiddleware)
+        @UseAfter(CustomMiddleware2)
         test() {}
       }
 
       // THEN
       const endpoint = EndpointMetadata.get(Test, "test");
-      expect(endpoint.afterMiddlewares).to.deep.equal([CustomMiddleware]);
+      expect(endpoint.afterMiddlewares).to.deep.equal([CustomMiddleware, CustomMiddleware2]);
     });
   });
   describe("when the decorator is use in another way", () => {

packages/common/src/mvc/decorators/method/useAfter.ts

@@ -26,11 +26,18 @@ export function UseAfter(...args: any[]): Function {
   return JsonEntityFn((entity, parameters) => {
     switch (entity.decoratorType) {
       case DecoratorTypes.METHOD:
-        (entity as EndpointMetadata).after(args);
+        const endpoint = entity as EndpointMetadata;
+        endpoint.afterMiddlewares = args.concat(endpoint.afterMiddlewares);
+
         break;
 
       case DecoratorTypes.CLASS:
-        entity.store.merge("middlewares", {useAfter: args});
+        const middlewares = entity.store.get("middlewares") || {};
+
+        entity.store.set("middlewares", {
+          ...middlewares,
+          useAfter: [...args, ...(middlewares.useAfter || [])]
+        });
         break;
 
       default:

packages/common/src/mvc/decorators/method/useBefore.spec.ts

@@ -6,32 +6,38 @@ class CustomMiddleware {
   use() {}
 }
 
+class CustomMiddleware2 {
+  use() {}
+}
+
 describe("UseBefore()", () => {
   describe("when the decorator is use on a class", () => {
     it("should add the middleware on the use stack", () => {
       // WHEN
       @UseBefore(CustomMiddleware)
+      @UseBefore(CustomMiddleware2)
       class Test {
         test() {}
       }
 
       // THEN
       const result = Store.from(Test).get("middlewares");
 
-      expect(result).to.deep.eq({useBefore: [CustomMiddleware]});
+      expect(result).to.deep.eq({useBefore: [CustomMiddleware, CustomMiddleware2]});
     });
   });
   describe("when the decorator is use on a method", () => {
     it("should add the middleware on the use stack", () => {
       // WHEN
       class Test {
         @UseBefore(CustomMiddleware)
+        @UseBefore(CustomMiddleware2)
         test() {}
       }
 
       const endpoint = EndpointMetadata.get(Test, "test");
       // THEN
-      expect(endpoint.beforeMiddlewares).to.deep.eq([CustomMiddleware]);
+      expect(endpoint.beforeMiddlewares).to.deep.eq([CustomMiddleware, CustomMiddleware2]);
     });
   });
   describe("when the decorator is use in another way", () => {

packages/common/src/mvc/decorators/method/useBefore.ts

@@ -1,6 +1,6 @@
-import {EndpointMetadata} from "../../models/EndpointMetadata";
 import {DecoratorTypes, UnsupportedDecoratorType} from "@tsed/core";
 import {JsonEntityFn} from "@tsed/schema";
+import {EndpointMetadata} from "../../models/EndpointMetadata";
 
 /**
  * Mounts the specified middleware function or functions at the specified path: the middleware function is executed when
@@ -26,11 +26,18 @@ export function UseBefore(...args: any[]): Function {
   return JsonEntityFn((entity, parameters) => {
     switch (entity.decoratorType) {
       case DecoratorTypes.METHOD:
-        (entity as EndpointMetadata).before(args);
+        const endpoint = entity as EndpointMetadata;
+        endpoint.beforeMiddlewares = args.concat(endpoint.beforeMiddlewares);
+
         break;
 
       case DecoratorTypes.CLASS:
-        entity.store.merge("middlewares", {useBefore: args});
+        const middlewares = entity.store.get("middlewares") || {};
+
+        entity.store.set("middlewares", {
+          ...middlewares,
+          useBefore: [...args, ...(middlewares.useBefore || [])]
+        });
         break;
 
       default:

packages/platform-koa/package.json

@@ -69,12 +69,12 @@
     "ejs": "3.1.5"
   },
   "dependencies": {
-    "@koa/router": "9.4.0",
-    "koa-compose": "4.1.0",
-    "koa-static": "5.0.0",
-    "koa-mount": "4.0.0",
-    "multer": "1.4.2",
-    "encodeurl": "1.0.2"
+    "@koa/router": "^9.4.0",
+    "koa-compose": "^4.1.0",
+    "koa-static": "^5.0.0",
+    "koa-mount": "^4.0.0",
+    "multer": "^1.4.2",
+    "encodeurl": "^1.0.2"
   },
   "peerDependencies": {}
 }

packages/platform-koa/src/decorators/ctx.ts

@@ -1,9 +1,11 @@
-import {mapParamsOptions, UseParam} from "@tsed/common";
+import {UseParam} from "@tsed/common";
 import type {Context} from "koa";
 
 /**
  * Return the original Koa context.
  * @decorator
+ * @operation
+ * @input
  * @koa
  */
 export function KoaCtx(): ParameterDecorator {
@@ -16,6 +18,8 @@ export function KoaCtx(): ParameterDecorator {
 /**
  * Return the original Koa context.
  * @decorator
+ * @operation
+ * @input
  * @koa
  */
 export function Ctx(): ParameterDecorator {