@teleporthq/teleport-plugin-next-workflows 0.45.0 → 0.45.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleporthq/teleport-plugin-next-workflows",
-  "version": "0.45.0",
+  "version": "0.45.2",
   "description": "A plugin for workflow code generation in Next.js projects.",
   "author": "teleportHQ",
   "license": "MIT",
@@ -69,5 +69,5 @@
     "@teleporthq/teleport-shared": "^0.45.0",
     "@teleporthq/teleport-types": "^0.45.0"
   },
-  "gitHead": "72396d1815ef1f0c184f27126dbfd0fd9c6dc0f8"
+  "gitHead": "3be925a09c56ec0afe44940a623cbfcc54e5170f"
 }

package/src/auth-generator.ts

@@ -2297,6 +2297,8 @@ const generateKnownAddressEmailCode = (options: {
   sender: { provider: string | null; from: string; secretEnv: string }
   pagePath: string
   tokenInFragment: boolean
+  /** The route already declares `__emailSender` (the welcome send brings it). */
+  senderHelperDeclared: boolean
 }): string => {
   const { sender } = options
   const senderConstants = `
@@ -2320,10 +2322,11 @@ async function sendSetPasswordEmail() {
   const ttlMinutes = Math.round(PASSWORD_RESET_TOKEN_TTL_SECONDS / 60)
   // Where the link carries the token, as the forgot-password link does.
   const tokenLinkPrefix = options.tokenInFragment ? '#token=' : '?token='
-  const noticeSend = generateProviderSendFunction(sender.provider).replace(
-    'async function __sendProviderEmail(',
-    'async function __sendNoticeEmail('
-  )
+  const noticeSend = generateProviderSendFunction(
+    sender.provider,
+    undefined,
+    !options.senderHelperDeclared
+  ).replace('async function __sendProviderEmail(', 'async function __sendNoticeEmail(')
   return `${senderConstants}
 
 ${noticeSend}
@@ -2537,6 +2540,7 @@ ${generateKnownAddressEmailCode({
   sender: noticeSender,
   pagePath: setPasswordPagePath,
   tokenInFragment: signup.tokenInFragment === true,
+  senderHelperDeclared: !!welcomeProvider,
 })}
 
 function waitUntilElapsed(startedAt, ms) {

package/src/nodes/email/outbound-message-guard.ts

@@ -547,25 +547,31 @@ var __outboundMessageGuard = typeof __outboundMessageGuard !== 'undefined' ? __o
 export interface OutboundHandlerSourceOptions {
   /** Helper source appended after the handler (the sender, the recipients). */
   extraSource?: string
-  /** When set, the serialized source is refused if it names a module. */
-  nodeType?: string
+  /**
+   * The node's type. Names the handler (see below), and the serialized source
+   * is refused if it names a module.
+   */
+  nodeType: string
 }
 
 export const outboundMessageHandlerSources = (
   handler: HandlerFn,
-  options: OutboundHandlerSourceOptions = {}
+  options: OutboundHandlerSourceOptions
 ): Pick<NodeHandlerGenerator, 'generateHandler' | 'generateServerHandler'> => {
   const extra = options.extraSource ? '\n' + options.extraSource : ''
-  const finish = (source: string): string =>
-    options.nodeType ? assertHandlerHasNoModuleRefs(source, options.nodeType) : source
+  const finish = (source: string): string => assertHandlerHasNoModuleRefs(source, options.nodeType)
+  // The handler arrives by value from its node's module level, where a
+  // consumer's minifier inlines it anonymous; it gets the name the emitters
+  // look for (see resolveHandlerEntryName).
+  const handlerSource = () => handlerToString(handler, options.nodeType.replace(/-/g, '_'))
   return {
     generateHandler: () =>
-      finish(generateOutboundMessageGuardCode() + '\n\n' + handlerToString(handler) + extra),
+      finish(generateOutboundMessageGuardCode() + '\n\n' + handlerSource() + extra),
     generateServerHandler: (serverOptions?: ServerHandlerOptions) =>
       finish(
         generateOutboundMessageGuardCode(serverHandlerPrefix(serverOptions)) +
           '\n\n' +
-          handlerToString(handler) +
+          handlerSource() +
           extra
       ),
   }

package/src/nodes/sms/sms-infobip.ts

@@ -72,5 +72,5 @@ async function sms_infobip(config: any, context: Record<string, unknown>) {
 export const smsInfobip: NodeHandlerGenerator = {
   nodeType: 'sms-infobip',
   executionEnv: 'server',
-  ...outboundMessageHandlerSources(sms_infobip),
+  ...outboundMessageHandlerSources(sms_infobip, { nodeType: 'sms-infobip' }),
 }

package/src/nodes/sms/sms-smsapi.ts

@@ -57,5 +57,5 @@ async function sms_smsapi(config: any, context: Record<string, unknown>) {
 export const smsSmsapi: NodeHandlerGenerator = {
   nodeType: 'sms-smsapi',
   executionEnv: 'server',
-  ...outboundMessageHandlerSources(sms_smsapi),
+  ...outboundMessageHandlerSources(sms_smsapi, { nodeType: 'sms-smsapi' }),
 }

package/src/nodes/sms/sms-textmagic.ts

@@ -50,5 +50,5 @@ async function sms_textmagic(config: any, context: Record<string, unknown>) {
 export const smsTextmagic: NodeHandlerGenerator = {
   nodeType: 'sms-textmagic',
   executionEnv: 'server',
-  ...outboundMessageHandlerSources(sms_textmagic),
+  ...outboundMessageHandlerSources(sms_textmagic, { nodeType: 'sms-textmagic' }),
 }

package/src/nodes/sms/sms-twilio.ts

@@ -56,5 +56,5 @@ export const smsTwilio: NodeHandlerGenerator = {
   dependencies: {
     twilio: '^5.0.0',
   },
-  ...outboundMessageHandlerSources(sms_twilio),
+  ...outboundMessageHandlerSources(sms_twilio, { nodeType: 'sms-twilio' }),
 }

package/src/nodes/types.ts

@@ -1,7 +1,12 @@
 export type HandlerFn = (config: unknown, context: Record<string, unknown>) => Promise<unknown>
 
-export function handlerToString(fn: HandlerFn): string {
-  return fn.toString()
+// `name` gives the handler its name back when a consumer's minifier inlined
+// it, as an anonymous expression, into the one call that reads it (a handler
+// passed by value at module level): `async function(e,t){…}` cannot stand as
+// a statement, `async function email_resend(e,t){…}` can.
+export function handlerToString(fn: HandlerFn, name?: string): string {
+  const source = fn.toString()
+  return name ? source.replace(/^(async\s+)?function\s*\(/, `$1function ${name}(`) : source
 }
 
 // A `function` keyword opening a line with no name after it: an anonymous

package/src/transactional-email-code.ts

@@ -67,16 +67,20 @@ export const EXISTING_ACCOUNT_EMAIL = 'existing-account'
 // is configured the function is a no-op so the route stays self-contained and
 // never throws. With `ledger`, the provider function is emitted as
 // `__sendProviderEmailRaw` and `__sendProviderEmail` records every attempt
-// (success or throw) before returning / rethrowing.
+// (success or throw) before returning / rethrowing. `withSenderHelper: false`
+// leaves the helper out, for a second send in a file that already declares it:
+// Next compiles a route as a module, where a function declared twice fails the
+// build ("the name `__emailSender` is defined multiple times").
 export const generateProviderSendFunction = (
   provider?: string | null,
-  ledger?: TransactionalEmailLedger
+  ledger?: TransactionalEmailLedger,
+  withSenderHelper = true
 ): string => {
   const raw = generateRawProviderSendFunction(provider)
   if (!provider || !SUPPORTED_EMAIL_PROVIDERS.has(provider)) {
     return raw
   }
-  const senderHelper = EmailSender.generateEmailSenderHelperCode()
+  const senderHelper = withSenderHelper ? EmailSender.generateEmailSenderHelperCode() : ''
   if (!ledger) {
     return `${senderHelper}
 ${raw}`