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

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
   }