@teleporthq/teleport-plugin-next-workflows 0.43.65 → 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__/cart-clear-db-mirror.test.ts

@@ -1,3 +1,4 @@
+import { RegionalPricing } from '@teleporthq/teleport-shared'
 import { cartClear } from '../src/nodes/cart/cart-clear'
 
 // Regression: after a cash-on-delivery order the buyer's cart came back.
@@ -42,4 +43,15 @@ describe('cart-clear mirrors the empty cart into the database cart', () => {
   it('stamps the clear so the provider can tell it apart from a first visit', () => {
     expect(handlerCode).toContain("localStorage.setItem('workflow_cart_cleared_at'")
   })
+
+  it('forgets the shipping method picked for the emptied cart', () => {
+    // Otherwise the next order silently pre-selects (and charges) a rate the
+    // buyer chose for a previous one instead of the cheapest.
+    expect(handlerCode).toContain(
+      `localStorage.removeItem('${RegionalPricing.SHIPPING_RATE_STORAGE_KEY}')`
+    )
+    expect(handlerCode).toContain(
+      `dispatchEvent(new CustomEvent('${RegionalPricing.SHIPPING_RATE_CHANGED_EVENT}'))`
+    )
+  })
 })

package/__tests__/cart-get-total-regional-pricing.test.ts

@@ -0,0 +1,166 @@
+/* tslint:disable:no-eval */
+import { cartGetTotal } from '../src/nodes/cart/cart-get-total'
+import { resolveHandlerEntryName } from '../src/nodes/types'
+
+/**
+ * `cart-get-total` is where the place-order workflow's money comes from, so on
+ * a store with shipping zones and tax jurisdictions it re-prices the basket AT
+ * SUBMIT — for the address on the checkout form at that moment, from the rows
+ * the provider displayed — with the same shared rule the provider uses.
+ *
+ * A store without the feature must come out exactly as before: no `regional`
+ * key, and the untouched single-rate fields.
+ */
+
+function evalHandler(code: string): any {
+  return eval('(' + code + ')')
+}
+
+const runHandler = async () => evalHandler(cartGetTotal.generateHandler())()
+
+function mount(storage: Record<string, unknown>, fields: Record<string, string>): void {
+  const store: Record<string, string> = {}
+  for (const key of Object.keys(storage)) {
+    const value = storage[key]
+    store[key] = typeof value === 'string' ? value : JSON.stringify(value)
+  }
+  ;(global as any).localStorage = {
+    getItem: (key: string) => (key in store ? store[key] : null),
+  }
+  ;(global as any).document = {
+    querySelector: (selector: string) => {
+      const match = /^\[name="([^"]+)"\]$/.exec(selector)
+      const name = match ? match[1] : ''
+      return name in fields ? { value: fields[name] } : null
+    },
+  }
+}
+
+afterEach(() => {
+  delete (global as any).localStorage
+  delete (global as any).document
+})
+
+const STORE = {
+  deliveryEnabled: true,
+  storePickupEnabled: true,
+  deliveryPrice: 5,
+  freeDeliveryEnabled: false,
+  freeDeliveryThreshold: 0,
+  defaultTaxRate: 20,
+  defaultTaxIncluded: false,
+}
+
+const ROWS = {
+  zones: [{ id: 'z1', name: 'Germany', countries: 'DE', cod_enabled: 'f', is_active: 't' }],
+  rates: [
+    { id: 'r1', zone_id: 'z1', name: 'Standard', rate_type: 'flat', price: '10.00' },
+    { id: 'r2', zone_id: 'z1', name: 'Express', rate_type: 'flat', price: '20.00', sort_order: 1 },
+  ],
+  taxRates: [{ id: 't1', country_code: 'DE', rate: '19', tax_mode: 'added', tax_shipping: true }],
+}
+
+const CART = [{ id: 'l1', productId: 'p1', price: 100, quantity: 1 }]
+
+const settingsWith = (regional: Record<string, unknown> | null) => ({
+  maxQuantityPerProduct: null,
+  deliveryConfig: { deliveryPrice: 5, freeDeliveryEnabled: false, freeDeliveryThreshold: 0 },
+  taxConfig: { storefrontTaxRate: 20 },
+  ...(regional ? { regional } : {}),
+})
+
+const REGIONAL = {
+  store: STORE,
+  currency: 'EUR',
+  countryCodes: { germany: 'DE', brazil: 'BR' },
+  rows: ROWS,
+}
+
+describe('cart-get-total — regional pricing', () => {
+  it('stays one function expression whose entry point still resolves', () => {
+    const source = cartGetTotal.generateHandler()
+    expect(source.trim().startsWith('async function cart_get_total()')).toBe(true)
+    expect(resolveHandlerEntryName(source, 'cart-get-total')).toBe('cart_get_total')
+  })
+
+  it('adds no regional figures for a store without the feature', async () => {
+    mount({ workflow_cart: CART, workflow_cart_settings: settingsWith(null) }, {})
+    const out = await runHandler()
+    expect(out.regional).toBeUndefined()
+    expect(out.tax).toBe(20)
+    expect(out.total).toBe(120)
+  })
+
+  it("prices the destination read off the form, with the buyer's chosen rate", async () => {
+    mount(
+      {
+        workflow_cart: CART,
+        workflow_cart_settings: settingsWith(REGIONAL),
+        workflow_shipping_rate: 'r2',
+      },
+      { billingCountry: 'Germany', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.subtotal).toBe(100)
+    expect(out.tax).toBe(19)
+    expect(out.total).toBe(119)
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      destination: { countryCode: 'DE', countryName: 'Germany' },
+      zoneName: 'Germany',
+      rateName: 'Express',
+      codAvailable: false,
+      goodsGross: 119,
+      shippingNet: 20,
+      shippingTax: 3.8,
+      shippingGross: 23.8,
+      taxRate: 19,
+      lines: [{ key: 'l1', productId: 'p1', unitGross: 119, taxRate: 19 }],
+    })
+  })
+
+  it('prices an address no zone lists at the store fee and default rate', async () => {
+    mount(
+      { workflow_cart: CART, workflow_cart_settings: settingsWith(REGIONAL) },
+      { billingCountry: 'Brazil', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      zoneName: '',
+      rateName: '',
+      codAvailable: true,
+      shippingNet: 5,
+      shippingGross: 5,
+    })
+    // Brazil has no tax row: the store default applies.
+    expect(out.tax).toBe(20)
+  })
+
+  it('prices the shipping address once its block is on the form', async () => {
+    mount(
+      { workflow_cart: CART, workflow_cart_settings: settingsWith(REGIONAL) },
+      { billingCountry: 'Germany', state: '', shippingCountry: 'Brazil', shippingState: '' }
+    )
+    const out = await runHandler()
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      zoneName: '',
+      shippingGross: 5,
+      destination: { countryCode: 'BR' },
+    })
+  })
+
+  it('falls back to the single-rate figures while the rows are still loading', async () => {
+    mount(
+      {
+        workflow_cart: CART,
+        workflow_cart_settings: settingsWith({ ...REGIONAL, rows: null }),
+      },
+      { billingCountry: 'Germany', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.tax).toBe(20)
+    expect(out.regional).toMatchObject({ status: 'ok', shippingNet: 5, taxRate: 20 })
+  })
+})

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__/continue-on-error.test.ts

@@ -0,0 +1,119 @@
+import { generateSharedRuntimeUtilsCode, generateServerSegmentAPIRoute } from '../src'
+import type { WorkflowSegment } from '../src/types'
+
+// A node marked `continueOnError` reports a failed RESULT ({ success: false } /
+// { error }) under its id instead of aborting the workflow, so the next
+// if-statement can read `success` and warn. The default is unchanged: a
+// failed result aborts, and so does a handler that throws — with or without
+// the flag, because every provider handler reports failure as a result.
+
+interface SharedUtils {
+  executeNodes: (
+    nodes: unknown[],
+    edges: unknown[],
+    context: Record<string, unknown>,
+    handlers: Record<string, unknown>,
+    workflowConfig: unknown,
+    callServerSegment: unknown,
+    executionId: string
+  ) => Promise<void>
+  continuesOnError: (node: unknown) => boolean
+}
+
+function loadSharedRuntime(): SharedUtils {
+  const src = generateSharedRuntimeUtilsCode()
+  const wrapper: { exports: Record<string, unknown> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', src)(wrapper, wrapper.exports)
+  return wrapper.exports as unknown as SharedUtils
+}
+
+const sendNode = (continueOnError?: boolean) => ({
+  id: 'send',
+  type: 'email-resend',
+  label: 'Send Shipped Email',
+  stepNumber: 1,
+  config: {
+    to: 'jane@example.com',
+    ...(continueOnError === undefined ? {} : { continueOnError }),
+  },
+})
+const afterNode = { id: 'after', type: 'toast-show', label: 'Toast', stepNumber: 2, config: {} }
+const edges = [{ id: 'e1', source: 'send', target: 'after' }]
+
+describe('continuesOnError — classification', () => {
+  it('opts in only on an explicit true', () => {
+    const utils = loadSharedRuntime()
+    expect(utils.continuesOnError(sendNode(true))).toBe(true)
+    expect(utils.continuesOnError(sendNode(false))).toBe(false)
+    expect(utils.continuesOnError(sendNode())).toBe(false)
+    expect(utils.continuesOnError({ id: 'x', type: 'toast-show' })).toBe(false)
+    expect(utils.continuesOnError(null)).toBe(false)
+  })
+})
+
+describe('executeNodes — a refused result on a continueOnError node', () => {
+  const refused = { id: '', success: false, error: 'Domain not verified' }
+
+  it('is published under the node id and the chain goes on', async () => {
+    const utils = loadSharedRuntime()
+    const ran: string[] = []
+    const handlers = {
+      'email-resend': async () => refused,
+      'toast-show': async () => {
+        ran.push('toast')
+        return { shown: true }
+      },
+    }
+    const context: Record<string, unknown> = {}
+    await utils.executeNodes([sendNode(true), afterNode], edges, context, handlers, {}, null, 'x1')
+    expect(context.send).toEqual(refused)
+    expect(ran).toEqual(['toast'])
+  })
+
+  it('still aborts the chain without the flag', async () => {
+    const utils = loadSharedRuntime()
+    const ran: string[] = []
+    const handlers = {
+      'email-resend': async () => refused,
+      'toast-show': async () => {
+        ran.push('toast')
+        return { shown: true }
+      },
+    }
+    const context: Record<string, unknown> = {}
+    await expect(
+      utils.executeNodes([sendNode(), afterNode], edges, context, handlers, {}, null, 'x2')
+    ).rejects.toThrow('Domain not verified')
+    expect(ran).toEqual([])
+  })
+
+  it('does not swallow a handler that throws', async () => {
+    const utils = loadSharedRuntime()
+    const handlers = {
+      'email-resend': async () => {
+        throw new Error('network down')
+      },
+      'toast-show': async () => ({ shown: true }),
+    }
+    await expect(
+      utils.executeNodes([sendNode(true), afterNode], edges, {}, handlers, {}, null, 'x3')
+    ).rejects.toThrow('network down')
+  })
+})
+
+describe('generated server segment route', () => {
+  const segment: WorkflowSegment = {
+    id: 'server-1',
+    env: 'server',
+    nodeIds: ['send'],
+    nodes: [{ ...sendNode(true), executionEnv: 'server' }],
+    edges: [],
+  }
+  it('gates its fatal-result check on the same predicate', () => {
+    const route = generateServerSegmentAPIRoute(segment, 'Send Shipped Email')
+    expect(route).toContain(
+      'if (utils.isFatalNodeResult(result) && !utils.continuesOnError(node)) {'
+    )
+  })
+})