# All files / server/src/join index.js

100% Statements 29/29
87.5% Branches 14/16
100% Functions 3/3
100% Lines 27/27

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    5928x
    28x
    28x

    28x
    2076x

    98x
    34x

    64x
    64x

    28x

    243x

    243x
    245x
    2219x
    2219x

    2098x

    22x
    22x
    22x
    22x
    21x
    21x

    2076x
    2054x
    2052x
    110x

    23x

     const load = require('loadware');
    const assert = require('assert');
    const reply = require('../../reply');

    // Recursively resolve possible function returns
    const processReturn = (ctx, ret) => {
      if (!ret) return;

      // Use the returned reply instance
      if (ret.constructor.name === 'Reply') {
        return ret.exec(ctx);
      }

      // TODO: make a check for only accepting the right types of return values

      // Create a whole new reply thing
      const fn = typeof ret === 'number' ? 'status' : 'send';
      return reply[fn](ret).exec(ctx);
    };

    // Pass an array of modern middleware and return a single modern middleware
    module.exports = (...middles) => {

      // Flattify all of the middleware
      const middle = load(middles);

      // Go through each of them
      return async ctx => {
        for (const mid of middle) {
          try {
            if (ctx.req.solved) return;

            // DO NOT MERGE; the else is relevant only for ctx.error
            if (ctx.error) {
              // See if this middleware can fix it
              Eif (mid.error) {
                assert(mid.error instanceof Function, 'Error handler should be a function');
                const ret = await mid.error(ctx);
                await processReturn(ctx, ret);
                Eif (ctx.res.headersSent) {
                  ctx.req.solved = true;
                }
              }
            }
            // No error, call next middleware. Skips middleware if there's an error
            else {
              const ret = await mid(ctx);
              await processReturn(ctx, ret);
              if (ctx.res.headersSent) {
                ctx.req.solved = true;
              }
            }
          } catch (err) {
            ctx.error = err;
          }
        }
      };
    };