Method executeHandler

src/consumer.ts:539–598

* Trigger the applications handleMessage function * @param message The message that was received from SQS

(message: Message)

   * @param message The message that was received from SQS
   */
  private async executeHandler(message: Message): Promise<Message> {
    let handleMessageTimeoutId: NodeJS.Timeout | undefined = undefined;

    try {
      let result: Message | undefined | null;

      if (this.handleMessageTimeout) {
        const pending: Promise<never> = new Promise<never>((_, reject) => {
          handleMessageTimeoutId = setTimeout(() => {
            reject(new TimeoutError());
          }, this.handleMessageTimeout);
        });
        result = await Promise.race([this.handleMessage(message), pending]);
      } else {
        result = await this.handleMessage(message);
      }

      if (this.alwaysAcknowledge) {
        return message;
      }

      if (result instanceof Object) {
        return result;
      }

      if (result === undefined) {
        return null;
      }

      if (result === null) {
        if (this.strictReturn) {
          throw new Error(
            "strictReturn is enabled: handleMessage must return a Message object or an object with the same MessageId. Returning null is not allowed.",
          );
        }
        console.warn(
          "[DEPRECATION] Future versions will throw on void/null returns. Enable `strictReturn` now to prepare.",
        );
        return null;
      }

      return null;
    } catch (err) {
      if (err instanceof TimeoutError) {
        throw toTimeoutError(
          err,
          `Message handler timed out after ${this.handleMessageTimeout}ms: Operation timed out.`,
          message,
        );
      }
      if (err instanceof Error) {
        throw toStandardError(err, `Unexpected message handler failure: ${err.message}`, message);
      }
      throw err;
    } finally {
      if (handleMessageTimeoutId) {
        clearTimeout(handleMessageTimeoutId);
      }