@teleporthq/teleport-plugin-next-workflows 0.43.65 → 0.43.67

package/src/transactional-email-code.ts

@@ -4,7 +4,9 @@
  * dispatch, template filler, dependency map, and config-key list in ONE place so
  * every route stays byte-for-byte consistent.
  */
+import { UIDLLocalizedEmailTemplates } from '@teleporthq/teleport-types'
 import { getEmailProviderDependencies } from './invoice/email-sender-code'
+import { EMAIL_LOCALE_FILE_NAME, EMAIL_LOCALE_PATH } from './email-locale/email-locale-scope'
 
 export const SUPPORTED_EMAIL_PROVIDERS = new Set([
   'resend',
@@ -25,10 +27,67 @@ export const transactionalEmailDependencies = (
   return getEmailProviderDependencies(provider)
 }
 
-// Provider-specific `__sendProviderEmail({ from, to, subject, html, apiKey })`.
-// 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.
-export const generateProviderSendFunction = (provider?: string | null): string => {
+/**
+ * Where a transactional route's sends are recorded in the sent-email ledger:
+ * the purpose slug, the `source` column and the route file, plus the require
+ * prefix from the route's directory back to the project root.
+ */
+export interface TransactionalEmailLedger {
+  emailType: string
+  source: string
+  sourceRef: string
+  relativePrefix: string
+}
+
+// Provider-specific `__sendProviderEmail({ from, to, subject, html, apiKey,
+// tokenValues?, userId? })`. 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 `__sendProviderEmailRaw` and `__sendProviderEmail` records every
+// attempt (success or throw) before returning / rethrowing.
+export const generateProviderSendFunction = (
+  provider?: string | null,
+  ledger?: TransactionalEmailLedger
+): string => {
+  const raw = generateRawProviderSendFunction(provider)
+  if (!ledger || !provider || !SUPPORTED_EMAIL_PROVIDERS.has(provider)) {
+    return raw
+  }
+  return `${raw.replace(
+    'async function __sendProviderEmail(',
+    'async function __sendProviderEmailRaw('
+  )}
+
+var __sentEmailLog = require('${ledger.relativePrefix}/utils/email/sent-email-log');
+
+async function __sendProviderEmail(msg) {
+  var failure = null;
+  try {
+    await __sendProviderEmailRaw(msg);
+  } catch (err) {
+    failure = err;
+  }
+  // Recorded in the background; the route settles the ledger before it replies.
+  __sentEmailLog.recordSentEmail({
+    emailType: ${JSON.stringify(ledger.emailType)},
+    audience: 'customer',
+    to: msg.to,
+    from: msg.from,
+    subject: msg.subject,
+    html: msg.html,
+    payload: msg.tokenValues,
+    provider: ${JSON.stringify(provider)},
+    status: failure ? 'failed' : 'sent',
+    error: failure ? (failure.message || String(failure)) : null,
+    source: ${JSON.stringify(ledger.source)},
+    sourceRef: ${JSON.stringify(ledger.sourceRef)},
+    userId: msg.userId,
+  });
+  if (failure) { throw failure; }
+}`
+}
+
+const generateRawProviderSendFunction = (provider?: string | null): string => {
   switch (provider) {
     case 'resend':
       return `async function __sendProviderEmail(msg) {
@@ -94,6 +153,54 @@ export const generateFillTemplateFn = (): string => `function fillTemplate(str,
   return out;
 }`
 
+/**
+ * The per-language copies of a transactional route's email, as the UIDL mapper
+ * wrote them on the node config. Anything that is not a locale→copy map is
+ * treated as "no copies", so a hand-edited config can never break the route.
+ */
+export const readLocalizedEmailTemplates = (value: unknown): UIDLLocalizedEmailTemplates => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {}
+  }
+  const copies: UIDLLocalizedEmailTemplates = {}
+  for (const [locale, copy] of Object.entries(value as Record<string, unknown>)) {
+    if (!copy || typeof copy !== 'object') {
+      continue
+    }
+    const { body, subject } = copy as { body?: unknown; subject?: unknown }
+    if (typeof body !== 'string' || !body) {
+      continue
+    }
+    copies[locale] = typeof subject === 'string' && subject ? { body, subject } : { body }
+  }
+  return copies
+}
+
+/** The `require` of the shared locale module from a route `relativePrefix` deep. */
+export const generateEmailLocaleRequire = (relativePrefix: string): string =>
+  `var __emailLocale = require('${relativePrefix}/${EMAIL_LOCALE_PATH.join(
+    '/'
+  )}/${EMAIL_LOCALE_FILE_NAME}');`
+
+/**
+ * Emits `function <fnName>(locale)` returning `{ subject, body, locale }` — the
+ * copy of the route's email for the language a request came from, read from
+ * the baked constants. The default language and any language without a copy
+ * fall back to the base subject/body.
+ */
+export const generateLocalizedEmailCopyFn = (params: {
+  fnName: string
+  subjectConst: string
+  bodyConst: string
+  localizedConst: string
+}): string => `function ${params.fnName}(locale) {
+  return __emailLocale.pickLocalizedTemplate(
+    { subject: ${params.subjectConst}, body: ${params.bodyConst} },
+    ${params.localizedConst},
+    locale
+  );
+}`
+
 // The account-signup node's welcome-email config keys. They must NEVER be
 // forwarded from the client signup handler to /api/auth/signup nor inserted as
 // user columns (they'd corrupt createUser and leak into the client bundle).
@@ -109,4 +216,5 @@ export const WELCOME_EMAIL_CONFIG_KEYS = [
   'bodyComponentId',
   'bodyTemplatePurpose',
   'templateParams',
+  'localizedTemplates',
 ]

package/src/webhook-generator.ts

@@ -572,7 +572,10 @@ module.exports = async function handler(req, res) {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
-              orderId: resource.id || '',
+              // The internal order id, so the route can load the order's own
+              // lines and the rates they were charged at; the capture id is
+              // only a fallback for a resource that carries no custom_id.
+              orderId: __extractInternalOrderId(resource) || resource.id || '',
               customerEmail: (resource.payer && resource.payer.email_address) || '',
               customerName: resource.payer && resource.payer.name ? ((resource.payer.name.given_name || '') + ' ' + (resource.payer.name.surname || '')).trim() : '',
               totalAmount: resource.amount ? Number(resource.amount.value) || 0 : 0,
@@ -661,7 +664,7 @@ async function verifyPaypalWebhook(headers, body, webhookId, clientId, clientSec
 }
 
 ${
-  autoGenerateInvoice
+  autoGenerateInvoice || hasOrderNotifications
     ? `
 // Pull the internal teleport_orders UUID out of the PayPal resource's
 // custom_id field. Order creation embeds it as JSON
@@ -683,7 +686,13 @@ function __extractInternalOrderId(resource) {
   }
   return '';
 }
+`
+    : ''
+}
 
+${
+  autoGenerateInvoice
+    ? `
 async function handlePaypalInvoiceGeneration(resource, eventType, clientId, clientSecret, baseUrl) {
   try {
     var customerEmail = '';

package/src/workflow-component-plugin.ts

@@ -1330,7 +1330,8 @@ function __normalizeAdminFormRow(row, defaults) {
     var camel = k.replace(/_([a-z])/g, function(_, ch) { return ch.toUpperCase() })
     var v = row[k]
     if (v === undefined) v = row[camel]
-    if (k === 'tags') {
+    // A per-language copy (\`es_tags\`) holds the same shape as \`tags\`.
+    if (k === 'tags' || /^.{2,5}_tags$/.test(k)) {
       v = __normalizeTagsForFormInput(v)
     }
     if (k === 'gallery_images' || k === 'additional_image_urls') {
@@ -1401,7 +1402,7 @@ function __normalizeAdminFormRow(row, defaults) {
         nodes: s.nodes.map((n) => ({
           id: n.id,
           type: n.type,
-          config: redactServerNodeConfig(n.config, s.env),
+          config: redactServerNodeConfig(n.config, s.env, n.type),
           stepNumber: n.stepNumber,
           label: n.label,
         })),
@@ -1425,7 +1426,7 @@ function __normalizeAdminFormRow(row, defaults) {
         return {
           id: n.id,
           type: n.type,
-          config: redactServerNodeConfig(n.config, env),
+          config: redactServerNodeConfig(n.config, env, n.type),
           stepNumber: n.stepNumber,
           label: n.label,
           executionEnv: env,

package/src/workflow-project-plugin.ts

@@ -62,13 +62,19 @@ import {
   getDatabaseDriverDependencies,
 } from './auth-generator'
 import { generateInvoiceFiles, resolveInvoiceDataSource } from './invoice'
+import { ensureSentEmailLogModule, hasEmailSendingNodeType } from './sent-email-log'
+import { ensureEmailLocaleModule, resolveEmailLocaleConfig } from './email-locale'
+import { workflowUtilsImportLine, workflowUtilsRequireLine } from './workflow-utils-alias'
 import { generateWebhookFiles } from './webhook-generator'
 import { needsDataAPIRoute, generateDataAPIRoute } from './data-api-route-generator'
 import {
   generateAccountDeleteRoute,
   accountDeleteRouteDependencies,
 } from './account-delete-route-generator'
-import { transactionalEmailDependencies } from './transactional-email-code'
+import {
+  readLocalizedEmailTemplates,
+  transactionalEmailDependencies,
+} from './transactional-email-code'
 import {
   needsRuntimeStorageRoute,
   generateRuntimeStorageUploadRoute,
@@ -347,13 +353,21 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
     const customNodes = uidl.workflows.customNodes || {}
     const usedNodeTypes = collectUsedNodeTypes(uidl.workflows)
 
+    // Server routes that run a mail-sending node require the sent-email
+    // ledger module (see generateNodeHandlersForSegment).
+    if (hasEmailSendingNodeType(usedNodeTypes)) {
+      ensureSentEmailLogModule(structure)
+    }
+
     files.set('workflow-runtime-utils', {
       path: ['utils', 'workflows'],
       files: [
         {
           name: 'runtime-utils',
           fileType: FileType.JS,
-          content: generateSharedRuntimeUtilsCode(),
+          content: generateSharedRuntimeUtilsCode({
+            emailLocales: resolveEmailLocaleConfig(uidl),
+          }),
         },
       ],
     })
@@ -655,6 +669,7 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
       const emailSecretEnvName =
         extractSecretEnvName(deleteConfig.apiKey) || extractSecretEnvName(deleteConfig.serverToken)
 
+      ensureEmailLocaleModule(structure)
       files.set('account-delete-current-route', {
         path: ['pages', 'api', 'account'],
         files: [
@@ -668,6 +683,7 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
               emailSecretEnvName,
               emailSubject: typeof deleteConfig.subject === 'string' ? deleteConfig.subject : '',
               emailBodyHtml: typeof deleteConfig.body === 'string' ? deleteConfig.body : '',
+              localizedTemplates: readLocalizedEmailTemplates(deleteConfig.localizedTemplates),
               siteName: uidl.name || '',
               deletedEmailPattern:
                 typeof deleteConfig.deletedEmailPattern === 'string'
@@ -684,6 +700,10 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
           dependencies[pkg] = version
         }
       }
+      // A configured provider means the route records its sends.
+      if (Object.keys(providerDeps).length > 0) {
+        ensureSentEmailLogModule(structure)
+      }
     }
 
     if (needsRuntimeStorageRoute(usedNodeTypes)) {
@@ -1175,7 +1195,10 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
       })
       .join(',\n')
 
+    // Bound before the map so a handler can reach the runtime's helpers by the
+    // shared alias (see workflow-utils-alias.ts).
     return `// Auto-generated workflow node handlers (${env})
+${workflowUtilsRequireLine('./runtime-utils')}
 
 module.exports = {
 ${entries}
@@ -1255,7 +1278,7 @@ ${entries}
       const nodesJson = JSON.stringify(
         (cn.nodes || []).map((n: any) => ({
           ...n,
-          config: redactServerNodeConfig(n.config, resolveNodeExecutionEnv(n)),
+          config: redactServerNodeConfig(n.config, resolveNodeExecutionEnv(n), n.type),
           // Runtime marker consumed by clientExecutableBranchNodes (client
           // runtime) so streaming on-stream/on-end branches never execute
           // server nodes (whose config was just redacted) client-side.
@@ -1299,7 +1322,7 @@ ${entries}
             nodes: s.nodes.map((n) => ({
               id: n.id,
               type: n.type,
-              config: redactServerNodeConfig(n.config, s.env),
+              config: redactServerNodeConfig(n.config, s.env, n.type),
               stepNumber: n.stepNumber,
               label: n.label,
             })),
@@ -1645,12 +1668,16 @@ module.exports = __customNodeRegistry;
       const welcomeSecretEnvName =
         extractSecretEnvName(signupConfig.apiKey) || extractSecretEnvName(signupConfig.serverToken)
 
+      // The route reads the signup page's language off the request, so the
+      // locale module must exist whether or not a welcome email is configured.
+      ensureEmailLocaleModule(structure)
       const signupRouteCode = generateSignupRouteFile(auth, {
         emailProvider: welcomeProvider,
         fromEmail: typeof signupConfig.from === 'string' ? signupConfig.from : '',
         emailSecretEnvName: welcomeSecretEnvName,
         emailSubject: typeof signupConfig.subject === 'string' ? signupConfig.subject : '',
         emailBodyHtml: typeof signupConfig.body === 'string' ? signupConfig.body : '',
+        localizedTemplates: readLocalizedEmailTemplates(signupConfig.localizedTemplates),
         siteName: uidl.name || '',
       })
       files.set('auth-signup-route', {
@@ -1670,6 +1697,10 @@ module.exports = __customNodeRegistry;
           dependencies[pkg] = version
         }
       }
+      // A configured provider means the route records its sends.
+      if (Object.keys(welcomeProviderDeps).length > 0) {
+        ensureSentEmailLogModule(structure)
+      }
     }
 
     const nextAuthRouteCode = generateNextAuthRouteFile()
@@ -1953,6 +1984,7 @@ module.exports = __customNodeRegistry;
     return `// Auto-generated global workflow hooks
 import { useEffect } from 'react';
 ${needsRouter ? `import Router from 'next/router';\n` : ''}import workflowRuntime from './runtime';
+${workflowUtilsImportLine('./runtime-utils')}
 const executeWorkflowWithSegments = workflowRuntime.executeWorkflowWithSegments;
 
 export function useGlobalWorkflows() {

package/src/workflow-utils-alias.ts

@@ -0,0 +1,26 @@
+/**
+ * How a node handler reaches the shared workflow runtime (`runtime-utils.js`).
+ *
+ * Handlers are authored as plain functions and inlined by `.toString()` into
+ * several generated files — the client and server handler maps, the global
+ * workflows hook and every API route — which sit in different directories, so
+ * a `require` with a relative path inside a handler could not resolve from all
+ * of them. Instead, each of those files binds the runtime to this one
+ * identifier before its first handler, and a handler that needs a helper the
+ * runtime owns (currently the locale-aware `localizeHref`) calls it through
+ * the alias. `nodes/workflow-utils-global.d.ts` declares it for the handler
+ * sources; the tests that evaluate emitted handler code bind it themselves.
+ */
+export const WORKFLOW_UTILS_ALIAS = '__workflowUtils'
+
+/** The binding for a CommonJS file: `var __workflowUtils = require('<specifier>');` */
+export const workflowUtilsRequireLine = (specifier: string): string =>
+  `var ${WORKFLOW_UTILS_ALIAS} = require('${specifier}');`
+
+/** The binding for an ES module file: `import __workflowUtils from '<specifier>';` */
+export const workflowUtilsImportLine = (specifier: string): string =>
+  `import ${WORKFLOW_UTILS_ALIAS} from '${specifier}';`
+
+/** The binding for a file that already holds the runtime in `<identifier>`. */
+export const workflowUtilsAliasLine = (identifier: string): string =>
+  `const ${WORKFLOW_UTILS_ALIAS} = ${identifier};`