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

package/__tests__/invoice-delivery-fee.test.ts

@@ -140,6 +140,66 @@ describe('invoice PDF renderer — delivery fee', () => {
     expect(withoutFee).not.toContain('<span>Delivery</span>')
   })
 
+  it('renders the template Delivery row gated on Invoice.hasShipping only when there is a fee', () => {
+    // The GUI emits the row's rendering condition as an `expr` reference
+    // (`invoiceData?.Invoice?.hasShipping`) compared with the STRING operand
+    // 'true'. The renderer resolves that expr to boolean true, so a strict
+    // `===` against the operand can never pass — the row was hidden on every
+    // invoice that had a fee.
+    const textNode = (children: unknown[]) => ({
+      type: 'element',
+      content: { elementType: 'text', semanticType: 'p', children },
+    })
+    const templateUidl = {
+      name: 'invoice-template',
+      node: {
+        type: 'element',
+        content: {
+          elementType: 'container',
+          children: [
+            {
+              type: 'conditional',
+              content: {
+                reference: { type: 'expr', content: 'invoiceData?.Invoice?.hasShipping' },
+                condition: { conditions: [{ operation: '=', operand: 'true' }] },
+                node: {
+                  type: 'element',
+                  content: {
+                    elementType: 'container',
+                    name: 'Delivery Row',
+                    children: [
+                      textNode([{ type: 'static', content: 'Delivery:' }]),
+                      textNode([{ type: 'expr', content: 'invoiceData?.Invoice?.shippingAmount' }]),
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    }
+    const code = generatePdfGeneratorCode(FAKE_SETTINGS, templateUidl, {})
+    const moduleObject = { exports: {} as Record<string, unknown> }
+    new Function('require', 'module', 'exports', `${code}; return module.exports;`)(
+      require,
+      moduleObject,
+      moduleObject.exports
+    )
+    const templated = moduleObject.exports as unknown as PdfGeneratorModule
+
+    const withFee = templated.buildInvoiceHtml({
+      ...baseInvoice,
+      shippingAmount: 9.99,
+      total: 209.99,
+    })
+    expect(withFee).toContain('Delivery:')
+    expect(withFee).toContain('$9.99')
+
+    const withoutFee = templated.buildInvoiceHtml({ ...baseInvoice, total: 200 })
+    expect(withoutFee).not.toContain('Delivery:')
+  })
+
   it('fills the {{shippingAmount}} merge token in the invoice email', () => {
     const data = pdfGenerator.buildDataContext({
       ...baseInvoice,
@@ -153,3 +213,47 @@ describe('invoice PDF renderer — delivery fee', () => {
     expect(pdfGenerator.replacePlaceholders('Due: {{totalAmount}}', data)).toBe('Due: $209.99')
   })
 })
+
+describe('invoice PDF renderer — each line says which VAT rate it was taxed at', () => {
+  const pdfGenerator = loadPdfGenerator()
+  const regionalInvoice = {
+    invoiceNumber: 'INV-0001',
+    taxRate: 20,
+    taxIncludedInPrice: false,
+    subtotal: 247,
+    taxAmount: 40,
+    shippingAmount: 0,
+    total: 287,
+    currency: 'RON',
+    items: [
+      {
+        name: 'Kettle',
+        quantity: 2,
+        unitPrice: 100,
+        totalPrice: 200,
+        taxRate: 20,
+        taxIncluded: false,
+      },
+      { name: 'Book', quantity: 1, unitPrice: 47, totalPrice: 47, taxRate: 9, taxIncluded: true },
+    ],
+  }
+
+  it('binds the per-line rate and VAT beside the net price', () => {
+    const products = (
+      pdfGenerator.buildInvoiceDataScope(regionalInvoice).invoiceData as unknown as {
+        Products: Array<Record<string, string>>
+      }
+    ).Products
+    expect(products.map((product) => product.lineVatRate)).toEqual(['20%', '9%'])
+    expect(products[0].lineVatAmount).toContain('40.00')
+    expect(products[1].lineVatAmount).toContain('3.88')
+  })
+
+  it('prints the VAT % and VAT columns and a VAT total on the fallback invoice', () => {
+    const html = pdfGenerator.buildInvoiceHtml(regionalInvoice)
+    expect(html).toContain('>VAT %</th>')
+    expect(html).toContain('>20%</td>')
+    expect(html).toContain('>9%</td>')
+    expect(html).toContain('<span>VAT</span>')
+  })
+})

package/__tests__/invoice-regional-tax.test.ts

@@ -0,0 +1,126 @@
+/* tslint:disable:function-constructor */
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import { REGIONAL_INVOICE_TAX_CODE } from '../src/invoice/regional-invoice-tax-code'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+/**
+ * The invoice of an order priced by region (shipping zones + tax
+ * jurisdictions) is computed from the rates the order was CHARGED at —
+ * `teleport_orders.tax_breakdown` — not from the store's single default rate,
+ * and its total must equal `goods + shipping_amount - discount_amount`, the
+ * amount the buyer was debited.
+ */
+
+interface RegionalInvoiceTax {
+  taxRate: number
+  taxIncluded: boolean
+  subtotal: number
+  taxAmount: number
+  shippingNet: number
+  total: number
+  itemTax: Array<{ rate: number; included: boolean; amount: number }>
+}
+
+const api = new Function(
+  REGIONAL_INVOICE_TAX_CODE +
+    '\nreturn { parse: parseOrderTaxBreakdown, resolve: resolveRegionalInvoiceTax };'
+)() as {
+  parse: (raw: unknown) => Record<string, unknown> | null
+  resolve: (
+    breakdown: Record<string, unknown>,
+    items: Array<Record<string, unknown>>,
+    discountAmount: number,
+    shippingAmount: number
+  ) => RegionalInvoiceTax
+}
+
+const cents = (n: number) => Math.round(n * 100) / 100
+
+// Germany: food at 7% and tools at 19%, both added on top; 6.00 shipping taxed
+// at 19% → shipping_amount 7.14 on the order.
+const GERMAN_ORDER = {
+  taxRate: 19,
+  taxIncluded: false,
+  taxDecimals: 2,
+  shippingTax: 1.14,
+  lines: [
+    { productId: 'p1', variantId: '', taxRate: 7, taxIncluded: false },
+    { productId: 'p2', variantId: 'v2', taxRate: 19, taxIncluded: false },
+  ],
+}
+const GERMAN_ITEMS = [
+  { productId: 'p1', variantId: null, quantity: 2, unitPrice: 10, totalPrice: 20 },
+  { productId: 'p2', variantId: 'v2', quantity: 1, unitPrice: 25.99, totalPrice: 25.99 },
+]
+
+describe('invoice — regional tax breakdown', () => {
+  it('reads the breakdown from the TEXT column, and nothing from a legacy order', () => {
+    expect(api.parse(JSON.stringify(GERMAN_ORDER))).toMatchObject({ taxRate: 19 })
+    expect(api.parse(null)).toBeNull()
+    expect(api.parse('not json')).toBeNull()
+    expect(api.parse('{"taxRate":19}')).toBeNull()
+  })
+
+  it('taxes each line at its own rate and reconciles with the order total', () => {
+    const result = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 0, 7.14)
+    // goods: 21.40 + 30.93 = 52.33, tax 1.40 + 4.94 = 6.34; shipping tax 1.14.
+    expect(cents(result.total)).toBe(59.47)
+    expect(cents(result.taxAmount)).toBe(7.48)
+    expect(cents(result.subtotal)).toBe(45.99)
+    // Delivery prints net, so Subtotal + Tax + Delivery is the total.
+    expect(cents(result.shippingNet)).toBe(6)
+    expect(cents(result.subtotal + result.taxAmount + result.shippingNet)).toBe(59.47)
+    expect(result.itemTax).toEqual([
+      { rate: 7, included: false, amount: 1.4 },
+      { rate: 19, included: false, amount: 4.94 },
+    ])
+    expect(result.taxRate).toBe(19)
+  })
+
+  it('takes a discount off the goods first, then the shipping, shrinking each tax in proportion', () => {
+    const goodsOnly = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 10.466, 7.14)
+    // 52.33 - 10.466 leaves 80% of the goods: 6.34 * 0.8 = 5.072, shipping untouched.
+    expect(cents(goodsOnly.total)).toBe(cents(52.33 - 10.466 + 7.14))
+    expect(cents(goodsOnly.taxAmount)).toBe(cents(6.34 * 0.8 + 1.14))
+
+    const intoShipping = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 55.9, 7.14)
+    // The goods are fully discounted and 3.57 of 7.14 shipping is left: half its tax.
+    expect(cents(intoShipping.total)).toBe(3.57)
+    expect(cents(intoShipping.taxAmount)).toBe(0.57)
+    expect(intoShipping.subtotal).toBe(0)
+    expect(cents(intoShipping.shippingNet)).toBe(3)
+  })
+
+  it('extracts included tax without adding it, and falls back to the standard rate for an unmatched line', () => {
+    const french = api.resolve(
+      { taxRate: 20, taxIncluded: true, taxDecimals: 2, shippingTax: 1, lines: [] },
+      [{ productId: 'p9', quantity: 1, unitPrice: 25.99, totalPrice: 25.99 }],
+      0,
+      6
+    )
+    expect(cents(french.total)).toBe(31.99)
+    expect(cents(french.taxAmount)).toBe(5.33)
+    expect(french.itemTax).toEqual([{ rate: 20, included: true, amount: 4.33 }])
+  })
+})
+
+describe('/api/invoices/generate — regional tax wiring', () => {
+  const route = generateInvoiceGenerateRouteCode({
+    invoicePrefix: 'INV-',
+    defaultTaxRate: 20,
+    showDiscount: false,
+    taxIncludedInPrice: false,
+    companyDetails: {},
+    template: { document: null },
+    tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+    emailDelivery: { enabled: false },
+  } as unknown as UIDLInvoiceSettings)
+
+  it('prices from the order breakdown unless the caller names its own rate', () => {
+    expect(route).toContain('function resolveRegionalInvoiceTax(')
+    expect(route).toContain('var regionalTaxBreakdown = body.taxRate == null')
+    expect(route).toContain('parseOrderTaxBreakdown(orderShippingSource.tax_breakdown)')
+    expect(route).toContain('taxIncludedInPrice: taxIncludedInPrice,')
+    expect(route).toContain('variantId: row.variant_id || row.variantId || null,')
+  })
+})

package/__tests__/locale-aware-redirects.test.ts

@@ -0,0 +1,355 @@
+import { NextWorkflowProjectPlugin } from '../src/workflow-project-plugin'
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+  generateWebhookWorkflowAPIRoute,
+} from '../src/api-route-generator'
+import { generateClientRuntimeCode } from '../src/executor-generator'
+import { paymentChargeUser } from '../src/nodes/payment/payment-charge-user'
+import {
+  WORKFLOW_UTILS_ALIAS,
+  workflowUtilsAliasLine,
+  workflowUtilsImportLine,
+} from '../src/workflow-utils-alias'
+import { WorkflowSegment } from '../src/types'
+import { loadHandler, HandlerFn } from './_helpers/load-handler'
+import { bindWorkflowUtils } from './_helpers/bind-workflow-utils'
+import { compileGeneratedMiddleware } from './_helpers/run-generated-middleware'
+
+/**
+ * A visitor who switched the site to Spanish must stay on the Spanish site
+ * through every redirect the generated app performs: the account handlers'
+ * "back to the home page", the navigation nodes, the payment provider's return
+ * URLs and the middleware's sign-in redirect. Next.js serves the non-default
+ * languages under a "/<locale>" prefix, so each of those has to put the run's
+ * (or the request's) locale back on the path it builds. Executed, not grepped:
+ * what matters is where the browser is sent.
+ */
+
+interface BrowserStub {
+  location: { href: string }
+  open: jest.Mock
+  localStorage: { setItem: jest.Mock; removeItem: jest.Mock }
+  dispatchEvent: jest.Mock
+  setTimeout: (fn: () => void, ms: number) => void
+  document: { createElement: () => Record<string, unknown>; body: { appendChild: jest.Mock } }
+  __teleportNextAuth: Record<string, jest.Mock>
+}
+
+const installBrowser = (): BrowserStub => {
+  const element = { textContent: '', setAttribute: jest.fn() }
+  const browser: BrowserStub = {
+    location: { href: '' },
+    open: jest.fn(),
+    localStorage: { setItem: jest.fn(), removeItem: jest.fn() },
+    dispatchEvent: jest.fn(),
+    // The farewell redirect is delayed so its toast is readable; run it now.
+    setTimeout: (fn) => fn(),
+    document: { createElement: () => element, body: { appendChild: jest.fn() } },
+    __teleportNextAuth: {
+      signIn: jest.fn(async () => ({})),
+      signOut: jest.fn(async () => undefined),
+    },
+  }
+  ;(globalThis as any).window = browser
+  ;(globalThis as any).CustomEvent = class {
+    public type: string
+    public detail: unknown
+    constructor(type: string, init?: { detail?: unknown }) {
+      this.type = type
+      this.detail = init ? init.detail : undefined
+    }
+  }
+  return browser
+}
+
+const okJson = (payload: unknown) => async () => ({ ok: true, json: async () => payload })
+
+describe('client handlers keep the language of the run', () => {
+  let unbindWorkflowUtils: () => void
+  let browser: BrowserStub
+
+  beforeAll(() => {
+    unbindWorkflowUtils = bindWorkflowUtils()
+  })
+
+  afterAll(() => {
+    unbindWorkflowUtils()
+  })
+
+  beforeEach(() => {
+    browser = installBrowser()
+  })
+
+  afterEach(() => {
+    delete (globalThis as any).window
+    delete (globalThis as any).CustomEvent
+    delete (globalThis as any).fetch
+  })
+
+  it('account-login lands on the home page of the language signed in from', async () => {
+    const handler: HandlerFn = loadHandler('account-login')
+    ;(globalThis as any).fetch = okJson({ user: { id: 'u-1' } })
+    await handler({ email: 'a@b.c', password: 'secret' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es')
+    await handler({ email: 'a@b.c', password: 'secret' }, { __locale: 'en' })
+    expect(browser.location.href).toBe('/')
+  })
+
+  it('account-signup lands on the home page of the language signed up from', async () => {
+    const handler: HandlerFn = loadHandler('account-signup')
+    ;(globalThis as any).fetch = okJson({ user: { id: 'u-1' } })
+    await handler({ email: 'a@b.c', password: 'secret' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es')
+    await handler({ email: 'a@b.c', password: 'secret' }, {})
+    expect(browser.location.href).toBe('/')
+  })
+
+  it('account-logout lands on the home page of the language signed out from', async () => {
+    const handler: HandlerFn = loadHandler('account-logout')
+    await handler({}, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es')
+  })
+
+  it('account-delete-current lands on the configured page in the language deleted from', async () => {
+    const handler: HandlerFn = loadHandler('account-delete-current')
+    ;(globalThis as any).fetch = okJson({ success: true })
+    await handler({ redirectTo: '/goodbye' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es/goodbye')
+    await handler({}, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es')
+  })
+
+  it('account-social-login asks the provider to return to the language started from', async () => {
+    const handler: HandlerFn = loadHandler('account-social-login')
+    await handler({ provider: 'google' }, { __locale: 'es' })
+    expect(browser.__teleportNextAuth.signIn).toHaveBeenCalledWith('google', {
+      callbackUrl: '/es',
+    })
+    await handler({ provider: 'google', callbackUrl: '/my-profile' }, { __locale: 'es' })
+    expect(browser.__teleportNextAuth.signIn).toHaveBeenLastCalledWith('google', {
+      callbackUrl: '/es/my-profile',
+    })
+  })
+
+  it('navigation-navigate-to-url localizes a site path and leaves everything else alone', async () => {
+    const handler: HandlerFn = loadHandler('navigation-navigate-to-url')
+    await handler({ url: '/sign-in' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('/es/sign-in')
+    await handler({ url: '/sign-in', openInNewTab: true }, { __locale: 'es' })
+    expect(browser.open).toHaveBeenCalledWith('/es/sign-in', '_blank')
+    await handler({ url: 'https://example.com/x' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('https://example.com/x')
+    await handler({ url: '/api/invoices/download?id=1' }, { __locale: 'es' })
+    expect(browser.location.href).toBe('/api/invoices/download?id=1')
+    await handler({ url: '/sign-in' }, {})
+    expect(browser.location.href).toBe('/sign-in')
+  })
+})
+
+describe('payment-charge-user returns the buyer to the language of the checkout', () => {
+  let unbindWorkflowUtils: () => void
+
+  beforeAll(() => {
+    unbindWorkflowUtils = bindWorkflowUtils()
+  })
+
+  afterAll(() => {
+    unbindWorkflowUtils()
+  })
+
+  const source = paymentChargeUser.generateHandler()
+  // The entry and the helpers up to the real absolutizer; the provider calls
+  // are stubbed to capture the URLs they were handed.
+  const entrySource = source.slice(
+    source.indexOf('async function payment_charge_user'),
+    source.indexOf('function toStripeMinorUnits')
+  )
+
+  const charge = async (
+    config: Record<string, unknown>,
+    context: Record<string, unknown>
+  ): Promise<Record<string, unknown>> => {
+    const capture = async (
+      _config: unknown,
+      _currency: unknown,
+      _amount: unknown,
+      successUrl: string,
+      cancelUrl: string
+    ) => ({ successUrl, cancelUrl })
+    // eslint-disable-next-line no-new-func
+    const factory = new Function(
+      'chargeWithStripe',
+      'chargeWithPaypal',
+      `${entrySource}\nreturn payment_charge_user;`
+    )
+    return factory(capture, capture)(config, context)
+  }
+
+  it('prefixes site-relative return paths with the run locale before absolutizing', async () => {
+    const result = await charge(
+      { successUrl: '/orders/ORD-42?payment=success', cancelUrl: '/checkout', amount: 10 },
+      { __baseUrl: 'https://shop.test', __locale: 'es' }
+    )
+    expect(result).toEqual({
+      successUrl: 'https://shop.test/es/orders/ORD-42?payment=success',
+      cancelUrl: 'https://shop.test/es/checkout',
+    })
+  })
+
+  it('keeps the bare paths for the default language and an external override untouched', async () => {
+    expect(
+      await charge(
+        { successUrl: '/orders/ORD-42', cancelUrl: 'https://pay.example/back', amount: 10 },
+        { __baseUrl: 'https://shop.test', __locale: 'en' }
+      )
+    ).toEqual({
+      successUrl: 'https://shop.test/orders/ORD-42',
+      cancelUrl: 'https://pay.example/back',
+    })
+    expect(
+      await charge({ successUrl: '/orders/ORD-42', amount: 10 }, { __baseUrl: 'https://shop.test' })
+    ).toMatchObject({ successUrl: 'https://shop.test/orders/ORD-42' })
+  })
+})
+
+describe('every file that inlines handlers binds the shared runtime alias', () => {
+  const segment: WorkflowSegment = {
+    id: 'seg-1',
+    env: 'server',
+    nodeIds: ['n1'],
+    nodes: [
+      {
+        id: 'n1',
+        type: 'payment-charge-user',
+        config: { amount: 10 },
+        executionEnv: 'server',
+        stepNumber: 1,
+        label: 'Charge',
+      } as any,
+    ],
+    edges: [],
+  }
+  const workflow = {
+    id: 'wf-1',
+    name: 'WF',
+    nodes: [segment.nodes[0]],
+    edges: [],
+  }
+
+  it('api routes alias the runtime they already require', () => {
+    const routes = [
+      generateServerSegmentAPIRoute(segment, 'wf'),
+      generateStreamingServerSegmentAPIRoute(segment, 'wf'),
+      generateCronAPIRoute({
+        ...workflow,
+        trigger: {
+          type: 'event-cron-triggered',
+          nodeId: 't',
+          scope: 'global',
+          config: { schedule: '0 * * * *', urlPath: 'cron_x' },
+        },
+      } as any),
+      generateWebhookWorkflowAPIRoute({
+        ...workflow,
+        trigger: { type: 'event-webhook-triggered', nodeId: 't', scope: 'global', config: {} },
+        webhookConfig: { urlPath: 'hooks/x', httpMethod: 'POST', signatureSecret: '' },
+      } as any),
+    ]
+    for (const route of routes) {
+      const aliasAt = route.indexOf(workflowUtilsAliasLine('utils'))
+      expect(aliasAt).toBeGreaterThan(route.indexOf('server-runtime'))
+      expect(aliasAt).toBeLessThan(route.indexOf('const nodeHandlers = {'))
+    }
+  })
+
+  it('the global workflows hook imports the runtime as an ES module', () => {
+    const plugin = new NextWorkflowProjectPlugin()
+    const hook: string = (plugin as any).generateGlobalWorkflowsHook([
+      {
+        id: 'global-wf',
+        trigger: { type: 'event-custom-triggered', config: { eventName: 'x' } },
+        nodes: [
+          {
+            id: 'n1',
+            type: 'navigation-navigate-to-url',
+            config: { url: '/sign-in' },
+            stepNumber: 1,
+          },
+        ],
+        edges: [],
+      },
+    ])
+    expect(hook).toContain(workflowUtilsImportLine('./runtime-utils'))
+    // Pure ESM, like the runtime import beside it (see the hook's emitter).
+    expect(hook).not.toContain(`${WORKFLOW_UTILS_ALIAS} = require(`)
+    expect(hook.indexOf(workflowUtilsImportLine('./runtime-utils'))).toBeLessThan(
+      hook.indexOf('export function useGlobalWorkflows')
+    )
+  })
+
+  it('the client runtime localizes a terminal redirect it performs itself', () => {
+    expect(generateClientRuntimeCode()).toContain(
+      'window.location.href = utils.localizeHref(__redirectUrl, context.__locale);'
+    )
+  })
+})
+
+describe('middleware redirects keep the request locale', () => {
+  const auth: any = {
+    enabled: true,
+    dataSourceId: 'ds-1',
+    dataSourceType: 'postgres',
+    passwordAuthEnabled: true,
+    providers: [],
+    roles: ['admin'],
+    tables: {},
+    folderProtection: {},
+    authPages: {
+      signIn: { pageId: 'sign-in', pageName: 'sign-in', route: '/sign-in' },
+      signUp: { pageId: 'sign-up', pageName: 'sign-up', route: '/sign-up' },
+    },
+    pageProtection: {
+      ORDERS: { requiresAuth: true, allowedRoles: [], pageName: 'Orders', route: '/orders' },
+      ADMIN: {
+        requiresAuth: true,
+        allowedRoles: ['admin'],
+        pageName: 'Admin',
+        route: '/admin',
+      },
+    },
+    callbackBaseUrl: '',
+    envKeys: {},
+    customUserProperties: [],
+  }
+  const run = compileGeneratedMiddleware(auth)
+
+  it('sends a guest to the sign-in page of the language they were browsing in', async () => {
+    const result = await run('/orders', { locale: 'es', defaultLocale: 'en' })
+    expect(result).toEqual({
+      kind: 'redirect',
+      location: 'https://shop.test/es/sign-in?callbackUrl=%2Fes%2Forders',
+    })
+  })
+
+  it('keeps the bare routes for the default language and for a project without languages', async () => {
+    expect(await run('/orders', { locale: 'en', defaultLocale: 'en' })).toEqual({
+      kind: 'redirect',
+      location: 'https://shop.test/sign-in?callbackUrl=%2Forders',
+    })
+    expect(await run('/orders')).toEqual({
+      kind: 'redirect',
+      location: 'https://shop.test/sign-in?callbackUrl=%2Forders',
+    })
+  })
+
+  it('sends a signed-in visitor without the role to the home page of their language', async () => {
+    const result = await run('/admin', {
+      locale: 'es',
+      defaultLocale: 'en',
+      sessionUser: { id: 'u-1', role: 'user' },
+    })
+    expect(result).toEqual({ kind: 'redirect', location: 'https://shop.test/es' })
+  })
+})

package/__tests__/navigation-go-to-page.test.ts

@@ -1,5 +1,6 @@
 /* tslint:disable:no-eval */
 import { navigationGoToPage } from '../src/nodes/navigation/navigation-go-to-page'
+import { bindWorkflowUtils } from './_helpers/bind-workflow-utils'
 
 function createHandler() {
   const fnStr = navigationGoToPage.generateHandler()
@@ -23,11 +24,17 @@ function withWindow(): FakeWindow {
 describe('navigation-go-to-page', () => {
   let handler: any
   let win: FakeWindow
+  let unbindWorkflowUtils: () => void
 
   beforeAll(() => {
+    unbindWorkflowUtils = bindWorkflowUtils()
     handler = createHandler()
   })
 
+  afterAll(() => {
+    unbindWorkflowUtils()
+  })
+
   beforeEach(() => {
     win = withWindow()
   })
@@ -36,6 +43,42 @@ describe('navigation-go-to-page', () => {
     delete (global as any).window
   })
 
+  describe('language of the run', () => {
+    // The visitor stays in the language they are browsing in: the run's locale
+    // (put on the context by the runtime) prefixes every site-relative target.
+    it('prefixes the target with a non-default locale', async () => {
+      await handler({ pageId: '/about', openInNewTab: false }, { __locale: 'es' })
+      expect(win.location.href).toBe('/es/about')
+    })
+
+    it('prefixes the home page, a details page and its query params alike', async () => {
+      await handler({ pageId: '/', openInNewTab: false }, { __locale: 'es' })
+      expect(win.location.href).toBe('/es')
+      await handler(
+        {
+          openInNewTab: false,
+          differentiator: 'ORD-42',
+          targetPage: { pageId: 'p', staticUrl: '/orders', isDetailsPage: true },
+          queryParams: [{ key: 'payment', value: 'success' }],
+        },
+        { __locale: 'es' }
+      )
+      expect(win.location.href).toBe('/es/orders/ORD-42?payment=success')
+    })
+
+    it('opens the localized target in a new tab when requested', async () => {
+      await handler({ pageId: '/about', openInNewTab: true }, { __locale: 'es' })
+      expect(win.open).toHaveBeenCalledWith('/es/about', '_blank')
+    })
+
+    it('keeps the bare route for the default language and for a run without a locale', async () => {
+      await handler({ pageId: '/about', openInNewTab: false }, { __locale: 'en' })
+      expect(win.location.href).toBe('/about')
+      await handler({ pageId: '/about', openInNewTab: false }, {})
+      expect(win.location.href).toBe('/about')
+    })
+  })
+
   describe('legacy UIDL (no targetPage)', () => {
     it('navigates to the rewritten pageId', async () => {
       const result = await handler({ pageId: '/about', openInNewTab: false }, {})