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

package/__tests__/email-locale-senders.test.ts

@@ -0,0 +1,268 @@
+import type { UIDLInvoiceEmailDelivery, UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+import { generateSignupRouteFile } from '../src/auth-generator'
+import { generateAccountDeleteRoute } from '../src/account-delete-route-generator'
+import { generateEmailSenderCode } from '../src/invoice/email-sender-code'
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+import { generateEmailLocaleModuleCode } from '../src/email-locale'
+import { readLocalizedEmailTemplates } from '../src/transactional-email-code'
+import { nodeRegistry } from '../src'
+
+/**
+ * The email senders that live OUTSIDE the workflow runtime — the welcome and
+ * farewell routes, the invoice sender, the data-api that stamps an order's
+ * language — each read the shared locale module. These tests pin that every
+ * one of them selects the copy of the language it resolved, and that the
+ * order row keeps the storefront language it was written from.
+ */
+
+const LOCALIZED = {
+  es: { subject: 'Bienvenido {{userName}}', body: '<p>Hola {{userName}}</p>' },
+}
+
+const extractFunctionSource = (haystack: string, funcDecl: string): string => {
+  const startIdx = haystack.indexOf(funcDecl)
+  if (startIdx === -1) {
+    throw new Error('Helper not found: ' + funcDecl)
+  }
+  let depth = 0
+  let i = haystack.indexOf('{', startIdx)
+  for (; i < haystack.length; i++) {
+    const ch = haystack.charAt(i)
+    if (ch === '{') {
+      depth++
+    } else if (ch === '}') {
+      depth--
+      if (depth === 0) {
+        return haystack.slice(startIdx, i + 1)
+      }
+    }
+  }
+  throw new Error('Unbalanced braces for ' + funcDecl)
+}
+
+const loadLocaleModule = () => {
+  const moduleShim = { exports: {} as Record<string, unknown> }
+  // eslint-disable-next-line no-new-func
+  new Function(
+    'module',
+    'exports',
+    generateEmailLocaleModuleCode({ locales: ['en', 'es'], defaultLocale: 'en' })
+  )(moduleShim, moduleShim.exports)
+  return moduleShim.exports
+}
+
+describe('readLocalizedEmailTemplates', () => {
+  it('keeps only well-formed copies', () => {
+    expect(
+      readLocalizedEmailTemplates({
+        es: { subject: 'S', body: 'B' },
+        fr: { body: 'B' },
+        de: { subject: 'only a subject' },
+        it: { subject: '', body: '' },
+        pt: 'B',
+      })
+    ).toEqual({ es: { subject: 'S', body: 'B' }, fr: { body: 'B' } })
+  })
+
+  it('answers no copies for anything that is not a map', () => {
+    expect(readLocalizedEmailTemplates(undefined)).toEqual({})
+    expect(readLocalizedEmailTemplates([{ body: 'B' }])).toEqual({})
+    expect(readLocalizedEmailTemplates('es')).toEqual({})
+  })
+})
+
+describe('welcome and farewell routes', () => {
+  const auth = { enabled: true, dataSourceType: 'postgresql' } as any
+  const signup = generateSignupRouteFile(auth, {
+    emailProvider: 'resend',
+    emailSubject: 'Welcome {{userName}}',
+    emailBodyHtml: '<p>Hi {{userName}}</p>',
+    localizedTemplates: LOCALIZED,
+  })
+  const del = generateAccountDeleteRoute({
+    emailProvider: 'resend',
+    emailSubject: 'Goodbye {{userName}}',
+    emailBodyHtml: '<p>Bye {{userName}}</p>',
+    localizedTemplates: LOCALIZED,
+  })
+
+  it('bake the per-language copies and require the locale module', () => {
+    expect(signup).toContain(`const WELCOME_EMAIL_LOCALIZED = ${JSON.stringify(LOCALIZED)};`)
+    expect(signup).toContain("var __emailLocale = require('../../../utils/email/email-locale');")
+    expect(del).toContain(`const EMAIL_LOCALIZED = ${JSON.stringify(LOCALIZED)};`)
+    expect(del).toContain("var __emailLocale = require('../../../utils/email/email-locale');")
+  })
+
+  it('send the copy of the request language', () => {
+    expect(signup).toContain('var copy = resolveWelcomeEmailCopy(locale);')
+    expect(signup).toContain('var subject = fillTemplate(copy.subject, tokenValues);')
+    expect(signup).toContain('var html = fillTemplate(copy.body, tokenValues);')
+    expect(del).toContain('var copy = resolveFarewellEmailCopy(locale);')
+    expect(del).toContain('var subject = fillTemplate(copy.subject, tokenValues);')
+    expect(del).toContain('var html = fillTemplate(copy.body, tokenValues);')
+  })
+
+  it('resolve the language off the request at the call site', () => {
+    expect(signup).toContain('newUser && newUser.id, __emailLocale.resolveRequestLocale(req));')
+    expect(del).toContain('}, userId, __emailLocale.resolveRequestLocale(req));')
+  })
+
+  it('the copy selector honours the locale module rules', () => {
+    const locale = loadLocaleModule()
+    const selector = extractFunctionSource(signup, 'function resolveWelcomeEmailCopy(')
+    // eslint-disable-next-line no-new-func
+    const resolveWelcomeEmailCopy = new Function(
+      '__emailLocale',
+      'WELCOME_EMAIL_SUBJECT',
+      'WELCOME_EMAIL_BODY_HTML',
+      'WELCOME_EMAIL_LOCALIZED',
+      `${selector}; return resolveWelcomeEmailCopy;`
+    )(locale, 'Welcome {{userName}}', '<p>Hi {{userName}}</p>', LOCALIZED)
+    expect(resolveWelcomeEmailCopy('es')).toEqual({
+      subject: 'Bienvenido {{userName}}',
+      body: '<p>Hola {{userName}}</p>',
+      locale: 'es',
+    })
+    expect(resolveWelcomeEmailCopy('en')).toEqual({
+      subject: 'Welcome {{userName}}',
+      body: '<p>Hi {{userName}}</p>',
+      locale: 'en',
+    })
+  })
+
+  it('the signup route never inserts the copies as a user column', () => {
+    expect(signup).toContain('"localizedTemplates":1')
+  })
+})
+
+describe('invoice email', () => {
+  const delivery: UIDLInvoiceEmailDelivery = {
+    enabled: true,
+    provider: 'resend',
+    fromEmail: 'billing@example.com',
+    fromName: 'Billing',
+    subject: 'Invoice {{invoiceNumber}}',
+    body: '<p>Invoice {{invoiceNumber}}</p>',
+    secretKeys: {},
+    localizedTemplates: {
+      es: { subject: 'Factura {{invoiceNumber}}', body: '<p>Factura {{invoiceNumber}}</p>' },
+    },
+  }
+
+  it('the sender picks the copy of the invoice locale', () => {
+    const sender = generateEmailSenderCode(delivery)
+    expect(sender).toContain("var emailLocale = require('../email/email-locale');")
+    expect(sender).toContain(
+      `var LOCALIZED_TEMPLATES = ${JSON.stringify(delivery.localizedTemplates)};`
+    )
+
+    const locale = loadLocaleModule()
+    const buildEmailData = extractFunctionSource(sender, 'function buildEmailData(')
+    const pdfGenerator = {
+      buildDataContext: (data: { invoiceNumber: string }) => ({
+        invoiceNumber: data.invoiceNumber,
+      }),
+    }
+    const replacePlaceholders = (template: string, data: Record<string, string>) =>
+      template.replace(/\{\{(\w+)\}\}/g, (_m, key) => data[key] || '')
+    // eslint-disable-next-line no-new-func
+    const build = new Function(
+      'emailLocale',
+      'pdfGenerator',
+      'replacePlaceholders',
+      'SUBJECT_TEMPLATE',
+      'BODY_TEMPLATE',
+      'LOCALIZED_TEMPLATES',
+      `${buildEmailData}; return buildEmailData;`
+    )(
+      locale,
+      pdfGenerator,
+      replacePlaceholders,
+      delivery.subject,
+      delivery.body,
+      delivery.localizedTemplates
+    )
+    expect(build({ invoiceNumber: 'INV-7', locale: 'es', customerEmail: 'a@b.c' })).toMatchObject({
+      subject: 'Factura INV-7',
+      body: '<p>Factura INV-7</p>',
+    })
+    expect(build({ invoiceNumber: 'INV-7', customerEmail: 'a@b.c' })).toMatchObject({
+      subject: 'Invoice INV-7',
+      body: '<p>Invoice INV-7</p>',
+    })
+  })
+
+  it('the generate route resolves the locale: order row, then caller, then request', () => {
+    const settings = {
+      invoicePrefix: 'INV-',
+      defaultTaxRate: 0,
+      showDiscount: false,
+      template: { document: null as unknown },
+      tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+      emailDelivery: delivery,
+    } as unknown as UIDLInvoiceSettings
+    const route = generateInvoiceGenerateRouteCode(settings)
+    expect(route).toContain("var emailLocale = require('../../../utils/email/email-locale');")
+    expect(route).toContain('var invoiceLocale = emailLocale.normalizeEmailLocale(orderRow.locale)')
+    expect(route).toContain('|| emailLocale.normalizeEmailLocale(body.locale)')
+    expect(route).toContain('|| emailLocale.resolveRequestLocale(req);')
+    expect(route).toContain('locale: invoiceLocale,')
+  })
+
+  it('a project without email delivery needs no locale module', () => {
+    const route = generateInvoiceGenerateRouteCode({
+      invoicePrefix: 'INV-',
+      emailDelivery: { enabled: false },
+    } as unknown as UIDLInvoiceSettings)
+    expect(route).not.toContain('email-locale')
+    expect(route).not.toContain('invoiceLocale')
+  })
+
+  it('the generate-invoice node forwards the run locale as a hint', () => {
+    const source = nodeRegistry['ecommerce-generate-invoice'].generateHandler()
+    expect(source).toContain('payload.locale = runLocale')
+  })
+})
+
+describe('data-api stamps the storefront language on an order', () => {
+  const code = generateDataAPIRoute()
+  const stamp = extractFunctionSource(code, 'function stampRequestLocale(')
+  // eslint-disable-next-line no-new-func
+  const stampRequestLocale = new Function(
+    'LOCALE_STAMPED_TABLES',
+    'LOCALE_COLUMN',
+    `${stamp}; return stampRequestLocale;`
+  )({ teleport_orders: 1 }, 'locale')
+
+  it('adds the locale to an orders insert when the table has the column', () => {
+    const entries = [['status', 'pending']]
+    expect(
+      stampRequestLocale('teleport_orders', entries, { locale: 'character varying' }, 'es')
+    ).toEqual([
+      ['status', 'pending'],
+      ['locale', 'es'],
+    ])
+  })
+
+  it('leaves the insert alone when the column, the locale or the table does not apply', () => {
+    const entries = [['status', 'pending']]
+    expect(stampRequestLocale('teleport_orders', entries, {}, 'es')).toBe(entries)
+    expect(stampRequestLocale('teleport_orders', entries, { locale: 'text' }, '')).toBe(entries)
+    expect(stampRequestLocale('teleport_products', entries, { locale: 'text' }, 'es')).toBe(entries)
+  })
+
+  it('never overrides a locale the workflow mapped itself', () => {
+    const entries = [['locale', 'fr']]
+    expect(stampRequestLocale('teleport_orders', entries, { locale: 'text' }, 'es')).toBe(entries)
+  })
+
+  it('is wired into handleCreate from the request body', () => {
+    expect(code).toContain(
+      'entries = stampRequestLocale(tableName, entries, colTypes, body.__requestLocale);'
+    )
+    expect(nodeRegistry['data-create-item'].generateHandler()).toContain(
+      'reqBody.__requestLocale = __runLocale'
+    )
+  })
+})

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 }, {})