@adonisjs/mail/build/src/transports/sparkpost.js

Mail provider for adonis framework and has support for all common mailing services to send emails

import {
  E_MAIL_TRANSPORT_ERROR
} from "../../chunk-3EFD4MAA.js";
import {
  MailResponse
} from "../../chunk-CRXUSCKP.js";
import {
  debug_default
} from "../../chunk-ZF2M7BIF.js";
import {
  __name
} from "../../chunk-XE4OXN2W.js";

// src/transports/sparkpost.ts
import got from "got";
import { text } from "node:stream/consumers";
import { ObjectBuilder } from "@poppinss/utils";
import { createTransport } from "nodemailer";
var NodeMailerTransport = class NodeMailerTransport2 {
  static {
    __name(this, "NodeMailerTransport");
  }
  name = "sparkpost";
  version = "1.0.0";
  #config;
  constructor(config) {
    this.#config = config;
  }
  /**
  * Returns base url for sending emails
  */
  #getBaseUrl() {
    return this.#config.baseUrl.replace(/\/$/, "");
  }
  /**
  * Formatting recipients for sparkpost API call
  */
  #formatRecipients(recipients) {
    if (!recipients) {
      return [];
    }
    if (Array.isArray(recipients)) {
      return recipients.map((recipient) => {
        if (typeof recipient === "string") {
          return {
            address: {
              email: recipient
            }
          };
        }
        return {
          address: {
            email: recipient.address,
            ...recipient.name ? {
              name: recipient.name
            } : {}
          }
        };
      });
    }
    if (typeof recipients === "string") {
      return [
        {
          address: {
            email: recipients
          }
        }
      ];
    }
    return [
      {
        address: {
          email: recipients.address,
          ...recipients.name ? {
            name: recipients.name
          } : {}
        }
      }
    ];
  }
  /**
  * Returns an array of recipients accepted by the SparkPost API
  */
  #getRecipients(mail) {
    return this.#formatRecipients(mail.data.to).concat(this.#formatRecipients(mail.data.cc)).concat(this.#formatRecipients(mail.data.bcc));
  }
  /**
  * Returns an object of options accepted by the sparkpost mail API
  */
  #getOptions(config) {
    const options = new ObjectBuilder({});
    options.add("start_time", config.startTime);
    options.add("initial_open", config.initialOpen);
    options.add("open_tracking", config.openTracking);
    options.add("click_tracking", config.clickTracking);
    options.add("transactional", config.transactional);
    options.add("sandbox", config.sandbox);
    options.add("skip_suppression", config.skipSuppression);
    options.add("ip_pool", config.ipPool);
    return options.toObject();
  }
  /**
  * Send email
  */
  async send(mail, callback) {
    const url = `${this.#getBaseUrl()}/transmissions`;
    const options = this.#getOptions(this.#config);
    const envelope = mail.message.getEnvelope();
    const recipients = this.#getRecipients(mail);
    debug_default('sparkpost mail url "%s"', url);
    debug_default("sparkpost mail options %O", options);
    debug_default("sparkpost mail envelope %O", envelope);
    debug_default("sparkpost mail recipients %O", recipients);
    try {
      const mimeMessage = await text(mail.message.createReadStream());
      const response = await got.post(url, {
        json: {
          options,
          recipients,
          content: {
            email_rfc822: mimeMessage
          }
        },
        responseType: "json",
        headers: {
          Authorization: this.#config.key
        }
      });
      const sparkPostMessageId = response.body.results.id;
      const messageId = sparkPostMessageId ? sparkPostMessageId.replace(/^<|>$/g, "") : mail.message.messageId();
      callback(null, {
        messageId,
        envelope,
        ...response.body.results
      });
    } catch (error) {
      callback(new E_MAIL_TRANSPORT_ERROR("Unable to send email using the sparkpost transport", {
        cause: error
      }), void 0);
    }
  }
};
var SparkPostTransport = class {
  static {
    __name(this, "SparkPostTransport");
  }
  #config;
  constructor(config) {
    this.#config = config;
  }
  /**
  * Send message
  */
  async send(message, config) {
    const nodemailerTransport = new NodeMailerTransport({
      ...this.#config,
      ...config
    });
    const transporter = createTransport(nodemailerTransport);
    const sparkPostResponse = await transporter.sendMail(message);
    return new MailResponse(sparkPostResponse.messageId, sparkPostResponse.envelope, sparkPostResponse);
  }
};
export {
  SparkPostTransport
};
//# sourceMappingURL=sparkpost.js.map