koa-body 中间件解析原理

常见的请求数据类型：

1. application/json  常见于post请求 未经过任何处理 以json的格式通过body传输

2. application/x-www-form-urlencoded 提交的表单数据会转换为键值对并按照key1=val&key2=val2的方式进行编码，常见于POST提交表单以及原生的处理方式。

3. multipart/form-data 多媒体类型 多用于上传图片文件等 以boundary作为分隔。

4. text/xml 以xml的格式传输数据 多用于文本传输

Koa-body 原理解析：

1.  核心主要依赖于co-body 做上述4种不同的数据格式的转换。
2.   通过patchNodeAndKoa 进行不同数据格式的判断。最终返回响应体。

import { KoaBodyMiddlewareOptionsSchema } from './types';
import type { KoaBodyMiddlewareOptions } from './types';
import type { Context, Middleware, Next } from 'koa';
import * as Koa from 'koa';
import type { Files } from 'formidable';
import coBody from 'co-body';
import toHttpMethod from './utils/string-method-to-enum-method';
import throwableToError from './utils/throwable-to-error';
import { isJsonBody, isMultipartBody, isTextBody, isUrlencodedBody } from './utils/body-type-util';
import parseWithFormidable from './utils/parse-with-formidable';
import { patchNodeAndKoa } from './utils/patch-util';
import type { ContextWithBodyAndFiles } from './utils/patch-util';

export * from './types';

declare module 'koa' {
  interface Request extends Koa.BaseRequest {
    body?: any;
    files?: Files;
  }
}

export function koaBody(options: Partial<KoaBodyMiddlewareOptions> = {}): Middleware {
  const validatedOptions = KoaBodyMiddlewareOptionsSchema.parse(options);
  const optionsToUse = { ...options, ...validatedOptions };
  return async (ctx: Context, next: Next) => {
    const isJson = isJsonBody(ctx, optionsToUse);
    const isText = isTextBody(ctx, optionsToUse);
    const isUrlencoded = isUrlencodedBody(ctx, optionsToUse);
    const isMultipart = isMultipartBody(ctx, optionsToUse);
    const {
      encoding,
      jsonStrict,
      jsonLimit,
      includeUnparsed: returnRawBody,
      formLimit,
      textLimit,
      queryString,
      formidable,
      onError,
      patchNode,
      patchKoa,
    } = optionsToUse;
    // only parse the body on specifically chosen methods 只解析body中指定的请求方法
    if (validatedOptions.parsedMethods.includes(toHttpMethod(ctx.method.toUpperCase()))) {
      try {
        if (isJson) { // application/json 数据格式
          const jsonBody = await coBody.json(ctx, {
            encoding,
            limit: jsonLimit,
            strict: jsonStrict,
            returnRawBody,
          });
          patchNodeAndKoa(ctx as ContextWithBodyAndFiles, jsonBody, {
            isText,
            includeUnparsed: returnRawBody,
            isMultipart,
            patchKoa,
            patchNode,
          });
        } else if (isUrlencoded) { // urlencode数据格式 key=value value默认编码 get和post请求都可使用
          const urlEncodedBody = await coBody.form(ctx, {
            encoding,
            limit: formLimit,
            queryString: queryString,
            returnRawBody,
          });
          patchNodeAndKoa(ctx as ContextWithBodyAndFiles, urlEncodedBody, {
            isText,
            includeUnparsed: returnRawBody,
            isMultipart,
            patchKoa,
            patchNode,
          });
        } else if (isText) { // 文本数据格式
          const textBody = await coBody.text(ctx, {
            encoding,
            limit: textLimit,
            returnRawBody,
          });
          patchNodeAndKoa(ctx as ContextWithBodyAndFiles, textBody, {
            isText,
            includeUnparsed: returnRawBody,
            isMultipart,
            patchKoa,
            patchNode,
          });
        } else if (isMultipart) { // 多媒体数据格式 
          const multipartBody = await parseWithFormidable(ctx, formidable || {});
          patchNodeAndKoa(ctx as ContextWithBodyAndFiles, multipartBody, {
            isText,
            includeUnparsed: returnRawBody,
            isMultipart,
            patchKoa,
            patchNode,
          });
        }
      } catch (parsingError) {
        const error = throwableToError(parsingError);
        if (typeof onError === 'function') {
          onError(error, ctx);
        } else {
          throw error;
        }
      }
    } else { // 处理未指定的请求方法
      patchNodeAndKoa(
        ctx as ContextWithBodyAndFiles,
        {},
        {
          isText,
          includeUnparsed: returnRawBody,
          isMultipart,
          patchKoa,
          patchNode,
        },
      );
    }

    return next();
  };
}

export default koaBody;

export function patchNodeAndKoa(ctx: ContextWithBodyAndFiles, body: any, options: PatchOptions) {
  const { patchKoa, patchNode, isMultipart, includeUnparsed, isText } = options;
　// 请求放置在Node
  if (patchNode) {
    if (isMultipart) {
      ctx.req.body = body.fields;
      ctx.req.files = body.files;
    } else if (includeUnparsed) {
      ctx.req.body = body.parsed || {};
      if (!isText) {
        ctx.req.body[symbolUnparsed] = body.raw;
      }
    } else {
      ctx.req.body = body;
    }
  }
  if (patchKoa) { // 请求放置在Koa
    if (isMultipart) {
      ctx.request.body = body.fields;
      ctx.request.files = body.files;
    } else if (includeUnparsed) {
      ctx.request.body = body.parsed || {};
      if (!isText) {
        ctx.request.body[symbolUnparsed] = body.raw;
      }
    } else {
      ctx.request.body = body;
    }
  }
}