function _rawCallbackContext()

in src/CallbackContext.js [21:96]
45 lines of code
6 McCabe index (conditional complexity)

function _rawCallbackContext(client, id, scheduleNext) {
  const postError = (err, callback) => {
    structuredConsole.logError('Invoke Error', err);
    client.postInvocationError(err, id, callback);
  };

  let isCompleteInvoked = false;
  const complete = (result, callback) => {
    if (isCompleteInvoked) {
      console.error(
        'Invocation has already been reported as done. Cannot call complete more than once per invocation.',
      );
      return;
    }
    isCompleteInvoked = true;
    client.postInvocationResponse(result, id, callback);
  };

  let waitForEmptyEventLoop = true;

  const callback = function (err, result) {
    BeforeExitListener.reset();
    if (err !== undefined && err !== null) {
      postError(err, scheduleNext);
    } else {
      if (!waitForEmptyEventLoop) {
        complete(result, scheduleNext);
      } else {
        BeforeExitListener.set(() => {
          setImmediate(() => {
            complete(result, scheduleNext);
          });
        });
      }
    }
  };

  const done = (err, result) => {
    BeforeExitListener.reset();
    if (err !== undefined && err !== null) {
      postError(err, scheduleNext);
    } else {
      complete(result, scheduleNext);
    }
  };
  const succeed = (result) => {
    done(null, result);
  };
  const fail = (err) => {
    if (err === undefined || err === null) {
      done('handled');
    } else {
      done(err, null);
    }
  };

  const callbackContext = {
    get callbackWaitsForEmptyEventLoop() {
      return waitForEmptyEventLoop;
    },
    set callbackWaitsForEmptyEventLoop(value) {
      waitForEmptyEventLoop = value;
    },
    succeed: succeed,
    fail: fail,
    done: done,
  };

  return [
    callback,
    callbackContext,
    function () {
      isCompleteInvoked = true;
    },
  ];
}