@tsed/platform-koa 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-koa",
   "description": "Koa package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -53,12 +54,12 @@
   "repository": "https://github.com/tsedio/tsed",
   "devDependencies": {
     "@koa/cors": "5.0.0",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/platform-test-sdk": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/platform-test-sdk": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "@types/koa": "2.15.0",
     "@types/koa-bodyparser": "4.3.12",
     "@types/koa-compose": "3.2.8",
@@ -86,13 +87,13 @@
     "tslib": "2.7.0"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/openspec": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1",
+    "@tsed/openspec": "8.0.3",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/schema": "8.0.3",
     "cross-env": "7.0.3",
     "koa": ">=2.13.0",
     "koa-bodyparser": ">=4.3.0",

package/src/components/PlatformKoa.spec.ts

@@ -0,0 +1,64 @@
+import {PlatformKoa} from "./PlatformKoa.js";
+
+class Server {}
+
+describe("PlatformKoa", () => {
+  describe("create()", () => {
+    it("should create platform", () => {
+      const platform = PlatformKoa.create(Server, {});
+
+      expect(platform.adapter).toBeInstanceOf(PlatformKoa);
+    });
+  });
+  describe("bootstrap()", () => {
+    it("should create platform", async () => {
+      const platform = await PlatformKoa.bootstrap(Server, {});
+
+      expect(platform.adapter).toBeInstanceOf(PlatformKoa);
+    });
+  });
+  describe("bodyParser()", () => {
+    it("should return the body parser (json)", () => {
+      const stub = vi.fn().mockReturnValue("body");
+
+      const platform = PlatformKoa.create(Server, {
+        koa: {
+          bodyParser: stub
+        }
+      });
+
+      const result = platform.adapter.bodyParser("json", {strict: true});
+
+      expect(result).toEqual("body");
+      expect(stub).toHaveBeenCalledWith({strict: true});
+    });
+    it("should return the body parser (raw)", () => {
+      const stub = vi.fn().mockReturnValue("body");
+
+      const platform = PlatformKoa.create(Server, {
+        koa: {
+          bodyParser: stub
+        }
+      });
+
+      const result = platform.adapter.bodyParser("raw", {strict: true});
+
+      expect(result).toEqual("body");
+      expect(stub).toHaveBeenCalledWith({strict: true});
+    });
+    it("should return the body parser (urlencoded)", () => {
+      const stub = vi.fn().mockReturnValue("body");
+
+      const platform = PlatformKoa.create(Server, {
+        koa: {
+          bodyParser: stub
+        }
+      });
+
+      const result = platform.adapter.bodyParser("urlencoded", {strict: true});
+
+      expect(result).toEqual("body");
+      expect(stub).toHaveBeenCalledWith({strict: true});
+    });
+  });
+});

package/src/components/PlatformKoa.ts

@@ -0,0 +1,209 @@
+import KoaRouter from "@koa/router";
+import {catchAsyncError, isFunction, Type} from "@tsed/core";
+import {constant, inject, runInContext} from "@tsed/di";
+import {PlatformExceptions} from "@tsed/platform-exceptions";
+import {
+  adapter,
+  application,
+  createContext,
+  Platform,
+  PlatformAdapter,
+  PlatformApplication,
+  PlatformBuilder,
+  PlatformHandler,
+  PlatformMulter,
+  PlatformMulterSettings,
+  PlatformRequest,
+  PlatformResponse,
+  PlatformStaticsOptions
+} from "@tsed/platform-http";
+import {PlatformHandlerMetadata, PlatformHandlerType, PlatformLayer} from "@tsed/platform-router";
+import Koa, {Context, Next} from "koa";
+import koaBodyParser, {Options} from "koa-bodyparser";
+// @ts-ignore
+import koaQs from "koa-qs";
+import send from "koa-send";
+
+import {staticsMiddleware} from "../middlewares/staticsMiddleware.js";
+import {PlatformKoaHandler} from "../services/PlatformKoaHandler.js";
+import {PlatformKoaRequest} from "../services/PlatformKoaRequest.js";
+import {PlatformKoaResponse} from "../services/PlatformKoaResponse.js";
+import {getMulter} from "../utils/multer.js";
+
+declare global {
+  namespace TsED {
+    export interface Application extends Koa {}
+  }
+
+  namespace TsED {
+    export interface StaticsOptions extends send.SendOptions {}
+  }
+}
+
+// @ts-ignore
+KoaRouter.prototype.$$match = KoaRouter.prototype.match;
+KoaRouter.prototype.match = function match(...args: any[]) {
+  const matched = this.$$match(...args);
+  if (matched) {
+    if (matched.path.length) {
+      matched.route = true;
+    }
+  }
+
+  return matched;
+};
+
+/**
+ * @platform
+ * @koa
+ */
+export class PlatformKoa extends PlatformAdapter<Koa> {
+  readonly NAME = "koa";
+  readonly providers = [
+    {
+      token: PlatformResponse,
+      useClass: PlatformKoaResponse
+    },
+    {
+      token: PlatformRequest,
+      useClass: PlatformKoaRequest
+    },
+    {
+      token: PlatformHandler,
+      useClass: PlatformKoaHandler
+    },
+    {token: PlatformApplication},
+    {token: Platform}
+  ];
+
+  /**
+   * Create new serverless application. In this mode, the component scan are disabled.
+   * @param module
+   * @param settings
+   */
+  static create(module: Type<any>, settings: Partial<TsED.Configuration> = {}) {
+    return PlatformBuilder.create<Koa>(module, {
+      ...settings,
+      adapter: PlatformKoa
+    });
+  }
+
+  /**
+   * Bootstrap a server application
+   * @param module
+   * @param settings
+   */
+  static bootstrap(module: Type<any>, settings: Partial<TsED.Configuration> = {}) {
+    return PlatformBuilder.bootstrap<Koa>(module, {
+      ...settings,
+      adapter: PlatformKoa
+    });
+  }
+
+  onInit() {
+    this.app.getApp().silent = true;
+  }
+
+  mapLayers(layers: PlatformLayer[]) {
+    const options = constant("koa.router", {});
+    const rawRouter = new KoaRouter(options) as any;
+
+    layers.forEach((layer) => {
+      switch (layer.method) {
+        case "statics":
+          rawRouter.use(layer.path, this.statics(layer.path as string, layer.opts as any));
+          break;
+
+        default:
+          rawRouter[layer.method](...layer.getArgs());
+      }
+    });
+
+    application().getApp().use(rawRouter.routes()).use(rawRouter.allowedMethods());
+  }
+
+  mapHandler(handler: Function, metadata: PlatformHandlerMetadata) {
+    return async (koaContext: Koa.Context, next: Koa.Next) => {
+      const {$ctx} = koaContext.request;
+
+      $ctx.next = next;
+
+      const error = await catchAsyncError(() => handler($ctx));
+
+      if (error) {
+        $ctx.error = error;
+      }
+
+      if (metadata.type !== PlatformHandlerType.RESPONSE_FN) {
+        return $ctx.next && $ctx.error ? $ctx.next($ctx.error) : $ctx.next();
+      }
+    };
+  }
+
+  useContext(): this {
+    const invoke = createContext();
+    const platformExceptions = inject(PlatformExceptions);
+
+    application().use((koaContext: Context, next: Next) => {
+      const $ctx = invoke({
+        request: koaContext.request as any,
+        response: koaContext.response as any,
+        koaContext
+      });
+
+      return runInContext($ctx, async () => {
+        try {
+          await $ctx.start();
+          await next();
+          const status = koaContext.status || 404;
+
+          if (status === 404 && !$ctx.isDone()) {
+            platformExceptions?.resourceNotFound($ctx);
+          }
+        } catch (error) {
+          platformExceptions?.catch(error, $ctx);
+        } finally {
+          await $ctx.finish();
+        }
+      });
+    });
+
+    return this;
+  }
+
+  createApp() {
+    const app = constant<Koa | undefined>("koa.app") || new Koa();
+    koaQs(app, "extended");
+
+    return {
+      app,
+      callback() {
+        return app.callback();
+      }
+    };
+  }
+
+  multipart(options: PlatformMulterSettings): PlatformMulter {
+    return getMulter(options);
+  }
+
+  statics(endpoint: string, options: PlatformStaticsOptions) {
+    return staticsMiddleware(options);
+  }
+
+  bodyParser(_: "json" | "urlencoded" | "raw" | "text", additionalOptions: any = {}): any {
+    const opts = constant(`koa.bodyParser`);
+    let parser: any = koaBodyParser;
+
+    let options: Options = {};
+
+    if (isFunction(opts)) {
+      parser = opts;
+      options = {};
+    }
+
+    return parser({...options, ...additionalOptions});
+  }
+}
+
+adapter(PlatformKoa);

package/src/decorators/ctx.spec.ts

@@ -0,0 +1,14 @@
+import {JsonParameterStore} from "@tsed/schema";
+
+import {Ctx} from "./ctx.js";
+
+describe("@Ctx", () => {
+  it("should call store the right configuration", () => {
+    class Ctrl {
+      test(@Ctx() ctx: Ctx) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual("KOA_CTX");
+  });
+});

package/src/decorators/ctx.ts

@@ -0,0 +1,32 @@
+import {UseParam} from "@tsed/platform-params";
+import type {Context} from "koa";
+
+/**
+ * Return the original Koa context.
+ * @decorator
+ * @operation
+ * @input
+ * @koa
+ */
+export function KoaCtx(): ParameterDecorator {
+  return UseParam({
+    paramType: "KOA_CTX",
+    dataPath: "$ctx.request.ctx",
+    useMapper: false,
+    useValidation: false
+  });
+}
+
+/**
+ * Return the original Koa context.
+ * @decorator
+ * @operation
+ * @input
+ * @koa
+ */
+export function Ctx(): ParameterDecorator {
+  return KoaCtx();
+}
+
+export type Ctx = Context;
+export type KoaCtx = Context;

package/src/decorators/state.spec.ts

@@ -0,0 +1,16 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+
+import {State} from "./state.js";
+
+describe("@State", () => {
+  it("should call ParamFilter.useParam method with the correct parameters", () => {
+    class Ctrl {
+      test(@State("expression") test: any) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.expression).toEqual("expression");
+    expect(param.paramType).toEqual(ParamTypes.LOCALS);
+  });
+});

package/src/decorators/state.ts

@@ -0,0 +1,43 @@
+import {Locals} from "@tsed/platform-params";
+
+/**
+ * State return the value from koa.ctx.state object.
+ *
+ * #### Example
+ *
+ * ```typescript
+ *  * @Middleware()
+ * class StateMiddleware {
+ *   use(@State() state: any) {
+ *      // set some on locals
+ *      state.user = "user"
+ *   }
+ * }
+ *
+ * @Controller('/')
+ * @UseBefore(StateMiddleware)
+ * class MyCtrl {
+ *    @Get('/')
+ *    @View('home.ejs') // will use locals and returned data to render the page
+ *    get(@State('user') user: any) {
+ *       console.log('user', user);
+ *
+ *       return {
+ *         description: 'Hello world'
+ *       }
+ *    }
+ * }
+ * ```
+ *
+ * @param expression The path of the property to get.
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ * @koa
+ */
+export function State(expression: string): ParameterDecorator;
+export function State(): ParameterDecorator;
+export function State(...args: any[]): ParameterDecorator {
+  return (Locals as any)(...args);
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./components/PlatformKoa.js";
+export * from "./decorators/ctx.js";
+export * from "./decorators/state.js";
+export * from "./interfaces/interfaces.js";
+export * from "./interfaces/PlatformKoaSettings.js";
+export * from "./middlewares/staticsMiddleware.js";
+export * from "./services/PlatformKoaHandler.js";
+export * from "./services/PlatformKoaRequest.js";
+export * from "./services/PlatformKoaResponse.js";
+export * from "./utils/multer.js";

package/src/interfaces/PlatformKoaSettings.ts

@@ -0,0 +1,15 @@
+import type {RouterOptions} from "@koa/router";
+import type {Middleware} from "koa";
+import type {Options} from "koa-bodyparser";
+
+export interface PlatformKoaSettings {
+  /**
+   * Koa router options
+   */
+  router?: RouterOptions;
+  /**
+   * Body parser options
+   * @param opts
+   */
+  bodyParser?: ((opts?: Options) => Middleware) | Options;
+}

package/src/interfaces/interfaces.ts

@@ -0,0 +1,18 @@
+import Koa from "koa";
+
+import {PlatformKoaSettings} from "./PlatformKoaSettings.js";
+
+export * from "./PlatformKoaSettings.js";
+
+declare global {
+  namespace TsED {
+    export interface Configuration {
+      /**
+       * Configuration related to Koa platform application.
+       */
+      koa: PlatformKoaSettings;
+    }
+
+    export interface NextFunction extends Koa.Next {}
+  }
+}

package/src/middlewares/staticsMiddleware.ts

@@ -0,0 +1,34 @@
+import {PlatformStaticsOptions} from "@tsed/platform-http";
+import type {Context} from "koa";
+import send from "koa-send";
+
+/**
+ * @ignore
+ * @param options
+ */
+export function staticsMiddleware(options: PlatformStaticsOptions): any {
+  if (options.index !== false) options.index = options.index || "index.html";
+
+  return async (ctx: Context, next: any) => {
+    if (["GET", "HEAD"].includes(ctx.method) && !ctx.body) {
+      let path = ctx.path;
+
+      if (ctx._matchedRoute && ctx._matchedRoute !== "/") {
+        path = path.replace(String(ctx._matchedRoute).replace("/(.*)", ""), "");
+      }
+      try {
+        const done = await send(ctx as any, path, options as send.SendOptions);
+
+        if (done) {
+          return;
+        }
+      } catch (err) {
+        if (err.status !== 404) {
+          throw err;
+        }
+      }
+    }
+
+    return next();
+  };
+}

package/src/services/PlatformKoaHandler.ts

@@ -0,0 +1,22 @@
+import "./PlatformKoaRequest.js";
+
+import {PlatformContext, PlatformHandler} from "@tsed/platform-http";
+import {PlatformParamsCallback} from "@tsed/platform-params";
+
+export class PlatformKoaHandler extends PlatformHandler {
+  onRequest(handler: PlatformParamsCallback, $ctx: PlatformContext) {
+    if (!(($ctx.error instanceof Error && !$ctx.handlerMetadata.hasErrorParam) || ($ctx.handlerMetadata.hasErrorParam && !$ctx.error))) {
+      return super.onRequest(handler, $ctx);
+    }
+
+    return Promise.resolve();
+  }
+
+  public flush($ctx: PlatformContext) {
+    if (!$ctx.error && $ctx.data === undefined && $ctx.getResponse().body) {
+      $ctx.data = $ctx.getResponse().body;
+    }
+
+    return super.flush($ctx);
+  }
+}

package/src/services/PlatformKoaRequest.spec.ts

@@ -0,0 +1,112 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {PlatformKoaRequest} from "./PlatformKoaRequest.js";
+
+function createRequest() {
+  const req = PlatformTest.createRequest();
+  const koaRequest = {
+    protocol: "http",
+    req,
+    get ctx() {
+      return koaCtx;
+    }
+  };
+
+  const koaCtx: any = {
+    request: koaRequest,
+    cookie: {
+      test: "test"
+    },
+    cookies: {
+      test: "test"
+    },
+    session: {
+      test: "test"
+    }
+  };
+
+  const ctx = PlatformTest.createRequestContext({
+    event: {
+      request: koaRequest,
+      koaContext: koaCtx
+    },
+    RequestKlass: PlatformKoaRequest
+  });
+
+  return {req, request: ctx.request, koaCtx, koaRequest};
+}
+
+describe("PlatformKoaRequest", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+  it("should create a PlatformRequest instance", () => {
+    const {koaRequest, request} = createRequest();
+
+    expect(request.raw).toEqual(koaRequest);
+  });
+
+  describe("secure", () => {
+    it("should get cookies from cookie", () => {
+      const {koaCtx, request} = createRequest();
+      koaCtx.request.secure = true;
+
+      expect(request.secure).toEqual(true);
+    });
+  });
+
+  describe("protocol()", () => {
+    it("should return the protocol request state (http)", () => {
+      const {koaCtx, request} = createRequest();
+
+      koaCtx.request.req.protocol = "http";
+
+      expect(request.protocol).toEqual("http");
+    });
+    it("should return the protocol request state (https)", () => {
+      const {koaCtx, request} = createRequest();
+
+      koaCtx.request.protocol = "https";
+
+      expect(request.protocol).toEqual("https");
+    });
+  });
+
+  describe("host()", () => {
+    it("should return the host", () => {
+      const {koaCtx, request} = createRequest();
+
+      koaCtx.request.host = "host";
+
+      expect(request.host).toEqual("host");
+    });
+  });
+
+  describe("cookies", () => {
+    it("should get cookies from cookies", () => {
+      const {koaCtx, request} = createRequest();
+
+      koaCtx.cookie = null;
+
+      expect(request.cookies).toEqual({test: "test"});
+    });
+    it("should get cookies from cookie", () => {
+      const {request} = createRequest();
+
+      expect(request.cookies).toEqual({test: "test"});
+    });
+  });
+  describe("session", () => {
+    it("should get session", () => {
+      const {request} = createRequest();
+
+      expect(request.session).toEqual({test: "test"});
+    });
+  });
+  describe("getReq()", () => {
+    it("should return nodejs request", () => {
+      const {req, request} = createRequest();
+
+      expect(request.getReq()).toEqual(req);
+    });
+  });
+});

package/src/services/PlatformKoaRequest.ts

@@ -0,0 +1,51 @@
+import "@koa/router";
+
+import {PlatformContext, PlatformRequest} from "@tsed/platform-http";
+import Koa from "koa";
+
+declare module "koa" {
+  export interface Request {
+    id: string;
+    $ctx: PlatformContext;
+  }
+}
+
+declare global {
+  namespace TsED {
+    export interface Request extends Koa.Request {}
+  }
+}
+
+/**
+ * @platform
+ * @koa
+ */
+export class PlatformKoaRequest extends PlatformRequest<Koa.Request> {
+  get ctx(): Koa.Context {
+    return this.$ctx.event.koaContext as Koa.Context;
+  }
+
+  get protocol(): string {
+    return this.ctx.request.protocol;
+  }
+
+  get host(): string {
+    return this.ctx.request.host;
+  }
+
+  get secure(): boolean {
+    return this.ctx.request.secure;
+  }
+
+  get cookies(): {[p: string]: any} {
+    return this.ctx.cookie || this.ctx.cookies;
+  }
+
+  get session(): any {
+    return this.ctx.session;
+  }
+
+  getReq() {
+    return this.ctx.request.req;
+  }
+}

package/src/services/PlatformKoaResponse.spec.ts

@@ -0,0 +1,224 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {PlatformKoaRequest} from "./PlatformKoaRequest.js";
+import {PlatformKoaResponse} from "./PlatformKoaResponse.js";
+
+function createResponse() {
+  const res = PlatformTest.createResponse();
+  const req = PlatformTest.createRequest();
+
+  const koaContext: any = {
+    response: {}
+  };
+
+  const koaResponse: any = Object.assign(res, {
+    res,
+    get ctx() {
+      return koaContext;
+    }
+  });
+
+  const koaRequest: any = {
+    ...req,
+    req,
+    get ctx() {
+      return koaContext;
+    }
+  };
+
+  koaContext.response = koaResponse;
+
+  const ctx = PlatformTest.createRequestContext({
+    event: {
+      response: koaResponse,
+      request: koaRequest
+    },
+    ResponseKlass: PlatformKoaResponse,
+    RequestKlass: PlatformKoaRequest
+  });
+
+  return {res, response: ctx.response as PlatformKoaResponse, ctx, koaResponse, koaRequest, koaContext};
+}
+
+describe("PlatformKoaResponse", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+  it("should create a PlatformResponse instance", () => {
+    const {koaResponse, response} = createResponse();
+
+    expect(response.raw).toEqual(koaResponse);
+  });
+
+  describe("getRes()", () => {
+    it("return res", async () => {
+      const {res, response} = createResponse();
+
+      const result = await response.getRes();
+
+      expect(result).toEqual(res);
+    });
+  });
+  describe("statusCode", () => {
+    it("return statusCode", () => {
+      const {response} = createResponse();
+
+      response.status(302);
+
+      expect(response.statusCode).toEqual(302);
+    });
+  });
+  describe("hasStatus", () => {
+    it("return hasStatus", () => {
+      const {response} = createResponse();
+
+      response.status(404);
+      expect(response.statusCode).toEqual(404);
+      expect(response.hasStatus()).toEqual(false);
+
+      response.status(201);
+      expect(response.hasStatus()).toEqual(true);
+    });
+  });
+  describe("contentType()", () => {
+    it("should set contentType", () => {
+      const {ctx, koaResponse} = createResponse();
+
+      ctx.response.contentType("text/html");
+
+      expect(koaResponse.type).toEqual("text/html");
+    });
+  });
+  describe("body()", () => {
+    it("should set body", () => {
+      const {response, koaResponse} = createResponse();
+
+      response.body("body");
+
+      expect(koaResponse.body).toEqual("body");
+      expect(response.getBody()).toEqual("body");
+    });
+  });
+  describe("location", () => {
+    it("should set header location", () => {
+      const {res, response} = createResponse();
+
+      response.location("https://location");
+
+      expect(res.headers).toEqual({
+        location: "https://location",
+        "x-request-id": "id"
+      });
+    });
+
+    it("should go back based on Referrer", async () => {
+      const {res, response} = createResponse();
+
+      response.request.raw.headers["referrer"] = "https://location/back";
+
+      await response.location("back");
+
+      expect(res.headers).toEqual({
+        location: "https://location/back",
+        "x-request-id": "id"
+      });
+    });
+
+    it("should go back based on default path", async () => {
+      const {res, response} = createResponse();
+
+      await response.location("back");
+
+      expect(res.headers).toEqual({
+        location: "/",
+        "x-request-id": "id"
+      });
+    });
+  });
+  describe("redirect", () => {
+    it("should set header location (HEAD)", async () => {
+      const {res, response, koaRequest, koaResponse} = createResponse();
+
+      res.headers["location"] = "https://location";
+      koaRequest.method = "HEAD";
+
+      await response.redirect(301, "https://location");
+
+      // expect(koaResponse.body).toEqual("Moved Permanently. Redirecting to https://location");
+      expect(response.statusCode).toEqual(301);
+      expect(res.headers).toEqual({
+        location: "https://location",
+        "x-request-id": "id"
+      });
+      expect(res.data).toEqual(undefined);
+    });
+    it("should set header location (POST)", async () => {
+      const {res, response, koaRequest, koaResponse, ctx} = createResponse();
+
+      res.headers["location"] = "https://location";
+      koaRequest.method = "POST";
+
+      await response.redirect(301, "https://location");
+
+      // expect(koaResponse.body).toEqual("Moved Permanently. Redirecting to https://location");
+      expect(response.statusCode).toEqual(301);
+      expect(res.headers).toEqual({
+        "content-length": 50,
+        location: "https://location",
+        "x-request-id": "id"
+      });
+    });
+  });
+  describe("getHeaders()", () => {
+    it("should get headers", () => {
+      const {ctx} = createResponse();
+
+      ctx.response.setHeader("contentType", "application/json");
+
+      const result = ctx.response.getHeaders();
+
+      expect(result).toEqual({
+        contenttype: "application/json",
+        "x-request-id": "id"
+      });
+    });
+  });
+  describe("cookie()", () => {
+    it("should manipulate cookies", () => {
+      const {res, response, koaContext} = createResponse();
+      koaContext.cookies = {};
+      koaContext.cookies.set = (...args: any[]) => {
+        if (!args[1]) {
+          res.headers["set-cookie"] = res.headers["set-cookie"].filter((cookie: string) => cookie.startsWith(args[0] + "="));
+          return;
+        }
+
+        let value = `${args[0]}=${args[1]}`;
+
+        if (!res.headers["set-cookie"]) {
+          res.headers["set-cookie"] = [value];
+        } else {
+          res.headers["set-cookie"] = [].concat(res.headers["set-cookie"], value as any);
+        }
+      };
+
+      response.cookie("locale", "fr-FR");
+      expect(res.headers).toEqual({
+        "set-cookie": ["locale=fr-FR"],
+        "x-request-id": "id"
+      });
+
+      response.cookie("filename", "test");
+      expect(res.headers).toEqual({
+        "set-cookie": ["locale=fr-FR", "filename=test"],
+        "x-request-id": "id"
+      });
+
+      response.cookie("filename", null);
+
+      expect(res.headers).toEqual({
+        "set-cookie": ["filename=test"],
+        "x-request-id": "id"
+      });
+    });
+  });
+});

package/src/services/PlatformKoaResponse.ts

@@ -0,0 +1,112 @@
+import {PlatformResponse} from "@tsed/platform-http";
+import {ServerResponse} from "http";
+import Koa from "koa";
+
+declare global {
+  namespace TsED {
+    export interface Response extends Koa.Response {}
+  }
+}
+
+/**
+ * @platform
+ * @koa
+ */
+export class PlatformKoaResponse extends PlatformResponse<Koa.Response> {
+  get ctx() {
+    return this.raw.ctx;
+  }
+
+  get statusCode() {
+    return this.raw.status;
+  }
+
+  get locals() {
+    return this.ctx.state;
+  }
+
+  /**
+   * Return the Node.js response object
+   */
+  getRes(): ServerResponse {
+    return this.raw.res;
+  }
+
+  hasStatus() {
+    // KOA set 404 by default
+    return this.statusCode !== 404;
+  }
+
+  /**
+   * Sets the HTTP status for the response.
+   *
+   * @param status
+   */
+  status(status: number) {
+    this.raw.status = status;
+
+    return this;
+  }
+
+  /**
+   * Set `Content-Type` response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  contentType(contentType: string) {
+    this.raw.type = contentType;
+
+    return this;
+  }
+
+  getHeaders() {
+    return this.raw.headers;
+  }
+
+  stream(data: any) {
+    this.raw.body = data;
+    return this;
+  }
+
+  getBody(): any {
+    return this.raw.body;
+  }
+
+  cookie(name: string, value: string | null, opts?: TsED.SetCookieOpts) {
+    if (value === null) {
+      this.ctx.cookies.set(name);
+    } else {
+      this.ctx.cookies.set(name, value, opts);
+    }
+    return this;
+  }
+
+  protected json(data: any) {
+    this.end(data);
+    return this;
+  }
+
+  protected buffer(data: Buffer) {
+    this.end(data);
+    return this;
+  }
+
+  protected end(data?: string | Buffer) {
+    if ([301, 302, 303, 307, 308].includes(this.statusCode)) {
+      if (this.request.method === "HEAD") {
+        this.getRes().end();
+      } else {
+        this.getRes().end(data);
+      }
+    } else {
+      this.raw.body = data;
+    }
+  }
+}

package/src/utils/multer.ts

@@ -0,0 +1,65 @@
+import Koa from "koa";
+import {promisify} from "util";
+
+let multer: any;
+import("multer").then(({default: m}) => (multer = m));
+
+/**
+ * @ignore
+ */
+function createRawMiddleware(middleware: any) {
+  return async (request: Koa.Request) => {
+    const ctx: any = request.ctx;
+
+    await middleware(ctx.req, ctx.res);
+
+    const forwardKey = (key: string) => {
+      if (ctx.req[key]) {
+        ctx.request[key] = ctx.req[key];
+        ctx[key] = ctx.req[key];
+        delete ctx.req[key];
+      }
+    };
+
+    if ("request" in ctx) {
+      if (ctx.req.body) {
+        ctx.request.body = ctx.req.body;
+        delete ctx.req.body;
+      }
+
+      forwardKey("file");
+      forwardKey("files");
+    }
+  };
+}
+
+/**
+ * @ignore
+ */
+function makePromise(multer: any, name: string) {
+  // istanbul ignore next
+  if (!multer[name]) return;
+
+  const fn = multer[name];
+
+  multer[name] = function apply(...args: any[]) {
+    const middleware: any = Reflect.apply(fn, this, args);
+
+    return createRawMiddleware(promisify(middleware));
+  };
+}
+
+/**
+ * @ignore
+ */
+export function getMulter(options: any) {
+  const m = multer(options);
+
+  makePromise(m, "any");
+  makePromise(m, "array");
+  makePromise(m, "fields");
+  makePromise(m, "none");
+  makePromise(m, "single");
+
+  return m;
+}