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

package/__tests__/_helpers/bind-workflow-utils.ts

@@ -0,0 +1,30 @@
+import { EmailLocaleConfig, generateEmailLocaleModuleCode } from '../../src/email-locale'
+import { WORKFLOW_UTILS_ALIAS } from '../../src/workflow-utils-alias'
+
+// A node handler evaluated on its own has no generated file around it to bind
+// `__workflowUtils` (see workflow-utils-alias.ts), so a test that RUNS such a
+// handler binds it here — to the real generated locale helpers, so the
+// behaviour under test is the one a generated project ships.
+
+export const TEST_LOCALES: EmailLocaleConfig = { locales: ['en', 'es'], defaultLocale: 'en' }
+
+export const loadEmailLocaleModule = (
+  config: EmailLocaleConfig = TEST_LOCALES
+): Record<string, unknown> => {
+  const moduleShim = { exports: {} as Record<string, unknown> }
+  // eslint-disable-next-line no-new-func
+  new Function('module', 'exports', generateEmailLocaleModuleCode(config))(
+    moduleShim,
+    moduleShim.exports
+  )
+  return moduleShim.exports
+}
+
+/** Binds the alias on the global scope; returns the function that unbinds it. */
+export const bindWorkflowUtils = (config: EmailLocaleConfig = TEST_LOCALES): (() => void) => {
+  const globalRef = global as unknown as Record<string, unknown>
+  globalRef[WORKFLOW_UTILS_ALIAS] = loadEmailLocaleModule(config)
+  return () => {
+    delete globalRef[WORKFLOW_UTILS_ALIAS]
+  }
+}

package/__tests__/_helpers/run-generated-middleware.ts

@@ -29,6 +29,13 @@ export interface MiddlewareRequestOptions {
   /** Session user the stubbed `/api/auth/session` returns; omit for a guest. */
   sessionUser?: MiddlewareSessionUser | null
   origin?: string
+  /**
+   * The request's language as Next.js reports it on `nextUrl` — the prefix
+   * is already stripped from `pathname`, so pass the bare route. Omit both for
+   * a project without internationalization.
+   */
+  locale?: string
+  defaultLocale?: string
 }
 
 interface RawMiddlewareResult {
@@ -113,9 +120,11 @@ export const compileGeneratedMiddleware = (auth: UIDLAuthentication) => {
 
     const getTokenStub = async (): Promise<null> => null
     const middleware = factory(NEXT_RESPONSE_STUB, getTokenStub, fetchImpl)
+    const localePrefix =
+      options.locale && options.locale !== options.defaultLocale ? `/${options.locale}` : ''
     const result = await middleware({
-      nextUrl: { pathname },
-      url: `${origin}${pathname}`,
+      nextUrl: { pathname, locale: options.locale, defaultLocale: options.defaultLocale },
+      url: `${origin}${localePrefix}${pathname}`,
       cookies: {
         get: (name: string) =>
           sessionUser && name === 'next-auth.session-token' ? { name, value: 'stub' } : undefined,

package/__tests__/admin-form-row-hydration.test.ts

@@ -0,0 +1,55 @@
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+// The admin form hydration helpers are emitted verbatim into the generated
+// page from a template literal in the plugin. Pull them out of the source and
+// run them, so what is asserted is what the page runs.
+const pluginSource = readFileSync(join(__dirname, '../src/workflow-component-plugin.ts'), 'utf8')
+
+const extractHelper = (name: string): string => {
+  const match = pluginSource.match(new RegExp(`function ${name}\\([^)]*\\) \\{[\\s\\S]*?\\n\\}\\n`))
+  if (!match) {
+    throw new Error(`helper ${name} not found in the plugin source`)
+  }
+  // Backticks are escaped inside the template literal.
+  return match[0].replace(/\\`/g, '`')
+}
+
+const helpers = new Function(
+  `${extractHelper('__normalizeTagsForFormInput')}\n${extractHelper('__normalizeAdminFormRow')}\n` +
+    'return { normalizeRow: __normalizeAdminFormRow, normalizeTags: __normalizeTagsForFormInput }'
+)() as {
+  normalizeRow: (row: unknown, defaults: Record<string, unknown>) => Record<string, unknown>
+  normalizeTags: (value: unknown) => string
+}
+
+const DEFAULTS = { name: '', tags: '', es_name: '', es_tags: '', zh_tags: '' }
+
+describe('__normalizeAdminFormRow', () => {
+  it('keeps the per-language columns the form binds', () => {
+    const row = { id: 3, name: 'Lamp', es_name: 'Lámpara', color: 'red' }
+    expect(helpers.normalizeRow(row, DEFAULTS)).toEqual({
+      name: 'Lamp',
+      tags: '',
+      es_name: 'Lámpara',
+      es_tags: '',
+      zh_tags: '',
+    })
+  })
+
+  it('reshapes a language copy of the tags like the tags themselves', () => {
+    const row = { tags: ['light', 'desk'], es_tags: '{"luz","escritorio"}', zh_tags: ['灯'] }
+    expect(helpers.normalizeRow(row, DEFAULTS)).toMatchObject({
+      tags: 'light, desk',
+      es_tags: 'luz, escritorio',
+      zh_tags: '灯',
+    })
+  })
+
+  it('falls back to the default for a language the row has nothing for', () => {
+    expect(helpers.normalizeRow({ name: 'Lamp', es_name: null }, DEFAULTS)).toMatchObject({
+      es_name: '',
+      es_tags: '',
+    })
+  })
+})

package/__tests__/client-config-redaction.test.ts

@@ -222,3 +222,56 @@ describe('server API route still carries the SQL', () => {
     expect(route).toContain(DATA_SOURCE_ID)
   })
 })
+
+describe('route-backed account nodes: the email their route sends never ships to the browser', () => {
+  const { redactServerNodeConfig } = require('../src/segment-splitter')
+
+  const signupConfig = {
+    email: { type: 'workflowContext', nodeId: 'form', path: ['form', 'email'] },
+    password: { type: 'workflowContext', nodeId: 'form', path: ['form', 'password'] },
+    name: 'Jane',
+    company: 'Acme',
+    emailProvider: 'email-resend',
+    apiKey: { type: 'dynamic', content: { referenceType: 'secret', id: 'RESEND_APIKEY' } },
+    from: 'hello@example.com',
+    subject: 'Welcome {{userName}}',
+    body: '<p>SECRET_WELCOME_BODY</p>',
+    templateParams: [{ key: 'userName', value: 'Jane' }],
+    localizedTemplates: { es: { body: '<p>SECRET_WELCOME_BODY_ES</p>' } },
+  }
+
+  it('keeps the credentials and the user columns of a signup, drops the welcome email', () => {
+    const redacted = redactServerNodeConfig(signupConfig, 'client', 'account-signup')
+    expect(redacted).toEqual({
+      email: signupConfig.email,
+      password: signupConfig.password,
+      name: 'Jane',
+      company: 'Acme',
+    })
+  })
+
+  it('keeps what the delete handler reads, drops the farewell email', () => {
+    const redacted = redactServerNodeConfig(
+      {
+        successMessage: 'Bye',
+        redirectTo: '/',
+        emailProvider: 'email-resend',
+        serverToken: 'x',
+        domain: 'mg.example.com',
+        deletedEmailPattern: 'deleted-{{userId}}@x.invalid',
+        subject: 'Goodbye',
+        body: '<p>SECRET_FAREWELL</p>',
+        localizedTemplates: { es: { body: '<p>SECRET_FAREWELL_ES</p>' } },
+      },
+      'client',
+      'account-delete-current'
+    )
+    expect(redacted).toEqual({ successMessage: 'Bye', redirectTo: '/' })
+  })
+
+  it('leaves every other client node config untouched', () => {
+    const config = { message: 'hi', subject: 'kept', body: 'kept' }
+    expect(redactServerNodeConfig(config, 'client', 'toast-show')).toBe(config)
+    expect(redactServerNodeConfig(config, 'client')).toBe(config)
+  })
+})

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

@@ -0,0 +1,323 @@
+import {
+  generateEmailLocaleModuleCode,
+  resolveEmailLocaleConfig,
+  EMAIL_LOCALE_HEADER,
+} from '../src/email-locale'
+
+/**
+ * The shared locale module decides which language a customer email goes out
+ * in and which path a navigation lands on. It is EXECUTED here rather than
+ * grepped: every helper must be total (an unknown locale can never select a
+ * template that does not exist, nor send a visitor to a locale the app does
+ * not serve), and the precedence between the explicit header, the referring
+ * page and the Next.js cookie is what keeps a request without the header from
+ * silently falling back to the main language.
+ */
+
+interface EmailLocaleModule {
+  EMAIL_LOCALES: string[]
+  DEFAULT_EMAIL_LOCALE: string
+  normalizeEmailLocale: (value: unknown) => string | null
+  resolveRequestLocale: (req: unknown) => string
+  getClientLocale: () => string | null
+  localizeHref: (href: unknown, locale: unknown) => unknown
+  pickLocalizedTemplate: (
+    base: { subject?: string; body?: string },
+    localized: unknown,
+    locale: unknown
+  ) => { subject?: string; body?: string; locale: string }
+}
+
+const loadModule = (config: { locales: string[]; defaultLocale: string }): EmailLocaleModule => {
+  const code = generateEmailLocaleModuleCode(config)
+  const moduleShim = { exports: {} as EmailLocaleModule }
+  // eslint-disable-next-line no-new-func
+  new Function('module', 'exports', 'require', code)(moduleShim, moduleShim.exports, () => ({}))
+  return moduleShim.exports
+}
+
+const request = (headers: Record<string, string | string[]>) => ({ headers })
+
+describe('resolveEmailLocaleConfig', () => {
+  it('reads the project languages and the main locale off the UIDL', () => {
+    const uidl = {
+      internationalization: {
+        main: { name: 'English', locale: 'en' },
+        languages: { en: 'English', es: 'Spanish' },
+        translations: {},
+      },
+    } as any
+    expect(resolveEmailLocaleConfig(uidl)).toEqual({ locales: ['en', 'es'], defaultLocale: 'en' })
+  })
+
+  it('always lists the main locale, even when the language map omits it', () => {
+    const uidl = {
+      internationalization: {
+        main: { name: 'French', locale: 'fr' },
+        languages: { es: 'Spanish' },
+        translations: {},
+      },
+    } as any
+    expect(resolveEmailLocaleConfig(uidl)).toEqual({ locales: ['fr', 'es'], defaultLocale: 'fr' })
+  })
+
+  it('has no locales at all for a project without internationalization', () => {
+    expect(resolveEmailLocaleConfig({} as any)).toEqual({ locales: [], defaultLocale: '' })
+  })
+})
+
+describe('email-locale module', () => {
+  const locales = loadModule({ locales: ['en', 'es', 'pt-BR'], defaultLocale: 'en' })
+
+  describe('normalizeEmailLocale', () => {
+    it('answers the canonical code, case-insensitively', () => {
+      expect(locales.normalizeEmailLocale('es')).toBe('es')
+      expect(locales.normalizeEmailLocale(' ES ')).toBe('es')
+      expect(locales.normalizeEmailLocale('pt-br')).toBe('pt-BR')
+    })
+
+    it('rejects anything that is not a project locale', () => {
+      expect(locales.normalizeEmailLocale('de')).toBeNull()
+      expect(locales.normalizeEmailLocale('')).toBeNull()
+      expect(locales.normalizeEmailLocale(null)).toBeNull()
+      expect(locales.normalizeEmailLocale(42)).toBeNull()
+      expect(locales.normalizeEmailLocale({ locale: 'es' })).toBeNull()
+    })
+  })
+
+  describe('resolveRequestLocale', () => {
+    it('prefers the explicit header the client runtime sends', () => {
+      expect(
+        locales.resolveRequestLocale(
+          request({
+            [EMAIL_LOCALE_HEADER]: 'es',
+            cookie: 'NEXT_LOCALE=pt-BR',
+            referer: 'https://shop.example/pt-BR/checkout',
+          })
+        )
+      ).toBe('es')
+    })
+
+    it('takes the first value of a repeated header', () => {
+      expect(locales.resolveRequestLocale(request({ [EMAIL_LOCALE_HEADER]: ['es', 'en'] }))).toBe(
+        'es'
+      )
+    })
+
+    it('falls back to the locale prefix of the referring page', () => {
+      expect(
+        locales.resolveRequestLocale(request({ referer: 'https://shop.example/es/cart' }))
+      ).toBe('es')
+    })
+
+    it('trusts the page the request came from over a stored locale cookie', () => {
+      expect(
+        locales.resolveRequestLocale(
+          request({ cookie: 'session=abc; NEXT_LOCALE=pt-BR; other=1', referer: 'https://x/es/' })
+        )
+      ).toBe('es')
+    })
+
+    it('falls back to the Next.js locale cookie when nothing names the page', () => {
+      expect(
+        locales.resolveRequestLocale(request({ cookie: 'session=abc; NEXT_LOCALE=pt-BR; other=1' }))
+      ).toBe('pt-BR')
+    })
+
+    it('reads an unprefixed referring page as the default language', () => {
+      expect(locales.resolveRequestLocale(request({ referer: 'https://shop.example/cart' }))).toBe(
+        'en'
+      )
+    })
+
+    it('ignores values that are not project locales and lands on the default', () => {
+      expect(
+        locales.resolveRequestLocale(
+          request({
+            [EMAIL_LOCALE_HEADER]: 'de',
+            cookie: 'NEXT_LOCALE=fr',
+            referer: 'not a url',
+          })
+        )
+      ).toBe('en')
+    })
+
+    it('answers the default language for a request without headers', () => {
+      expect(locales.resolveRequestLocale(null)).toBe('en')
+      expect(locales.resolveRequestLocale({})).toBe('en')
+    })
+  })
+
+  describe('pickLocalizedTemplate', () => {
+    const base = { subject: 'Hello {{name}}', body: '<p>Hi {{name}}</p>' }
+    const localized = {
+      es: { subject: 'Hola {{name}}', body: '<p>Hola {{name}}</p>' },
+      'pt-BR': { body: '<p>Olá {{name}}</p>' },
+    }
+
+    it('returns the copy of the requested language', () => {
+      expect(locales.pickLocalizedTemplate(base, localized, 'es')).toEqual({
+        subject: 'Hola {{name}}',
+        body: '<p>Hola {{name}}</p>',
+        locale: 'es',
+      })
+    })
+
+    it('keeps the base subject when the language has no subject of its own', () => {
+      expect(locales.pickLocalizedTemplate(base, localized, 'pt-br')).toEqual({
+        subject: 'Hello {{name}}',
+        body: '<p>Olá {{name}}</p>',
+        locale: 'pt-BR',
+      })
+    })
+
+    it('returns the base copy for the default language', () => {
+      expect(locales.pickLocalizedTemplate(base, localized, 'en')).toEqual({
+        ...base,
+        locale: 'en',
+      })
+    })
+
+    it('returns the base copy for a language without a copy, an unknown one, or none', () => {
+      const expected = { ...base, locale: 'en' }
+      expect(locales.pickLocalizedTemplate(base, { es: localized.es }, 'pt-BR')).toEqual(expected)
+      expect(locales.pickLocalizedTemplate(base, localized, 'de')).toEqual(expected)
+      expect(locales.pickLocalizedTemplate(base, localized, undefined)).toEqual(expected)
+      expect(locales.pickLocalizedTemplate(base, null, 'es')).toEqual(expected)
+    })
+
+    it('never selects a copy with an empty body', () => {
+      expect(
+        locales.pickLocalizedTemplate(base, { es: { subject: 'Hola', body: '' } }, 'es')
+      ).toEqual({ ...base, locale: 'en' })
+    })
+  })
+
+  describe('getClientLocale', () => {
+    const globalRef = global as unknown as Record<string, unknown>
+
+    const withBrowser = <T>(browser: Record<string, unknown>, run: () => T): T => {
+      globalRef.window = browser.window
+      globalRef.document = browser.document
+      try {
+        return run()
+      } finally {
+        delete globalRef.window
+        delete globalRef.document
+      }
+    }
+
+    it('is inert outside a browser', () => {
+      expect(locales.getClientLocale()).toBeNull()
+    })
+
+    it('reads the router live, so a client-side language switch is not lost', () => {
+      // After `router.push(..., { locale: 'es' })` Next.js updates the router
+      // and <html lang>, but the page data keeps the locale the document was
+      // served in.
+      expect(
+        withBrowser(
+          {
+            window: { next: { router: { locale: 'es' } }, __NEXT_DATA__: { locale: 'en' } },
+            document: { documentElement: { lang: 'es' } },
+          },
+          () => locales.getClientLocale()
+        )
+      ).toBe('es')
+    })
+
+    it('falls back to <html lang>, then to the page data', () => {
+      expect(
+        withBrowser(
+          {
+            window: { __NEXT_DATA__: { locale: 'en' } },
+            document: { documentElement: { lang: 'es' } },
+          },
+          () => locales.getClientLocale()
+        )
+      ).toBe('es')
+      expect(
+        withBrowser({ window: { __NEXT_DATA__: { locale: 'pt-br' } }, document: {} }, () =>
+          locales.getClientLocale()
+        )
+      ).toBe('pt-BR')
+    })
+
+    it('ignores a candidate that is not a project locale', () => {
+      expect(
+        withBrowser(
+          {
+            window: { next: { router: { locale: 'de' } } },
+            document: { documentElement: { lang: 'x' } },
+          },
+          () => locales.getClientLocale()
+        )
+      ).toBeNull()
+    })
+  })
+
+  describe('localizeHref', () => {
+    it('prefixes a site-relative page path with a non-default locale', () => {
+      expect(locales.localizeHref('/', 'es')).toBe('/es')
+      expect(locales.localizeHref('/sign-in', 'es')).toBe('/es/sign-in')
+      expect(locales.localizeHref('/orders/ORD-42?payment=success', 'pt-br')).toBe(
+        '/pt-BR/orders/ORD-42?payment=success'
+      )
+      expect(locales.localizeHref('/?ref=1#top', 'es')).toBe('/es?ref=1#top')
+      expect(locales.localizeHref('/products/', 'es')).toBe('/es/products/')
+    })
+
+    it('keeps the bare path for the default language, an unknown locale and no locale', () => {
+      expect(locales.localizeHref('/sign-in', 'en')).toBe('/sign-in')
+      expect(locales.localizeHref('/sign-in', 'de')).toBe('/sign-in')
+      expect(locales.localizeHref('/sign-in', undefined)).toBe('/sign-in')
+      expect(locales.localizeHref('/sign-in', null)).toBe('/sign-in')
+    })
+
+    it('never touches a path that already names a locale', () => {
+      expect(locales.localizeHref('/es/cart', 'es')).toBe('/es/cart')
+      expect(locales.localizeHref('/es', 'es')).toBe('/es')
+      expect(locales.localizeHref('/en/cart', 'es')).toBe('/en/cart')
+    })
+
+    it('never touches an API route, a Next.js internal path or a file', () => {
+      expect(locales.localizeHref('/api/invoices/download?id=1', 'es')).toBe(
+        '/api/invoices/download?id=1'
+      )
+      expect(locales.localizeHref('/api', 'es')).toBe('/api')
+      expect(locales.localizeHref('/_next/static/x.js', 'es')).toBe('/_next/static/x.js')
+      expect(locales.localizeHref('/brochure.pdf', 'es')).toBe('/brochure.pdf')
+      expect(locales.localizeHref('/sitemap.xml?v=2', 'es')).toBe('/sitemap.xml?v=2')
+    })
+
+    it('never touches anything that is not a site-relative path', () => {
+      expect(locales.localizeHref('https://shop.example/cart', 'es')).toBe(
+        'https://shop.example/cart'
+      )
+      expect(locales.localizeHref('//cdn.example/x', 'es')).toBe('//cdn.example/x')
+      expect(locales.localizeHref('#top', 'es')).toBe('#top')
+      expect(locales.localizeHref('mailto:a@b.c', 'es')).toBe('mailto:a@b.c')
+      expect(locales.localizeHref('products', 'es')).toBe('products')
+      expect(locales.localizeHref('', 'es')).toBe('')
+      expect(locales.localizeHref(undefined, 'es')).toBeUndefined()
+      expect(locales.localizeHref(42, 'es')).toBe(42)
+    })
+  })
+})
+
+describe('email-locale module without internationalization', () => {
+  const none = loadModule({ locales: [], defaultLocale: '' })
+
+  it('recognises no locale and keeps the single template', () => {
+    expect(none.normalizeEmailLocale('en')).toBeNull()
+    expect(none.resolveRequestLocale(request({ [EMAIL_LOCALE_HEADER]: 'en' }))).toBe('')
+    expect(
+      none.pickLocalizedTemplate({ subject: 'S', body: 'B' }, { en: { body: 'X' } }, 'en')
+    ).toEqual({ subject: 'S', body: 'B', locale: '' })
+  })
+
+  it('never prefixes a path', () => {
+    expect(none.localizeHref('/sign-in', 'en')).toBe('/sign-in')
+    expect(none.localizeHref('/', 'es')).toBe('/')
+  })
+})