Middlewares run in unexpected order

Unexpected to me, anyway 😀 Wanted to raise an issue before attempting a PR, in case this is the desired behaviour.

Repro: https://github.com/Rich-Harris/polka-middleware-order-repro

Essentially, it seems that middlewares without a basepath run before middlewares with one, regardless of the order in which they’re added to the app. This means that a generic app.use(foo) will take precedence over an earlier app.use(basepath, serve('assets')), which can prevent assets from being served.

[Rich-Harris]

Thanks for helping me think this stuff through, by the way 😀

You’re absolutely right, Sapper should only deal with requests pertaining to its basepath. In fact, that insight led me to a much nicer way of doing things — now, all you need to do to mount an app on a basepath is this:

polka()
  .use('/my-basepath', serve('assets'), sapper({routes}))
  .listen(PORT);

No configuration or environment variables necessary, it just works!

So I’ll close this issue rather than continuing to clutter up your tracker. The one thing that does give me pause is that I often order my middlewares to do this sort of thing:

app.use('/requests-that-should-not-be-logged', someMiddleware());
app.use(loggingMiddleware());

With Express, requests handled by earlier middlewares don’t get handled by later middlewares (unless the earlier middleware wants that to happen, with next()), and controlling that is fairly intuitive. If I understand correctly, that’s a little harder with Polka? You’ve spent more time thinking about this than me though, so your way probably makes more sense — I only mention it because it’s a potential sticking point for Express refugees.

[lukeed]

Great! Happy to help~! And not clutter at all haha

My general recommendation is that if you have a particular exception/filter, that you should manually filter that route from the global scope. That is, of course, assuming you’re using an off-the-shelf solution and can’t work in the behavior into the middleware directly.

Looking at the morgan logger example, you could do something like this:

const logger = morgan('dev'); // instantiate early

polka()
  .use((req, res, next) => {
    return req.url.includes('ignore-this') ? next() : logger(req, res, next);
  })
  .use('/items', require('./items')
  .use('/ignore-this', something())
  // ...

Although, most of the big-name loggers out there already include some kind of skip/ignore option. Morgan, for example, has opts.skip, which essentially does the same thing.