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

package/src/invoice/invoice-html-code.ts

@@ -265,6 +265,54 @@ function formatDateValue(raw) {
   }
 }
 
+// How the invoice says it was paid: the method in words, with the provider that
+// took the money when a provider did ("Card (Stripe)", "Paid online" for a
+// booking paid through the site, "Cash on delivery", "Gift card"), and the
+// provider's payment id as "Ref. pi_…". The stored values are ids.
+var PAYMENT_PROVIDER_LABELS = {
+  stripe: 'Stripe', paypal: 'PayPal', mollie: 'Mollie', razorpay: 'Razorpay',
+  square: 'Square', paddle: 'Paddle', coingate: 'CoinGate',
+};
+var PAYMENT_METHOD_LABELS = {
+  card: 'Card',
+  online: 'Paid online',
+  cash_on_delivery: 'Cash on delivery',
+  cod: 'Cash on delivery',
+  cash: 'Cash',
+  store_pickup: 'Paid at pickup',
+  pickup: 'Paid at pickup',
+  gift_card: 'Gift card',
+  bank_transfer: 'Bank transfer',
+};
+var PAYMENT_METHODS_NAMING_PROVIDER = { card: true, online: true };
+
+function humanizePaymentId(value) {
+  var words = String(value).replace(/[_-]+/g, ' ').trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+function paymentProviderLabel(provider) {
+  var id = String(provider || '').trim().toLowerCase();
+  return PAYMENT_PROVIDER_LABELS[id] || (id ? humanizePaymentId(id) : '');
+}
+
+function paymentMethodLabel(method, provider) {
+  var id = String(method || '').trim().toLowerCase();
+  var providerLabel = paymentProviderLabel(provider);
+  if (PAYMENT_METHOD_LABELS[id]) {
+    return PAYMENT_METHOD_LABELS[id] +
+      (PAYMENT_METHODS_NAMING_PROVIDER[id] && providerLabel ? ' (' + providerLabel + ')' : '');
+  }
+  if (PAYMENT_PROVIDER_LABELS[id]) return 'Paid online (' + PAYMENT_PROVIDER_LABELS[id] + ')';
+  if (!id) return providerLabel ? 'Paid online (' + providerLabel + ')' : '';
+  return humanizePaymentId(id);
+}
+
+function paymentReference(paymentId) {
+  var ref = String(paymentId || '').trim();
+  return ref ? 'Ref. ' + ref : '';
+}
+
 function buildInvoiceDataScope(invoiceData) {
   var contextCompany = extractStaticAttrsFromContext(TEMPLATE_COMPONENT_UIDL).Company || {};
   var sym = invoiceData.currencySymbol || '$';
@@ -311,10 +359,13 @@ function buildInvoiceDataScope(invoiceData) {
   var giftCardLast4 = String(invoiceData.giftCardLast4 || '').trim();
   var totalNumber = Number(invoiceData.total);
   if (!isFinite(totalNumber)) totalNumber = 0;
+  // What is left to pay after the gift card. The invoice records what the
+  // provider or the courier was to collect; once that is paid, nothing is left.
   var amountDueNumber = Number(invoiceData.amountDue);
   if (invoiceData.amountDue == null || !isFinite(amountDueNumber)) {
     amountDueNumber = Math.max(0, totalNumber - giftCardAmountNumber);
   }
+  if (isSettledInvoice(invoiceData.status)) amountDueNumber = 0;
 
   // A paid invoice asks for nothing: where the due date would print, it says
   // when it was paid. The order keeps no payment method finer than its
@@ -376,9 +427,9 @@ function buildInvoiceDataScope(invoiceData) {
   realCustomer.hasVat = realCustomer.vat ? 'true' : 'false';
 
   var realPayment = {
-    method: invoiceData.paymentMethod || '',
-    provider: invoiceData.paymentProvider || '',
-    intentId: invoiceData.paymentIntentId || '',
+    method: paymentMethodLabel(invoiceData.paymentMethod, invoiceData.paymentProvider),
+    provider: paymentProviderLabel(invoiceData.paymentProvider),
+    intentId: paymentReference(invoiceData.paymentIntentId),
     orderId: invoiceData.orderId || '',
   };
 
@@ -746,6 +797,39 @@ function renderComponentReference(content, scope, depth) {
   return rendered;
 }
 
+// A paid invoice asks for nothing, so, as in the email, its amount-due line is
+// left out. The template shows that line whenever a gift card was used, which
+// cannot tell whether the rest was paid since. The line is the innermost
+// container holding the field (the editor lays each summary line out as a row
+// of texts), and only when the field is all it holds: a container that also
+// holds a block or another field is the merchant's own, and stays.
+var AMOUNT_DUE_FIELD = /\\bInvoice\\??\\.amountDue\\b/;
+
+function isPaidAmountDueLine(content, scope) {
+  var inv = scope.invoiceData && scope.invoiceData.Invoice;
+  if (!inv || !isSettledInvoice(inv.status)) return false;
+  var fields = { amountDue: 0, other: 0 };
+  return countLineFields(content.children, fields) && fields.amountDue > 0 && fields.other === 0;
+}
+
+// Counts the fields a line prints into \`fields\`; false when it holds anything
+// but text, which makes it a block rather than a line.
+function countLineFields(children, fields) {
+  var list = children || [];
+  for (var i = 0; i < list.length; i++) {
+    var child = list[i];
+    if (!child || child.type === 'static') continue;
+    if (child.type === 'expr') {
+      if (AMOUNT_DUE_FIELD.test(String(child.content))) fields.amountDue++;
+      else fields.other++;
+      continue;
+    }
+    var isText = child.type === 'element' && child.content && child.content.elementType === 'text';
+    if (!isText || !countLineFields(child.content.children, fields)) return false;
+  }
+  return true;
+}
+
 function renderNode(node, scope, componentName, depth) {
   if (!node) return '';
   if (typeof depth !== 'number') depth = 0;
@@ -801,6 +885,10 @@ function renderNode(node, scope, componentName, depth) {
     return fragChildren.map(function (c) { return renderNode(c, scope, componentName, depth); }).join('');
   }
 
+  if (elementType === 'container' && isPaidAmountDueLine(content, scope)) {
+    return '';
+  }
+
   var tag = content.semanticType || elementTypeToTag(elementType);
   var baseClass = classNameForNode(componentName, content.name);
   var referencedClasses = collectReferencedStyleClasses(content.referencedStyles);
@@ -1034,11 +1122,14 @@ function buildFallbackInvoiceHtml(scope) {
   }
   totalsRows += '<div style="display:flex;justify-content:space-between;font-weight:bold;border-top:2px solid #333;padding-top:4px;"><span>Total</span><span>' + escapeHtml(inv.total) + '</span></div>';
   // A gift card settles part (or all) of the total, so what is left to pay is
-  // printed beneath it — 0.00 included, which is the buyer's proof of that.
+  // printed beneath it — 0.00 included, which is the buyer's proof of that —
+  // until the invoice is paid, whose paid date says nothing is left.
   if (inv.hasGiftCard === 'true') {
     var giftCardLabel = 'Paid by gift card' + (inv.giftCardLast4 ? ' \\u2022\\u2022\\u2022\\u2022' + inv.giftCardLast4 : '');
     totalsRows += '<div style="display:flex;justify-content:space-between;margin-top:4px;margin-bottom:4px;"><span>' + escapeHtml(giftCardLabel) + '</span><span>\\u2212' + escapeHtml(inv.giftCardAmount) + '</span></div>';
-    totalsRows += '<div style="display:flex;justify-content:space-between;font-weight:bold;"><span>Amount due</span><span>' + escapeHtml(inv.amountDue) + '</span></div>';
+    if (!isSettledInvoice(inv.status)) {
+      totalsRows += '<div style="display:flex;justify-content:space-between;font-weight:bold;"><span>Amount due</span><span>' + escapeHtml(inv.amountDue) + '</span></div>';
+    }
   }
   parts.push('<div style="display:flex;justify-content:flex-end;margin-top:16px;"><div style="width:240px;">' +
     totalsRows +

package/src/nodes/account/account-delete-current.ts

@@ -18,10 +18,13 @@ async function account_delete_current(config: any, context: Record<string, unkno
   if (typeof runLocale === 'string' && runLocale) {
     deleteHeaders['x-teleport-locale'] = runLocale
   }
+  // A template that asks for the password passes what the visitor typed; the
+  // route checks it the way sign-in does and deletes nothing when it is wrong.
+  const password = config && typeof config.password === 'string' ? config.password : ''
   const response = await fetch(baseUrl + '/api/account/delete-current', {
     method: 'POST',
     headers: deleteHeaders,
-    body: '{}',
+    body: JSON.stringify(password ? { password } : {}),
   })
 
   let data: any = {}

package/src/nodes/account/account-hash-password.ts

@@ -47,6 +47,7 @@ async function account_hash_password(config: any, context: Record<string, unknow
 export const accountHashPassword: NodeHandlerGenerator = {
   nodeType: 'account-hash-password',
   executionEnv: 'server',
+  resultIsCredential: true,
   dependencies: {
     bcryptjs: '^2.4.3',
   },

package/src/nodes/types.ts

@@ -114,6 +114,12 @@ export interface NodeHandlerGenerator {
   nodeType: string
   executionEnv: 'client' | 'server' | 'universal'
   isTerminal?: boolean
+  /**
+   * The node's result is a credential (a password hash). A server segment
+   * never replies it as it is: the browser receives it sealed, and only the
+   * app's own later server segments can open it (see credential-results.ts).
+   */
+  resultIsCredential?: boolean
   dependencies?: Record<string, string>
   generateHandler(): string
   generateServerHandler?(): string

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
@@ -27,6 +29,14 @@
  * that needs a trustworthy figure (a price, an owner) reads it from the
  * database itself.
  *
+ * A result that is a credential (a password hash, see credential-results.ts)
+ * makes the same trip SEALED: `segmentReply` replies it encrypted with a key
+ * derived from NEXTAUTH_SECRET (AES-256-GCM) and signs the sealed form, and
+ * `claimSegmentContext` opens every sealed value a request hands it (a
+ * relayed result once its signature holds). The browser relays it without
+ * ever reading it, and a later segment's reply hands back the sealed form,
+ * never the opened one.
+ *
  * The facts about the graph each route needs are baked into its
  * SEGMENT_CONFIG at generation time (see segment-trust.ts).
  */
@@ -34,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() {
@@ -51,6 +63,59 @@ function mac(text) {
   return crypto.createHmac('sha256', stepKey()).update(text).digest('hex');
 }
 
+var __sealKeyCache = { secret: null, key: null };
+
+function sealKey() {
+  var secret = process.env.NEXTAUTH_SECRET || '';
+  if (__sealKeyCache.secret !== secret) {
+    __sealKeyCache = {
+      secret: secret,
+      key: crypto.createHmac('sha256', secret).update('teleport-workflow-seal:v1').digest()
+    };
+  }
+  return __sealKeyCache.key;
+}
+
+var SEAL_IV_BYTES = 12;
+var SEAL_TAG_BYTES = 16;
+
+var SEAL_AAD = Buffer.from('teleport-workflow-sealed-result:v1', 'utf8');
+
+// The sealed form of a credential result; undefined (the result is then not
+// replied at all) without an app secret, whose key anyone could derive.
+function sealResult(value) {
+  if (!process.env.NEXTAUTH_SECRET) return undefined;
+  var serialized;
+  try { serialized = JSON.stringify(value); } catch (e) { return undefined; }
+  if (serialized === undefined) return undefined;
+  var iv = crypto.randomBytes(SEAL_IV_BYTES);
+  var cipher = crypto.createCipheriv('aes-256-gcm', sealKey(), iv);
+  cipher.setAAD(SEAL_AAD);
+  var data = Buffer.concat([cipher.update(serialized, 'utf8'), cipher.final()]);
+  return { __sealed: Buffer.concat([iv, cipher.getAuthTag(), data]).toString('base64') };
+}
+
+function isSealedResult(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value) &&
+    typeof value.__sealed === 'string' && Object.keys(value).length === 1;
+}
+
+// { value } when the sealed form opens under this app's key, else null.
+function openSealedResult(sealed) {
+  if (!process.env.NEXTAUTH_SECRET) return null;
+  try {
+    var raw = Buffer.from(sealed.__sealed, 'base64');
+    if (raw.length <= SEAL_IV_BYTES + SEAL_TAG_BYTES) return null;
+    var decipher = crypto.createDecipheriv('aes-256-gcm', sealKey(), raw.subarray(0, SEAL_IV_BYTES));
+    decipher.setAAD(SEAL_AAD);
+    decipher.setAuthTag(raw.subarray(SEAL_IV_BYTES, SEAL_IV_BYTES + SEAL_TAG_BYTES));
+    var data = Buffer.concat([decipher.update(raw.subarray(SEAL_IV_BYTES + SEAL_TAG_BYTES)), decipher.final()]);
+    return { value: JSON.parse(data.toString('utf8')) };
+  } catch (e) {
+    return null;
+  }
+}
+
 // Without an app secret every key here would derive from '' — a value anyone
 // can compute — so nothing verifies: relayed server results are dropped and no
 // request passes as an internal call. (The generator gives every app with
@@ -206,10 +271,48 @@ function resetPreviousResult(segmentConfig, context) {
 // merge will.
 var __incomingOrders = new WeakMap();
 
+// The sealed results this segment opened, so its reply hands the caller back
+// the sealed form it relayed (see resealRelayedResults).
+var __openedResults = new WeakMap();
+
+// Opens every sealed value the request hands this segment, so its nodes read
+// the credential itself: a relayed server result (whose signature
+// dropUnsignedResults checked first), or a value the browser holds from one
+// (a custom node's output, the previous result). Only this app's server
+// seals, so what opens is what it sealed.
+function openSealedResults(context) {
+  var opened = [];
+  Object.keys(context).forEach(function(key) {
+    if (isControlKey(key) && key !== '__previousNodeResult') return;
+    if (!isSealedResult(context[key])) return;
+    var result = openSealedResult(context[key]);
+    if (!result) return;
+    opened.push({ sealed: context[key], value: result.value });
+    context[key] = result.value;
+  });
+  __openedResults.set(context, opened);
+}
+
+// Every reply entry that is an opened value (the value itself, or the previous
+// result taken from it) goes back sealed.
+function resealRelayedResults(context, reply) {
+  var opened = __openedResults.get(context) || [];
+  if (opened.length === 0) return;
+  Object.keys(reply).forEach(function(key) {
+    for (var i = 0; i < opened.length; i++) {
+      if (reply[key] === opened[i].value) {
+        reply[key] = opened[i].sealed;
+        return;
+      }
+    }
+  });
+}
+
 function claimSegmentContext(segmentConfig, context) {
   var orderKeys = readSignedOrder(context);
   if (orderKeys) restoreOrder(context, orderKeys);
   dropUnsignedResults(segmentConfig, context, orderKeys);
+  openSealedResults(context);
   stripForeignControlKeys(segmentConfig, context);
   __incomingOrders.set(context, Object.keys(context).filter(function(k) { return !isControlKey(k); }));
   utils.claimSegmentContext(segmentConfig, context);
@@ -219,6 +322,13 @@ function claimSegmentContext(segmentConfig, context) {
 
 function segmentReply(segmentConfig, context, snapshot) {
   var reply = utils.segmentReply(segmentConfig, context, snapshot);
+  resealRelayedResults(context, reply);
+  var credentialIds = utils.credentialResultNodeIds(segmentConfig);
+  Object.keys(credentialIds).forEach(function(id) {
+    if (context[id] === undefined) return;
+    var sealed = sealResult(context[id]);
+    if (sealed) reply[id] = sealed;
+  });
   var sigs = {};
   var incoming = context.__sig && typeof context.__sig === 'object' && !Array.isArray(context.__sig) ? context.__sig : {};
   Object.keys(incoming).forEach(function(id) {
@@ -288,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
   }