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

package/__tests__/data-api-invalid-body.test.ts

@@ -0,0 +1,110 @@
+/* tslint:disable:function-constructor */
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+
+/**
+ * The generated `/api/data/<ds>/<op>` route answers a request whose body is
+ * empty or is not a JSON object with 400, without opening a database
+ * connection; it used to fail with a 500 parsing it.
+ */
+
+const SECRET = 'server-secret'
+
+interface RouteResult {
+  status: number
+  body: any
+  connections: number
+  queries: string[]
+}
+
+function bootRoute() {
+  const queries: string[] = []
+  let connections = 0
+  class FakeClient {
+    public async connect(): Promise<void> {
+      connections++
+    }
+    public async end(): Promise<void> {
+      return
+    }
+    public async query(sql: string): Promise<{ rows: any[]; rowCount: number }> {
+      queries.push(sql)
+      if (/^SELECT COUNT/i.test(sql)) {
+        return { rows: [{ count: '0' }], rowCount: 1 }
+      }
+      return { rows: [], rowCount: 0 }
+    }
+  }
+  const moduleObj: { exports: any } = { exports: {} }
+  const fakeRequire = (name: string): any => {
+    if (name === 'pg') {
+      return { Client: FakeClient }
+    }
+    if (name === 'next-auth/jwt') {
+      return { getToken: async () => null }
+    }
+    throw new Error('unexpected require: ' + name)
+  }
+  new Function('require', 'module', 'exports', 'process', 'console', generateDataAPIRoute())(
+    fakeRequire,
+    moduleObj,
+    moduleObj.exports,
+    { env: { NEXTAUTH_SECRET: SECRET, TELEPORT_DB_CONNECTION_STRING: 'postgresql://x' } },
+    { error: () => undefined, warn: () => undefined, log: () => undefined }
+  )
+  const handler = moduleObj.exports
+  return async (body: unknown): Promise<RouteResult> => {
+    queries.length = 0
+    connections = 0
+    const result: RouteResult = { status: 0, body: null, connections: 0, queries: [] }
+    const res = {
+      status(statusCode: number) {
+        result.status = statusCode
+        return this
+      },
+      json(payload: any) {
+        result.body = payload
+        return this
+      },
+    }
+    await handler(
+      {
+        method: 'POST',
+        query: { params: ['ds-1', 'select'] },
+        headers: { 'x-internal-data-secret': SECRET },
+        body,
+      },
+      res
+    )
+    result.connections = connections
+    result.queries = queries.slice()
+    return result
+  }
+}
+
+describe('data API — a request body that is not a JSON object', () => {
+  const run = bootRoute()
+
+  it.each([
+    ['an empty body', ''],
+    ['text that is not JSON', 'tableName=products'],
+    ['truncated JSON', '{"tableName": "prod'],
+    ['no body', undefined],
+    ['a JSON null', 'null'],
+    ['a JSON array', '[{"tableName":"products"}]'],
+    ['a parsed array', [{ tableName: 'products' }]],
+  ])('answers 400 to %s, without touching the database', async (_label, body) => {
+    const result = await run(body)
+
+    expect(result.status).toBe(400)
+    expect(result.body).toEqual({ error: 'Invalid request body. Expected a JSON object.' })
+    expect(result.connections).toBe(0)
+    expect(result.queries).toEqual([])
+  })
+
+  it('still reads a JSON object sent as a string', async () => {
+    const result = await run(JSON.stringify({ tableName: 'products' }))
+
+    expect(result.status).toBe(200)
+    expect(result.queries.some((sql) => /FROM "?products"?/i.test(sql))).toBe(true)
+  })
+})

package/__tests__/data-node-not-awaited.test.ts

@@ -18,8 +18,9 @@ import type { WorkflowSegment } from '../src/types'
 //   1. the workflow does not wait for the query;
 //   2. the node's context entry is `null` — never a partial or stale value;
 //   3. a failure cannot abort the workflow (it is logged, not thrown);
-//   4. the server route STILL settles the query before it responds, because a
-//      serverless function may be frozen the instant it replies;
+//   4. the server route STILL lands the query, because a serverless function
+//      may be frozen the instant it replies: on Vercel through waitUntil, after
+//      the reply; elsewhere before it (pending-work-after-reply.test.ts);
 //   5. the client dispatches an all-fire-and-forget SEGMENT without awaiting the
 //      round trip, which is where the latency the visitor feels actually goes.
 
@@ -448,9 +449,9 @@ describe('generated server segment route', () => {
     expect(route).toContain('context[node.id] = null;')
   })
 
-  it('settles in-flight queries BEFORE responding (the platform can freeze us)', () => {
-    expect(route).toContain('await utils.settlePendingNodePromises(context);')
-    const settleAt = route.indexOf('await utils.settlePendingNodePromises(context);')
+  it('hands in-flight queries off (or settles them) BEFORE responding (the platform can freeze us)', () => {
+    expect(route).toContain('await utils.handOffPendingNodePromises(context);')
+    const settleAt = route.indexOf('await utils.handOffPendingNodePromises(context);')
     const respondAt = route.indexOf(
       'res.status(200).json({ success: true, results: utils.segmentReply(SEGMENT_CONFIG, context, __incomingSnapshot) });'
     )
@@ -464,7 +465,7 @@ describe('generated server segment route', () => {
 
   it('drains even when the segment throws', () => {
     expect(route).toContain(
-      'if (__wfContext) { await utils.settlePendingNodePromises(__wfContext); }'
+      'if (__wfContext) { await utils.handOffPendingNodePromises(__wfContext); }'
     )
   })
 

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()
+  })
+})