@teleporthq/teleport-project-generator-next 0.43.65 → 0.43.67

package/__tests__/cart-locale-stamp.test.ts

@@ -0,0 +1,125 @@
+import { generateCartApiRoute } from '../src/ecommerce/cart-api-routes-generator'
+import { generateEcommerceContextFileContent } from '../src/ecommerce/ecommerce-context-generator'
+
+// The abandoned-cart reminder runs from a cron, with no visitor behind it, so
+// the language it emails a shopper in has to be remembered on the cart itself.
+// The provider sends the page locale with every sync; the route writes it to
+// `teleport_cart.locale` — and ONLY once it has confirmed the column exists,
+// because a store provisioned before the column must keep syncing as before
+// (a failed UPDATE inside the sync transaction would roll the whole cart back).
+
+const PG_CFG = { connectionString: 'env:DATABASE_URL' }
+
+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)
+}
+
+describe('cart route — storefront language on the cart row', () => {
+  const route = generateCartApiRoute('postgresql', PG_CFG) as string
+
+  it('validates the language through the shared locale module', () => {
+    expect(route).toContain("var emailLocale = require('../../../utils/email/email-locale')")
+    expect(route).toContain('emailLocale.normalizeEmailLocale(body && body.locale)')
+  })
+
+  it('checks the column once per process before ever writing it', () => {
+    expect(route).toContain("table_name = 'teleport_cart' AND column_name = 'locale' LIMIT 1")
+    expect(route).toContain('if (cartLocaleColumnPresent !== null) return cartLocaleColumnPresent')
+  })
+
+  it('touches the cart through the locale-aware helper inside the sync transaction', () => {
+    expect(route).toContain('await touchCart(client, cartId, body)')
+    expect(route).not.toContain(
+      "await client.query('UPDATE teleport_cart SET updated_at = NOW() WHERE id = $1', [cartId])\n    await client.query('COMMIT')"
+    )
+  })
+
+  it('writes the locale only when it is known AND the column exists', async () => {
+    const source = extractFunctionSource(route, 'async function touchCart(')
+    const queries: Array<{ sql: string; params: unknown[] }> = []
+    const client = {
+      query: async (sql: string, params: unknown[]) => {
+        queries.push({ sql, params })
+        return { rows: [] }
+      },
+    }
+    const emailLocale = {
+      normalizeEmailLocale: (value: unknown) => (value === 'es' ? 'es' : null),
+    }
+    const run = async (columnPresent: boolean, body: unknown) => {
+      queries.length = 0
+      // eslint-disable-next-line no-new-func
+      const touchCart = new Function(
+        'emailLocale',
+        'cartHasLocaleColumn',
+        `${source}; return touchCart;`
+      )(emailLocale, async () => columnPresent)
+      await touchCart(client, 'cart-1', body)
+      return queries
+    }
+
+    expect(await run(true, { locale: 'es' })).toEqual([
+      {
+        sql: 'UPDATE teleport_cart SET updated_at = NOW(), locale = $2 WHERE id = $1',
+        params: ['cart-1', 'es'],
+      },
+    ])
+    expect(await run(false, { locale: 'es' })).toEqual([
+      { sql: 'UPDATE teleport_cart SET updated_at = NOW() WHERE id = $1', params: ['cart-1'] },
+    ])
+    expect(await run(true, { locale: 'xx' })).toEqual([
+      { sql: 'UPDATE teleport_cart SET updated_at = NOW() WHERE id = $1', params: ['cart-1'] },
+    ])
+    expect(await run(true, undefined)).toEqual([
+      { sql: 'UPDATE teleport_cart SET updated_at = NOW() WHERE id = $1', params: ['cart-1'] },
+    ])
+  })
+})
+
+describe('ecommerce provider — cart sync carries the page locale', () => {
+  it('reads the live page locale through the shared module and sends it with the synced items', () => {
+    const content = generateEcommerceContextFileContent(
+      { enabled: true } as any,
+      undefined,
+      'ds-1',
+      true,
+      false
+    )
+    // Live, not `window.__NEXT_DATA__.locale`: the page data keeps the locale
+    // the document was served in after a client-side language switch.
+    expect(content).toContain("import emailLocale from './utils/email/email-locale'")
+    expect(content).toContain('var pageLocale = emailLocale.getClientLocale()')
+    expect(content).not.toContain('__NEXT_DATA__')
+    expect(content).toContain(
+      'body: JSON.stringify({ items: payload, sessionId: getOrCreateSessionId(), locale: pageLocale })'
+    )
+  })
+
+  it('needs no locale module when the cart is not backed by the database', () => {
+    const content = generateEcommerceContextFileContent(
+      { enabled: true } as any,
+      undefined,
+      'ds-1',
+      false,
+      false
+    )
+    expect(content).not.toContain('email-locale')
+  })
+})

package/__tests__/ecommerce-regional-pricing.test.ts

@@ -0,0 +1,271 @@
+/* tslint:disable:no-eval function-constructor */
+import { parse } from '@babel/parser'
+import { UIDLEcommerceSettings, UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+import { RegionalPricing } from '@teleporthq/teleport-shared'
+import { generateEcommerceContextFileContent } from '../src/ecommerce/ecommerce-context-generator'
+
+/**
+ * The storefront provider's half of shipping zones + tax jurisdictions.
+ *
+ * The rule itself is pinned by teleport-shared's parity table. What this pins is
+ * the provider around it: a store WITHOUT the feature gets none of its code, a
+ * store with it emits a module that parses, and the projections from a quote to
+ * what the cart and checkout pages bind are right — run, not pattern-matched.
+ */
+
+const baseSettings = (overrides: Partial<UIDLEcommerceSettings> = {}): UIDLEcommerceSettings =>
+  ({
+    cashOnDelivery: true,
+    deliveryEnabled: true,
+    storePickupEnabled: true,
+    guestCheckout: true,
+    stockManagement: false,
+    orderNotifications: false,
+    deliveryConfig: {
+      deliveryPrice: 5,
+      freeDeliveryEnabled: true,
+      freeDeliveryThreshold: 50,
+      allowDeliveryNotes: true,
+    },
+    stockManagementConfig: null,
+    orderNotificationConfig: null,
+    paymentProviders: [],
+    vouchersEnabled: true,
+    ...overrides,
+  } as UIDLEcommerceSettings)
+
+const INVOICE = {
+  defaultTaxRate: 19,
+  taxIncludedInPrice: false,
+  companyDetails: {},
+} as UIDLInvoiceSettings
+
+const REGIONAL = {
+  enabled: true,
+  currency: 'EUR',
+  countryCodes: { germany: 'DE', france: 'FR' },
+  storeCountryCode: 'DE',
+}
+
+const regionalSource = (): string =>
+  generateEcommerceContextFileContent(
+    baseSettings({ regionalPricing: REGIONAL }),
+    INVOICE,
+    'ds-1',
+    false,
+    false,
+    false
+  )
+
+const grab = (source: string, name: string): string => {
+  const start = source.indexOf(`function ${name}(`)
+  if (start === -1) {
+    throw new Error(`emitted provider is missing function ${name}`)
+  }
+  const end = source.indexOf('\n}', start)
+  return source.slice(start, end + 2)
+}
+
+describe('EcommerceProvider — regional pricing is opt-in', () => {
+  it('emits none of it for a store without the feature', () => {
+    const legacy = generateEcommerceContextFileContent(baseSettings(), INVOICE, 'ds-1')
+    expect(legacy).not.toContain('__rpQuote')
+    expect(legacy).not.toContain('teleport_shipping_zones')
+    expect(legacy).not.toContain('weightUnit')
+    // The checkout's regional surfaces still resolve, to "nothing to show".
+    expect(legacy).toContain("shippingOptionsVisible: 'false'")
+    expect(legacy).toContain("shippingStatus: 'ok'")
+    expect(legacy).toContain("codAvailable: 'true'")
+  })
+
+  it('stays off when the flag is present but disabled, or there is no datasource', () => {
+    const disabled = generateEcommerceContextFileContent(
+      baseSettings({ regionalPricing: { ...REGIONAL, enabled: false } }),
+      INVOICE,
+      'ds-1'
+    )
+    const noDataSource = generateEcommerceContextFileContent(
+      baseSettings({ regionalPricing: REGIONAL }),
+      INVOICE,
+      null
+    )
+    expect(disabled).not.toContain('__rpQuote')
+    expect(noDataSource).not.toContain('__rpQuote')
+  })
+})
+
+describe('EcommerceProvider — regional pricing emitted module', () => {
+  const source = regionalSource()
+
+  it('parses as the JSX module Next compiles', () => {
+    expect(() => parse(source, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('reads all three tables through the datasource and mirrors the snapshot for checkout', () => {
+    for (const table of [
+      'teleport_shipping_zones',
+      'teleport_shipping_rates',
+      'teleport_tax_rates',
+    ]) {
+      expect(source).toContain(table)
+    }
+    expect(source).toContain("'/api/data/' + PRODUCTS_DATA_SOURCE_ID + '/select'")
+    expect(source).toContain(
+      `const SHIPPING_RATE_STORAGE_KEY = '${RegionalPricing.SHIPPING_RATE_STORAGE_KEY}'`
+    )
+    expect(source).toContain('regional: {')
+  })
+
+  it('bakes the store defaults the quote falls back to', () => {
+    expect(source).toContain(
+      'const REGIONAL_STORE = {"deliveryEnabled":true,"storePickupEnabled":true,"deliveryPrice":5,"freeDeliveryEnabled":true,"freeDeliveryThreshold":50,"defaultTaxRate":19,"defaultTaxIncluded":false}'
+    )
+  })
+
+  it('stamps weight and categories onto hydrated cart lines', () => {
+    expect(source).toContain('weightUnit: product.weight_unit || null')
+    expect(source).toContain(
+      'categoryIds: __rpStringArray(product.category_filter_ids || product.category_ids).map(String)'
+    )
+  })
+
+  it('prices the voucher against lines already grossed in the destination tax', () => {
+    expect(source).toContain('regionalVoucherItems(regionalQuote, cartItems)')
+    expect(source).not.toContain('        STOREFRONT_TAX_RATE,\n        shippingMeta,')
+  })
+})
+
+describe('EcommerceProvider — quote projections', () => {
+  const source = regionalSource()
+  const api = new Function(
+    [
+      RegionalPricing.generateRegionalPricingHelperCode(),
+      'var STOREFRONT_TAX_RATE = 19;',
+      grab(source, 'roundMoney'),
+      grab(source, 'applyStorefrontTax'),
+      grab(source, 'cartItemDisplayPrice'),
+      grab(source, 'cartItemQuantity'),
+      grab(source, 'cartItemLineTotal'),
+      grab(source, 'cartItemHasDiscount'),
+      grab(source, 'cartItemOriginalLineTotal'),
+      grab(source, 'formatCartMoney'),
+      grab(source, 'regionalLineFor'),
+      grab(source, 'regionalLinePricing'),
+      grab(source, 'regionalVoucherItems'),
+      grab(source, 'regionalShippingMeta'),
+      grab(source, 'regionalShippingOptions'),
+      grab(source, 'regionalSettingsView'),
+      'return { quote: __rpQuote, normalize: __rpNormalizeConfig, linePricing: regionalLinePricing,' +
+        ' voucherItems: regionalVoucherItems, shippingMeta: regionalShippingMeta,' +
+        ' options: regionalShippingOptions, settingsView: regionalSettingsView };',
+    ].join('\n')
+  )()
+
+  const STORE = {
+    deliveryEnabled: true,
+    storePickupEnabled: true,
+    deliveryPrice: 5,
+    freeDeliveryEnabled: true,
+    freeDeliveryThreshold: 50,
+    defaultTaxRate: 19,
+    defaultTaxIncluded: false,
+  }
+  const CONFIG = api.normalize({
+    zones: [{ id: 'z1', name: 'France', countries: 'FR', free_shipping_threshold: '100' }],
+    rates: [
+      { id: 'r1', zone_id: 'z1', name: 'Standard', price: '4.90' },
+      { id: 'r2', zone_id: 'z1', name: 'Express', price: '12', estimated_days: 'Next day' },
+    ],
+    taxRates: [{ id: 't1', country_code: 'FR', rate: 20, tax_mode: 'added', tax_shipping: true }],
+  })
+  const CART = [
+    { id: 'l1', productId: 'p1', price: 10, quantity: 2, originalPrice: 12.5 },
+    { productId: 'p2', price: 5, quantity: 1 },
+  ]
+  const FRANCE = { countryCode: 'FR', countryName: 'France', region: '' }
+  const quoteFor = (selectedRateId: string | null) =>
+    api.quote({
+      config: CONFIG,
+      store: STORE,
+      items: CART,
+      destination: FRANCE,
+      fulfillment: 'delivery',
+      selectedRateId,
+      currency: 'EUR',
+    })
+
+  it('prices each line in the destination tax, including the struck price and a line with no id', () => {
+    const quote = quoteFor(null)
+    expect(api.linePricing(quote, CART[0], 0)).toEqual({
+      unitPrice: 12,
+      lineTotal: 24,
+      originalLineTotal: 30,
+    })
+    expect(api.linePricing(quote, CART[1], 1)).toEqual({
+      unitPrice: 6,
+      lineTotal: 6,
+      originalLineTotal: null,
+    })
+  })
+
+  it('hands the voucher rule gross unit prices', () => {
+    const items = api.voucherItems(quoteFor(null), CART)
+    expect(items.map((item: { price: number }) => item.price)).toEqual([12, 6])
+    // The stored cart is never rewritten.
+    expect(CART[0].price).toBe(10)
+  })
+
+  it('lists the shipping methods with taxed prices and the selection', () => {
+    expect(api.options(quoteFor('r2'))).toEqual([
+      {
+        id: 'r1',
+        name: 'Standard',
+        estimatedDays: '',
+        price: '5.88',
+        isFree: 'false',
+        selected: 'false',
+      },
+      {
+        id: 'r2',
+        name: 'Express',
+        estimatedDays: 'Next day',
+        price: '14.40',
+        isFree: 'false',
+        selected: 'true',
+      },
+    ])
+  })
+
+  it('feeds the shipping meta from the quote, taxed shipping included', () => {
+    expect(api.shippingMeta(quoteFor(null))).toEqual({
+      shippingIsFree: false,
+      shippingPrice: 5.88,
+      totalWithShipping: 35.88,
+      freeDeliveryProgress: '30%',
+      freeDeliveryRemaining: 70,
+    })
+  })
+
+  it("shows the matched zone's fee and threshold through Settings.Delivery", () => {
+    const settings = {
+      deliveryEnabled: true,
+      Delivery: { deliveryPrice: 5, allowDeliveryNotes: true },
+    }
+    expect(api.settingsView(settings, quoteFor(null)).Delivery).toEqual({
+      deliveryPrice: 4.9,
+      allowDeliveryNotes: true,
+      freeDeliveryEnabled: true,
+      freeDeliveryThreshold: 100,
+    })
+    const pickup = api.quote({
+      config: CONFIG,
+      store: STORE,
+      items: CART,
+      destination: FRANCE,
+      fulfillment: 'pickup',
+      selectedRateId: null,
+      currency: 'EUR',
+    })
+    expect(api.settingsView(settings, pickup)).toBe(settings)
+  })
+})

package/__tests__/email-sender-and-low-stock-alert.test.ts

@@ -161,8 +161,8 @@ describe('generateEmailSenderModule — shared dispatcher', () => {
   it('emits diagnostic console logs on every dispatch (success + failure)', () => {
     const code = generateEmailSenderModule(baseSettings(), { logTag: 'test-tag' })
     expect(code).toContain("console.log('[test-tag] dispatching to '")
-    expect(code).toContain("console.log('[test-tag] sent successfully')")
-    expect(code).toContain("console.error('[test-tag] dispatch failed:")
+    expect(code).toContain("console.log('[test-tag] sent to ' + recipient)")
+    expect(code).toContain("console.error('[test-tag] dispatch failed for ' + recipient")
     expect(code).toContain("console.log('[test-tag] skipped: no recipients configured')")
   })
 
@@ -456,3 +456,166 @@ describe('generateEmailSenderModule — list-block expansion (executed, not grep
     expect(hasOwnItemList('')).toBe(false)
   })
 })
+
+describe('generateEmailSenderModule — one provider call per recipient (executed)', () => {
+  // Postmark refuses a WHOLE call when any address in it is refused (its
+  // pending-approval rule: every recipient must share the From domain), which
+  // used to fail every recipient because of one. The only honest check is to
+  // run the emitted sender against a provider stub and count the calls.
+  interface LedgerEntry {
+    to: string[]
+    status: string
+    error: string | null
+    providerMessageId: string | null
+  }
+
+  const loadSender = (refuse: (recipient: string) => boolean) => {
+    const code = generateEmailSenderModule(baseSettings(), { logTag: 'test' })
+    const ledger: LedgerEntry[] = []
+    const calls: string[] = []
+    const fetchStub = (_url: string, init: { body: string }) => {
+      const payload = JSON.parse(init.body) as { To: string }
+      calls.push(payload.To)
+      if (payload.To.startsWith('throws@')) {
+        throw new Error('transport exploded before the request left')
+      }
+      if (refuse(payload.To)) {
+        return Promise.resolve({
+          ok: false,
+          status: 422,
+          text: () => Promise.resolve('{"ErrorCode":412,"Message":"domain not allowed"}'),
+        })
+      }
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ MessageID: 'msg-' + payload.To }),
+      })
+    }
+    const requireStub = (specifier: string) => {
+      if (specifier === '../email/sent-email-log') {
+        return {
+          recordSentEmail: (entry: LedgerEntry) => ledger.push(entry),
+          settleSentEmailLog: () => Promise.resolve(),
+        }
+      }
+      return {}
+    }
+    const moduleShim = { exports: {} as Record<string, (...fnArgs: any[]) => any> }
+    // The emitted postmark dispatcher calls the free identifier `fetch`; naming
+    // it as a parameter shadows Node's global with the stub for this module.
+    // eslint-disable-next-line no-new-func
+    new Function('module', 'require', 'process', 'fetch', code)(
+      moduleShim,
+      requireStub,
+      { env: { POSTMARK_SERVER_TOKEN: 'token' } },
+      fetchStub
+    )
+    const silence = jest.spyOn(console, 'log').mockImplementation(() => undefined)
+    const silenceErr = jest.spyOn(console, 'error').mockImplementation(() => undefined)
+    const silenceWarn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    const restore = () => {
+      silence.mockRestore()
+      silenceErr.mockRestore()
+      silenceWarn.mockRestore()
+    }
+    return { send: moduleShim.exports.sendNotificationEmail, ledger, calls, restore }
+  }
+
+  it('delivers to every accepted recipient when another one is refused', async () => {
+    const { send, ledger, calls, restore } = loadSender((to) => to === 'bad@other.io')
+    try {
+      const result = await send(['good@example.com', 'bad@other.io'], 'Subject', '<p>Hi</p>', {
+        emailType: 'order-notification',
+      })
+      expect(calls).toEqual(['good@example.com', 'bad@other.io'])
+      expect(result).toEqual({
+        sent: true,
+        recipients: ['good@example.com', 'bad@other.io'],
+        delivered: ['good@example.com'],
+        failed: [
+          {
+            recipient: 'bad@other.io',
+            error: 'Postmark API error 422: {"ErrorCode":412,"Message":"domain not allowed"}',
+          },
+        ],
+      })
+      // One ledger row per recipient, each with its own verdict.
+      expect(ledger.map((e) => [e.to, e.status, e.providerMessageId])).toEqual([
+        [['good@example.com'], 'sent', 'msg-good@example.com'],
+        [['bad@other.io'], 'failed', null],
+      ])
+      expect(ledger[1].error).toContain('domain not allowed')
+    } finally {
+      restore()
+    }
+  })
+
+  it('keeps sending after a refused address instead of stopping at it', async () => {
+    const { send, calls, restore } = loadSender((to) => to === 'bad@other.io')
+    try {
+      const result = await send(['bad@other.io', 'good@example.com'], 'S', 'B')
+      expect(calls).toEqual(['bad@other.io', 'good@example.com'])
+      expect(result.delivered).toEqual(['good@example.com'])
+    } finally {
+      restore()
+    }
+  })
+
+  it("treats a synchronous transport failure as that recipient's failure, not the batch's", async () => {
+    const { send, calls, restore } = loadSender(() => false)
+    try {
+      const result = await send(['throws@example.com', 'good@example.com'], 'S', 'B')
+      expect(calls).toEqual(['throws@example.com', 'good@example.com'])
+      expect(result.delivered).toEqual(['good@example.com'])
+      expect(result.failed).toEqual([
+        { recipient: 'throws@example.com', error: 'transport exploded before the request left' },
+      ])
+    } finally {
+      restore()
+    }
+  })
+
+  it('rejects only when no recipient accepted the email, naming each refusal', async () => {
+    const { send, ledger, calls, restore } = loadSender(() => true)
+    try {
+      await expect(send(['a@other.io', 'b@other.io'], 'S', 'B')).rejects.toThrow(
+        'no recipient accepted the email — a@other.io: Postmark API error 422: ' +
+          '{"ErrorCode":412,"Message":"domain not allowed"}; b@other.io: Postmark API error 422: ' +
+          '{"ErrorCode":412,"Message":"domain not allowed"}'
+      )
+      expect(calls).toHaveLength(2)
+      expect(ledger.map((e) => e.status)).toEqual(['failed', 'failed'])
+    } finally {
+      restore()
+    }
+  })
+
+  it('trims, drops blanks and de-duplicates the recipient list before sending', async () => {
+    const { send, calls, restore } = loadSender(() => false)
+    try {
+      const result = await send(
+        [' A@example.com ', 'a@example.com', '', null, 42, 'b@example.com'],
+        'S',
+        'B'
+      )
+      expect(calls).toEqual(['A@example.com', 'b@example.com'])
+      expect(result.recipients).toEqual(['A@example.com', 'b@example.com'])
+      expect(result.failed).toEqual([])
+    } finally {
+      restore()
+    }
+  })
+
+  it('skips the provider entirely when the list is empty', async () => {
+    const { send, calls, ledger, restore } = loadSender(() => false)
+    try {
+      expect(await send([], 'S', 'B')).toEqual({ sent: false, reason: 'no_recipients' })
+      expect(await send(undefined, 'S', 'B')).toEqual({ sent: false, reason: 'no_recipients' })
+      expect(calls).toEqual([])
+      expect(ledger).toEqual([])
+    } finally {
+      restore()
+    }
+  })
+})

package/__tests__/i18n-language-switcher-links.test.ts

@@ -0,0 +1,98 @@
+import { ComponentUIDL, GeneratedFile } from '@teleporthq/teleport-types'
+import { createReactComponentGenerator } from '@teleporthq/teleport-component-generator-react'
+import { createNextInternationalizationPlugin } from '../src/internationalization/locale-mapper-component'
+
+/**
+ * A language switcher's link resolves to the iterated locale code
+ * (`href={<language>?.short}`), which the internationalization plugin rewrites
+ * into the Next.js locale switch `<Link href={router.asPath} locale={…}>`. A
+ * bare `<a href="es">` would resolve RELATIVE to the current page — "/es/es"
+ * from the Spanish home — and land on a 404. The inline switcher renders its
+ * links from an array mapper's render prop, so the rewrite has to reach into
+ * JSX attributes, not only children.
+ */
+
+/** The link ability the editor puts on a switcher option: a URL that is the iterated locale code. */
+const localeLink = (url: Record<string, unknown>) => ({
+  type: 'url',
+  content: { url, newTab: false },
+})
+
+const switcherComponent = (link: Record<string, unknown>): ComponentUIDL =>
+  ({
+    name: 'LanguageSwitcher',
+    node: {
+      type: 'element',
+      content: {
+        elementType: 'container',
+        attrs: {
+          'data-active-locale': {
+            type: 'dynamic',
+            content: { referenceType: 'global', id: 'locale', path: ['short'] },
+          },
+        },
+        children: [
+          {
+            type: 'cms-list-repeater',
+            content: {
+              elementType: 'Repeater',
+              name: 'languages',
+              key: 'languages',
+              renderPropIdentifier: 'languageOption',
+              source: 'locales',
+              nodes: {
+                list: {
+                  type: 'element',
+                  content: {
+                    elementType: 'container',
+                    children: [
+                      {
+                        type: 'element',
+                        content: {
+                          elementType: 'text',
+                          semanticType: 'span',
+                          abilities: { link },
+                          children: [{ type: 'static', content: 'es' }],
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          },
+        ],
+      },
+    },
+  } as unknown as ComponentUIDL)
+
+const jsFileOf = (files: GeneratedFile[]): string =>
+  files.find((file) => file.fileType === 'js')?.content ?? ''
+
+const generate = async (uidl: ComponentUIDL): Promise<string> => {
+  const generator = createReactComponentGenerator()
+  generator.addPlugin(createNextInternationalizationPlugin())
+  const { files } = await generator.generateComponent(uidl, { skipValidation: true })
+  return jsFileOf(files)
+}
+
+describe('language switcher links inside an array mapper render prop', () => {
+  it('become Next.js locale switches that keep the visitor on the current page', async () => {
+    const code = await generate(
+      switcherComponent(localeLink({ type: 'expr', content: 'languageOption?.short' }))
+    )
+
+    expect(code).toContain('<Link href={router.asPath} locale={languageOption?.short}>')
+    expect(code).not.toContain('href={languageOption?.short}')
+    expect(code).toContain('const router = useRouter()')
+  })
+
+  it('leave any other link alone — only the bare locale code is a locale switch', async () => {
+    const code = await generate(
+      switcherComponent(localeLink({ type: 'expr', content: "'/' + languageOption?.short" }))
+    )
+
+    expect(code).toContain("<a href={'/' + languageOption?.short}>")
+    expect(code).not.toContain('router.asPath')
+  })
+})