koa-convert

koa-convert

Convert Koa legacy (0.x & 1.x) generator middleware to modern promise middleware (2.x).

It could also convert modern promise middleware back to legacy generator middleware (useful to help modern middleware support Koa v0.x or v1.x).

Note

Router middleware is special case here. Because it reimplements middleware composition internally, we cannot not simply convert it.

You may use following packages for routing, which are koa 2.x ready now:

• koa-route@3.0.0
• koa-simple-router
• koa-router@next
• koa-66

Installation

# npm ..
$ npm i koa-convert
# yarn ..
$ yarn add koa-convert

Usage

const Koa = require('koa') // koa v2.x
const convert = require('koa-convert')
const app = new Koa()

app.use(modernMiddleware)

app.use(convert(legacyMiddleware))

app.use(convert.compose(legacyMiddleware, modernMiddleware))

function * legacyMiddleware (next) {
  // before
  yield next
  // after
}

function modernMiddleware (ctx, next) {
  // before
  return next().then(() => {
    // after
  })
}

Distinguish legacy and modern middleware

In koa 0.x and 1.x (without experimental flag), app.use has an assertion that all (legacy) middleware must be generator function and it's tested with fn.constructor.name == 'GeneratorFunction' at here.

Therefore, we can distinguish legacy and modern middleware with fn.constructor.name == 'GeneratorFunction'.

Migration

app.use(legacyMiddleware) is everywhere in 0.x and 1.x and it would be painful to manually change all of them to app.use(convert(legacyMiddleware)).

You can use following snippet to make migration easier.

const _use = app.use
app.use = x => _use.call(app, convert(x))

The above snippet will override app.use method and implicitly convert all legacy generator middleware to modern promise middleware.

Therefore, you can have both app.use(modernMiddleware) and app.use(legacyMiddleware) and your 0.x or 1.x should work without modification.

Complete example:

const Koa = require('koa') // v2.x
const convert = require('koa-convert')
const app = new Koa()

// ---------- override app.use method ----------

const _use = app.use
app.use = x => _use.call(app, convert(x))

// ---------- end ----------

app.use(modernMiddleware)

// this will be converted to modern promise middleware implicitly
app.use(legacyMiddleware)

function * legacyMiddleware (next) {
  // before
  yield next
  // after
}

function modernMiddleware (ctx, next) {
  // before
  return next().then(() => {
    // after
  })
}

API

convert()

Convert legacy generator middleware to modern promise middleware.

modernMiddleware = convert(legacyMiddleware)

convert.compose()

Convert and compose multiple middleware (could mix legacy and modern ones) and return modern promise middleware.

composedModernMiddleware = convert.compose(legacyMiddleware, modernMiddleware)
// or
composedModernMiddleware = convert.compose([legacyMiddleware, modernMiddleware])

convert.back()

Convert modern promise middleware back to legacy generator middleware.

This is useful to help modern promise middleware support koa 0.x or 1.x.

legacyMiddleware = convert.back(modernMiddleware)

License

MIT

Similar packages

Other packages similar to koa-convert

koa-compose

koa-compose is a package for composing Koa middleware. While it doesn't directly convert middleware from the old to the new format, it's useful for managing middleware in Koa applications, especially when dealing with async functions. It complements koa-convert by providing a structured way to combine multiple middleware functions into a single middleware.

koa-adapter

koa-adapter is another package that aims to provide compatibility layers for Koa middleware, though it's less focused on converting from the old generator-based middleware to the new async-based middleware. Instead, it focuses on adapting Express middleware to be used in Koa applications, serving a slightly different but related purpose to koa-convert.