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

package/dist/cjs/payments/payment-core-code.js

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePaymentCoreCode = void 0;
+/**
+ * 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.
+ */
+const generatePaymentCoreCode = (declared = {}) => `'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,
+};
+`;
+exports.generatePaymentCoreCode = generatePaymentCoreCode;
+//# sourceMappingURL=payment-core-code.js.map

package/dist/cjs/payments/payment-core-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-core-code.js","sourceRoot":"","sources":["../../../src/payments/payment-core-code.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;GAeG;AACI,MAAM,uBAAuB,GAAG,CACrC,WAAuC,EAAE,EACjC,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAyDgB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuVpD,CAAA;AAlZY,QAAA,uBAAuB,2BAkZnC"}

package/dist/cjs/payments/payment-driver-code-map.d.ts

@@ -0,0 +1,4 @@
+import type { PaymentDriverId } from './payment-drivers-scope';
+/** The module source of each provider's driver (`utils/payments/drivers/<id>.js`). */
+export declare const PAYMENT_DRIVER_CODE: Record<PaymentDriverId, () => string>;
+//# sourceMappingURL=payment-driver-code-map.d.ts.map

package/dist/cjs/payments/payment-driver-code-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-driver-code-map.d.ts","sourceRoot":"","sources":["../../../src/payments/payment-driver-code-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAS9D,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,MAAM,CAQrE,CAAA"}

package/dist/cjs/payments/payment-driver-code-map.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAYMENT_DRIVER_CODE = void 0;
+const stripe_driver_code_1 = require("./drivers/stripe-driver-code");
+const paypal_driver_code_1 = require("./drivers/paypal-driver-code");
+const mollie_driver_code_1 = require("./drivers/mollie-driver-code");
+const razorpay_driver_code_1 = require("./drivers/razorpay-driver-code");
+const square_driver_code_1 = require("./drivers/square-driver-code");
+const paddle_driver_code_1 = require("./drivers/paddle-driver-code");
+const coingate_driver_code_1 = require("./drivers/coingate-driver-code");
+/** The module source of each provider's driver (`utils/payments/drivers/<id>.js`). */
+exports.PAYMENT_DRIVER_CODE = {
+    stripe: stripe_driver_code_1.generateStripeDriverCode,
+    paypal: paypal_driver_code_1.generatePaypalDriverCode,
+    mollie: mollie_driver_code_1.generateMollieDriverCode,
+    razorpay: razorpay_driver_code_1.generateRazorpayDriverCode,
+    square: square_driver_code_1.generateSquareDriverCode,
+    paddle: paddle_driver_code_1.generatePaddleDriverCode,
+    coingate: coingate_driver_code_1.generateCoingateDriverCode,
+};
+//# sourceMappingURL=payment-driver-code-map.js.map

package/dist/cjs/payments/payment-driver-code-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-driver-code-map.js","sourceRoot":"","sources":["../../../src/payments/payment-driver-code-map.ts"],"names":[],"mappings":";;;AACA,qEAAuE;AACvE,qEAAuE;AACvE,qEAAuE;AACvE,yEAA2E;AAC3E,qEAAuE;AACvE,qEAAuE;AACvE,yEAA2E;AAE3E,sFAAsF;AACzE,QAAA,mBAAmB,GAA0C;IACxE,MAAM,EAAE,6CAAwB;IAChC,MAAM,EAAE,6CAAwB;IAChC,MAAM,EAAE,6CAAwB;IAChC,QAAQ,EAAE,iDAA0B;IACpC,MAAM,EAAE,6CAAwB;IAChC,MAAM,EAAE,6CAAwB;IAChC,QAAQ,EAAE,iDAA0B;CACrC,CAAA"}

package/dist/cjs/payments/payment-drivers-scope.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Where a store's payment drivers live, which providers have one, and which
+ * generated code needs them.
+ *
+ * Every provider a store can take money with has ONE driver module in the
+ * generated app (`utils/payments/drivers/<id>.js`), behind one registry
+ * (`utils/payments/index.js`). The payment workflow nodes and the payment
+ * webhook routes reach it through the `__paymentDrivers` binding a route's
+ * preamble declares (see `generatePaymentDriversPreamble`); nothing else in
+ * the store talks to a provider.
+ */
+export declare const PAYMENT_DRIVERS_FILE_KEY = "payment-drivers";
+export declare const PAYMENT_DRIVERS_PATH: string[];
+export declare const PAYMENT_DRIVERS_DIRECTORY: string[];
+/** The providers the generated store can charge, refund and bill through. */
+export declare const PAYMENT_DRIVER_IDS: readonly ["stripe", "paypal", "mollie", "razorpay", "square", "paddle", "coingate"];
+export type PaymentDriverId = (typeof PAYMENT_DRIVER_IDS)[number];
+/**
+ * The NAMES (never the values) of the secrets the merchant saved for each
+ * provider, by the provider form's field key.
+ */
+export type DeclaredPaymentCredentials = Partial<Record<PaymentDriverId, Record<string, string>>>;
+/**
+ * Drivers every store that takes online payments carries, whatever it
+ * configured: a workflow authored (or AI-generated) before providers were
+ * explicit names no provider and has always meant Stripe, or PayPal by name.
+ */
+export declare const DEFAULT_PAYMENT_DRIVER_IDS: readonly PaymentDriverId[];
+/** The workflow nodes whose handler calls a driver. */
+export declare const PAYMENT_DRIVER_NODE_TYPES: Set<string>;
+/** The webhook signature scheme a payment webhook verifies with. */
+export declare const PAYMENT_DRIVER_SIGNATURE_ALGORITHM = "payment-driver";
+export declare const isPaymentDriverId: (value: unknown) => value is "stripe" | "paypal" | "mollie" | "razorpay" | "square" | "paddle" | "coingate";
+export declare const usesPaymentDriverNode: (nodeTypes: Iterable<string>) => boolean;
+//# sourceMappingURL=payment-drivers-scope.d.ts.map

package/dist/cjs/payments/payment-drivers-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-drivers-scope.d.ts","sourceRoot":"","sources":["../../../src/payments/payment-drivers-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,wBAAwB,oBAAoB,CAAA;AACzD,eAAO,MAAM,oBAAoB,UAAwB,CAAA;AACzD,eAAO,MAAM,yBAAyB,UAAmC,CAAA;AAEzE,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,qFAQrB,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;AAEjG;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,eAAe,EAAyB,CAAA;AAE1F,uDAAuD;AACvD,eAAO,MAAM,yBAAyB,aAOpC,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,kCAAkC,mBAAmB,CAAA;AAElE,eAAO,MAAM,iBAAiB,UAAW,OAAO,4FACwC,CAAA;AAExF,eAAO,MAAM,qBAAqB,cAAe,SAAS,MAAM,CAAC,KAAG,OAOnE,CAAA"}

package/dist/cjs/payments/payment-drivers-scope.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Where a store's payment drivers live, which providers have one, and which
+ * generated code needs them.
+ *
+ * Every provider a store can take money with has ONE driver module in the
+ * generated app (`utils/payments/drivers/<id>.js`), behind one registry
+ * (`utils/payments/index.js`). The payment workflow nodes and the payment
+ * webhook routes reach it through the `__paymentDrivers` binding a route's
+ * preamble declares (see `generatePaymentDriversPreamble`); nothing else in
+ * the store talks to a provider.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usesPaymentDriverNode = exports.isPaymentDriverId = exports.PAYMENT_DRIVER_SIGNATURE_ALGORITHM = exports.PAYMENT_DRIVER_NODE_TYPES = exports.DEFAULT_PAYMENT_DRIVER_IDS = exports.PAYMENT_DRIVER_IDS = exports.PAYMENT_DRIVERS_DIRECTORY = exports.PAYMENT_DRIVERS_PATH = exports.PAYMENT_DRIVERS_FILE_KEY = void 0;
+exports.PAYMENT_DRIVERS_FILE_KEY = 'payment-drivers';
+exports.PAYMENT_DRIVERS_PATH = ['utils', 'payments'];
+exports.PAYMENT_DRIVERS_DIRECTORY = ['utils', 'payments', 'drivers'];
+/** The providers the generated store can charge, refund and bill through. */
+exports.PAYMENT_DRIVER_IDS = [
+    'stripe',
+    'paypal',
+    'mollie',
+    'razorpay',
+    'square',
+    'paddle',
+    'coingate',
+];
+/**
+ * Drivers every store that takes online payments carries, whatever it
+ * configured: a workflow authored (or AI-generated) before providers were
+ * explicit names no provider and has always meant Stripe, or PayPal by name.
+ */
+exports.DEFAULT_PAYMENT_DRIVER_IDS = ['stripe', 'paypal'];
+/** The workflow nodes whose handler calls a driver. */
+exports.PAYMENT_DRIVER_NODE_TYPES = new Set([
+    'payment-charge-user',
+    'payment-refund',
+    'payment-ensure-subscription-plan',
+    'payment-manage-subscription',
+    'payment-billing-portal',
+    'payment-close-checkout',
+]);
+/** The webhook signature scheme a payment webhook verifies with. */
+exports.PAYMENT_DRIVER_SIGNATURE_ALGORITHM = 'payment-driver';
+const isPaymentDriverId = (value) => typeof value === 'string' && exports.PAYMENT_DRIVER_IDS.includes(value);
+exports.isPaymentDriverId = isPaymentDriverId;
+const usesPaymentDriverNode = (nodeTypes) => {
+    for (const nodeType of nodeTypes) {
+        if (exports.PAYMENT_DRIVER_NODE_TYPES.has(nodeType)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.usesPaymentDriverNode = usesPaymentDriverNode;
+//# sourceMappingURL=payment-drivers-scope.js.map

package/dist/cjs/payments/payment-drivers-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-drivers-scope.js","sourceRoot":"","sources":["../../../src/payments/payment-drivers-scope.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAEU,QAAA,wBAAwB,GAAG,iBAAiB,CAAA;AAC5C,QAAA,oBAAoB,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;AAC5C,QAAA,yBAAyB,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAA;AAEzE,6EAA6E;AAChE,QAAA,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,QAAQ;IACR,UAAU;CACF,CAAA;AAUV;;;;GAIG;AACU,QAAA,0BAA0B,GAA+B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE1F,uDAAuD;AAC1C,QAAA,yBAAyB,GAAG,IAAI,GAAG,CAAC;IAC/C,qBAAqB;IACrB,gBAAgB;IAChB,kCAAkC;IAClC,6BAA6B;IAC7B,wBAAwB;IACxB,wBAAwB;CACzB,CAAC,CAAA;AAEF,oEAAoE;AACvD,QAAA,kCAAkC,GAAG,gBAAgB,CAAA;AAE3D,MAAM,iBAAiB,GAAG,CAAC,KAAc,EAA4B,EAAE,CAC5E,OAAO,KAAK,KAAK,QAAQ,IAAK,0BAAwC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAD3E,QAAA,iBAAiB,qBAC0D;AAEjF,MAAM,qBAAqB,GAAG,CAAC,SAA2B,EAAW,EAAE;IAC5E,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;QAChC,IAAI,iCAAyB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;YAC3C,OAAO,IAAI,CAAA;SACZ;KACF;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAPY,QAAA,qBAAqB,yBAOjC"}

package/dist/cjs/payments/payment-registry-code.d.ts

@@ -0,0 +1,8 @@
+import type { PaymentDriverId } from './payment-drivers-scope';
+/**
+ * Emits `utils/payments/index.js`: the one door to the store's payment
+ * drivers. Each driver is required by a literal path so the Next.js bundler
+ * packs exactly the providers this store uses, and built once per process.
+ */
+export declare const generatePaymentRegistryCode: (driverIds: readonly PaymentDriverId[]) => string;
+//# sourceMappingURL=payment-registry-code.d.ts.map

package/dist/cjs/payments/payment-registry-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-registry-code.d.ts","sourceRoot":"","sources":["../../../src/payments/payment-registry-code.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAE9D;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,cAAe,SAAS,eAAe,EAAE,KAAG,MA8BnF,CAAA"}

package/dist/cjs/payments/payment-registry-code.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePaymentRegistryCode = void 0;
+/**
+ * Emits `utils/payments/index.js`: the one door to the store's payment
+ * drivers. Each driver is required by a literal path so the Next.js bundler
+ * packs exactly the providers this store uses, and built once per process.
+ */
+const generatePaymentRegistryCode = (driverIds) => {
+    const factories = driverIds
+        .map((id) => `  ${JSON.stringify(id)}: require('./drivers/${id}'),`)
+        .join('\n');
+    return `'use strict';
+/**
+ * Payment driver registry. Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+var core = require('./core');
+
+var factories = {
+${factories}
+};
+
+var instances = {};
+
+/** The driver for \`providerId\`, or null when this store carries none for it. */
+function get(providerId) {
+  var id = String(providerId == null ? '' : providerId).trim().toLowerCase();
+  if (!Object.prototype.hasOwnProperty.call(factories, id)) {
+    return null;
+  }
+  if (!instances[id]) {
+    instances[id] = factories[id](core);
+  }
+  return instances[id];
+}
+
+module.exports = { get: get, ids: Object.keys(factories), core: core };
+`;
+};
+exports.generatePaymentRegistryCode = generatePaymentRegistryCode;
+//# sourceMappingURL=payment-registry-code.js.map

package/dist/cjs/payments/payment-registry-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-registry-code.js","sourceRoot":"","sources":["../../../src/payments/payment-registry-code.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACI,MAAM,2BAA2B,GAAG,CAAC,SAAqC,EAAU,EAAE;IAC3F,MAAM,SAAS,GAAG,SAAS;SACxB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,wBAAwB,EAAE,KAAK,CAAC;SACnE,IAAI,CAAC,IAAI,CAAC,CAAA;IACb,OAAO;;;;;;;EAOP,SAAS;;;;;;;;;;;;;;;;;;CAkBV,CAAA;AACD,CAAC,CAAA;AA9BY,QAAA,2BAA2B,+BA8BvC"}

package/dist/cjs/pg-client-code.d.ts

@@ -8,4 +8,14 @@
  * The returned code requires `pg` and exposes a top-level `getClient()`.
  */
 export declare const generatePgClientCode: () => string;
+/**
+ * `generatePgClientCode()` with the driver loaded on first use instead of at
+ * module load, plus the `__loadPg()` loader it calls (null when `pg` is not
+ * installed). A module that some projects require without a Postgres driver —
+ * the sent-email ledger, the push subscription store — would otherwise fail
+ * the build of every route that imports it ("Collecting page data").
+ * `new Client(opts)` keeps working: a constructor that returns an object
+ * yields that object.
+ */
+export declare const generateLazyPgClientCode: () => string;
 //# sourceMappingURL=pg-client-code.d.ts.map

package/dist/cjs/pg-client-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pg-client-code.d.ts","sourceRoot":"","sources":["../../src/pg-client-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,QAAO,MA4DrC,CAAA"}
+{"version":3,"file":"pg-client-code.d.ts","sourceRoot":"","sources":["../../src/pg-client-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,QAAO,MA4DrC,CAAA;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAiB3C,CAAA"}