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

package/__tests__/invoice-payment-line.test.ts

@@ -0,0 +1,68 @@
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+import { generatePdfGeneratorCode } from '../src/invoice/pdf-generator-code'
+import { evaluateEmittedModule } from './_helpers/load-invoice-route'
+
+/**
+ * The invoice's payment line says how the order was paid in words, with the
+ * provider that took the money ("Card (Stripe)", "Cash on delivery", "Paid
+ * online" for a booking), and the provider's payment id as "Ref. pi_…". It
+ * used to print the stored ids ("card", "cash_on_delivery", "pi_…") as they
+ * are. Run on the EMITTED renderer.
+ */
+
+const SETTINGS = {
+  invoicePrefix: 'INV-',
+  defaultTaxRate: 0,
+  companyDetails: {},
+  template: { document: null as unknown },
+  tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+  emailDelivery: { enabled: false },
+} as unknown as UIDLInvoiceSettings
+
+interface PdfGeneratorModule {
+  buildInvoiceDataScope: (invoiceData: Record<string, unknown>) => {
+    invoiceData: { Payment: Record<string, string> }
+  }
+}
+
+const renderer = evaluateEmittedModule<PdfGeneratorModule>(
+  generatePdfGeneratorCode(SETTINGS, null, null),
+  require
+)
+
+const paymentOf = (invoice: Record<string, unknown>) =>
+  renderer.buildInvoiceDataScope({ items: [], ...invoice }).invoiceData.Payment
+
+describe('the invoice payment line', () => {
+  it.each([
+    ['card', 'stripe', 'Card (Stripe)'],
+    ['card', '', 'Card'],
+    ['online', '', 'Paid online'],
+    ['online', 'mollie', 'Paid online (Mollie)'],
+    ['cash_on_delivery', '', 'Cash on delivery'],
+    ['cash_on_delivery', 'cash_on_delivery', 'Cash on delivery'],
+    ['cod', '', 'Cash on delivery'],
+    ['cash', '', 'Cash'],
+    ['store_pickup', '', 'Paid at pickup'],
+    ['gift_card', '', 'Gift card'],
+    ['bank_transfer', '', 'Bank transfer'],
+    ['paypal', '', 'Paid online (PayPal)'],
+    ['stripe', '', 'Paid online (Stripe)'],
+    ['', 'coingate', 'Paid online (CoinGate)'],
+    ['apple_pay', '', 'Apple pay'],
+    ['', '', ''],
+  ])('prints method %j with provider %j as %j', (method, provider, label) => {
+    expect(paymentOf({ paymentMethod: method, paymentProvider: provider }).method).toBe(label)
+  })
+
+  it('names the provider in words', () => {
+    expect(paymentOf({ paymentProvider: 'paypal' }).provider).toBe('PayPal')
+    expect(paymentOf({ paymentProvider: '' }).provider).toBe('')
+  })
+
+  it('prints the payment id as a reference, and nothing without one', () => {
+    expect(paymentOf({ paymentIntentId: 'pi_3Nabc' }).intentId).toBe('Ref. pi_3Nabc')
+    expect(paymentOf({ paymentIntentId: '' }).intentId).toBe('')
+    expect(paymentOf({}).intentId).toBe('')
+  })
+})

package/__tests__/invoice-tender.test.ts

@@ -387,6 +387,122 @@ describe('invoice PDF renderer — vouchers and the gift-card tender', () => {
     expect(voucherHtml).not.toContain('Amount due:')
   })
 
+  describe('an order paid partly by gift card and the rest by card', () => {
+    // 96.00 in all: 40.00 from the gift card, 56.00 charged to the buyer's card
+    // or collected by the courier.
+    const splitTender: Row = {
+      ...giftCardInvoice,
+      giftCardAmount: 40,
+      amountDue: 56,
+    }
+    const paidSplitTender: Row = { ...splitTender, status: 'paid', paidAt: '2026-10-20' }
+    // Cash on delivery the courier has not collected yet.
+    const unpaidSplitTender: Row = { ...splitTender, status: 'issued' }
+
+    const textNode = (children: unknown[]) => ({
+      type: 'element',
+      content: { elementType: 'text', semanticType: 'p', children },
+    })
+    const totalsLine = (label: string, valuePath: string) => ({
+      type: 'element',
+      content: {
+        elementType: 'container',
+        children: [
+          textNode([{ type: 'static', content: label }]),
+          textNode([{ type: 'expr', content: `invoiceData?.Invoice?.${valuePath}` }]),
+        ],
+      },
+    })
+    const giftCardGated = (line: unknown) => ({
+      type: 'conditional',
+      content: {
+        reference: { type: 'expr', content: 'invoiceData?.Invoice?.hasGiftCard' },
+        condition: { conditions: [{ operation: '=', operand: 'true' }] },
+        node: line,
+      },
+    })
+    // The editor's default layout: the grand total, then a block holding the
+    // gift-card line and the amount-due line, both shown when a card was used.
+    const editorTemplate = loadPdfGenerator({
+      name: 'invoice-template',
+      node: {
+        type: 'element',
+        content: {
+          elementType: 'container',
+          children: [
+            totalsLine('Total:', 'total'),
+            {
+              type: 'element',
+              content: {
+                elementType: 'container',
+                children: [
+                  giftCardGated(totalsLine('Paid by gift card:', 'giftCardAmount')),
+                  giftCardGated(totalsLine('Amount due:', 'amountDue')),
+                ],
+              },
+            },
+          ],
+        },
+      },
+    })
+
+    it('prints no amount due on the PDF once the order is paid, and keeps the gift card line', () => {
+      const html = editorTemplate.buildInvoiceHtml(paidSplitTender)
+      expect(html).toContain('<p>Total:</p><p>$96.00</p>')
+      expect(html).toContain('<p>Paid by gift card:</p><p>$40.00</p>')
+      expect(html).not.toContain('Amount due')
+      expect(html).not.toContain('$56.00')
+    })
+
+    it('still prints the real amount due while the rest is not collected', () => {
+      const html = editorTemplate.buildInvoiceHtml(unpaidSplitTender)
+      expect(html).toContain('<p>Paid by gift card:</p><p>$40.00</p>')
+      expect(html).toContain('<p>Amount due:</p><p>$56.00</p>')
+    })
+
+    it('keeps a block of the merchant that holds the amount due beside another field, owing nothing', () => {
+      const merchantTemplate = loadPdfGenerator({
+        name: 'invoice-template',
+        node: {
+          type: 'element',
+          content: {
+            elementType: 'container',
+            children: [
+              textNode([
+                { type: 'static', content: 'Total ' },
+                { type: 'expr', content: 'invoiceData?.Invoice?.total' },
+              ]),
+              textNode([
+                { type: 'static', content: 'Balance ' },
+                { type: 'expr', content: 'invoiceData?.Invoice?.amountDue' },
+              ]),
+            ],
+          },
+        },
+      })
+      const html = merchantTemplate.buildInvoiceHtml(paidSplitTender)
+      expect(html).toContain('<p>Total $96.00</p><p>Balance $0.00</p>')
+    })
+
+    it('prints no amount due in the fallback HTML once the order is paid', () => {
+      const paidHtml = pdfGenerator.buildInvoiceHtml(paidSplitTender)
+      expect(paidHtml).toContain('<span>Paid by gift card ••••1234</span><span>−$40.00</span>')
+      expect(paidHtml).not.toContain('Amount due')
+
+      const unpaidHtml = pdfGenerator.buildInvoiceHtml(unpaidSplitTender)
+      expect(unpaidHtml).toContain('<span>Paid by gift card ••••1234</span><span>−$40.00</span>')
+      expect(unpaidHtml).toContain('<span>Amount due</span><span>$56.00</span>')
+    })
+
+    it('leaves the amount due out of the email of the paid order as well', () => {
+      const email = pdfGenerator.replacePlaceholders(
+        '<p>Paid by gift card −{{giftCardAmount}}</p><p>Amount due {{amountDue}}</p>',
+        pdfGenerator.buildDataContext(paidSplitTender)
+      )
+      expect(email).toBe('<p>Paid by gift card −$40.00</p>')
+    })
+  })
+
   it('fills the {{amountDue}}, {{giftCardAmount}} and {{discountAmount}} merge tokens', () => {
     const giftCard = pdfGenerator.buildDataContext(giftCardInvoice)
     expect(

package/__tests__/pending-work-after-reply.test.ts

@@ -0,0 +1,294 @@
+import { generateServerSegmentAPIRoute } from '../src/api-route-generator'
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+import { isFireAndForgetNode } from '../src/await-result'
+import { NextWorkflowProjectPlugin } from '../src/workflow-project-plugin'
+import { VERCEL_FUNCTIONS_PACKAGE, VERCEL_FUNCTIONS_VERSION } from '../src/vercel-functions'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+
+/**
+ * A step the author chose not to wait for still has to finish on the server,
+ * but the visitor no longer waits for it: a cash order's invoice (rendered,
+ * stored and mailed, 8–14 s) runs on after the segment has replied. On Vercel
+ * the route hands that work to waitUntil; anywhere else it awaits it before
+ * replying, as before.
+ */
+
+const REQUEST_CONTEXT = Symbol.for('@vercel/request-context')
+
+const invoiceNode = (awaitResult?: boolean) => ({
+  id: 'invoice',
+  type: 'ecommerce-generate-invoice',
+  label: 'Generate Invoice',
+  stepNumber: 1,
+  config: { orderId: 'order-1', ...(awaitResult === undefined ? {} : { awaitResult }) },
+})
+
+const segmentOf = (node: ReturnType<typeof invoiceNode>): WorkflowSegment =>
+  ({
+    id: 'seg-cash',
+    env: 'server',
+    nodeIds: [node.id],
+    nodes: [node],
+    edges: [],
+  } as unknown as WorkflowSegment)
+
+const deferred = () => {
+  let resolve: () => void = () => undefined
+  const promise = new Promise<void>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+const settleMicrotasks = () => new Promise((done) => setTimeout(done, 20))
+
+interface Reply {
+  status: number
+  body: any
+}
+
+const originalFetch = globalThis.fetch
+
+beforeEach(() => {
+  jest.spyOn(console, 'info').mockImplementation(() => undefined)
+})
+
+afterEach(() => {
+  jest.restoreAllMocks()
+  globalThis.fetch = originalFetch
+  delete (globalThis as Record<symbol, unknown>)[REQUEST_CONTEXT]
+})
+
+/**
+ * Boots the generated segment route with `modules` installed, and an invoice
+ * route that answers only once `invoiceGate` opens.
+ */
+const bootRoute = (node: ReturnType<typeof invoiceNode>, modules: Record<string, unknown>) => {
+  const invoiceGate = deferred()
+  const progress = { invoiceFinished: false }
+  globalThis.fetch = (async () => {
+    await invoiceGate.promise
+    progress.invoiceFinished = true
+    return { ok: true, status: 200, json: async () => ({ invoiceId: 'inv-1' }) }
+  }) as unknown as typeof fetch
+
+  const runtime = loadServerRuntime(modules)
+  const routeModule: { exports: unknown } = { exports: {} }
+  // tslint:disable-next-line:function-constructor
+  new Function('module', 'exports', 'require', generateServerSegmentAPIRoute(segmentOf(node)))(
+    routeModule,
+    routeModule.exports,
+    (id: string) => {
+      if (id.endsWith('server-runtime')) {
+        return runtime
+      }
+      throw new Error('Unexpected require: ' + id)
+    }
+  )
+  const handler = routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+  const reply: Reply = { status: 0, body: undefined }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  const handled = handler(
+    { method: 'POST', body: { context: {} }, headers: { host: 'shop.example' } },
+    res
+  )
+  return { handled, reply, progress, openInvoiceGate: invoiceGate.resolve }
+}
+
+const onVercel = () => {
+  ;(globalThis as Record<symbol, unknown>)[REQUEST_CONTEXT] = {
+    get: () => ({ waitUntil: (): void => undefined }),
+  }
+}
+
+const fakeVercelFunctions = () => {
+  const handedOff: Array<Promise<unknown>> = []
+  return {
+    handedOff,
+    module: {
+      waitUntil: (promise: Promise<unknown>) => {
+        handedOff.push(promise)
+      },
+    },
+  }
+}
+
+describe('the invoice step may be left not awaited', () => {
+  it('is fire-and-forget only on an explicit awaitResult: false', () => {
+    expect(isFireAndForgetNode(invoiceNode(false) as never)).toBe(true)
+    expect(isFireAndForgetNode(invoiceNode(true) as never)).toBe(false)
+    expect(isFireAndForgetNode(invoiceNode() as never)).toBe(false)
+  })
+
+  it('is mirrored inside the generated runtime', () => {
+    const shared: { exports: Record<string, any> } = { exports: {} }
+    // tslint:disable-next-line:function-constructor
+    new Function('module', 'exports', generateSharedRuntimeUtilsCode())(shared, shared.exports)
+    expect(shared.exports.isFireAndForgetNode(invoiceNode(false))).toBe(true)
+    expect(shared.exports.isFireAndForgetNode(invoiceNode())).toBe(false)
+  })
+})
+
+describe('a segment route with a not-awaited step', () => {
+  it('replies on Vercel before the step finishes, and hands the step to waitUntil', async () => {
+    onVercel()
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(false), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    const outcome = await Promise.race([
+      run.handled.then(() => 'replied'),
+      settleMicrotasks().then(() => 'still waiting'),
+    ])
+
+    expect(outcome).toBe('replied')
+    expect(run.reply.status).toBe(200)
+    expect(run.reply.body.success).toBe(true)
+    expect(run.progress.invoiceFinished).toBe(false)
+    expect(vercel.handedOff).toHaveLength(1)
+
+    run.openInvoiceGate()
+    await vercel.handedOff[0]
+    expect(run.progress.invoiceFinished).toBe(true)
+  })
+
+  it('waits for the step before replying outside a Vercel request', async () => {
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(false), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.progress.invoiceFinished).toBe(true)
+    expect(run.reply.status).toBe(200)
+    expect(vercel.handedOff).toHaveLength(0)
+  })
+
+  it('waits for the step before replying when @vercel/functions is not installed', async () => {
+    onVercel()
+    const run = bootRoute(invoiceNode(false), {})
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.progress.invoiceFinished).toBe(true)
+    expect(run.reply.status).toBe(200)
+  })
+
+  it('still runs an awaited invoice step before replying, on Vercel too', async () => {
+    onVercel()
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.reply.body.results.invoice.invoiceId).toBe('inv-1')
+    expect(vercel.handedOff).toHaveLength(0)
+  })
+})
+
+describe('the generated project declares @vercel/functions', () => {
+  const generate = async (
+    workflows: Record<string, unknown>,
+    dependencies: Record<string, string> = {}
+  ) => {
+    const structure: any = {
+      uidl: {
+        name: 'Store',
+        globals: { settings: { title: 'Store', language: 'en' }, env: {} },
+        root: {
+          name: 'Root',
+          stateDefinitions: {
+            route: { type: 'string', defaultValue: 'Home', values: [{ value: 'Home' }] },
+          },
+          node: { type: 'element', content: { elementType: 'container', children: [] } },
+        },
+        components: {},
+        workflows: { workflows },
+      },
+      strategy: { pages: { options: {} } },
+      files: new Map(),
+      dependencies: { ...dependencies },
+      devDependencies: {},
+    }
+    await new NextWorkflowProjectPlugin().runAfter(structure)
+    return structure
+  }
+
+  const cronWorkflow = {
+    id: 'wf-cron',
+    name: 'Nightly count',
+    trigger: {
+      type: 'event-cron-triggered',
+      nodeId: 't',
+      scope: 'global',
+      config: { schedule: '0 * * * *', urlPath: 'cron_nightly' },
+    },
+    nodes: [
+      {
+        id: 'count',
+        type: 'data-count',
+        config: { dataSourceId: 'ds-1', tableName: 'orders', filters: [] },
+        stepNumber: 1,
+        label: 'Count orders',
+      },
+    ],
+    edges: [{ id: 'e1', source: 't', target: 'count' }],
+  }
+
+  const filesRequiringIt = (structure: any): string[] => {
+    const names: string[] = []
+    for (const record of structure.files.values()) {
+      for (const file of record.files || []) {
+        if (
+          typeof file.content === 'string' &&
+          file.content.includes(`require('${VERCEL_FUNCTIONS_PACKAGE}')`)
+        ) {
+          names.push([...record.path, file.name].join('/'))
+        }
+      }
+    }
+    return names
+  }
+
+  it('when an emitted file requires it', async () => {
+    const structure = await generate({ [cronWorkflow.id]: cronWorkflow })
+
+    expect(filesRequiringIt(structure)).toContain('utils/workflows/server-runtime')
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBe(VERCEL_FUNCTIONS_VERSION)
+  })
+
+  it('keeps a version the project already declares', async () => {
+    const structure = await generate(
+      { [cronWorkflow.id]: cronWorkflow },
+      { [VERCEL_FUNCTIONS_PACKAGE]: '^2.2.10' }
+    )
+
+    expect(filesRequiringIt(structure)).toContain('utils/workflows/server-runtime')
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBe('^2.2.10')
+  })
+
+  it('never without a file that requires it', async () => {
+    const structure = await generate({})
+
+    expect(filesRequiringIt(structure)).toEqual([])
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBeUndefined()
+  })
+})

package/__tests__/runtime-condition-operands.test.ts

@@ -0,0 +1,86 @@
+import { generateSharedRuntimeUtilsCode } from '../src'
+
+/**
+ * The editor's workflow templates (delete account, password reset request,
+ * bookings, reviews, social, loyalty) write an if-statement's sides as
+ * `leftOperand` / `rightOperand` with the operator `'='`. The runtime read only
+ * `leftValue` / `rightValue`, so each of those checks compared undefined with
+ * undefined and always took its "true" branch. Both spellings are read now,
+ * and `'='` is equality.
+ */
+
+type SharedUtils = {
+  resolveConfig: (cfg: unknown, ctx: Record<string, unknown>) => Record<string, unknown>
+  evaluateCondition: (cfg: unknown, ctx: Record<string, unknown>) => boolean
+}
+
+function loadSharedRuntime(): SharedUtils {
+  const wrapper: { exports: Record<string, unknown> } = { exports: {} }
+  // tslint:disable-next-line:function-constructor
+  new Function('module', 'exports', generateSharedRuntimeUtilsCode())(wrapper, wrapper.exports)
+  return wrapper.exports as unknown as SharedUtils
+}
+
+const ref = (nodeId: string, ...path: string[]) => ({
+  type: 'workflowContext',
+  nodeId,
+  path: [nodeId, ...path],
+})
+
+// The "Is Password Correct?" step of the editor's delete-account template.
+const isPasswordCorrect = {
+  conditionType: 'simple-comparison',
+  leftOperand: ref('verify-password', 'isMatch'),
+  operator: '=',
+  rightOperand: true,
+}
+
+describe('an if-statement written with leftOperand / rightOperand', () => {
+  const utils = loadSharedRuntime()
+  // What every route does with an if-statement node: resolve, then evaluate.
+  const evaluate = (config: unknown, context: Record<string, unknown>) =>
+    utils.evaluateCondition(utils.resolveConfig(config, context), context)
+
+  it('takes the branch its operands choose', () => {
+    expect(evaluate(isPasswordCorrect, { 'verify-password': { isMatch: true } })).toBe(true)
+    expect(evaluate(isPasswordCorrect, { 'verify-password': { isMatch: false } })).toBe(false)
+  })
+
+  it('reads a missing operand as missing, not as equal to the other side', () => {
+    expect(evaluate(isPasswordCorrect, {})).toBe(false)
+  })
+
+  it("treats '=' as equality without warning about the operator", () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    try {
+      expect(evaluate({ leftOperand: 'a', operator: '=', rightOperand: 'a' }, {})).toBe(true)
+      expect(evaluate({ leftOperand: 'a', operator: '=', rightOperand: 'b' }, {})).toBe(false)
+      expect(evaluate({ leftValue: 3, operator: '=', rightValue: '3' }, {})).toBe(true)
+      expect(warn).not.toHaveBeenCalled()
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('applies inside multiple conditions', () => {
+    const both = {
+      conditionType: 'multiple-conditions',
+      logicOperator: 'AND',
+      conditions: [
+        { leftOperand: ref('form', 'agreed'), operator: '=', rightOperand: true },
+        { leftOperand: ref('form', 'email'), operator: 'is-not-empty' },
+      ],
+    }
+    expect(evaluate(both, { form: { agreed: true, email: 'a@b.c' } })).toBe(true)
+    expect(evaluate(both, { form: { agreed: false, email: 'a@b.c' } })).toBe(false)
+  })
+
+  it('keeps leftValue / rightValue first when a config carries both', () => {
+    expect(
+      evaluate(
+        { leftValue: 'x', leftOperand: 'y', operator: '===', rightValue: 'x', rightOperand: 'z' },
+        {}
+      )
+    ).toBe(true)
+  })
+})

package/__tests__/sent-email-log-module.test.ts

@@ -340,6 +340,60 @@ describe('sent-email-log runtime module', () => {
       }
     })
 
+    it('writes one row per delivery when the node reached its recipients one call each', async () => {
+      const { api, queries, restore } = loadModule({})
+      try {
+        const wrapped = api.wrapEmailNodeHandler('email-resend', async () => ({
+          id: 're-1',
+          success: true,
+          error: 'refused for blocked@lumen.test (only the owner)',
+          deliveries: [
+            { to: 'jane@lumen.test', success: true, id: 're-1' },
+            { to: 'blocked@lumen.test', success: false, error: 'only the owner' },
+            { to: 'ana@lumen.test', success: true, id: 're-3' },
+          ],
+        }))
+        const context: any = {}
+        await wrapped(
+          {
+            to: ['jane@lumen.test', 'blocked@lumen.test', 'ana@lumen.test'],
+            cc: 'ops@lumen.test',
+            from: 'shop@acme.com',
+            subject: 'Hi',
+            body: '<p>x</p>',
+            emailPurpose: 'welcome',
+            emailAudience: 'customer',
+          },
+          context
+        )
+        expect(context.__pendingNodePromises).toHaveLength(3)
+        await Promise.all(context.__pendingNodePromises)
+        const rows = queries.map(rowOf)
+        expect(
+          rows.map((row) => [
+            row.recipient_email,
+            row.recipients,
+            row.status,
+            row.provider_message_id,
+            row.error_message,
+          ])
+        ).toEqual([
+          ['jane@lumen.test', '["jane@lumen.test"]', 'sent', 're-1', null],
+          ['blocked@lumen.test', '["blocked@lumen.test"]', 'failed', null, 'only the owner'],
+          ['ana@lumen.test', '["ana@lumen.test"]', 'sent', 're-3', null],
+        ])
+        for (const row of rows) {
+          expect(row.cc).toBe('["ops@lumen.test"]')
+          expect(row.email_type).toBe('welcome')
+          expect(row.audience).toBe('customer')
+          expect(row.provider).toBe('resend')
+          expect(row.source_ref).toBe('email-resend')
+        }
+      } finally {
+        restore()
+      }
+    })
+
     it('records an integration node only for its send-email action, and forwards extra arguments', async () => {
       const { api, queries, restore } = loadModule({})
       try {