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

100% Statements 23/23
90% Branches 9/10
100% Functions 3/3
100% Lines 22/22

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
    5127x
    27x
    27x

    27x
    2202x

    103x
    34x

    69x
    69x

    27x

    248x

    248x
    250x
    2225x

    2225x

    24x
    24x
    24x
    24x

    2201x
    2178x

    25x

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

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

      // Use the returned reply instance
      if (ret.constructor.name === 'Reply') {
        return await 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 await 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 {
            // 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');
                let ret = await mid.error(ctx);
                await processReturn(ctx, ret);
              }
            }
            // No error, call next middleware. Skips middleware if there's an error
            else {
              let ret = await mid(ctx);
              await processReturn(ctx, ret);
            }
          } catch (err) {
            ctx.error = err;
          }
        }
      };
    };