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

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

@@ -0,0 +1,45 @@
+import { EmailLocaleConfig, generateEmailLocaleModuleCode } from '../../src/email-locale'
+import { generateSignedInDestinationCode } from '../../src/auth-return/signed-in-destination-code'
+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
+}
+
+/**
+ * The runtime's `signedInDestination`, over the given `localizeHref`. It reads
+ * `window` when called, so a test can install its browser stub afterwards.
+ */
+const loadSignedInDestination = (localizeHref: unknown): unknown =>
+  // eslint-disable-next-line no-new-func
+  new Function('localizeHref', `${generateSignedInDestinationCode()}\nreturn signedInDestination`)(
+    localizeHref
+  )
+
+/** 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>
+  const localeHelpers = loadEmailLocaleModule(config)
+  globalRef[WORKFLOW_UTILS_ALIAS] = {
+    ...localeHelpers,
+    signedInDestination: loadSignedInDestination(localeHelpers.localizeHref),
+  }
+  return () => {
+    delete globalRef[WORKFLOW_UTILS_ALIAS]
+  }
+}

package/__tests__/_helpers/fake-fetch.ts

@@ -0,0 +1,96 @@
+export interface FetchCall {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body: string
+  /** The body parsed as JSON, or null when it is not JSON. */
+  json: any
+}
+
+export interface FakeAnswer {
+  status?: number
+  body?: unknown
+}
+
+export type FetchResponder = (call: FetchCall) => FakeAnswer
+
+/** Process-wide caches the drivers keep, cleared around every fake-fetch run. */
+const DRIVER_CACHES = ['__paypalBaseUrlCache', '__coingateBaseUrlCache', '__squareBaseUrlCache']
+
+/**
+ * Runs `run` with `globalThis.fetch` answered by `respond` (status 200 unless
+ * it says otherwise), recording every call, then restores fetch and clears the
+ * drivers' environment caches so no test leaks into the next.
+ */
+export const withFetch = async <T>(
+  respond: FetchResponder,
+  run: (calls: FetchCall[]) => Promise<T>
+): Promise<T> => {
+  const calls: FetchCall[] = []
+  const scope = globalThis as Record<string, unknown>
+  const previous = scope.fetch
+  scope.fetch = async (
+    url: string,
+    init: { method?: string; headers?: Record<string, string>; body?: string } = {}
+  ) => {
+    const body = typeof init.body === 'string' ? init.body : ''
+    let json: any = null
+    try {
+      json = body ? JSON.parse(body) : null
+    } catch (_e) {
+      json = null
+    }
+    const call: FetchCall = {
+      url,
+      method: init.method || 'GET',
+      headers: init.headers || {},
+      body,
+      json,
+    }
+    calls.push(call)
+    const answer = respond(call)
+    const status = answer.status ?? 200
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      headers: new Map([['content-type', 'application/json']]),
+      json: async () => answer.body,
+      text: async () => JSON.stringify(answer.body ?? null),
+    }
+  }
+  try {
+    return await run(calls)
+  } finally {
+    scope.fetch = previous
+    DRIVER_CACHES.forEach((key) => {
+      delete scope[key]
+    })
+  }
+}
+
+/** Runs `run` with `env` set (an `undefined` value removes the variable), then restores. */
+export const withEnv = async <T>(
+  env: Record<string, string | undefined>,
+  run: () => Promise<T>
+): Promise<T> => {
+  const saved: Record<string, string | undefined> = {}
+  for (const key of Object.keys(env)) {
+    saved[key] = process.env[key]
+    if (env[key] === undefined) {
+      delete process.env[key]
+    } else {
+      process.env[key] = env[key]
+    }
+  }
+  try {
+    return await run()
+  } finally {
+    for (const key of Object.keys(env)) {
+      if (saved[key] === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = saved[key]
+      }
+    }
+  }
+}

package/__tests__/_helpers/fake-stripe.ts

@@ -0,0 +1,52 @@
+export interface StripeCall {
+  method: string
+  params: unknown
+  options?: unknown
+}
+
+/** What each fake SDK method answers; a function may throw to act as a refusal. */
+export type StripeScript = Record<string, (params: unknown, options?: unknown) => unknown>
+
+/**
+ * A recording stand-in for the `stripe` package: every method the store's
+ * Stripe driver calls, each recorded as `'<resource>.<method>'` and answered
+ * from `script` (or with an empty object).
+ */
+export const createFakeStripe = (
+  script: StripeScript = {}
+): { FakeStripe: unknown; calls: StripeCall[] } => {
+  const calls: StripeCall[] = []
+  const method = (name: string) => async (params: unknown, options?: unknown) => {
+    calls.push(options === undefined ? { method: name, params } : { method: name, params, options })
+    const answer = script[name]
+    return answer ? answer(params, options) : {}
+  }
+  function FakeStripe(this: Record<string, unknown>, key: string) {
+    this.key = key
+    this.checkout = {
+      sessions: {
+        create: method('checkout.sessions.create'),
+        retrieve: method('checkout.sessions.retrieve'),
+        expire: method('checkout.sessions.expire'),
+        list: method('checkout.sessions.list'),
+      },
+    }
+    this.coupons = { create: method('coupons.create') }
+    this.paymentIntents = { retrieve: method('paymentIntents.retrieve') }
+    this.invoices = { retrieve: method('invoices.retrieve') }
+    this.refunds = { create: method('refunds.create') }
+    this.subscriptions = {
+      retrieve: method('subscriptions.retrieve'),
+      cancel: method('subscriptions.cancel'),
+      update: method('subscriptions.update'),
+    }
+    this.billingPortal = {
+      sessions: { create: method('billingPortal.sessions.create') },
+      configurations: {
+        list: method('billingPortal.configurations.list'),
+        create: method('billingPortal.configurations.create'),
+      },
+    }
+  }
+  return { FakeStripe, calls }
+}

package/__tests__/_helpers/load-handler.ts

@@ -1,4 +1,6 @@
 import { nodeRegistry } from '../../src'
+import { PAYMENT_DRIVER_NODE_TYPES } from '../../src/payments/payment-drivers-scope'
+import { loadPaymentDrivers, PaymentDriverRegistry } from './load-payment-drivers'
 
 // Shared loader for re-evaluating a runtime handler in the test process.
 //
@@ -78,15 +80,32 @@ const handlerSymbolFor = (nodeType: string): string => nodeType.replace(/-/g, '_
  * Throws if the type isn't registered. The returned function captures the
  * eval scope, so `__awaiter`/`__generator` references inside it resolve to
  * the helpers piped in here.
+ *
+ * A payment node reaches its provider through `__paymentDrivers`, which a
+ * generated route binds before its handlers: it is bound here to the store's
+ * emitted drivers (every provider, a missing Stripe SDK) unless a test hands
+ * its own registry.
  */
-export const loadHandler = (nodeType: string): HandlerFn => {
+export const loadHandler = (
+  nodeType: string,
+  options: { paymentDrivers?: PaymentDriverRegistry; cartPricingSettings?: unknown } = {}
+): HandlerFn => {
   const generator = nodeRegistry[nodeType]
   if (!generator) {
     throw new Error(`No handler registered for node type: ${nodeType}`)
   }
   const src = generator.generateHandler()
   const symbol = handlerSymbolFor(nodeType)
+  const paymentDrivers =
+    options.paymentDrivers ||
+    (PAYMENT_DRIVER_NODE_TYPES.has(nodeType) ? loadPaymentDrivers() : undefined)
   // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const factory = new Function(`${TS_EMIT_HELPERS}\n${src}\nreturn ${symbol};`)
-  return factory() as HandlerFn
+  // `__cartPricingSettings` stands in for the route preamble's require of
+  // `utils/ecommerce/cart-pricing-settings` (cart-pricing-preamble.ts).
+  const factory = new Function(
+    '__paymentDrivers',
+    '__cartPricingSettings',
+    `${TS_EMIT_HELPERS}\n${src}\nreturn ${symbol};`
+  )
+  return factory(paymentDrivers, options.cartPricingSettings) as HandlerFn
 }

package/__tests__/_helpers/load-invoice-route.ts

@@ -0,0 +1,75 @@
+/* tslint:disable:function-constructor */
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+import { generateInvoiceAssemblyCode } from '../../src/invoice/invoice-assembly-code'
+
+/**
+ * Evaluates EMITTED CommonJS source (a generated route or util) as a real
+ * module, resolving its `require` calls through `requireFn`.
+ */
+export function evaluateEmittedModule<T>(code: string, requireFn: NodeRequire): T {
+  const factory = new Function(
+    'require',
+    'module',
+    'exports',
+    `${code}; return module.exports;`
+  ) as (req: NodeRequire, mod: { exports: unknown }, exp: unknown) => T
+  const moduleObject = { exports: {} as unknown }
+  return factory(requireFn, moduleObject, moduleObject.exports)
+}
+
+export interface InvoiceRouteStubs {
+  /** Stands in for `utils/invoices/data-access.js`. */
+  dataAccess: unknown
+  /** Stands in for `utils/invoices/pdf-generator.js`. */
+  pdfGenerator: unknown
+  /** Any other module id the code under test requires, e.g. `next-auth/jwt`. */
+  modules?: Record<string, unknown>
+}
+
+/**
+ * The `require` an emitted invoice route sees: the two stubs, the REAL emitted
+ * `utils/invoices/invoice-assembly.js` built from `settings` (wired to the same
+ * stubs), a no-op `pg`, and Node's own resolution for everything else.
+ */
+export function createInvoiceRouteRequire(
+  settings: UIDLInvoiceSettings,
+  stubs: InvoiceRouteStubs
+): NodeRequire {
+  let assembly: unknown = null
+  const requireFn = ((id: string) => {
+    if (id.indexOf('data-access') !== -1) {
+      return stubs.dataAccess
+    }
+    if (id.indexOf('pdf-generator') !== -1) {
+      return stubs.pdfGenerator
+    }
+    if (id.indexOf('invoice-assembly') !== -1) {
+      if (!assembly) {
+        assembly = evaluateEmittedModule(generateInvoiceAssemblyCode(settings), requireFn)
+      }
+      return assembly
+    }
+    if (stubs.modules && id in stubs.modules) {
+      return stubs.modules[id]
+    }
+    if (id === 'pg') {
+      return { Client: class {} }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(id)
+  }) as unknown as NodeRequire
+  return requireFn
+}
+
+/**
+ * The app secret the invoice routes' own server callers present (the invoice
+ * node and the payment webhooks send it as `x-internal-data-secret`). Tests
+ * that play such a caller set it as NEXTAUTH_SECRET and send it.
+ */
+export const INVOICE_TEST_APP_SECRET = 'invoice-test-app-secret'
+
+/** Headers of a request from this deployment's own server code. */
+export const serverCallHeaders = (): Record<string, string> => ({
+  host: 'localhost:3000',
+  'x-internal-data-secret': INVOICE_TEST_APP_SECRET,
+})

package/__tests__/_helpers/load-payment-drivers.ts

@@ -0,0 +1,69 @@
+import { evaluateEmittedModule } from './load-invoice-route'
+import { generatePaymentCoreCode } from '../../src/payments/payment-core-code'
+import { generatePaymentRegistryCode } from '../../src/payments/payment-registry-code'
+import { PAYMENT_DRIVER_CODE } from '../../src/payments/payment-driver-code-map'
+import { PAYMENT_DRIVER_IDS, PaymentDriverId } from '../../src/payments/payment-drivers-scope'
+
+export interface PaymentDriverRegistry {
+  ids: string[]
+  core: any
+  get(providerId: string): any
+}
+
+export interface LoadPaymentDriversOptions {
+  /** The providers the store carries; every driver by default. */
+  ids?: PaymentDriverId[]
+  /**
+   * What the Stripe driver's `require('stripe')` returns — a fake SDK
+   * constructor. Absent, a fake a test put on
+   * `globalThis.__non_webpack_require__` answers (resolved at call time, so a
+   * test can install it after loading), else the require throws exactly as it
+   * would in a store whose `stripe` package is missing.
+   */
+  stripe?: unknown
+}
+
+/**
+ * The store's `utils/payments` registry, evaluated from the EMITTED module
+ * sources exactly as a generated route requires it.
+ */
+export const loadPaymentDrivers = (
+  options: LoadPaymentDriversOptions = {}
+): PaymentDriverRegistry => {
+  const ids = options.ids || [...PAYMENT_DRIVER_IDS]
+  const driverRequire = ((id: string) => {
+    if (id === 'stripe') {
+      if (options.stripe) {
+        return options.stripe
+      }
+      const injected = (globalThis as { __non_webpack_require__?: (name: string) => unknown })
+        .__non_webpack_require__
+      if (typeof injected === 'function') {
+        return injected('stripe')
+      }
+      throw new Error("Cannot find module 'stripe'")
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(id)
+  }) as unknown as NodeRequire
+  const core = evaluateEmittedModule(generatePaymentCoreCode(), driverRequire)
+  const drivers: Record<string, unknown> = {}
+  for (const id of ids) {
+    drivers[id] = evaluateEmittedModule(PAYMENT_DRIVER_CODE[id](), driverRequire)
+  }
+  const registryRequire = ((id: string) => {
+    if (id === './core') {
+      return core
+    }
+    const driver = /^\.\/drivers\/([a-z]+)$/.exec(id)
+    if (driver) {
+      return drivers[driver[1]]
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(id)
+  }) as unknown as NodeRequire
+  return evaluateEmittedModule<PaymentDriverRegistry>(
+    generatePaymentRegistryCode(ids),
+    registryRequire
+  )
+}

package/__tests__/_helpers/load-server-runtime.ts

@@ -0,0 +1,33 @@
+import * as crypto from 'crypto'
+import { generateSharedRuntimeUtilsCode } from '../../src/executor-generator'
+import { generateServerRuntimeCode } from '../../src/server-runtime-code'
+
+/**
+ * The generated `utils/workflows/server-runtime.js` exactly as a route loads
+ * it: the shared runtime utilities plus the server-only signed hand-off,
+ * internal-call token and trusted base URL.
+ */
+export function loadServerRuntime(): Record<string, any> {
+  const shared: { exports: Record<string, unknown> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', generateSharedRuntimeUtilsCode())(shared, shared.exports)
+  const server: { exports: Record<string, any> } = { exports: {} }
+  const requireFn = (id: string): unknown => {
+    if (id === 'crypto') {
+      return crypto
+    }
+    if (id === './runtime-utils') {
+      return shared.exports
+    }
+    throw new Error(`Unexpected require in server runtime: ${id}`)
+  }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', 'process', 'Buffer', generateServerRuntimeCode())(
+    server,
+    server.exports,
+    requireFn,
+    process,
+    Buffer
+  )
+  return server.exports
+}

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

@@ -1,5 +1,5 @@
 import { UIDLAuthentication } from '@teleporthq/teleport-types'
-import { generateMiddlewareFile } from '../../src/auth-generator'
+import { generateMiddlewareFile, MiddlewareOptions } from '../../src/auth-generator'
 
 /**
  * Loads the middleware `generateMiddlewareFile` emits and runs it against a
@@ -25,10 +25,35 @@ export interface MiddlewareSessionUser {
   role?: string
 }
 
+/**
+ * What the stubbed `/api/auth/subscriber-access` answers: a body, a non-2xx
+ * status, or a thrown network error. Omitted, the route answers "not entitled".
+ */
+export type SubscriberAccessStub =
+  | { entitled: boolean; redirectTo?: string }
+  | { status: number }
+  | { throws: true }
+
+export interface MiddlewareFetchCall {
+  url: string
+  cookie: string
+}
+
 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
+  /** The subscriber-access route's answer for this request. */
+  subscriberAccess?: SubscriberAccessStub
+  /** Receives every `fetch` the middleware makes, in order. */
+  fetchCalls?: MiddlewareFetchCall[]
 }
 
 interface RawMiddlewareResult {
@@ -58,7 +83,15 @@ const stripModuleSyntax = (code: string): string =>
  */
 export const extractProtectedRoutes = (
   code: string
-): Record<string, { requiresAuth: boolean; allowedRoles: string[] }> => {
+): Record<
+  string,
+  {
+    requiresAuth: boolean
+    allowedRoles: string[]
+    requiresSubscription?: boolean
+    subscriptionProductIds?: string[]
+  }
+> => {
   // Non-greedy up to the first `};`. `JSON.stringify(…, null, 2)` never emits
   // that sequence inside the object, so the first hit is the real terminator —
   // and the empty-map case (`= {};`) is covered by the same pattern.
@@ -90,12 +123,15 @@ const NEXT_RESPONSE_STUB = {
  * Compiles the middleware once for an auth config. Reuse the returned function
  * across requests in a test to avoid re-generating the file per assertion.
  */
-export const compileGeneratedMiddleware = (auth: UIDLAuthentication) => {
+export const compileGeneratedMiddleware = (
+  auth: UIDLAuthentication,
+  middlewareOptions: MiddlewareOptions = {}
+) => {
   const factory = new Function(
     'NextResponse',
     'getToken',
     'fetch',
-    `${stripModuleSyntax(generateMiddlewareFile(auth))}; return middleware;`
+    `${stripModuleSyntax(generateMiddlewareFile(auth, middlewareOptions))}; return middleware;`
   ) as unknown as MiddlewareFactory
 
   return async (
@@ -105,17 +141,31 @@ export const compileGeneratedMiddleware = (auth: UIDLAuthentication) => {
     const origin = options.origin || 'https://shop.test'
     const sessionUser = options.sessionUser ?? null
     const cookieHeader = sessionUser ? 'next-auth.session-token=stub' : ''
-
-    const fetchImpl = async () => ({
-      ok: true,
-      json: async () => ({ user: sessionUser }),
-    })
+    const subscriberAccess: SubscriberAccessStub = options.subscriberAccess ?? { entitled: false }
+
+    const fetchImpl = async (url: string, init?: { headers?: { cookie?: string } }) => {
+      if (options.fetchCalls) {
+        options.fetchCalls.push({ url: String(url), cookie: init?.headers?.cookie ?? '' })
+      }
+      if (String(url).indexOf('/api/auth/subscriber-access') === -1) {
+        return { ok: true, json: async () => ({ user: sessionUser }) }
+      }
+      if ('throws' in subscriberAccess) {
+        throw new Error('network down')
+      }
+      if ('status' in subscriberAccess) {
+        return { ok: false, status: subscriberAccess.status, json: async () => ({}) }
+      }
+      return { ok: true, json: async () => subscriberAccess }
+    }
 
     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-hydration-target.test.ts

@@ -0,0 +1,39 @@
+import { UIDLStateDefinition } from '@teleporthq/teleport-types'
+import { findFormStateKeyForHydration } from '../src/admin-form-hydration'
+
+const objectState = (defaultValue: Record<string, unknown>): UIDLStateDefinition => ({
+  type: 'object',
+  defaultValue,
+})
+
+describe('findFormStateKeyForHydration', () => {
+  it('copies the loaded row into the selected-item form, whatever order the states arrive in', () => {
+    // The editor stores a page's states by id, so the product update page's
+    // options editor states can come before its form.
+    const states: Record<string, UIDLStateDefinition> = {
+      productsUpdateOptionsPriceBy: objectState({ mode: 'fixed', open: 'false' }),
+      productsUpdateOptionsMeta: objectState({ isEmpty: 'false' }),
+      productsSelectedItemData: objectState({ name: '', price: '' }),
+      productsSelectedItemId: { type: 'string', defaultValue: '' },
+      productsUpdateOptionsEdit: objectState({ label: '' }),
+    }
+    expect(findFormStateKeyForHydration(states)).toBe('productsSelectedItemData')
+  })
+
+  it('keeps the only object state of a page without a selected-item form', () => {
+    const states: Record<string, UIDLStateDefinition> = {
+      isOpen: { type: 'boolean', defaultValue: false },
+      initialAccountFormData: objectState({ first_name: '' }),
+    }
+    expect(findFormStateKeyForHydration(states)).toBe('initialAccountFormData')
+  })
+
+  it('never picks an empty object, an array or a missing state', () => {
+    expect(
+      findFormStateKeyForHydration({
+        rows: { type: 'array', defaultValue: [] },
+        emptyObject: objectState({}),
+      })
+    ).toBeUndefined()
+  })
+})