@teleporthq/teleport-plugin-next-workflows 0.44.8 → 0.44.10

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

@@ -1,69 +1,84 @@
 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_sendgrid(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 MailService = __nodeRequire('@sendgrid/mail').MailService
-    const sgMail = new MailService()
-    sgMail.setApiKey(apiKey)
+  async function sendTo(to: unknown) {
+    try {
+      const __nodeRequire =
+        typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : require
+      const MailService = __nodeRequire('@sendgrid/mail').MailService
+      const sgMail = new MailService()
+      sgMail.setApiKey(apiKey)
 
-    // SendGrid reads a "Name <email>" string's name verbatim, quotes included,
-    // so a named sender goes as its two parts.
-    const sender = __emailSender({ from, name: fromName })
-    const msg: Record<string, any> = {
-      to: Array.isArray(to) ? to : [to],
-      from: sender.name ? { email: sender.email, name: sender.name } : sender.email,
-      subject,
-      html: body,
-    }
+      // SendGrid reads a "Name <email>" string's name verbatim, quotes included,
+      // so a named sender goes as its two parts.
+      const sender = __emailSender({ from, name: fromName })
+      const msg: Record<string, any> = {
+        to: [to],
+        from: sender.name ? { email: sender.email, name: sender.name } : sender.email,
+        subject,
+        html: body,
+      }
 
-    if (replyTo) {
-      msg.replyTo = replyTo
-    }
-    if (cc) {
-      msg.cc = Array.isArray(cc) ? cc : [cc]
-    }
-    if (bcc) {
-      msg.bcc = Array.isArray(bcc) ? bcc : [bcc]
-    }
+      if (replyTo) {
+        msg.replyTo = replyTo
+      }
+      if (cc) {
+        msg.cc = Array.isArray(cc) ? cc : [cc]
+      }
+      if (bcc) {
+        msg.bcc = Array.isArray(bcc) ? bcc : [bcc]
+      }
 
-    const response = await sgMail.send(msg)
-    const statusCode = response && response[0] && response[0].statusCode
-    const messageId =
-      (response && response[0] && response[0].headers && response[0].headers['x-message-id']) || ''
+      const response = await sgMail.send(msg)
+      const statusCode = response && response[0] && response[0].statusCode
+      const messageId =
+        (response && response[0] && response[0].headers && response[0].headers['x-message-id']) ||
+        ''
 
-    return { messageId, success: statusCode === 202 || statusCode === 200 }
-  } catch (err: unknown) {
-    const error = err as any
-    let message = 'Failed to send email'
-    if (error.response && error.response.body && error.response.body.errors) {
-      message = error.response.body.errors
-        .map(function (e: any) {
-          return e.message
-        })
-        .join(', ')
-    } else if (error.message) {
-      message = error.message
+      return { messageId, success: statusCode === 202 || statusCode === 200 }
+    } catch (err: unknown) {
+      const error = err as any
+      let message = 'Failed to send email'
+      if (error.response && error.response.body && error.response.body.errors) {
+        message = error.response.body.errors
+          .map(function (e: any) {
+            return e.message
+          })
+          .join(', ')
+      } else if (error.message) {
+        message = error.message
+      }
+      return { messageId: '', success: false, error: message }
     }
-    return { messageId: '', success: false, 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 emailSendgrid: NodeHandlerGenerator = {
   nodeType: 'email-sendgrid',
@@ -73,7 +88,11 @@ export const emailSendgrid: NodeHandlerGenerator = {
   },
   generateHandler(): string {
     return assertHandlerHasNoModuleRefs(
-      handlerToString(email_sendgrid) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      handlerToString(email_sendgrid) +
+        '\n' +
+        EmailSender.generateEmailSenderHelperCode() +
+        '\n' +
+        EMAIL_RECIPIENTS_HELPER_SOURCE,
       'email-sendgrid'
     )
   },

package/src/sent-email-log/sent-email-log-code.ts

@@ -348,6 +348,19 @@ function __entryFromNode(nodeType, config, result, error) {
   };
 }
 
+// A node that reached several recipients one provider call each reports a
+// delivery per recipient; the ledger then says who got the email and who was
+// refused, one row per address. Any other result is one row for the node run.
+function __entriesFromNode(nodeType, config, result) {
+  var deliveries = result && Array.isArray(result.deliveries) ? result.deliveries : [];
+  if (deliveries.length === 0) return [__entryFromNode(nodeType, config, result, null)];
+  return deliveries.map(function (delivery) {
+    var entry = __entryFromNode(nodeType, config, delivery, null);
+    entry.to = delivery.to;
+    return entry;
+  });
+}
+
 /**
  * Wraps a server node handler so every send is recorded. The record is
  * registered on the workflow context's fire-and-forget queue — the same one
@@ -368,7 +381,10 @@ function wrapEmailNodeHandler(nodeType, handler) {
       __register(context, recordSentEmail(__entryFromNode(nodeType, config, null, err)));
       throw err;
     }
-    __register(context, recordSentEmail(__entryFromNode(nodeType, config, result, null)));
+    var entries = __entriesFromNode(nodeType, config, result);
+    for (var i = 0; i < entries.length; i++) {
+      __register(context, recordSentEmail(entries[i]));
+    }
     return result;
   };
 }

package/src/server-runtime-code.ts

@@ -1,3 +1,5 @@
+import { generateVercelFunctionsLoaderCode } from './vercel-functions'
+
 /**
  * `utils/workflows/server-runtime.js`: what every server route loads. It is the
  * shared runtime utilities plus the parts only a server may run — the signed
@@ -42,6 +44,8 @@ export const generateServerRuntimeCode = (): string => `'use strict';
 var crypto = require('crypto');
 var utils = require('./runtime-utils');
 
+${generateVercelFunctionsLoaderCode()}
+
 var __stepKeyCache = { secret: null, key: null };
 
 function stepKey() {
@@ -394,7 +398,25 @@ function trustedBaseUrl(req) {
   return origin;
 }
 
+// The work a segment's not-awaited steps left running (an invoice being
+// rendered and mailed) must still finish, but the visitor need not wait for
+// it: on Vercel it is handed to waitUntil, which keeps the function running
+// after the reply. Anywhere else the route awaits it before replying, since a
+// function frozen after its reply would drop it.
+function handOffPendingNodePromises(context) {
+  var queue = context && context.__pendingNodePromises;
+  if (!queue || queue.length === 0) return Promise.resolve();
+  // Drained through the queue itself: the route deletes it from the context
+  // before replying, and a parallel branch still running pushes onto it.
+  var drained = utils.settlePendingNodePromises({ __pendingNodePromises: queue });
+  var waitUntil = __vercelWaitUntil();
+  if (!waitUntil) return drained;
+  waitUntil(drained);
+  return Promise.resolve();
+}
+
 module.exports = Object.assign({}, utils, {
+  handOffPendingNodePromises: handOffPendingNodePromises,
   claimSegmentContext: claimSegmentContext,
   segmentReply: segmentReply,
   internalRequestHeaders: internalRequestHeaders,

package/src/transactional-email-code.ts

@@ -38,10 +38,17 @@ export interface TransactionalEmailLedger {
   source: string
   sourceRef: string
   relativePrefix: string
+  /**
+   * Records the send without the recipient's details: `msg.recordedTo` in
+   * place of the address, and neither the body nor the values it was filled
+   * with. For an email to someone whose details the route is removing (the
+   * farewell after an account deletion).
+   */
+  withoutRecipientDetails?: boolean
 }
 
-// Provider-specific `__sendProviderEmail({ from, fromName?, to, subject, html,
-// apiKey, tokenValues?, userId? })`, preceded by the `__emailSender` helper that
+// Provider-specific `__sendProviderEmail({ from, fromName?, to, recordedTo?,
+// subject, html, apiKey, tokenValues?, userId? })`, preceded by the `__emailSender` helper that
 // names the sender. No attachment (unlike the invoice sender). When no provider
 // 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
@@ -77,12 +84,12 @@ async function __sendProviderEmail(msg) {
   __sentEmailLog.recordSentEmail({
     emailType: ${JSON.stringify(ledger.emailType)},
     audience: 'customer',
-    to: msg.to,
+    to: ${ledger.withoutRecipientDetails ? 'msg.recordedTo' : 'msg.to'},
     from: sender.email,
     fromName: sender.name,
     subject: msg.subject,
-    html: msg.html,
-    payload: msg.tokenValues,
+    html: ${ledger.withoutRecipientDetails ? "''" : 'msg.html'},
+    payload: ${ledger.withoutRecipientDetails ? 'null' : 'msg.tokenValues'},
     provider: ${JSON.stringify(provider)},
     status: failure ? 'failed' : 'sent',
     error: failure ? (failure.message || String(failure)) : null,

package/src/vercel-functions.ts

@@ -0,0 +1,67 @@
+/**
+ * `@vercel/functions` in a generated project: `waitUntil`, which keeps a
+ * Vercel function running after its reply, and `attachDatabasePool`, which
+ * closes a pool's idle connections before the function is suspended.
+ *
+ * The generated code loads it inside a try, so a project that does not have
+ * it installed (or a bundler that cannot find it) keeps working without
+ * either. A project whose emitted files require it declares it (see
+ * `declareVercelFunctionsWhereRequired`).
+ */
+export const VERCEL_FUNCTIONS_PACKAGE = '@vercel/functions'
+
+// The 2.x line still supports Node 18, which the Next project template allows;
+// 3.x requires Node 20. attachDatabasePool is stable from 2.2.8.
+export const VERCEL_FUNCTIONS_VERSION = '^2.2.13'
+
+const VERCEL_FUNCTIONS_REQUIRE = `require('${VERCEL_FUNCTIONS_PACKAGE}')`
+
+/**
+ * `__vercelFunctions()` (the module, or null) and `__vercelWaitUntil()` (the
+ * module's waitUntil while this code runs inside a Vercel request, else null).
+ *
+ * waitUntil does nothing outside a Vercel request (a local `next dev`, another
+ * host): it reads the request context Vercel installs under
+ * `Symbol.for('@vercel/request-context')` and silently drops the promise when
+ * there is none. The same check here lets a caller await the work instead.
+ */
+export const generateVercelFunctionsLoaderCode = (): string => `var __vercelFunctionsModule;
+function __vercelFunctions() {
+  if (__vercelFunctionsModule === undefined) {
+    try { __vercelFunctionsModule = ${VERCEL_FUNCTIONS_REQUIRE}; } catch (_e) { __vercelFunctionsModule = null; }
+  }
+  return __vercelFunctionsModule;
+}
+
+function __vercelWaitUntil() {
+  var store = globalThis[Symbol.for('@vercel/request-context')];
+  var requestContext = store && typeof store.get === 'function' ? store.get() : null;
+  if (!requestContext || typeof requestContext.waitUntil !== 'function') return null;
+  var vercel = __vercelFunctions();
+  return vercel && typeof vercel.waitUntil === 'function' ? vercel.waitUntil : null;
+}`
+
+interface GeneratedFileRecord {
+  files?: Array<{ content?: unknown }>
+}
+
+/**
+ * Declares `@vercel/functions` in the project's dependencies when any emitted
+ * file requires it, keeping a version the project already declares.
+ */
+export const declareVercelFunctionsWhereRequired = (
+  files: Map<string, GeneratedFileRecord>,
+  dependencies: Record<string, string>
+): void => {
+  if (dependencies[VERCEL_FUNCTIONS_PACKAGE]) {
+    return
+  }
+  for (const record of files.values()) {
+    for (const file of record.files || []) {
+      if (typeof file.content === 'string' && file.content.includes(VERCEL_FUNCTIONS_REQUIRE)) {
+        dependencies[VERCEL_FUNCTIONS_PACKAGE] = VERCEL_FUNCTIONS_VERSION
+        return
+      }
+    }
+  }
+}

package/src/webhook-delivery-lease/webhook-delivery-lease-code.ts

@@ -22,6 +22,12 @@ import {
  * released before the route replies; one left by a run that died expires
  * after a lease longer than any route may run.
  *
+ * The table is used when it exists (the editor creates it with the payment
+ * tables) and created only when it does not: a site's database role may read
+ * and write its tables without being allowed to create one, and
+ * CREATE TABLE IF NOT EXISTS asks for that permission even when the table is
+ * there.
+ *
  * Contract: `claimWebhookDelivery` never throws. Without Postgres, a driver,
  * the table or the privilege to create it, it claims nothing and lets the
  * delivery run — as every delivery ran before the lease existed.
@@ -48,6 +54,7 @@ ${generateLazyPgClientCode()}
 var TABLE_NAME = '${WEBHOOK_DELIVERY_LEASE_TABLE}';
 var LEASE_SECONDS = ${WEBHOOK_DELIVERY_LEASE_SECONDS};
 var QUERY_TIMEOUT_MS = 5000;
+var TABLE_EXISTS_SQL = 'SELECT to_regclass($1) IS NOT NULL AS present';
 var CREATE_SQL = 'CREATE TABLE IF NOT EXISTS "' + TABLE_NAME + '" (' +
   'delivery_key TEXT PRIMARY KEY, claim_token TEXT NOT NULL, ' +
   'claimed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), attempts INTEGER NOT NULL DEFAULT 1)';
@@ -80,20 +87,28 @@ function __withTimeout(promise, ms) {
   return Promise.race([promise, timeout]).then(function (v) { clearTimeout(timer); return v; }, function (err) { clearTimeout(timer); throw err; });
 }
 
-async function __run(statements) {
+// Runs \`work(query)\` on one connection, closed afterwards.
+async function __run(work) {
   var client = getClient();
   await __withTimeout(client.connect(), QUERY_TIMEOUT_MS);
   try {
-    var result = null;
-    for (var i = 0; i < statements.length; i++) {
-      result = await __withTimeout(client.query(statements[i].sql, statements[i].values), QUERY_TIMEOUT_MS);
-    }
-    return result;
+    return await work(function (sql, values) {
+      return __withTimeout(client.query(sql, values || []), QUERY_TIMEOUT_MS);
+    });
   } finally {
     try { await client.end(); } catch (_e) {}
   }
 }
 
+async function __ensureTable(query) {
+  if (__tableReady) return;
+  var found = await query(TABLE_EXISTS_SQL, [TABLE_NAME]);
+  if (!found || !Array.isArray(found.rows) || !found.rows[0] || !found.rows[0].present) {
+    await query(CREATE_SQL);
+  }
+  __tableReady = true;
+}
+
 function __stableJson(value) {
   try { return JSON.stringify(value === undefined ? null : value) || ''; } catch (_e) { return ''; }
 }
@@ -120,12 +135,12 @@ async function claimWebhookDelivery(scope, rawBody, verifiedBody) {
     .update(__stableJson(verifiedBody))
     .digest('hex');
   var token = crypto.randomBytes(16).toString('hex');
-  var statements = __tableReady ? [] : [{ sql: CREATE_SQL, values: [] }];
-  statements.push({ sql: CLAIM_SQL, values: [key, token, LEASE_SECONDS] });
   var result;
   try {
-    result = await __run(statements);
-    __tableReady = true;
+    result = await __run(async function (query) {
+      await __ensureTable(query);
+      return query(CLAIM_SQL, [key, token, LEASE_SECONDS]);
+    });
   } catch (err) {
     var code = err && err.code;
     if (code === '42501') { __disable('no privilege to create or write table ' + TABLE_NAME); }
@@ -138,7 +153,7 @@ async function claimWebhookDelivery(scope, rawBody, verifiedBody) {
   return {
     claimed: true,
     release: function () {
-      return __run([{ sql: RELEASE_SQL, values: [key, token] }]).then(
+      return __run(function (query) { return query(RELEASE_SQL, [key, token]); }).then(
         function () {},
         function (err) { console.error('[webhook-delivery-lease] release failed: ' + (err && err.message ? err.message : String(err))); }
       );

package/src/workflow-project-plugin.ts

@@ -72,6 +72,7 @@ import {
 import { generateInvoiceFiles, resolveInvoiceDataSource } from './invoice'
 import { ensureSentEmailLogModule, hasEmailSendingNodeType } from './sent-email-log'
 import { ensureWebhookDeliveryLeaseModule } from './webhook-delivery-lease'
+import { declareVercelFunctionsWhereRequired } from './vercel-functions'
 import { ensureEmailLocaleModule, resolveEmailLocaleConfig } from './email-locale'
 import { workflowUtilsImportLine, workflowUtilsRequireLine } from './workflow-utils-alias'
 import { generateWebhookFiles } from './webhook-generator'
@@ -385,6 +386,7 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
       if (hasAuthentication) {
         this.injectSessionProviderIntoApp(structure)
       }
+      declareVercelFunctionsWhereRequired(files, dependencies)
       return structure
     }
 
@@ -974,6 +976,7 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
       this.injectSessionProviderIntoApp(structure)
     }
 
+    declareVercelFunctionsWhereRequired(files, dependencies)
     return structure
   }