koa-convert源码分析

koa-convert最主要的作用是：将koa1包中使用的Generator函数转换成Koa2中的async函数。更准确的说是将Generator函数转换成使用co包装成的Promise对象。然后执行对应的代码。当然该包中也提供了back方法，也可以把koa2中的async函数转换成koa1包中的Generator函数。

首先我们来看下使用Koa1中使用Generator函数和Koa2中使用的async函数的demo代码如下：

const Koa = require('koa');
const app = new Koa();

// koa1 使用generator函数的写法
app.use(function *(next) {
  console.log(1111); // 1. 第一步先打印 1111
  yield next;
  console.log(222222); // 4. 第四步打印 222222
});

// koa2的写法
app.use(async (ctx, next) => {
  console.log(3333); // 2. 第二步再打印 3333
  await next();
  console.log(44444); // 3. 第三部打印44444
});

app.listen(3001);
console.log('app started at port 3001...');

当我们在node命令行中使用 node app.js 命令时，然后浏览器中 输入地址：http://localhost:3001/ 访问的时候，我们可以看到命令中会分别打印 1111 3333 444444 222222.

我们再来看下，Koa源码中的application.js 代码如下：在use方法内部，代码如下：

const convert = require('koa-convert');
use(fn) {
  if (typeof fn !== 'function') throw new TypeError('middleware must be a function!');
  if (isGeneratorFunction(fn)) {
    deprecate('Support for generators will be removed in v3. ' +
              'See the documentation for examples of how to convert old middleware ' +
              'https://github.com/koajs/koa/blob/master/docs/migration.md');
    fn = convert(fn);
  }
  debug('use %s', fn._name || fn.name || '-');
  this.middleware.push(fn);
  return this;
}

如上koa2源码中的use函数，该函数有一个fn参数，首先判断该fn是不是一个函数，如果不是一个函数的话，直接抛出一个错误，提示，中间件必须为一个函数。第二步继续判断该fn函数是不是一个Generator函数，如果它是generator函数的话，就把该函数使用 koa-convert包转换成async函数。然后把对应的async函数放进 this.middleware数组中。最后返回该对象this。

这上面是koa2中的基本源码，下面我们来看看 koa-convert中的源码是如何做的呢？

const co = require('co')
const compose = require('koa-compose')

module.exports = convert

function convert (mw) {
  if (typeof mw !== 'function') {
    throw new TypeError('middleware must be a function')
  }
  if (mw.constructor.name !== 'GeneratorFunction') {
    // assume it's Promise-based middleware
    return mw
  }
  const converted = function (ctx, next) {
    return co.call(ctx, mw.call(ctx, createGenerator(next)))
  }
  converted._name = mw._name || mw.name
  return converted
}

function * createGenerator (next) {
  return yield next()
}

// convert.compose(mw, mw, mw)
// convert.compose([mw, mw, mw])
convert.compose = function (arr) {
  if (!Array.isArray(arr)) {
    arr = Array.from(arguments)
  }
  return compose(arr.map(convert))
}

1. 部分源码如上，首先引入co包中的代码，要深入了解co包中源码请看这篇文章, 该co的作用是：将Generator函数转换成promise对象，然后会自动执行该函数的代码。

2. 引入 koa-compose包，要深入了解 koa-compose包，请看这篇文章. 该包的作用是：将koa包中的中间件合并，然后依次执行各个中间件。

3. convert 函数
1. 该函数有一个参数mw，首先判断该参数mw是不是一个函数，如果该mw不是一个函数的话，就直接抛出一个异常提示，该中间件必须是一个函数。
2. 判断该 mw.constructor.name !== 'GeneratorFunction' 是不是一个Generator函数，如果不是Generator函数的话，就直接返回该mw。
3. 如果它是Generator函数的话，就会执行 converted 函数，该函数有2个参数，第一个参数ctx是运行Generator的上下文，第二个参数是传递给Generator函数的next参数。
4. 最后返回 return co.call(ctx, mw.call(ctx, createGenerator(next))); co的作用是介绍一个Generator函数，然后会返回一个Promise对象，然后该Generator函数会自动执行。createGenerator函数代码如下：

function * createGenerator (next) {
   return yield next()
}

因此 mw.call(ctx, createGenerator(next))，如果mw是一个Generator函数的话，就直接调用该Generator函数，返回return yield next(); 返回下一个中间件，然后使用调用co包，使返回一个Promise对象。该本身对象的代码会自动执行完。

5. 在convert函数代码中，有一句代码 mw.constructor.name !== 'GeneratorFunction' 是不是一个Generator函数。
可以如上面进行判断，比如如下代码演示是否是Generator函数还是AsyncFunction函数了，如下代码：

function* test () {};
console.log(test.constructor.name); // 打印 GeneratorFunction

async function test2() {};
console.log(test2.constructor.name); // 打印 AsyncFunction

如上所有的分析是 convert 函数的代码了，该代码一个最主要的作用，判断传递进来的mw参数是不是Generator函数，如果是Generator函数的话，就把该Generator函数转化成使用co包装成Promise对象了。
4. back函数代码如下：

convert.back = function (mw) {
  if (typeof mw !== 'function') {
    throw new TypeError('middleware must be a function')
  }
  if (mw.constructor.name === 'GeneratorFunction') {
    // assume it's generator middleware
    return mw
  }
  const converted = function * (next) {
    let ctx = this
    let called = false
    // no need try...catch here, it's ok even `mw()` throw exception
    yield Promise.resolve(mw(ctx, function () {
      if (called) {
        // guard against multiple next() calls
        // https://github.com/koajs/compose/blob/4e3e96baf58b817d71bd44a8c0d78bb42623aa95/index.js#L36
        return Promise.reject(new Error('next() called multiple times'))
      }
      called = true
      return co.call(ctx, next)
    }))
  }
  converted._name = mw._name || mw.name
  return converted
}

代码也是一样判断：
1. 判断mw是否是一个函数，如果不是一个函数，则抛出异常。
2. 判断mw.constructor.name === 'GeneratorFunction'; 如果是Generator函数的话，就直接返回该Generator函数。
如果不是Generaror函数的话，就执行 converted 方法，转换成Generator函数。同样的道理调用co模块返回一个Promise对象。

5. convert.compose函数代码如下：

convert.compose = function (arr) {
  if (!Array.isArray(arr)) {
    arr = Array.from(arguments)
  }
  return compose(arr.map(convert))
}

该函数的作用是：就是将一系列Generator函数组成的数组，直接转成Koa2中可执行的middleware形式。调用 koa-compose 包转换成中间件形式。