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

package/__tests__/invoice-billing-details.test.ts

@@ -91,7 +91,7 @@ async function runHandler(
           invoice = invoiceData
           return { invoice: invoiceData, created: true }
         },
-        storeInvoicePdf: async () => ({}),
+        storeInvoicePdf: async () => ({ firstPdf: true }),
         updateInvoice: async () => ({}),
       },
       pdfGenerator: {
@@ -122,6 +122,7 @@ async function runHandler(
 
 interface PdfGeneratorModule {
   buildInvoiceDataScope: (invoiceData: Row) => { invoiceData: Record<string, Row> }
+  buildInvoiceHtml: (invoiceData: Row) => string
 }
 
 function loadPdfGenerator(
@@ -214,6 +215,57 @@ describe('/api/invoices/generate — the buyer’s own invoice details', () => {
     })
   })
 
+  it('bills a store order shipped elsewhere at its billing address, under its company', async () => {
+    // The store checkout's "Billing Details", as its order records them; the
+    // goods go to someone else, in another town.
+    const storeOrder: Row = {
+      id: 'order-store',
+      order_number: 'ORD-7',
+      currency: 'USD',
+      total_amount: 40,
+      shipping_amount: 0,
+      billing_name: 'Ana Billing',
+      billing_email: 'ana@example.test',
+      billing_address: '1 Billing Street, Suite 4',
+      shipping_name: 'Ben Recipient',
+      shipping_address: '12 Delivery Lane',
+      shipping_city: 'Lyon',
+      shipping_state: 'Rhone',
+      shipping_zip: '69001',
+      shipping_country: 'FR',
+      metadata: JSON.stringify({
+        billingStreet: '1 Billing Street, Suite 4',
+        billingCompany: 'Acme Widgets Ltd',
+        billingCity: 'Halifax',
+        billingRegion: 'NS',
+        billingPostalCode: 'B3H 1A1',
+        billingCountry: 'CA',
+      }),
+    }
+    const items = [{ product_id: 'mug', product_name: 'Mug', quantity: 2, unit_price: 20 }]
+    const run = await runHandler(settingsWith({ defaultTaxRate: 0 }), storeOrder, items, {
+      orderId: 'order-store',
+    })
+    expect(run.status).toBe(200)
+    expect(run.invoice).toMatchObject({
+      customerName: 'Ana Billing',
+      customerCompany: 'Acme Widgets Ltd',
+      customerAddress: '1 Billing Street, Suite 4',
+      customerCity: 'Halifax',
+      customerState: 'NS',
+      customerZip: 'B3H 1A1',
+      customerCountry: 'CA',
+    })
+
+    const withoutCompany = await runHandler(
+      settingsWith({ defaultTaxRate: 0 }),
+      { ...storeOrder, metadata: JSON.stringify({ billingStreet: '1 Billing Street' }) },
+      items,
+      { orderId: 'order-store' }
+    )
+    expect(withoutCompany.invoice.customerCompany).toBe('')
+  })
+
   it('reads no metadata that is not a JSON object, and lets the caller’s VAT win', async () => {
     for (const metadata of ['not json', '[1,2]', null]) {
       const run = await runHandler(
@@ -275,4 +327,58 @@ describe('invoice PDF renderer — the buyer, never the template’s sample', ()
     })
     expect(invoiceData.Payment.intentId).toBe('')
   })
+
+  it('prints the company under the name only for a buyer who gave one', () => {
+    const withCompany = templated.buildInvoiceDataScope({
+      customerName: 'Ana Billing',
+      customerCompany: 'Acme Widgets Ltd',
+      items: [],
+    }).invoiceData.Customer
+    expect(withCompany).toMatchObject({ company: 'Acme Widgets Ltd', hasCompany: 'true' })
+    const withoutCompany = templated.buildInvoiceDataScope({ customerName: 'Ana', items: [] })
+      .invoiceData.Customer
+    expect(withoutCompany).toMatchObject({ company: '', hasCompany: 'false' })
+
+    // The template's company line, gated on its flag like the editor builds it.
+    const text = (children: unknown[]) => ({
+      type: 'element',
+      content: { elementType: 'text', semanticType: 'p', children },
+    })
+    const billTo = loadPdfGenerator(settings, {
+      name: 'invoice-template',
+      node: {
+        type: 'element',
+        content: {
+          elementType: 'container',
+          children: [
+            text([{ type: 'expr', content: 'invoiceData?.Customer?.name' }]),
+            {
+              type: 'conditional',
+              content: {
+                reference: { type: 'expr', content: 'invoiceData?.Customer?.hasCompany' },
+                condition: { conditions: [{ operation: '=', operand: 'true' }] },
+                node: text([{ type: 'expr', content: 'invoiceData?.Customer?.company' }]),
+              },
+            },
+          ],
+        },
+      },
+    })
+    expect(
+      billTo.buildInvoiceHtml({
+        customerName: 'Ana',
+        customerCompany: 'Acme Widgets Ltd',
+        items: [],
+      })
+    ).toContain('Acme Widgets Ltd')
+    expect(billTo.buildInvoiceHtml({ customerName: 'Ana', items: [] })).not.toContain('Acme')
+
+    // And the built-in layout used when a store has no template.
+    const fallback = loadPdfGenerator(settings, null).buildInvoiceHtml({
+      customerName: 'Ana Billing',
+      customerCompany: 'Acme Widgets Ltd',
+      items: [],
+    })
+    expect(fallback).toContain('<strong>Ana Billing</strong><br/>Acme Widgets Ltd<br/>')
+  })
 })

package/__tests__/invoice-data-access-replace.test.ts

@@ -21,6 +21,8 @@ interface DataAccess {
     invoiceNumber: string,
     pdfUrl: string
   ) => Promise<boolean>
+  recordOrderEvent: (event: Row) => Promise<void>
+  storeInvoicePdf: (id: string, pdf: Buffer, pdfUrl: string) => Promise<Row>
 }
 
 interface Statement {
@@ -153,6 +155,96 @@ describe('invoice data-access — replaceInvoice', () => {
     )
     expect(released()).toBe(2)
   })
+
+  it('tells the regeneration that gave the invoice its first PDF, by writing only a row without one', async () => {
+    const { dataAccess, statements } = loadPostgres()
+    expect(await dataAccess.replaceInvoice('inv-1', INVOICE_DATA, ITEMS)).toEqual({
+      firstPdf: true,
+    })
+
+    const updates = statements.filter((statement) => statement.sql.startsWith('UPDATE'))
+    expect(updates).toHaveLength(1)
+    expect(updates[0].sql).toMatch(/ WHERE id = \$\d+ AND pdf_size_bytes IS NULL$/)
+  })
+
+  it('rewrites an invoice that already had a PDF all the same, and says it was not the first', async () => {
+    const { dataAccess, statements } = loadPostgres((sql) =>
+      sql.endsWith('AND pdf_size_bytes IS NULL') ? { rowCount: 0 } : { rowCount: 1 }
+    )
+    expect(await dataAccess.replaceInvoice('inv-1', INVOICE_DATA, ITEMS)).toEqual({
+      firstPdf: false,
+    })
+
+    const updates = statements.filter((statement) => statement.sql.startsWith('UPDATE'))
+    expect(updates).toHaveLength(2)
+    expect(updates[1].sql).toMatch(/ WHERE id = \$\d+$/)
+    expect(updates[1].values).toEqual(updates[0].values)
+    expect(statements.map((statement) => statement.sql)).toContain('COMMIT')
+  })
+})
+
+/** The emitted MySQL data access over a mysql2 stub; `affected` answers each UPDATE. */
+function loadMysql(affected: (sql: string) => number) {
+  const statements: string[] = []
+  const connection = {
+    beginTransaction: async () => statements.push('BEGIN'),
+    commit: async () => statements.push('COMMIT'),
+    rollback: async () => statements.push('ROLLBACK'),
+    release: (): void => undefined,
+    execute: async (sql: string) => {
+      statements.push(sql)
+      return [{ affectedRows: sql.startsWith('UPDATE') ? affected(sql) : 1, insertId: 1 }]
+    },
+  }
+  const mysqlStub = {
+    createPool: () => ({ getConnection: async () => connection, execute: connection.execute }),
+  }
+  const code = `${generateDataAccessCode(SETTINGS, 'mysql', null)}\n${getRecordMappingCode(
+    'mysql'
+  )}`
+  const moduleObject = { exports: {} as unknown }
+  const dataAccess = new Function(
+    'require',
+    'module',
+    'exports',
+    `${code}; return module.exports;`
+  )(
+    (id: string) => (id === 'mysql2/promise' ? mysqlStub : require(id)),
+    moduleObject,
+    moduleObject.exports
+  ) as DataAccess
+  return { dataAccess, statements }
+}
+
+describe('invoice data-access — replaceInvoice on MySQL', () => {
+  it('tells the regeneration that gave the invoice its first PDF', async () => {
+    const { dataAccess, statements } = loadMysql(() => 1)
+    expect(await dataAccess.replaceInvoice('inv-1', INVOICE_DATA, ITEMS)).toEqual({
+      firstPdf: true,
+    })
+    const updates = statements.filter((sql) => sql.startsWith('UPDATE'))
+    expect(updates).toHaveLength(1)
+    expect(updates[0]).toMatch(/ WHERE id = \? AND pdf_size_bytes IS NULL$/)
+  })
+
+  it('rewrites an invoice that already had a PDF, and says it was not the first', async () => {
+    const { dataAccess, statements } = loadMysql((sql) =>
+      sql.endsWith('AND pdf_size_bytes IS NULL') ? 0 : 1
+    )
+    expect(await dataAccess.replaceInvoice('inv-1', INVOICE_DATA, ITEMS)).toEqual({
+      firstPdf: false,
+    })
+    expect(statements.filter((sql) => sql.startsWith('UPDATE'))).toHaveLength(2)
+    expect(statements).toContain('COMMIT')
+  })
+
+  it('reports an invoice that disappeared', async () => {
+    const { dataAccess, statements } = loadMysql(() => 0)
+    await expect(dataAccess.replaceInvoice('inv-1', INVOICE_DATA, ITEMS)).rejects.toThrow(
+      'Invoice inv-1 no longer exists'
+    )
+    expect(statements).toContain('ROLLBACK')
+  })
 })
 
 type SupabaseResult = { data: unknown; error: { message: string } | null }
@@ -162,9 +254,14 @@ type SupabaseResult = { data: unknown; error: { message: string } | null }
  * `failOn(op, table, nth)` fails the nth (1-based) call of that operation on
  * that table.
  */
-function loadSupabase(failOn: (op: string, table: string, nth: number) => boolean = () => false) {
+function loadSupabase(
+  failOn: (op: string, table: string, nth: number) => boolean = () => false,
+  storedInvoice: Row = {}
+) {
   const store: Record<string, Row[]> = {
-    teleport_invoices: [{ id: 'inv-1', invoice_number: 'INV-0004', total: 90, notes: 'old' }],
+    teleport_invoices: [
+      { id: 'inv-1', invoice_number: 'INV-0004', total: 90, notes: 'old', ...storedInvoice },
+    ],
     teleport_invoice_items: [{ id: 'old-1', invoice_id: 'inv-1', name: 'Old lamp' }],
   }
   const counts: Record<string, number> = {}
@@ -225,6 +322,11 @@ function loadSupabase(failOn: (op: string, table: string, nth: number) => boolea
           filters.push((row) => values.includes(row[column]))
           return builder
         },
+        // `is(column, null)`: SQL NULL, which an absent column also reads as.
+        is: (column: string, value: unknown) => {
+          filters.push((row) => (value === null ? row[column] == null : row[column] === value))
+          return builder
+        },
         maybeSingle: () => {
           single = true
           return builder
@@ -294,6 +396,35 @@ describe('invoice data-access — replaceInvoice on Supabase (no transactions)',
     )
     expect(lineNames()).toEqual(['Old lamp'])
   })
+
+  it('tells the regeneration that gave the invoice its first PDF', async () => {
+    const { dataAccess, invoice } = loadSupabase()
+    expect(
+      await dataAccess.replaceInvoice('inv-1', { ...INVOICE_DATA, pdfSizeBytes: 2048 }, ITEMS)
+    ).toEqual({ firstPdf: true })
+    expect(invoice()).toMatchObject({ total: 105, pdf_size_bytes: 2048 })
+  })
+
+  it('rewrites an invoice that already had a PDF, and says it was not the first', async () => {
+    const { dataAccess, invoice } = loadSupabase(() => false, { pdf_size_bytes: 1024 })
+    expect(
+      await dataAccess.replaceInvoice('inv-1', { ...INVOICE_DATA, pdfSizeBytes: 2048 }, ITEMS)
+    ).toEqual({ firstPdf: false })
+    expect(invoice()).toMatchObject({ total: 105, pdf_size_bytes: 2048 })
+  })
+
+  it('puts the invoice back without its PDF when a later step fails, so the next regeneration is the first', async () => {
+    const { dataAccess, invoice } = loadSupabase(
+      (op, table, nth) => op === 'delete' && table === 'teleport_invoice_items' && nth === 1
+    )
+    await expect(
+      dataAccess.replaceInvoice('inv-1', { ...INVOICE_DATA, pdfSizeBytes: 2048 }, ITEMS)
+    ).rejects.toThrow('delete teleport_invoice_items failed')
+    expect(invoice().pdf_size_bytes == null).toBe(true)
+    expect(
+      await dataAccess.replaceInvoice('inv-1', { ...INVOICE_DATA, pdfSizeBytes: 2048 }, ITEMS)
+    ).toEqual({ firstPdf: true })
+  })
 })
 
 describe('invoice data-access — linkOrderToInvoice', () => {
@@ -327,6 +458,46 @@ describe('invoice data-access — linkOrderToInvoice', () => {
   })
 })
 
+describe('invoice data-access — recordOrderEvent', () => {
+  it("writes the order's history line once per key", async () => {
+    const { dataAccess, statements } = loadPostgres()
+    await dataAccess.recordOrderEvent({
+      type: 'order-email-sent',
+      dedupeKey: 'order-email-sent:inv-1:invoice-email',
+      orderId: 'order-1',
+      payload: { purpose: 'invoice-email', to: 'ana@buyer.test' },
+      actor: 'Store admin',
+      actorType: 'merchant',
+    })
+
+    const [statement] = statements
+    expect(statement.sql).toBe(
+      'INSERT INTO teleport_events (id, event_type, dedupe_key, order_id, payload, actor, actor_type, status) ' +
+        'VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (dedupe_key) DO NOTHING'
+    )
+    expect(statement.values.slice(1)).toEqual([
+      'order-email-sent',
+      'order-email-sent:inv-1:invoice-email',
+      'order-1',
+      '{"purpose":"invoice-email","to":"ana@buyer.test"}',
+      'Store admin',
+      'merchant',
+      'recorded',
+    ])
+  })
+
+  it('keeps the key within the column', async () => {
+    const { dataAccess, statements } = loadPostgres()
+    await dataAccess.recordOrderEvent({
+      type: 'order-email-sent',
+      dedupeKey: 'k'.repeat(300),
+      actorType: 'merchant',
+    })
+    expect(String(statements[0].values[2])).toHaveLength(255)
+    expect(statements[0].values[3]).toBeNull()
+  })
+})
+
 describe('invoice data-access — every dialect exports the regeneration helpers', () => {
   it.each(['postgresql', 'mysql', 'supabase'])('%s', (dialect) => {
     const code = generateDataAccessCode(SETTINGS, dialect as never, null)
@@ -334,7 +505,70 @@ describe('invoice data-access — every dialect exports the regeneration helpers
     expect(code).toContain(
       'async function linkOrderToInvoice(orderId, invoiceId, invoiceNumber, pdfUrl)'
     )
+    expect(code).toContain('async function recordOrderEvent(event)')
     expect(code).toContain('replaceInvoice: replaceInvoice,')
     expect(code).toContain('linkOrderToInvoice: linkOrderToInvoice,')
+    expect(code).toContain('recordOrderEvent: recordOrderEvent,')
+  })
+})
+
+/**
+ * `storeInvoicePdf` — the payment's PDF, written only on an invoice that has
+ * none, so the invoice's first PDF (and with it its email) goes to exactly one
+ * of the payment and a regeneration, as `replaceInvoice` claims it.
+ */
+describe('invoice data-access — storeInvoicePdf writes only the first PDF', () => {
+  const PDF = Buffer.from('%PDF-1.4 INV-0004')
+
+  it('Postgres: one statement, on a row without a PDF', async () => {
+    const { dataAccess, statements } = loadPostgres()
+    expect(await dataAccess.storeInvoicePdf('inv-1', PDF, '/api/invoices/inv-1/pdf')).toEqual({
+      firstPdf: true,
+    })
+    expect(statements).toHaveLength(1)
+    expect(statements[0].sql).toBe(
+      'UPDATE teleport_invoices 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'
+    )
+    expect(statements[0].values).toEqual([
+      PDF,
+      PDF.length,
+      'application/pdf',
+      '/api/invoices/inv-1/pdf',
+      expect.any(String),
+      'inv-1',
+    ])
+  })
+
+  it('Postgres: an invoice that already has a PDF keeps it, and is not the first', async () => {
+    const { dataAccess } = loadPostgres(() => ({ rowCount: 0 }))
+    expect(await dataAccess.storeInvoicePdf('inv-1', PDF, '/api/invoices/inv-1/pdf')).toEqual({
+      firstPdf: false,
+    })
+  })
+
+  it('MySQL: the same condition, and the rows it changed', async () => {
+    const first = loadMysql(() => 1)
+    expect(await first.dataAccess.storeInvoicePdf('inv-1', PDF, '/x')).toEqual({ firstPdf: true })
+    expect(first.statements).toEqual([
+      'UPDATE teleport_invoices SET pdf_data = ?, pdf_size_bytes = ?, pdf_content_type = ?, ' +
+        'pdf_url = ?, updated_at = ? WHERE id = ? AND pdf_size_bytes IS NULL',
+    ])
+    const later = loadMysql(() => 0)
+    expect(await later.dataAccess.storeInvoicePdf('inv-1', PDF, '/x')).toEqual({ firstPdf: false })
+  })
+
+  it('Supabase: one filtered update', async () => {
+    const first = loadSupabase()
+    expect(await first.dataAccess.storeInvoicePdf('inv-1', PDF, '/x')).toEqual({ firstPdf: true })
+    expect(first.invoice()).toMatchObject({
+      pdf_data: PDF.toString('base64'),
+      pdf_size_bytes: PDF.length,
+      pdf_url: '/x',
+    })
+
+    const later = loadSupabase(() => false, { pdf_size_bytes: 1024, pdf_url: '/regenerated' })
+    expect(await later.dataAccess.storeInvoicePdf('inv-1', PDF, '/x')).toEqual({ firstPdf: false })
+    expect(later.invoice()).toMatchObject({ pdf_size_bytes: 1024, pdf_url: '/regenerated' })
   })
 })

package/__tests__/invoice-order-items-settle.test.ts

@@ -120,7 +120,7 @@ async function runHandler(options: {
       insertedItems.push(...items)
       return { invoice: invoiceData, created: true }
     },
-    storeInvoicePdf: async () => ({}),
+    storeInvoicePdf: async () => ({ firstPdf: true }),
     updateInvoice: async () => ({}),
   }
 

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

@@ -0,0 +1,191 @@
+import {
+  BUYER,
+  ORDER_ID,
+  Row,
+  Store,
+  historyLines,
+  invoiceOf,
+  ledgerRows,
+  openStore,
+  payWhilePdfServiceIsDown,
+  runsAsTheStore,
+  seedPaidOrder,
+} from './_helpers/invoice-store'
+
+/**
+ * The invoice email a payment sends is on its order's history.
+ *
+ * With Invoice Email Delivery on, the payment's `/api/invoices/generate`
+ * emails the buyer the invoice it just issued. The admin panel's Regenerate
+ * writes an "email sent" line on the order's history when it emails one; the
+ * payment wrote none, so the order never showed that its buyer got the
+ * invoice.
+ *
+ * Everything here is the code the store runs, as emitted (see
+ * `_helpers/invoice-store.ts`); only its database, the PDF service and the
+ * email provider are faked.
+ */
+describe("the payment's invoice email is on its order's history", () => {
+  runsAsTheStore()
+
+  it('the email the payment sends writes one "email sent" line, by the store', async () => {
+    const store = openStore()
+    seedPaidOrder(store.db, ORDER_ID)
+
+    const paid = await store.pay(ORDER_ID)
+
+    expect(paid.status).toBe(200)
+    const invoice = invoiceOf(store, ORDER_ID)
+    expect(store.emails.map((email) => email.To)).toEqual([BUYER])
+    expect(ledgerRows(store)).toEqual([
+      expect.objectContaining({ status: 'sent', source_ref: 'api/invoices/generate' }),
+    ])
+    // The line the regeneration writes, keyed on the same invoice: an
+    // invoice's email is on its order's history once, whoever sent it.
+    expect(historyLines(store)).toEqual([
+      expect.objectContaining({
+        event_type: 'order-email-sent',
+        dedupe_key: 'order-email-sent:' + String(invoice.id) + ':invoice-email',
+        order_id: ORDER_ID,
+        payload: JSON.stringify({ purpose: 'invoice-email', to: BUYER }),
+        actor: '',
+        actor_type: 'system',
+        status: 'recorded',
+      }),
+    ])
+  })
+
+  it('a payment reported again sends nothing and writes no second line', async () => {
+    const store = openStore()
+    seedPaidOrder(store.db, ORDER_ID)
+    expect((await store.pay(ORDER_ID)).status).toBe(200)
+
+    const again = await store.pay(ORDER_ID)
+
+    expect(again.body).toMatchObject({ success: true, alreadyIssued: true })
+    expect(store.emails).toHaveLength(1)
+    expect(historyLines(store)).toHaveLength(1)
+  })
+
+  it('an invoice an admin issues by hand is on the history under their name', async () => {
+    const store = openStore()
+    seedPaidOrder(store.db, ORDER_ID)
+
+    expect((await store.issueAsAdmin(ORDER_ID)).status).toBe(200)
+
+    expect(store.emails).toHaveLength(1)
+    expect(historyLines(store)).toEqual([
+      expect.objectContaining({ actor: 'Store admin', actor_type: 'merchant' }),
+    ])
+  })
+
+  it('a refused email writes no line, and the log says it failed', async () => {
+    const store = openStore()
+    seedPaidOrder(store.db, ORDER_ID)
+    store.provider.refuses = true
+
+    const paid = await store.pay(ORDER_ID)
+
+    expect(paid.status).toBe(200)
+    expect(store.emails).toHaveLength(1)
+    expect(ledgerRows(store)).toEqual([expect.objectContaining({ status: 'failed' })])
+    expect(historyLines(store)).toEqual([])
+    expect(store.errors).toContainEqual(expect.stringContaining('Email delivery FAILED'))
+  })
+
+  it('a history that cannot be written costs nothing else: the email goes and the payment is answered', async () => {
+    const store = openStore()
+    seedPaidOrder(store.db, ORDER_ID)
+    store.db.failNext(/^INSERT INTO teleport_events /, 'relation "teleport_events" does not exist')
+
+    const paid = await store.pay(ORDER_ID)
+
+    expect(paid.status).toBe(200)
+    expect(paid.body).toMatchObject({ success: true, invoiceNumber: 'INV-0001' })
+    expect(store.emails).toHaveLength(1)
+    expect(historyLines(store)).toEqual([])
+    expect(store.errors).toContainEqual(
+      expect.stringContaining('INV-0001 was emailed, but the order history could not record it')
+    )
+  })
+
+  it('Invoice Email Delivery off: no email and no line', async () => {
+    const store = openStore({ emailDelivery: false })
+    seedPaidOrder(store.db, ORDER_ID)
+
+    expect((await store.pay(ORDER_ID)).status).toBe(200)
+
+    expect(store.emails).toEqual([])
+    expect(historyLines(store)).toEqual([])
+  })
+})
+
+/**
+ * A retried payment and the merchant's Regenerate finishing the same invoice.
+ *
+ * The PDF service was down at payment, so the invoice is reserved without a
+ * PDF. A quarter of an hour later the provider retries the payment, which
+ * claims the stale reservation and renders it — and the merchant clicks
+ * Regenerate meanwhile. Each route emails the buyer when it gives the invoice
+ * its first PDF, so the database must give that to exactly one of them.
+ */
+describe('a retried payment and a regeneration finishing the same invoice', () => {
+  runsAsTheStore()
+
+  const PAYMENT_PDF = /^UPDATE teleport_invoices SET "?pdf_data"? = \$1/
+  const REGENERATION_PDF = /^UPDATE teleport_invoices SET "invoice_number" = \$1/
+
+  /** The order paid while the PDF service was down, its reservation older than any request lives. */
+  async function staleInvoice(store: Store): Promise<Row> {
+    seedPaidOrder(store.db, ORDER_ID)
+    const invoice = await payWhilePdfServiceIsDown(store, ORDER_ID)
+    invoice.updated_at = new Date(Date.now() - 20 * 60 * 1000).toISOString()
+    return invoice
+  }
+
+  it("the regeneration's PDF lands first: it emails the buyer, and the payment answers with its invoice", async () => {
+    const store = openStore()
+    const invoice = await staleInvoice(store)
+    const paymentsPdf = store.db.pauseNext(PAYMENT_PDF)
+
+    const payment = store.pay(ORDER_ID)
+    await paymentsPdf.reached
+    const regenerated = await store.regenerate(String(invoice.id))
+    paymentsPdf.release()
+    const paid = await payment
+
+    expect(store.emails.map((email) => email.To)).toEqual([BUYER])
+    expect(ledgerRows(store).map((row) => row.source_ref)).toEqual(['api/invoices/[id]/regenerate'])
+    expect(historyLines(store)).toEqual([expect.objectContaining({ actor_type: 'merchant' })])
+    expect(regenerated.status).toBe(200)
+    expect(paid.status).toBe(200)
+    expect(paid.body).toMatchObject({
+      success: true,
+      alreadyIssued: true,
+      invoiceId: invoice.id,
+      invoiceNumber: 'INV-0001',
+      pdfUrl: '/api/invoices/' + String(invoice.id) + '/pdf',
+    })
+    expect(store.db.row('teleport_orders', ORDER_ID)).toMatchObject({ invoice_id: invoice.id })
+  })
+
+  it("the payment's PDF lands first: it emails the buyer, and the regeneration does not", async () => {
+    const store = openStore()
+    const invoice = await staleInvoice(store)
+    const regenerationsPdf = store.db.pauseNext(REGENERATION_PDF)
+
+    const regeneration = store.regenerate(String(invoice.id))
+    await regenerationsPdf.reached
+    const paid = await store.pay(ORDER_ID)
+    regenerationsPdf.release()
+    const regenerated = await regeneration
+
+    expect(store.emails.map((email) => email.To)).toEqual([BUYER])
+    expect(ledgerRows(store).map((row) => row.source_ref)).toEqual(['api/invoices/generate'])
+    expect(historyLines(store)).toEqual([expect.objectContaining({ actor_type: 'system' })])
+    expect(paid.status).toBe(200)
+    expect(paid.body).toMatchObject({ success: true, invoiceId: invoice.id })
+    expect(paid.body).not.toHaveProperty('alreadyIssued')
+    expect(regenerated.status).toBe(200)
+  })
+})