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

package/src/payments/index.ts

@@ -0,0 +1,204 @@
+import {
+  FileType,
+  ProjectPluginStructure,
+  ProjectUIDL,
+  UIDLWorkflows,
+} from '@teleporthq/teleport-types'
+import { generatePaymentCoreCode } from './payment-core-code'
+import { generatePaymentRegistryCode } from './payment-registry-code'
+import { PAYMENT_DRIVER_CODE } from './payment-driver-code-map'
+import {
+  DEFAULT_PAYMENT_DRIVER_IDS,
+  DeclaredPaymentCredentials,
+  PAYMENT_DRIVERS_DIRECTORY,
+  PAYMENT_DRIVERS_FILE_KEY,
+  PAYMENT_DRIVERS_PATH,
+  PAYMENT_DRIVER_IDS,
+  PAYMENT_DRIVER_SIGNATURE_ALGORITHM,
+  PaymentDriverId,
+  isPaymentDriverId,
+  usesPaymentDriverNode,
+} from './payment-drivers-scope'
+
+/** The Stripe SDK the Stripe driver requires; every other driver talks over fetch. */
+const STRIPE_SDK_VERSION = '^14.0.0'
+
+/**
+ * The provider a payment webhook verifies through: the one its trigger names
+ * with the `payment-driver` scheme, or — for a webhook stored before that
+ * scheme existed, possibly with verification off, or a `payment-driver`
+ * trigger that names none — the provider its `webhooks/<id>-payment` path
+ * belongs to. Either way a payment webhook is ALWAYS verified: an unverified
+ * one would mark orders paid on any request.
+ *
+ * Null on the `payment-driver` scheme means no driver can verify the
+ * webhook (a provider without one, or none named on another path): its
+ * route must refuse every delivery.
+ */
+export const readWebhookPaymentProvider = (webhookConfig: unknown): PaymentDriverId | null => {
+  const config = (webhookConfig || {}) as {
+    signatureAlgorithm?: unknown
+    paymentProvider?: unknown
+    urlPath?: unknown
+  }
+  const named =
+    config.signatureAlgorithm === PAYMENT_DRIVER_SIGNATURE_ALGORITHM
+      ? String(config.paymentProvider || '').trim()
+      : ''
+  const provider = (
+    named ||
+    (/(?:^|\/)webhooks\/([a-z]+)-payment\/?$/.exec(String(config.urlPath || '')) || [])[1] ||
+    ''
+  ).toLowerCase()
+  return isPaymentDriverId(provider) ? provider : null
+}
+
+/**
+ * Whether a webhook takes payment events: a provider's own route, or any
+ * route on the `payment-driver` scheme. Such a route is always verified, and
+ * runs one delivery of a body at a time (`webhook-delivery-lease`).
+ */
+export const isPaymentWebhookConfig = (webhookConfig: unknown): boolean =>
+  readWebhookPaymentProvider(webhookConfig) !== null ||
+  ((webhookConfig || {}) as { signatureAlgorithm?: unknown }).signatureAlgorithm ===
+    PAYMENT_DRIVER_SIGNATURE_ALGORITHM
+
+/**
+ * The providers this store needs a driver for: every provider its checkout
+ * offers, every provider a payment webhook verifies through, and Stripe +
+ * PayPal whenever a payment node runs at all (a workflow that names no
+ * provider has always meant Stripe). Empty when the store takes no online
+ * payment, in which case no driver module is written.
+ */
+export const resolveStorePaymentDriverIds = (
+  uidl: Pick<ProjectUIDL, 'ecommerceSettings'> & { workflows?: UIDLWorkflows },
+  usedNodeTypes: Iterable<string>
+): PaymentDriverId[] => {
+  const wanted = new Set<PaymentDriverId>()
+  for (const provider of uidl.ecommerceSettings?.paymentProviders || []) {
+    const id = String(provider?.type || '').toLowerCase()
+    if (isPaymentDriverId(id)) {
+      wanted.add(id)
+    }
+  }
+  for (const workflow of Object.values(uidl.workflows?.workflows || {})) {
+    const id = readWebhookPaymentProvider((workflow as { webhookConfig?: unknown }).webhookConfig)
+    if (id) {
+      wanted.add(id)
+    }
+  }
+  if (wanted.size > 0 || usesPaymentDriverNode(usedNodeTypes)) {
+    DEFAULT_PAYMENT_DRIVER_IDS.forEach((id) => wanted.add(id))
+  }
+  return PAYMENT_DRIVER_IDS.filter((id) => wanted.has(id))
+}
+
+/** An environment variable name, the only shape a declared secret may take. */
+const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+/**
+ * The secret the merchant saved each live provider credential under, as the
+ * editor exported it (`ecommerceSettings.paymentProviders[].credentials`).
+ */
+export const readDeclaredPaymentCredentials = (
+  uidl: Pick<ProjectUIDL, 'ecommerceSettings'> | undefined
+): DeclaredPaymentCredentials => {
+  const declared: DeclaredPaymentCredentials = {}
+  for (const provider of uidl?.ecommerceSettings?.paymentProviders || []) {
+    const id = String(provider?.type || '').toLowerCase()
+    if (!isPaymentDriverId(id)) {
+      continue
+    }
+    const fields: Record<string, string> = {}
+    for (const [field, secretName] of Object.entries(provider.credentials || {})) {
+      if (typeof secretName === 'string' && ENV_NAME_PATTERN.test(secretName)) {
+        fields[field] = secretName
+      }
+    }
+    if (Object.keys(fields).length > 0) {
+      declared[id] = fields
+    }
+  }
+  return declared
+}
+
+/**
+ * Writes `utils/payments/` — core, registry and one driver per provider —
+ * once, whichever emitter asks first. Every emitter of code that reaches
+ * `__paymentDrivers` calls this with the store's providers.
+ */
+export const ensurePaymentDriversModule = (
+  structure: ProjectPluginStructure,
+  driverIds: readonly PaymentDriverId[]
+): void => {
+  const { files, dependencies } = structure
+  if (driverIds.length === 0 || files.has(PAYMENT_DRIVERS_FILE_KEY)) {
+    return
+  }
+  const declared = readDeclaredPaymentCredentials(structure.uidl)
+  files.set(PAYMENT_DRIVERS_FILE_KEY, {
+    path: PAYMENT_DRIVERS_PATH,
+    files: [
+      { name: 'index', fileType: FileType.JS, content: generatePaymentRegistryCode(driverIds) },
+      { name: 'core', fileType: FileType.JS, content: generatePaymentCoreCode(declared) },
+    ],
+  })
+  files.set(`${PAYMENT_DRIVERS_FILE_KEY}-drivers`, {
+    path: PAYMENT_DRIVERS_DIRECTORY,
+    files: driverIds.map((id) => ({
+      name: id,
+      fileType: FileType.JS,
+      content: PAYMENT_DRIVER_CODE[id](),
+    })),
+  })
+  if (driverIds.includes('stripe') && !dependencies.stripe) {
+    dependencies.stripe = STRIPE_SDK_VERSION
+  }
+}
+
+/**
+ * The environment variable a provider credential is deployed under — the
+ * editor's field key in upper snake case after the provider id
+ * (`stripe` + `secretKey` → `STRIPE_SECRET_KEY`), which is the first name
+ * each driver reads (`core.credential`).
+ */
+export const paymentCredentialEnvName = (providerId: string, field: string): string =>
+  `${providerId.toUpperCase()}_${field.replace(/([A-Z])/g, '_$1').toUpperCase()}`
+
+/**
+ * Declares every credential the merchant saved for a store provider in the
+ * project's `.env`, as a placeholder the deploy resolves to that exact stored
+ * secret (`MOLLIE_API_KEY=teleporthq.secrets.<stored name>`) — never by a
+ * guess at which secret looks like it. A line something else already filled
+ * is left alone.
+ */
+export const declarePaymentCredentialEnv = (uidl: ProjectUIDL): void => {
+  const declared = readDeclaredPaymentCredentials(uidl)
+  for (const [id, fields] of Object.entries(declared)) {
+    for (const [field, secretName] of Object.entries(fields || {})) {
+      if (!uidl.globals.env) {
+        uidl.globals.env = {}
+      }
+      const envName = paymentCredentialEnvName(id, field)
+      if (!uidl.globals.env[envName]) {
+        uidl.globals.env[envName] = `teleporthq.secrets.${secretName}`
+      }
+    }
+  }
+}
+
+/**
+ * The binding a route needs when it runs a payment node or verifies a
+ * payment webhook: a guarded require, so a route evaluated where the module
+ * is absent (a test harness, a stub `require`) still loads and every payment
+ * call answers "not supported" instead of crashing the route. Empty for every
+ * other route, which keeps those byte-identical.
+ */
+export const generatePaymentDriversPreamble = (needed: boolean, relativePrefix: string): string => {
+  if (!needed) {
+    return ''
+  }
+  return `var __paymentDrivers = null;
+try { __paymentDrivers = require('${relativePrefix}/utils/payments'); } catch (_e) { __paymentDrivers = null; }
+`
+}

package/src/payments/payment-core-code.ts

@@ -0,0 +1,421 @@
+import type { DeclaredPaymentCredentials } from './payment-drivers-scope'
+
+/**
+ * Emits `utils/payments/core.js` — what every provider driver in the store
+ * shares: credentials out of the environment, money in each provider's unit,
+ * JSON requests that never throw on a provider's HTML error page, the few
+ * crypto primitives webhook verification needs, and form encoding.
+ *
+ * `declared` names the secret the editor saved each credential under (names,
+ * never values): the one a driver reads before any guess by name.
+ *
+ * A STRING, like every module this package writes into a generated app: a
+ * minifier never rewrites a string literal, so what ships is exactly what the
+ * tests execute (see `commerce-tracking.ts` for what `fn.toString()` did).
+ *
+ * Contract: nothing here throws except `request` on a network failure, which a
+ * driver's own try/catch turns into its `error` answer.
+ */
+export const generatePaymentCoreCode = (
+  declared: DeclaredPaymentCredentials = {}
+): string => `'use strict';
+/**
+ * Payment core shared by every provider driver of this store.
+ * Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+var crypto = require('crypto');
+
+// Currencies whose smallest unit IS the major unit, and those with three
+// decimals (the ISO 4217 exponents every provider here follows unless its
+// driver says otherwise).
+var ZERO_DECIMAL_CURRENCIES = ['BIF', 'CLP', 'DJF', 'GNF', 'JPY', 'KMF', 'KRW', 'MGA', 'PYG', 'RWF', 'UGX', 'VND', 'VUV', 'XAF', 'XOF', 'XPF'];
+var THREE_DECIMAL_CURRENCIES = ['BHD', 'IQD', 'JOD', 'KWD', 'LYD', 'OMR', 'TND'];
+
+// A deploy resolves \`teleporthq.secrets.<name>\` to that secret's value; the
+// project run anywhere else (a download, a local build) still holds the
+// placeholder itself, which is no credential.
+var UNRESOLVED_SECRET_PREFIX = 'teleporthq.secrets.';
+
+/** A variable's value when it holds one: set, non-empty and no unresolved placeholder. */
+function usable(value) {
+  var text = value == null ? '' : String(value);
+  return text.length > 0 && text.indexOf(UNRESOLVED_SECRET_PREFIX) !== 0 ? text : '';
+}
+
+/**
+ * The first usable variable among \`names\`, else the first whose name
+ * starts with \`prefix\`: the editor stores a credential under a
+ * CONFIGURATION_* name that a second save may number (…_KEY2).
+ */
+function env(names, prefix) {
+  var values = process.env;
+  for (var i = 0; i < names.length; i++) {
+    var value = names[i] ? usable(values[names[i]]) : '';
+    if (value) {
+      return value;
+    }
+  }
+  if (prefix) {
+    var keys = Object.keys(values);
+    for (var k = 0; k < keys.length; k++) {
+      var candidate = keys[k].indexOf(prefix) === 0 ? usable(values[keys[k]]) : '';
+      if (candidate) {
+        return candidate;
+      }
+    }
+  }
+  return '';
+}
+
+/** "clientSecret" -> "CLIENT_SECRET", the editor's secret naming. */
+function snakeUpper(field) {
+  return String(field || '').replace(/([A-Z])/g, '_$1').toUpperCase();
+}
+
+// The secret the editor saved each credential under, by provider and field.
+// A re-typed key is saved under a NEW, numbered name (…_KEY_ID1), and the
+// unnumbered secret it replaced keeps the OLD value.
+var DECLARED_CREDENTIALS = ${JSON.stringify(declared)};
+
+function declaredCredential(providerId, field) {
+  var fields = Object.prototype.hasOwnProperty.call(DECLARED_CREDENTIALS, providerId) ? DECLARED_CREDENTIALS[providerId] : null;
+  return fields && Object.prototype.hasOwnProperty.call(fields, field) ? fields[field] : '';
+}
+
+/**
+ * A provider credential by its field name in the editor's provider form:
+ * PROVIDER_FIELD (what a deploy writes), then the secret the editor saved it
+ * under. A store exported before the editor named its secrets reads
+ * CONFIGURATION_PROVIDER_FIELD, then any numbered variant of it.
+ */
+function credential(providerId, field, extraNames) {
+  var canonical = String(providerId).toUpperCase() + '_' + snakeUpper(field);
+  var declared = declaredCredential(providerId, field);
+  if (declared) {
+    return env([canonical, declared]);
+  }
+  var configured = 'CONFIGURATION_' + canonical;
+  return env([canonical, configured].concat(extraNames || []), configured);
+}
+
+function minorFactor(currency) {
+  var upper = String(currency || '').toUpperCase();
+  if (ZERO_DECIMAL_CURRENCIES.indexOf(upper) >= 0) {
+    return 1;
+  }
+  if (THREE_DECIMAL_CURRENCIES.indexOf(upper) >= 0) {
+    return 1000;
+  }
+  return 100;
+}
+
+/** A major-unit amount as the provider's smallest integer unit; 0 for anything not positive. */
+function toMinor(major, currency) {
+  var amount = Number(major);
+  if (!isFinite(amount) || amount <= 0) {
+    return 0;
+  }
+  return Math.round(amount * minorFactor(currency));
+}
+
+function fromMinor(minor, currency) {
+  var amount = Number(minor);
+  if (!isFinite(amount)) {
+    return 0;
+  }
+  return amount / minorFactor(currency);
+}
+
+/** A major-unit amount as a decimal string with the currency's exact number of decimals. */
+function decimalString(major, currency) {
+  var factor = minorFactor(currency);
+  var digits = factor === 1 ? 0 : factor === 1000 ? 3 : 2;
+  return (toMinor(major, currency) / factor).toFixed(digits);
+}
+
+/** A provider's JSON answer, or null for an empty or HTML body. */
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch (_e) {
+    return null;
+  }
+}
+
+/** One provider call: \`{ ok, status, data }\`. Throws only when the network does. */
+async function request(url, init) {
+  var response = await fetch(url, init || {});
+  var data = await readJson(response);
+  return { ok: !!response.ok, status: response.status, data: data };
+}
+
+/** A root-relative URL made absolute against the request's origin; anything absolute untouched. */
+function absoluteUrl(url, baseUrl) {
+  var value = String(url || '');
+  if (!value || /^https?:\\/\\//i.test(value) || !baseUrl) {
+    return value;
+  }
+  var base = String(baseUrl).replace(/\\/+$/, '');
+  return value.charAt(0) === '/' ? base + value : base + '/' + value;
+}
+
+/** Where a provider that takes its webhook URL per payment sends this store's events. */
+function webhookUrl(baseUrl, providerId) {
+  return absoluteUrl('/api/webhooks/' + providerId + '-payment', baseUrl);
+}
+
+/** A request header by name, whatever case the platform delivered it in. */
+function header(headers, name) {
+  if (!headers) {
+    return '';
+  }
+  var wanted = String(name).toLowerCase();
+  var keys = Object.keys(headers);
+  for (var i = 0; i < keys.length; i++) {
+    if (keys[i].toLowerCase() === wanted) {
+      var value = headers[keys[i]];
+      return Array.isArray(value) ? String(value[0] || '') : String(value == null ? '' : value);
+    }
+  }
+  return '';
+}
+
+function hmac(algorithm, key, payload, encoding) {
+  return crypto.createHmac(algorithm, key).update(payload).digest(encoding || 'hex');
+}
+
+/** Constant-time comparison of two strings; false for any length mismatch. */
+function safeEqual(left, right) {
+  var a = Buffer.from(String(left || ''), 'utf8');
+  var b = Buffer.from(String(right || ''), 'utf8');
+  if (a.length === 0 || a.length !== b.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(a, b);
+}
+
+/**
+ * Nested form encoding (\`metadata[orderId]=…\`, \`items[0][name]=…\`), the shape
+ * form-based provider APIs read. Undefined and null values are left out.
+ */
+function formEncode(value, prefix) {
+  var parts = [];
+  function walk(current, path) {
+    if (current === undefined || current === null) {
+      return;
+    }
+    if (Array.isArray(current)) {
+      for (var i = 0; i < current.length; i++) {
+        walk(current[i], path + '[' + i + ']');
+      }
+      return;
+    }
+    if (typeof current === 'object') {
+      var keys = Object.keys(current);
+      for (var k = 0; k < keys.length; k++) {
+        walk(current[keys[k]], path ? path + '[' + keys[k] + ']' : keys[k]);
+      }
+      return;
+    }
+    parts.push(encodeURIComponent(path) + '=' + encodeURIComponent(String(current)));
+  }
+  walk(value, prefix || '');
+  return parts.join('&');
+}
+
+/** The object a form-encoded \`key=value&…\` body stands for (a repeated key keeps its last value). */
+function parseForm(text) {
+  var result = {};
+  var body = String(text || '');
+  if (!body) {
+    return result;
+  }
+  var pairs = body.split('&');
+  for (var i = 0; i < pairs.length; i++) {
+    if (!pairs[i]) {
+      continue;
+    }
+    var eq = pairs[i].indexOf('=');
+    var rawKey = eq >= 0 ? pairs[i].slice(0, eq) : pairs[i];
+    var rawValue = eq >= 0 ? pairs[i].slice(eq + 1) : '';
+    try {
+      result[decodeURIComponent(rawKey.replace(/\\+/g, ' '))] = decodeURIComponent(rawValue.replace(/\\+/g, ' '));
+    } catch (_e) {
+      result[rawKey] = rawValue;
+    }
+  }
+  return result;
+}
+
+/** The actionable half of a thrown error, never an object's stringification. */
+function describeError(err, fallback) {
+  if (err && typeof err === 'object') {
+    var raw = (err.raw && err.raw.message) || err.message;
+    if (typeof raw === 'string' && raw.trim()) {
+      return raw.trim();
+    }
+  }
+  return fallback || 'The payment provider could not be reached.';
+}
+
+/** The metadata a checkout attached (a JSON string or an object), as an object. */
+function readMetadata(value) {
+  if (!value) {
+    return {};
+  }
+  if (typeof value === 'object') {
+    return value;
+  }
+  try {
+    var parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch (_e) {
+    return {};
+  }
+}
+
+// How many result pages a driver reads when it searches the provider for an
+// order's checkouts; a search that would need more is refused, never guessed.
+var SEARCH_PAGE_LIMIT = 10;
+// An order that recorded no checkout had one opened by the request that placed
+// it, seconds after its row was written: the provider is searched around then.
+var SEARCH_BEFORE_MS = 10 * 60 * 1000;
+var SEARCH_AFTER_MS = 60 * 60 * 1000;
+
+/**
+ * The time window a checkout opened for an order placed at \`placedAt\` falls
+ * in: \`{ from, to }\` in milliseconds, or null for a time that cannot be read.
+ */
+function searchWindow(placedAt) {
+  var placed = new Date(String(placedAt || '')).getTime();
+  if (!isFinite(placed) || placed <= 0) {
+    return null;
+  }
+  return { from: placed - SEARCH_BEFORE_MS, to: placed + SEARCH_AFTER_MS };
+}
+
+/** Milliseconds as an ISO time; '' for anything that is not a time. */
+function isoTime(ms) {
+  var value = Number(ms);
+  return isFinite(value) && value > 0 ? new Date(value).toISOString() : '';
+}
+
+/** The later of two ISO times; '' only when neither is one. */
+function laterTime(left, right) {
+  var a = new Date(String(left || '')).getTime();
+  var b = new Date(String(right || '')).getTime();
+  if (!isFinite(a)) {
+    return isFinite(b) ? String(right) : '';
+  }
+  return isFinite(b) && b > a ? String(right) : String(left);
+}
+
+// The states a checkout can be left in, most binding first: money taken, money
+// on its way, a page that still takes money, a page that takes none.
+var CHECKOUT_STATE_RANK = { paid: 4, confirming: 3, open: 2, closed: 1 };
+
+/**
+ * Closes every checkout an order has open with its provider, so no page the
+ * store opened can take money for it again: the checkout the order recorded,
+ * or — when it recorded none — the ones the provider finds for it around the
+ * moment it was placed. Answers the most binding state among them:
+ *
+ * - \`paid\` / \`confirming\` — a checkout took the money, or is taking it;
+ * - \`open\` — one could not be closed (the provider has no way to close it
+ *   early, or cannot be searched): \`openUntil\` is when it runs out, '' when
+ *   the provider does not say; \`checkoutUrl\` and \`reference\` name its page
+ *   when the provider gave one;
+ * - \`closed\` — every checkout found takes no more money;
+ * - \`none\` — the provider has no checkout for the order.
+ *
+ * \`{ outcome: '', error }\` when the provider could not be asked: nothing may
+ * then be decided as if the pages were closed.
+ */
+async function closeOrderCheckouts(driver, input) {
+  var request = input || {};
+  if (!driver || typeof driver.closeCheckout !== 'function') {
+    return { outcome: '', openUntil: '', checkoutUrl: '', error: 'This store cannot close checkouts with that payment provider.' };
+  }
+  var reference = String(request.reference || '').trim();
+  var references = reference ? [reference] : [];
+  if (!reference) {
+    var found =
+      typeof driver.findCheckouts === 'function'
+        ? await driver.findCheckouts({ orderId: request.orderId, placedAt: request.placedAt })
+        : { searchable: false, openUntil: '' };
+    if (found && found.error) {
+      return { outcome: '', openUntil: '', checkoutUrl: '', error: String(found.error) };
+    }
+    if (found && found.searchable === false) {
+      var until = new Date(String(found.openUntil || '')).getTime();
+      return isFinite(until) && until > Date.now()
+        ? { outcome: 'open', openUntil: String(found.openUntil), checkoutUrl: '' }
+        : { outcome: 'none', openUntil: '', checkoutUrl: '' };
+    }
+    references = found && Array.isArray(found.references) ? found.references : [];
+  }
+  if (references.length === 0) {
+    return { outcome: 'none', openUntil: '', checkoutUrl: '' };
+  }
+  var best = { outcome: 'closed', openUntil: '', checkoutUrl: '', reference: '' };
+  // One page open for a time nobody knows keeps the whole answer open-ended.
+  var untilUnknown = false;
+  for (var i = 0; i < references.length; i++) {
+    var result;
+    try {
+      result = await driver.closeCheckout({ reference: references[i] });
+    } catch (err) {
+      result = { state: '', error: describeError(err) };
+    }
+    if (!result || result.error || !CHECKOUT_STATE_RANK[result.state]) {
+      return {
+        outcome: '',
+        openUntil: '',
+        checkoutUrl: '',
+        error: String((result && result.error) || 'The payment provider did not say what became of checkout ' + references[i] + '.'),
+      };
+    }
+    if (result.state === 'open') {
+      untilUnknown = untilUnknown || !result.openUntil;
+      best.openUntil = untilUnknown ? '' : laterTime(best.openUntil, result.openUntil);
+      if (!best.checkoutUrl && result.checkoutUrl) {
+        best.checkoutUrl = String(result.checkoutUrl);
+        best.reference = references[i];
+      }
+    }
+    if (CHECKOUT_STATE_RANK[result.state] > CHECKOUT_STATE_RANK[best.outcome]) {
+      best.outcome = result.state;
+    }
+  }
+  if (best.outcome !== 'open') {
+    best.openUntil = '';
+    best.checkoutUrl = '';
+    best.reference = '';
+  }
+  return best;
+}
+
+module.exports = {
+  env: env,
+  credential: credential,
+  minorFactor: minorFactor,
+  toMinor: toMinor,
+  fromMinor: fromMinor,
+  decimalString: decimalString,
+  readJson: readJson,
+  request: request,
+  absoluteUrl: absoluteUrl,
+  webhookUrl: webhookUrl,
+  header: header,
+  hmac: hmac,
+  safeEqual: safeEqual,
+  formEncode: formEncode,
+  parseForm: parseForm,
+  describeError: describeError,
+  readMetadata: readMetadata,
+  SEARCH_PAGE_LIMIT: SEARCH_PAGE_LIMIT,
+  searchWindow: searchWindow,
+  isoTime: isoTime,
+  closeOrderCheckouts: closeOrderCheckouts,
+};
+`

package/src/payments/payment-driver-code-map.ts

@@ -0,0 +1,19 @@
+import type { PaymentDriverId } from './payment-drivers-scope'
+import { generateStripeDriverCode } from './drivers/stripe-driver-code'
+import { generatePaypalDriverCode } from './drivers/paypal-driver-code'
+import { generateMollieDriverCode } from './drivers/mollie-driver-code'
+import { generateRazorpayDriverCode } from './drivers/razorpay-driver-code'
+import { generateSquareDriverCode } from './drivers/square-driver-code'
+import { generatePaddleDriverCode } from './drivers/paddle-driver-code'
+import { generateCoingateDriverCode } from './drivers/coingate-driver-code'
+
+/** The module source of each provider's driver (`utils/payments/drivers/<id>.js`). */
+export const PAYMENT_DRIVER_CODE: Record<PaymentDriverId, () => string> = {
+  stripe: generateStripeDriverCode,
+  paypal: generatePaypalDriverCode,
+  mollie: generateMollieDriverCode,
+  razorpay: generateRazorpayDriverCode,
+  square: generateSquareDriverCode,
+  paddle: generatePaddleDriverCode,
+  coingate: generateCoingateDriverCode,
+}