@teleporthq/teleport-plugin-next-workflows 0.44.9 → 0.44.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleporthq/teleport-plugin-next-workflows",
-  "version": "0.44.9",
+  "version": "0.44.11",
   "description": "A plugin for workflow code generation in Next.js projects.",
   "author": "teleportHQ",
   "license": "MIT",
@@ -66,8 +66,8 @@
   },
   "dependencies": {
     "@babel/types": "^7.5.5",
-    "@teleporthq/teleport-shared": "^0.44.7",
-    "@teleporthq/teleport-types": "^0.44.0"
+    "@teleporthq/teleport-shared": "^0.44.11",
+    "@teleporthq/teleport-types": "^0.44.11"
   },
-  "gitHead": "873247c0350141f525275e7c31a6e7dbf183ce4f"
+  "gitHead": "1947ff6b13b1b35ece621e04d28507185a3220ff"
 }

package/src/executor-generator.ts

@@ -892,9 +892,12 @@ async function settlePendingNodePromises(context) {
 // ({ error: '...' } / { success: false }) or through the AI-node contract
 // ({ error: true, message, code } — provider/auth failures). Both must halt
 // the workflow; treating error:true as success used to let the pipeline limp
-// into downstream NOT NULL violations.
+// into downstream NOT NULL violations. A result that says success: true is
+// the node's own verdict: an email node that reached some of its recipients
+// reports success with the refused addresses under error, and goes on.
 function isFatalNodeResult(result) {
   if (!result) return false;
+  if (result.success === true) return false;
   return result.success === false ||
     (typeof result.error === 'string' && result.error) ||
     result.error === true;

package/src/nodes/email/email-mailersend.ts

@@ -1,80 +1,94 @@
 import { NodeHandlerGenerator, handlerToString } from '../types'
+import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+import { EMAIL_RECIPIENTS_HELPER_SOURCE, EmailDeliveriesPlan } from './email-recipients'
+
+// Ambient, not imported: a serialized handler has no module scope, so
+// generateHandler appends the recipients helper's source (beside this file).
+declare function __emailRecipients(to: unknown): unknown[]
+declare function __emailDeliveries(plan: EmailDeliveriesPlan): Promise<unknown>
 
 async function email_mailersend(config: any, context: Record<string, unknown>) {
   const apiKey = config.apiKey
   const from = config.from
   const fromName = config.fromName || ''
-  const to = config.to
   const subject = config.subject
   const body = config.body
   const replyTo = config.replyTo
   const cc = config.cc
   const bcc = config.bcc
+  const recipients = __emailRecipients(config.to)
 
-  try {
-    const __nodeRequire =
-      typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
-    const mailersendPkg = __nodeRequire('mailersend')
-    const MailerSend = mailersendPkg.MailerSend
-    const EmailParams = mailersendPkg.EmailParams
-    const Sender = mailersendPkg.Sender
-    const Recipient = mailersendPkg.Recipient
+  async function sendTo(to: any) {
+    try {
+      const __nodeRequire =
+        typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
+      const mailersendPkg = __nodeRequire('mailersend')
+      const MailerSend = mailersendPkg.MailerSend
+      const EmailParams = mailersendPkg.EmailParams
+      const Sender = mailersendPkg.Sender
+      const Recipient = mailersendPkg.Recipient
 
-    const mailerSend = new MailerSend({ apiKey })
-    const sentFrom = new Sender(from, fromName)
+      const mailerSend = new MailerSend({ apiKey })
+      const sentFrom = new Sender(from, fromName)
 
-    const toList = Array.isArray(to) ? to : [to]
-    const recipients = toList.map(function (email: any) {
-      if (typeof email === 'object' && email.email) {
-        return new Recipient(email.email, email.name || '')
-      }
-      return new Recipient(email, '')
-    })
+      const recipient =
+        typeof to === 'object' && to.email
+          ? new Recipient(to.email, to.name || '')
+          : new Recipient(to, '')
 
-    const emailParams = new EmailParams()
-      .setFrom(sentFrom)
-      .setTo(recipients)
-      .setSubject(subject)
-      .setHtml(body)
+      const emailParams = new EmailParams()
+        .setFrom(sentFrom)
+        .setTo([recipient])
+        .setSubject(subject)
+        .setHtml(body)
 
-    if (replyTo) {
-      emailParams.setReplyTo(new Sender(replyTo))
-    }
+      if (replyTo) {
+        emailParams.setReplyTo(new Sender(replyTo))
+      }
 
-    if (cc) {
-      const ccList = Array.isArray(cc) ? cc : [cc]
-      emailParams.setCc(
-        ccList.map(function (email: any) {
-          return new Recipient(typeof email === 'object' ? email.email : email, '')
-        })
-      )
-    }
+      if (cc) {
+        const ccList = Array.isArray(cc) ? cc : [cc]
+        emailParams.setCc(
+          ccList.map(function (email: any) {
+            return new Recipient(typeof email === 'object' ? email.email : email, '')
+          })
+        )
+      }
 
-    if (bcc) {
-      const bccList = Array.isArray(bcc) ? bcc : [bcc]
-      emailParams.setBcc(
-        bccList.map(function (email: any) {
-          return new Recipient(typeof email === 'object' ? email.email : email, '')
-        })
-      )
-    }
+      if (bcc) {
+        const bccList = Array.isArray(bcc) ? bcc : [bcc]
+        emailParams.setBcc(
+          bccList.map(function (email: any) {
+            return new Recipient(typeof email === 'object' ? email.email : email, '')
+          })
+        )
+      }
 
-    const response = await mailerSend.email.send(emailParams)
-    const statusCode = response && response.statusCode
+      const response = await mailerSend.email.send(emailParams)
+      const statusCode = response && response.statusCode
 
-    if (statusCode === 202 || statusCode === 200) {
-      const messageId = (response.headers && response.headers['x-message-id']) || ''
-      return { messageId, success: true }
-    }
+      if (statusCode === 202 || statusCode === 200) {
+        const messageId = (response.headers && response.headers['x-message-id']) || ''
+        return { messageId, success: true }
+      }
 
-    return {
-      messageId: '',
-      success: false,
-      error: (response.body && response.body.message) || 'Failed to send email',
+      return {
+        messageId: '',
+        success: false,
+        error: (response.body && response.body.message) || 'Failed to send email',
+      }
+    } catch (err: unknown) {
+      return { messageId: '', success: false, error: (err as Error).message }
     }
-  } catch (err: unknown) {
-    return { messageId: '', success: false, error: (err as Error).message }
   }
+
+  if (recipients.length === 0) {
+    return { messageId: '', success: false, error: 'No recipient' }
+  }
+  if (recipients.length === 1) {
+    return sendTo(recipients[0])
+  }
+  return __emailDeliveries({ recipients, send: sendTo, idKey: 'messageId' })
 }
 export const emailMailersend: NodeHandlerGenerator = {
   nodeType: 'email-mailersend',
@@ -83,6 +97,9 @@ export const emailMailersend: NodeHandlerGenerator = {
     mailersend: '^2.0.0',
   },
   generateHandler(): string {
-    return handlerToString(email_mailersend)
+    return assertHandlerHasNoModuleRefs(
+      handlerToString(email_mailersend) + '\n' + EMAIL_RECIPIENTS_HELPER_SOURCE,
+      'email-mailersend'
+    )
   },
 }

package/src/nodes/email/email-mailgun.ts

@@ -1,63 +1,74 @@
 import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
 import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+import { EMAIL_RECIPIENTS_HELPER_SOURCE, EmailDeliveriesPlan } from './email-recipients'
 
 // Ambient, not imported: a serialized handler has no module scope, so
-// generateHandler appends the helper's source (EmailSender, teleport-shared).
+// generateHandler appends the helpers' source (EmailSender from teleport-shared,
+// the recipients helper beside this file).
 declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
+declare function __emailRecipients(to: unknown): unknown[]
+declare function __emailDeliveries(plan: EmailDeliveriesPlan): Promise<unknown>
 
 async function email_mailgun(config: any, context: Record<string, unknown>) {
   const apiKey = config.apiKey
   const domain = config.domain
   const from = config.from
   const fromName = config.fromName || ''
-  const to = config.to
   const subject = config.subject
   const body = config.body
   const replyTo = config.replyTo
   const cc = config.cc
   const bcc = config.bcc
+  const recipients = __emailRecipients(config.to)
 
-  try {
-    const __nodeRequire =
-      typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
-    const Mailgun = __nodeRequire('mailgun.js')
-    const FormData = __nodeRequire('form-data')
-    const mailgun = new Mailgun(FormData)
+  async function sendTo(to: unknown) {
+    try {
+      const __nodeRequire =
+        typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
+      const Mailgun = __nodeRequire('mailgun.js')
+      const FormData = __nodeRequire('form-data')
+      const mailgun = new Mailgun(FormData)
 
-    const clientOpts: Record<string, any> = { username: 'api', key: apiKey }
-    if (config.region === 'eu') {
-      clientOpts.url = 'https://api.eu.mailgun.net'
-    }
-    const mg = mailgun.client(clientOpts)
+      const clientOpts: Record<string, any> = { username: 'api', key: apiKey }
+      if (config.region === 'eu') {
+        clientOpts.url = 'https://api.eu.mailgun.net'
+      }
+      const mg = mailgun.client(clientOpts)
 
-    const fromField = __emailSender({ from, name: fromName }).header
-    const toField = Array.isArray(to) ? to : [to]
+      const msgPayload: Record<string, any> = {
+        from: __emailSender({ from, name: fromName }).header,
+        to: [to],
+        subject,
+        html: body,
+      }
 
-    const msgPayload: Record<string, any> = {
-      from: fromField,
-      to: toField,
-      subject,
-      html: body,
-    }
+      if (replyTo) {
+        msgPayload['h:Reply-To'] = replyTo
+      }
+      if (cc) {
+        msgPayload.cc = Array.isArray(cc) ? cc.join(', ') : cc
+      }
+      if (bcc) {
+        msgPayload.bcc = Array.isArray(bcc) ? bcc.join(', ') : bcc
+      }
 
-    if (replyTo) {
-      msgPayload['h:Reply-To'] = replyTo
-    }
-    if (cc) {
-      msgPayload.cc = Array.isArray(cc) ? cc.join(', ') : cc
-    }
-    if (bcc) {
-      msgPayload.bcc = Array.isArray(bcc) ? bcc.join(', ') : bcc
-    }
+      const result = await mg.messages.create(domain, msgPayload)
 
-    const result = await mg.messages.create(domain, msgPayload)
+      return { messageId: result.id || '', success: true }
+    } catch (err: unknown) {
+      const error = err as any
+      return { messageId: '', success: false, error: error.message || 'Failed to send email' }
+    }
+  }
 
-    return { messageId: result.id || '', success: true }
-  } catch (err: unknown) {
-    const error = err as any
-    return { messageId: '', success: false, error: error.message || 'Failed to send email' }
+  if (recipients.length === 0) {
+    return { messageId: '', success: false, error: 'No recipient' }
+  }
+  if (recipients.length === 1) {
+    return sendTo(recipients[0])
   }
+  return __emailDeliveries({ recipients, send: sendTo, idKey: 'messageId' })
 }
 export const emailMailgun: NodeHandlerGenerator = {
   nodeType: 'email-mailgun',
@@ -68,7 +79,11 @@ export const emailMailgun: NodeHandlerGenerator = {
   },
   generateHandler(): string {
     return assertHandlerHasNoModuleRefs(
-      handlerToString(email_mailgun) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      handlerToString(email_mailgun) +
+        '\n' +
+        EmailSender.generateEmailSenderHelperCode() +
+        '\n' +
+        EMAIL_RECIPIENTS_HELPER_SOURCE,
       'email-mailgun'
     )
   },

package/src/nodes/email/email-postmark.ts

@@ -1,16 +1,19 @@
 import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
 import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+import { EMAIL_RECIPIENTS_HELPER_SOURCE, EmailDeliveriesPlan } from './email-recipients'
 
 // Ambient, not imported: a serialized handler has no module scope, so
-// generateHandler appends the helper's source (EmailSender, teleport-shared).
+// generateHandler appends the helpers' source (EmailSender from teleport-shared,
+// the recipients helper beside this file).
 declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
+declare function __emailRecipients(to: unknown): unknown[]
+declare function __emailDeliveries(plan: EmailDeliveriesPlan): Promise<unknown>
 
 async function email_postmark(config: any, context: Record<string, unknown>) {
   const serverToken = config.serverToken
   const from = config.from
   const fromName = config.fromName
-  const to = config.to
   const subject = config.subject
   const body = config.body
   const replyTo = config.replyTo
@@ -18,45 +21,54 @@ async function email_postmark(config: any, context: Record<string, unknown>) {
   const bcc = config.bcc
   const tag = config.tag
   const trackOpens = config.trackOpens
+  const recipients = __emailRecipients(config.to)
 
-  try {
-    const __nodeRequire =
-      typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
-    const postmark = __nodeRequire('postmark')
-    const client = new postmark.ServerClient(serverToken)
+  async function sendTo(to: unknown) {
+    try {
+      const __nodeRequire =
+        typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
+      const postmark = __nodeRequire('postmark')
+      const client = new postmark.ServerClient(serverToken)
 
-    const toField = Array.isArray(to) ? to.join(', ') : to
+      const emailPayload: Record<string, any> = {
+        From: __emailSender({ from, name: fromName }).header,
+        To: to,
+        Subject: subject,
+        HtmlBody: body,
+      }
 
-    const emailPayload: Record<string, any> = {
-      From: __emailSender({ from, name: fromName }).header,
-      To: toField,
-      Subject: subject,
-      HtmlBody: body,
-    }
+      if (replyTo) {
+        emailPayload.ReplyTo = replyTo
+      }
+      if (cc) {
+        emailPayload.Cc = Array.isArray(cc) ? cc.join(', ') : cc
+      }
+      if (bcc) {
+        emailPayload.Bcc = Array.isArray(bcc) ? bcc.join(', ') : bcc
+      }
+      if (tag) {
+        emailPayload.Tag = tag
+      }
+      if (trackOpens !== undefined) {
+        emailPayload.TrackOpens = trackOpens
+      }
 
-    if (replyTo) {
-      emailPayload.ReplyTo = replyTo
-    }
-    if (cc) {
-      emailPayload.Cc = Array.isArray(cc) ? cc.join(', ') : cc
-    }
-    if (bcc) {
-      emailPayload.Bcc = Array.isArray(bcc) ? bcc.join(', ') : bcc
-    }
-    if (tag) {
-      emailPayload.Tag = tag
-    }
-    if (trackOpens !== undefined) {
-      emailPayload.TrackOpens = trackOpens
-    }
+      const result = await client.sendEmail(emailPayload)
 
-    const result = await client.sendEmail(emailPayload)
+      return { messageId: result.MessageID || '', success: true }
+    } catch (err: unknown) {
+      const error = err as any
+      return { messageId: '', success: false, error: error.message || 'Failed to send email' }
+    }
+  }
 
-    return { messageId: result.MessageID || '', success: true }
-  } catch (err: unknown) {
-    const error = err as any
-    return { messageId: '', success: false, error: error.message || 'Failed to send email' }
+  if (recipients.length === 0) {
+    return { messageId: '', success: false, error: 'No recipient' }
+  }
+  if (recipients.length === 1) {
+    return sendTo(recipients[0])
   }
+  return __emailDeliveries({ recipients, send: sendTo, idKey: 'messageId' })
 }
 export const emailPostmark: NodeHandlerGenerator = {
   nodeType: 'email-postmark',
@@ -66,7 +78,11 @@ export const emailPostmark: NodeHandlerGenerator = {
   },
   generateHandler(): string {
     return assertHandlerHasNoModuleRefs(
-      handlerToString(email_postmark) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      handlerToString(email_postmark) +
+        '\n' +
+        EmailSender.generateEmailSenderHelperCode() +
+        '\n' +
+        EMAIL_RECIPIENTS_HELPER_SOURCE,
       'email-postmark'
     )
   },

package/src/nodes/email/email-recipients.ts

@@ -0,0 +1,86 @@
+/**
+ * How a workflow email node reaches SEVERAL recipients: one provider call per
+ * address, so one refused address (a sender that only delivers to the account
+ * owner, a provider account still pending approval) never blocks the others,
+ * and the sent-email ledger can say exactly who got the email.
+ *
+ * Appended to the five `email-*` handlers the way `__emailSender` is: a
+ * serialized handler has no module scope, so each declares these ambiently
+ * and `generateHandler` concatenates this source. A STRING LITERAL with
+ * ONE-parameter functions, for the reasons `commerce-tracking.ts` gives (a
+ * consumer's minifier inlines a single-use `.toString()`, and
+ * `resolveHandlerEntryName` picks a minified entry point by its 2-param arity).
+ */
+
+export interface EmailDelivery {
+  to: string
+  success: boolean
+  id?: string
+  messageId?: string
+  error?: string
+}
+
+export interface EmailDeliveriesPlan {
+  recipients: unknown[]
+  send: (recipient: unknown) => Promise<unknown>
+  /** The key the handler reports the provider's message id under. */
+  idKey: 'id' | 'messageId'
+}
+
+export const EMAIL_RECIPIENTS_HELPER_SOURCE = `
+// The address of one recipient entry: a string, or MailerSend's { email, name }.
+function __emailAddressOf(entry) {
+  if (typeof entry === 'string') return entry.trim();
+  if (entry && typeof entry === 'object' && typeof entry.email === 'string') return entry.email.trim();
+  return '';
+}
+
+// A node's \`to\` as a list with no empty entries and no address twice
+// (case-insensitive); each entry keeps the shape it arrived in.
+function __emailRecipients(to) {
+  var entries = Array.isArray(to) ? to : [to];
+  var seen = {};
+  var recipients = [];
+  for (var i = 0; i < entries.length; i++) {
+    var key = __emailAddressOf(entries[i]).toLowerCase();
+    if (!key || seen[key]) continue;
+    seen[key] = true;
+    recipients.push(entries[i]);
+  }
+  return recipients;
+}
+
+// Sends to each recipient in turn through plan.send (one recipient per call)
+// and reports the whole: the first delivered id, success when at least one
+// was delivered, the refused addresses with their reasons, and one delivery
+// per recipient.
+async function __emailDeliveries(plan) {
+  var deliveries = [];
+  for (var i = 0; i < plan.recipients.length; i++) {
+    var recipient = plan.recipients[i];
+    var outcome;
+    try {
+      outcome = await plan.send(recipient);
+    } catch (err) {
+      outcome = { success: false, error: (err && err.message) || String(err) };
+    }
+    var delivery = { to: __emailAddressOf(recipient), success: outcome.success === true };
+    if (delivery.success) {
+      delivery[plan.idKey] = outcome[plan.idKey] || '';
+    } else {
+      delivery.error = outcome.error || 'Failed to send email';
+    }
+    deliveries.push(delivery);
+  }
+  var delivered = deliveries.filter(function (d) { return d.success; });
+  var refused = deliveries.filter(function (d) { return !d.success; });
+  var result = {};
+  result[plan.idKey] = delivered.length ? delivered[0][plan.idKey] : '';
+  result.success = delivered.length > 0;
+  if (refused.length) {
+    result.error = 'refused for ' + refused.map(function (d) { return d.to + ' (' + d.error + ')'; }).join('; ');
+  }
+  result.deliveries = deliveries;
+  return result;
+}
+`

package/src/nodes/email/email-resend.ts

@@ -1,57 +1,71 @@
 import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
 import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+import { EMAIL_RECIPIENTS_HELPER_SOURCE, EmailDeliveriesPlan } from './email-recipients'
 
 // Ambient, not imported: a serialized handler has no module scope, so
-// generateHandler appends the helper's source (EmailSender, teleport-shared).
+// generateHandler appends the helpers' source (EmailSender from teleport-shared,
+// the recipients helper beside this file).
 declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
+declare function __emailRecipients(to: unknown): unknown[]
+declare function __emailDeliveries(plan: EmailDeliveriesPlan): Promise<unknown>
 
 async function email_resend(config: any, context: Record<string, unknown>) {
   const apiKey = config.apiKey
   const from = config.from
   const fromName = config.fromName
-  const to = config.to
   const subject = config.subject
   const body = config.body
   const replyTo = config.replyTo
   const cc = config.cc
   const bcc = config.bcc
+  const recipients = __emailRecipients(config.to)
 
-  try {
-    const __nodeRequire =
-      typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
-    const Resend = __nodeRequire('resend').Resend
-    const resend = new Resend(apiKey)
+  async function sendTo(to: unknown) {
+    try {
+      const __nodeRequire =
+        typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
+      const Resend = __nodeRequire('resend').Resend
+      const resend = new Resend(apiKey)
 
-    const payload: Record<string, any> = {
-      from: __emailSender({ from, name: fromName }).header,
-      to: Array.isArray(to) ? to : [to],
-      subject,
-      html: body,
-    }
+      const payload: Record<string, any> = {
+        from: __emailSender({ from, name: fromName }).header,
+        to: [to],
+        subject,
+        html: body,
+      }
 
-    if (replyTo) {
-      // Resend SDK input uses the camelCase `replyTo` key (it maps to the
-      // on-the-wire `reply_to` internally); a snake_case key is silently dropped.
-      payload.replyTo = replyTo
-    }
-    if (cc) {
-      payload.cc = Array.isArray(cc) ? cc : [cc]
-    }
-    if (bcc) {
-      payload.bcc = Array.isArray(bcc) ? bcc : [bcc]
-    }
+      if (replyTo) {
+        // Resend SDK input uses the camelCase `replyTo` key (it maps to the
+        // on-the-wire `reply_to` internally); a snake_case key is silently dropped.
+        payload.replyTo = replyTo
+      }
+      if (cc) {
+        payload.cc = Array.isArray(cc) ? cc : [cc]
+      }
+      if (bcc) {
+        payload.bcc = Array.isArray(bcc) ? bcc : [bcc]
+      }
 
-    const data = await resend.emails.send(payload)
+      const data = await resend.emails.send(payload)
 
-    if (data.error) {
-      return { id: '', success: false, error: data.error.message || 'Failed to send email' }
+      if (data.error) {
+        return { id: '', success: false, error: data.error.message || 'Failed to send email' }
+      }
+
+      return { id: (data.data && data.data.id) || '', success: true }
+    } catch (err: unknown) {
+      return { id: '', success: false, error: (err as Error).message }
     }
+  }
 
-    return { id: (data.data && data.data.id) || '', success: true }
-  } catch (err: unknown) {
-    return { id: '', success: false, error: (err as Error).message }
+  if (recipients.length === 0) {
+    return { id: '', success: false, error: 'No recipient' }
+  }
+  if (recipients.length === 1) {
+    return sendTo(recipients[0])
   }
+  return __emailDeliveries({ recipients, send: sendTo, idKey: 'id' })
 }
 export const emailResend: NodeHandlerGenerator = {
   nodeType: 'email-resend',
@@ -61,7 +75,11 @@ export const emailResend: NodeHandlerGenerator = {
   },
   generateHandler(): string {
     return assertHandlerHasNoModuleRefs(
-      handlerToString(email_resend) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      handlerToString(email_resend) +
+        '\n' +
+        EmailSender.generateEmailSenderHelperCode() +
+        '\n' +
+        EMAIL_RECIPIENTS_HELPER_SOURCE,
       'email-resend'
     )
   },