Sendgrid plugin: Set different from-addresses when using localization options

[GitQuist]

Hi,

It would be valuable to be able to set a different from sender email address when using the medusa-plugin-sendgrid.

Since we can use one backend to serve several storefronts that can be hosted on separate domains, it makes sense to be able to use different senders based on localisation.

So to be clear we have:
Backend hosted at: api.example.com
Storefront 1 hosted at: example.com
Storefront 2 hosted at example.org

Then the emails sent in storefront 2 should have the sender [email protected] and not @example.com.

I've looked at the plugin code and I think this would makes sense to add (inspired by the templateId function)

In /medusa-plugin-sendgrid/services/sendgrid.js we can add the following

getLocalizedSenderFrom(locale) {
    if (this.options_.localization && this.options_.localization[locale]) {
      if (this.options_.localiation[locale].from) {
        return this.options_.localization[locale].from
      }
     return null
    }
    return null
  }

And use that in the sendNotification function like so:

  async sendNotification(event, eventData, attachmentGenerator) {
    const data = await this.fetchData(event, eventData, attachmentGenerator)

    let templateId = this.getTemplateId(event)
    let from = this.options_.from

    if (data.locale) {
      templateId = this.getLocalizedTemplateId(event, data.locale) || templateId
      from = this.getLocalizedSenderFrom(data.locale) || from
    }

    if (!templateId) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
        `Sendgrid service: No template was set for event: ${event}`
      )
    }

    const attachments = await this.fetchAttachments(
      event,
      data,
      attachmentGenerator
    )

    const sendOptions = {
      template_id: templateId,
      from: from,
      to: data.email,
      dynamic_template_data: data,
      has_attachments: attachments?.length,
    }

    if (attachments?.length) {
      sendOptions.has_attachments = true
      sendOptions.attachments = attachments.map((a) => {
        return {
          content: a.base64,
          filename: a.name,
          type: a.type,
          disposition: "attachment",
          contentId: a.name,
        }
      })
    }

    let status

    await SendGrid.send(sendOptions)
      .then(() => {
        status = "sent"
      })
      .catch((error) => {
        status = "failed"
        this.logger_.error(error)
      })

    // We don't want heavy docs stored in DB
    delete sendOptions.attachments

    return { to: data.email, status, data: sendOptions }
  }

What do you think? Is there any other way to solve this or would this make a good addition?

[korur]

@GitQuist did you find a solution for this?