@teleporthq/teleport-plugin-next-workflows 0.43.75 → 0.44.1

package/src/invoice/data-access-code.ts

@@ -27,7 +27,7 @@ ${generateGetInvoiceByIdCode(dsType, invoicesTable)}
 
 ${generateUpdateInvoiceCode(dsType, invoicesTable)}
 
-${generateStoreInvoicePdfCode(dsType)}
+${generateStoreInvoicePdfCode(dsType, invoicesTable)}
 
 ${generateGetOrderWithItemsCode(dsType)}
 
@@ -35,6 +35,8 @@ ${generateReplaceInvoiceCode(dsType, invoicesTable, invoiceItemsTable)}
 
 ${generateLinkOrderToInvoiceCode(dsType)}
 
+${generateRecordOrderEventCode(dsType)}
+
 module.exports = {
   getClient: getClient,
   reserveInvoice: reserveInvoice,
@@ -45,6 +47,7 @@ module.exports = {
   getOrderWithItems: getOrderWithItems,
   replaceInvoice: replaceInvoice,
   linkOrderToInvoice: linkOrderToInvoice,
+  recordOrderEvent: recordOrderEvent,
 };
 `
 }
@@ -356,18 +359,47 @@ ${cutoff}
 }`
 }
 
-// Puts the rendered PDF on the reserved row; `pdf_size_bytes` is what marks
-// the invoice finished (see `claimStaleInvoice`).
-function generateStoreInvoicePdfCode(dsType: string): string {
-  const pdfData = dsType === 'supabase' ? `pdfBuffer.toString('base64')` : 'pdfBuffer'
-  return `
+// Puts the rendered PDF on the reserved row — only while the row has none —
+// and resolves to `{ firstPdf }`: whether this write gave the invoice its
+// first PDF. `pdf_size_bytes` marks the invoice finished (see
+// `claimStaleInvoice`), and the invoice's first PDF is what its email is
+// claimed by: `replaceInvoice` writes first under the same condition, so of a
+// retried payment finishing a stale invoice and a regeneration racing it, one
+// writes the PDF and emails the buyer, and the other is told it was not first.
+function generateStoreInvoicePdfCode(dsType: string, table: string): string {
+  if (dsType === 'supabase') {
+    return `
 async function storeInvoicePdf(invoiceId, pdfBuffer, pdfUrl) {
-  return updateInvoice(invoiceId, {
-    pdf_data: ${pdfData},
+  var result = await getClient().from('${table}').update({
+    pdf_data: pdfBuffer.toString('base64'),
     pdf_size_bytes: pdfBuffer.length,
     pdf_content_type: 'application/pdf',
     pdf_url: pdfUrl,
-  });
+    updated_at: new Date().toISOString(),
+  }).eq('id', invoiceId).is('pdf_size_bytes', null).select('id');
+  if (result.error) throw new Error(result.error.message);
+  return { firstPdf: !!(result.data && result.data.length > 0) };
+}`
+  }
+
+  if (dsType === 'mysql' || dsType === 'mariadb' || dsType === 'tidb') {
+    return `
+async function storeInvoicePdf(invoiceId, pdfBuffer, pdfUrl) {
+  var [result] = await getClient().execute(
+    'UPDATE ${table} SET pdf_data = ?, pdf_size_bytes = ?, pdf_content_type = ?, pdf_url = ?, updated_at = ? WHERE id = ? AND pdf_size_bytes IS NULL',
+    [pdfBuffer, pdfBuffer.length, 'application/pdf', pdfUrl, new Date().toISOString(), invoiceId]
+  );
+  return { firstPdf: !!(result && result.affectedRows > 0) };
+}`
+  }
+
+  return `
+async function storeInvoicePdf(invoiceId, pdfBuffer, pdfUrl) {
+  var result = await getClient().query(
+    'UPDATE ${table} SET pdf_data = $1, pdf_size_bytes = $2, pdf_content_type = $3, pdf_url = $4, updated_at = $5 WHERE id = $6 AND pdf_size_bytes IS NULL',
+    [pdfBuffer, pdfBuffer.length, 'application/pdf', pdfUrl, new Date().toISOString(), invoiceId]
+  );
+  return { firstPdf: result.rowCount > 0 };
 }`
 }
 
@@ -565,6 +597,15 @@ async function getOrderWithItems(orderId) {
 // points at it (the order, the sent-email ledger) stays valid. Postgres and
 // MySQL do it in one transaction, and Supabase undoes its steps, so a failure
 // leaves the old invoice whole.
+//
+// Resolves to `{ firstPdf }`: whether this write gave the invoice its first
+// PDF — one whose PDF never came at payment, so its buyer was never emailed
+// it. The database decides: the row is first written only where it has no PDF
+// (the `pdf_size_bytes IS NULL` that `claimStaleInvoice` reads as
+// "unfinished"), and of two regenerations racing for the same invoice the
+// second waits for the first's row lock, then finds the PDF and matches
+// nothing. `storeInvoicePdf` writes the payment's PDF under the same
+// condition, so exactly one write is ever told `firstPdf: true`.
 function generateReplaceInvoiceCode(dsType: string, table: string, itemsTable: string): string {
   if (dsType === 'supabase') {
     return `
@@ -584,18 +625,23 @@ async function replaceInvoice(invoiceId, invoiceData, items) {
   var insertedIds = (inserted || []).map(function (row) { return row.id; });
   var written = null;
   try {
-    var record = await writeInvoiceRecord(mapInvoiceReplacementToRecord(invoiceData), async function (fields) {
-      var result = await client.from('${table}').update(fields).eq('id', invoiceId).select('id');
-      if (result.error) throw new Error(result.error.message);
-      if (!result.data || result.data.length === 0) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+    var outcome = await writeInvoiceRecord(mapInvoiceReplacementToRecord(invoiceData), async function (fields) {
+      var first = await client.from('${table}').update(fields).eq('id', invoiceId).is('pdf_size_bytes', null).select('id');
+      if (first.error) throw new Error(first.error.message);
+      var firstPdf = !!(first.data && first.data.length > 0);
+      if (!firstPdf) {
+        var result = await client.from('${table}').update(fields).eq('id', invoiceId).select('id');
+        if (result.error) throw new Error(result.error.message);
+        if (!result.data || result.data.length === 0) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+      }
       written = fields;
-      return fields;
+      return { firstPdf: firstPdf };
     });
     if (previousIds.length > 0) {
       var removed = await client.from('${itemsTable}').delete().in('id', previousIds);
       if (removed.error) throw new Error(removed.error.message);
     }
-    return record;
+    return outcome;
   } catch (err) {
     if (written) {
       var restored = {};
@@ -624,12 +670,17 @@ async function replaceInvoice(invoiceId, invoiceData, items) {
       var setClauses = columns.map(function(k) { return quoteIdent(k) + ' = ?'; }).join(', ');
       var values = columns.map(function(k) { return fields[k]; });
       values.push(invoiceId);
-      var [updated] = await conn.execute('UPDATE ${table} SET ' + setClauses + ' WHERE id = ?', values);
-      if (!updated || !updated.affectedRows) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+      var update = 'UPDATE ${table} SET ' + setClauses + ' WHERE id = ?';
+      var [first] = await conn.execute(update + ' AND pdf_size_bytes IS NULL', values);
+      var firstPdf = !!(first && first.affectedRows > 0);
+      if (!firstPdf) {
+        var [updated] = await conn.execute(update, values);
+        if (!updated || !updated.affectedRows) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+      }
       await conn.execute('DELETE FROM ${itemsTable} WHERE invoice_id = ?', [invoiceId]);
       await insertInvoiceItemRows(conn, invoiceId, items);
       await conn.commit();
-      return fields;
+      return { firstPdf: firstPdf };
     } catch (err) {
       try { await conn.rollback(); } catch (_rollbackErr) {}
       throw err;
@@ -653,12 +704,16 @@ async function replaceInvoice(invoiceId, invoiceData, items) {
       values.push(invoiceId);
       // The UPDATE takes the row lock first, so two regenerations of the same
       // invoice run one after the other instead of interleaving their lines.
-      var updated = await client.query('UPDATE ${table} SET ' + setClauses + ' WHERE id = $' + values.length, values);
-      if (!updated.rowCount) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+      var update = 'UPDATE ${table} SET ' + setClauses + ' WHERE id = $' + values.length;
+      var firstPdf = (await client.query(update + ' AND pdf_size_bytes IS NULL', values)).rowCount > 0;
+      if (!firstPdf) {
+        var updated = await client.query(update, values);
+        if (!updated.rowCount) throw new Error('Invoice ' + invoiceId + ' no longer exists');
+      }
       await client.query('DELETE FROM ${itemsTable} WHERE invoice_id = $1', [invoiceId]);
       await insertInvoiceItemRows(client, invoiceId, items);
       await client.query('COMMIT');
-      return fields;
+      return { firstPdf: firstPdf };
     } catch (err) {
       try { await client.query('ROLLBACK'); } catch (_rollbackErr) {}
       throw err;
@@ -719,6 +774,69 @@ async function linkOrderToInvoice(orderId, invoiceId, invoiceNumber, pdfUrl) {
 }`
 }
 
+// One line of an order's history: a row of the activity log the editor
+// provisions (`teleport_events`) and both order timelines read. Written like
+// every line the store's workflows write — teleport-gui's
+// `constants/order-event-types.ts` owns the vocabulary — so a replay collides
+// on the UNIQUE `dedupe_key` and adds nothing. `event` is
+// `{ type, dedupeKey, orderId, payload, actor, actorType }`.
+function generateRecordOrderEventCode(dsType: string): string {
+  const row = `
+var ORDER_EVENTS_TABLE = 'teleport_events';
+var ORDER_EVENT_DEDUPE_KEY_MAX_LENGTH = 255;
+
+function orderEventRow(event) {
+  return {
+    id: require('crypto').randomUUID(),
+    event_type: event.type,
+    dedupe_key: String(event.dedupeKey).slice(0, ORDER_EVENT_DEDUPE_KEY_MAX_LENGTH),
+    order_id: event.orderId || null,
+    payload: JSON.stringify(event.payload || {}),
+    actor: event.actor || '',
+    actor_type: event.actorType,
+    // Logged; a dispatcher claims the rows it delivers itself.
+    status: 'recorded',
+  };
+}`
+
+  if (dsType === 'supabase') {
+    return `${row}
+
+async function recordOrderEvent(event) {
+  var result = await getClient()
+    .from(ORDER_EVENTS_TABLE)
+    .upsert(orderEventRow(event), { onConflict: 'dedupe_key', ignoreDuplicates: true });
+  if (result.error) throw new Error(result.error.message);
+}`
+  }
+
+  if (dsType === 'mysql' || dsType === 'mariadb' || dsType === 'tidb') {
+    return `${row}
+
+async function recordOrderEvent(event) {
+  var record = orderEventRow(event);
+  var columns = Object.keys(record);
+  var placeholders = columns.map(function() { return '?'; }).join(', ');
+  await getClient().execute(
+    'INSERT INTO ' + ORDER_EVENTS_TABLE + ' (' + columns.join(', ') + ') VALUES (' + placeholders + ') ON DUPLICATE KEY UPDATE dedupe_key = dedupe_key',
+    columns.map(function(k) { return record[k]; })
+  );
+}`
+  }
+
+  return `${row}
+
+async function recordOrderEvent(event) {
+  var record = orderEventRow(event);
+  var columns = Object.keys(record);
+  var placeholders = columns.map(function(_, i) { return '$' + (i + 1); }).join(', ');
+  await getClient().query(
+    'INSERT INTO ' + ORDER_EVENTS_TABLE + ' (' + columns.join(', ') + ') VALUES (' + placeholders + ') ON CONFLICT (dedupe_key) DO NOTHING',
+    columns.map(function(k) { return record[k]; })
+  );
+}`
+}
+
 export const getRecordMappingCode = (dsType?: string): string => `
 function mapInvoiceToRecord(data) {
   return {

package/src/invoice/email-sender-code.ts

@@ -1,4 +1,5 @@
 import { UIDLInvoiceEmailDelivery } from '@teleporthq/teleport-types'
+import { EmailSender } from '@teleporthq/teleport-shared'
 
 export const generateEmailSenderCode = (emailDelivery: UIDLInvoiceEmailDelivery): string => {
   if (!emailDelivery || !emailDelivery.enabled || !emailDelivery.provider) {
@@ -33,6 +34,8 @@ var BODY_TEMPLATE = ${JSON.stringify(bodyTemplate)};
 // Per-language copies of the subject/body (main language excluded), chosen by
 // the locale the generate route resolved for the invoice (the order's).
 var LOCALIZED_TEMPLATES = ${JSON.stringify(localizedTemplates)};
+${EmailSender.generateEmailSenderHelperCode()}
+var SENDER = __emailSender(${JSON.stringify({ from: fromEmail, name: fromName })});
 
 function resolveSecretKey(keyName) {
   var envName = SECRET_KEYS[keyName];
@@ -52,7 +55,8 @@ function buildEmailData(invoiceData) {
     subject: replacePlaceholders(copy.subject, data),
     body: replacePlaceholders(copy.body, data),
     to: invoiceData.customerEmail || '',
-    from: ${JSON.stringify(fromName ? `${fromName} <${fromEmail}>` : fromEmail)},
+    from: SENDER.header,
+    sender: SENDER,
     templateData: data,
   };
 }
@@ -63,7 +67,9 @@ function attachmentName(invoiceData) {
 
 ${generateProviderSendFunction(emailDelivery.provider)}
 
-async function sendInvoiceEmail(invoiceData, pdfBuffer) {
+// sourceRef names the route that sent it in the ledger: the payment's
+// generate route unless the caller says otherwise.
+async function sendInvoiceEmail(invoiceData, pdfBuffer, sourceRef) {
   var emailData = buildEmailData(invoiceData);
   if (!emailData.to) return { success: false, error: 'No customer email provided' };
   var result;
@@ -77,6 +83,7 @@ async function sendInvoiceEmail(invoiceData, pdfBuffer) {
     audience: 'customer',
     to: emailData.to,
     from: emailData.from,
+    fromName: emailData.sender.name,
     subject: emailData.subject,
     html: emailData.body,
     payload: emailData.templateData,
@@ -91,7 +98,7 @@ async function sendInvoiceEmail(invoiceData, pdfBuffer) {
     status: result && result.success ? 'sent' : 'failed',
     error: result && !result.success ? result.error : null,
     source: 'invoice',
-    sourceRef: 'api/invoices/generate',
+    sourceRef: sourceRef || 'api/invoices/generate',
     orderId: invoiceData.orderId,
     referenceType: 'invoice',
     referenceId: invoiceData.id,
@@ -139,9 +146,12 @@ async function sendInvoiceEmailWithProvider(emailData, invoiceData, pdfBuffer) {
     var apiKey = resolveSecretKey('apiKey');
     if (!apiKey) return { success: false, error: 'SendGrid API key not configured' };
     sgMail.setApiKey(apiKey);
+    // SendGrid reads a "Name <email>" string's name verbatim, quotes included,
+    // so a named sender goes as its two parts.
+    var sender = emailData.sender;
     var msg = {
       to: emailData.to,
-      from: emailData.from,
+      from: sender.name ? { email: sender.email, name: sender.name } : sender.email,
       subject: emailData.subject,
       html: emailData.body,
       attachments: [{
@@ -217,26 +227,6 @@ async function sendInvoiceEmailWithProvider(emailData, invoiceData, pdfBuffer) {
 
     case 'mailersend':
       return `
-// Pulls "name" and "email" out of the RFC-5322-ish \`from\` string the
-// builder assembles. Three shapes in the wild:
-//   1. "Acme Billing <billing@acme.com>"  → name="Acme Billing",  email="billing@acme.com"
-//   2. "billing@acme.com"                  → name="",             email="billing@acme.com"
-//   3. ""                                   → {}, caller handles the fallback
-// The old implementation used naive \`.replace()\` chains that produced
-// \`name="billing@acme.com"\` in case (2) — MailerSend accepts that but the
-// email then appears in the recipient's client with itself as the sender
-// name, which is ugly. Kept as a pure helper (no fallbacks baked in) so
-// the caller decides what to do when a field is missing.
-function parseFromString(from) {
-  var str = String(from || '').trim();
-  if (!str) return { name: '', email: '' };
-  var m = /^(.*)<([^<>]+)>\\s*$/.exec(str);
-  if (m) {
-    return { name: m[1].trim(), email: m[2].trim() };
-  }
-  return { name: '', email: str };
-}
-
 async function sendInvoiceEmailWithProvider(emailData, invoiceData, pdfBuffer) {
   var invoiceNumber = invoiceData && invoiceData.invoiceNumber ? invoiceData.invoiceNumber : '(no number)';
   try {
@@ -256,7 +246,7 @@ async function sendInvoiceEmailWithProvider(emailData, invoiceData, pdfBuffer) {
 
     var mailerSend = new MailerSend({ apiKey: apiKey });
 
-    var parsedFrom = parseFromString(emailData.from);
+    var parsedFrom = emailData.sender;
     if (!parsedFrom.email) {
       console.error('[invoice-email][mailersend] skip — from address is empty (set invoiceSettings.emailDelivery.fromEmail)');
       return { success: false, error: 'Sender email not configured' };

package/src/invoice/index.ts

@@ -157,7 +157,7 @@ export const generateInvoiceFiles = (
       {
         name: 'regenerate',
         fileType: FileType.JS,
-        content: generateInvoiceRegenerateRouteCode(),
+        content: generateInvoiceRegenerateRouteCode(invoiceSettings),
       },
     ],
   })

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

@@ -33,6 +33,36 @@ var TEMPLATE_DOCUMENT = ${templateDocumentJson};
 ${REGIONAL_INVOICE_TAX_CODE}
 ${ProductOptions.generateProductOptionsHelperCode()}
 
+// The invoice details an order's metadata (JSON text) carries beside its
+// billing columns — the keys \`ORDER_BILLING_METADATA_KEYS\` (teleport-gui)
+// writes: the address in its parts, the company and the buyer's tax or VAT
+// number. Every part is '' when the order has none or its metadata is no JSON
+// object.
+function readOrderBillingMetadata(raw) {
+  var parsed = raw;
+  if (typeof raw === 'string') {
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      parsed = null;
+    }
+  }
+  var meta = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  function part(key) {
+    var value = meta[key];
+    return value === null || value === undefined ? '' : String(value).trim();
+  }
+  return {
+    taxId: part('billingTaxId'),
+    company: part('billingCompany'),
+    street: part('billingStreet'),
+    city: part('billingCity'),
+    postalCode: part('billingPostalCode'),
+    region: part('billingRegion'),
+    country: part('billingCountry'),
+  };
+}
+
 // The product options an order line was bought with: the short one-line label
 // (after the name) and every answer in full, one per line (the description).
 // Same rule as the order emails: a current snapshot names its options, while
@@ -416,15 +446,28 @@ function assembleInvoiceData(body, hydratedOrder, hydratedItems) {
   // field but the order has one, use it. Kept permissive on field
   // names (billing_* wins, falls back to shipping_*) because a buyer
   // who checked "bill to a different address" has both on the order.
+  //
+  // An order whose buyer gave invoice details of their own (a booking's
+  // "Add invoice details", a store checkout's "Billing Details") carries them
+  // in its metadata as well: the address in its parts, the company and the tax
+  // or VAT number. Those parts are the invoice's address — never mixed with a
+  // shipping address — the company is printed under the buyer's name, and the
+  // number is the buyer's VAT.
   var orderRow = orderShippingSource;
+  var orderBilling = readOrderBillingMetadata(orderRow.metadata);
+  var billedApart = !!(orderBilling.street || orderBilling.city || orderBilling.country);
   var fallbackCustomerName =
     orderRow.billing_name || orderRow.shipping_name || orderRow.customer_name || '';
   var fallbackCustomerEmail = orderRow.billing_email || orderRow.customer_email || '';
-  var fallbackCustomerAddress = orderRow.billing_address || orderRow.shipping_address || '';
-  var fallbackCustomerCity = orderRow.shipping_city || '';
-  var fallbackCustomerState = orderRow.shipping_state || '';
-  var fallbackCustomerZip = orderRow.shipping_zip || '';
-  var fallbackCustomerCountry = orderRow.shipping_country || '';
+  var fallbackCustomerAddress = billedApart
+    ? orderBilling.street
+    : orderRow.billing_address || orderRow.shipping_address || '';
+  var fallbackCustomerCity = billedApart ? orderBilling.city : orderRow.shipping_city || '';
+  var fallbackCustomerState = billedApart ? orderBilling.region : orderRow.shipping_state || '';
+  var fallbackCustomerZip = billedApart ? orderBilling.postalCode : orderRow.shipping_zip || '';
+  var fallbackCustomerCountry = billedApart
+    ? orderBilling.country
+    : orderRow.shipping_country || '';
   var fallbackPaymentMethod = orderRow.payment_method || '';
   var fallbackPaymentProvider = orderRow.payment_provider || '';
   var fallbackPaymentIntentId = orderRow.payment_intent_id || '';
@@ -446,7 +489,8 @@ function assembleInvoiceData(body, hydratedOrder, hydratedItems) {
     customerState: body.customerState || fallbackCustomerState || '',
     customerZip: body.customerZip || fallbackCustomerZip || '',
     customerCountry: body.customerCountry || fallbackCustomerCountry || '',
-    customerVat: body.customerVat || '',
+    customerVat: body.customerVat || orderBilling.taxId || '',
+    customerCompany: body.customerCompany || orderBilling.company || '',
     companyName: pdfGenerator.COMPANY_DETAILS.companyName || '',
     companyAddress: pdfGenerator.COMPANY_DETAILS.companyAddress || '',
     companyCity: pdfGenerator.COMPANY_DETAILS.companyCity || '',

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

@@ -355,9 +355,13 @@ function buildInvoiceDataScope(invoiceData) {
   // sample — right for a company address, wrong for a code or a card tail: an
   // order without a voucher must not print the designer's "SAVE20".
   var realInvoiceNeverSampled = { voucherCode: voucherCode, giftCardLast4: giftCardLast4 };
+  // The buyer and their payment are never sampled either: an order with no
+  // city (a booking, a pickup, a download) must not print the designer's
+  // sample customer's, nor a card it was not paid with.
 
   var realCustomer = {
     name: invoiceData.customerName || '',
+    company: invoiceData.customerCompany || '',
     email: invoiceData.customerEmail || '',
     address: invoiceData.customerAddress || '',
     city: invoiceData.customerCity || '',
@@ -366,6 +370,12 @@ function buildInvoiceDataScope(invoiceData) {
     country: invoiceData.customerCountry || '',
     vat: invoiceData.customerVat || '',
   };
+  // The "Bill to" lines a buyer may leave out show only when they did not
+  // (string flags: the template compares strings, as with \`hasShipping\`).
+  realCustomer.hasCompany = realCustomer.company ? 'true' : 'false';
+  realCustomer.hasZip = realCustomer.zip ? 'true' : 'false';
+  realCustomer.hasCountry = realCustomer.country ? 'true' : 'false';
+  realCustomer.hasVat = realCustomer.vat ? 'true' : 'false';
 
   var realPayment = {
     method: invoiceData.paymentMethod || '',
@@ -462,8 +472,8 @@ function buildInvoiceDataScope(invoiceData) {
     invoiceData: {
       Company: mergeWithDefaults(realCompany, defaults.Company),
       Invoice: Object.assign(mergeWithDefaults(realInvoice, defaults.Invoice), realInvoiceNeverSampled),
-      Customer: mergeWithDefaults(realCustomer, defaults.Customer),
-      Payment: mergeWithDefaults(realPayment, defaults.Payment),
+      Customer: realCustomer,
+      Payment: realPayment,
       Products: realProducts.length > 0 ? realProducts : (defaults.Products || []),
     },
   };
@@ -972,6 +982,7 @@ function buildFallbackInvoiceHtml(scope) {
     escapeHtml(comp.city || '') + '<br/>' +
     escapeHtml(comp.email || '') + '</div>');
   parts.push('<div style="flex:1;"><strong>' + escapeHtml(cust.name || '') + '</strong><br/>' +
+    (cust.company ? escapeHtml(cust.company) + '<br/>' : '') +
     escapeHtml(cust.email || '') + '<br/>' +
     escapeHtml(cust.address || '') + '<br/>' +
     escapeHtml(cust.city || '') + '</div>');

package/src/nodes/data/data-raw-query.ts

@@ -36,7 +36,17 @@ async function data_raw_query(config: any, context: any) {
     const data = await response.json()
 
     if (!response.ok) {
-      return { rows: [], result: [], error: data.error || 'Raw query failed' }
+      const failure: Record<string, unknown> = {
+        rows: [],
+        result: [],
+        error: data.error || 'Raw query failed',
+      }
+      // The database's SQLSTATE (the route keeps its message in the server log): a
+      // statement that raises on purpose is told apart from a broken one by it.
+      if (data.code) {
+        failure.code = data.code
+      }
+      return failure
     }
     const rows = data.rows || []
     return { rows, result: rows }

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

@@ -1,4 +1,10 @@
+import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
+import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+
+// Ambient, not imported: a serialized handler has no module scope, so
+// generateHandler appends the helper's source (EmailSender, teleport-shared).
+declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
 
 async function email_mailgun(config: any, context: Record<string, unknown>) {
   const apiKey = config.apiKey
@@ -25,7 +31,7 @@ async function email_mailgun(config: any, context: Record<string, unknown>) {
     }
     const mg = mailgun.client(clientOpts)
 
-    const fromField = fromName ? fromName + ' <' + from + '>' : from
+    const fromField = __emailSender({ from, name: fromName }).header
     const toField = Array.isArray(to) ? to : [to]
 
     const msgPayload: Record<string, any> = {
@@ -61,6 +67,9 @@ export const emailMailgun: NodeHandlerGenerator = {
     'form-data': '^4.0.0',
   },
   generateHandler(): string {
-    return handlerToString(email_mailgun)
+    return assertHandlerHasNoModuleRefs(
+      handlerToString(email_mailgun) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      'email-mailgun'
+    )
   },
 }

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

@@ -1,8 +1,15 @@
+import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
+import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+
+// Ambient, not imported: a serialized handler has no module scope, so
+// generateHandler appends the helper's source (EmailSender, teleport-shared).
+declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
 
 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
@@ -21,7 +28,7 @@ async function email_postmark(config: any, context: Record<string, unknown>) {
     const toField = Array.isArray(to) ? to.join(', ') : to
 
     const emailPayload: Record<string, any> = {
-      From: from,
+      From: __emailSender({ from, name: fromName }).header,
       To: toField,
       Subject: subject,
       HtmlBody: body,
@@ -58,6 +65,9 @@ export const emailPostmark: NodeHandlerGenerator = {
     postmark: '^4.0.0',
   },
   generateHandler(): string {
-    return handlerToString(email_postmark)
+    return assertHandlerHasNoModuleRefs(
+      handlerToString(email_postmark) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      'email-postmark'
+    )
   },
 }

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

@@ -1,8 +1,15 @@
+import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
+import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+
+// Ambient, not imported: a serialized handler has no module scope, so
+// generateHandler appends the helper's source (EmailSender, teleport-shared).
+declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
 
 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
@@ -17,7 +24,7 @@ async function email_resend(config: any, context: Record<string, unknown>) {
     const resend = new Resend(apiKey)
 
     const payload: Record<string, any> = {
-      from,
+      from: __emailSender({ from, name: fromName }).header,
       to: Array.isArray(to) ? to : [to],
       subject,
       html: body,
@@ -53,6 +60,9 @@ export const emailResend: NodeHandlerGenerator = {
     resend: '^4.0.0',
   },
   generateHandler(): string {
-    return handlerToString(email_resend)
+    return assertHandlerHasNoModuleRefs(
+      handlerToString(email_resend) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      'email-resend'
+    )
   },
 }

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

@@ -1,8 +1,15 @@
+import { EmailSender } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
+import { assertHandlerHasNoModuleRefs } from '../analytics/commerce-tracking'
+
+// Ambient, not imported: a serialized handler has no module scope, so
+// generateHandler appends the helper's source (EmailSender, teleport-shared).
+declare function __emailSender(sender: EmailSender.EmailSenderInput): EmailSender.EmailSenderParts
 
 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
@@ -17,9 +24,12 @@ async function email_sendgrid(config: any, context: Record<string, unknown>) {
     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,
+      from: sender.name ? { email: sender.email, name: sender.name } : sender.email,
       subject,
       html: body,
     }
@@ -62,6 +72,9 @@ export const emailSendgrid: NodeHandlerGenerator = {
     '@sendgrid/mail': '^8.0.0',
   },
   generateHandler(): string {
-    return handlerToString(email_sendgrid)
+    return assertHandlerHasNoModuleRefs(
+      handlerToString(email_sendgrid) + '\n' + EmailSender.generateEmailSenderHelperCode(),
+      'email-sendgrid'
+    )
   },
 }

package/src/nodes/general/general-custom-js.ts

@@ -194,6 +194,16 @@ async function general_custom_js(config: any, context: Record<string, unknown>)
       Object.keys(resolvedNamedParams).length > 0
     ) {
       list.push(resolvedNamedParams)
+      // The named inputs are also readable as `params.<name>`, the way the
+      // custom-node path overlays `__customParams`: generated functions
+      // reach for `params.activeStep` as often as `params.slice(-1)[0]`, and
+      // an undefined there silently saved `{}` to storage.
+      const namedKeys = Object.keys(resolvedNamedParams)
+      for (let nk = 0; nk < namedKeys.length; nk++) {
+        if (!(namedKeys[nk] in list)) {
+          ;(list as any)[namedKeys[nk]] = resolvedNamedParams[namedKeys[nk]]
+        }
+      }
     }
     params = list
   }