@teleporthq/teleport-plugin-next-workflows 0.43.39 → 0.43.41

package/src/ecommerce/stock-decrement.ts

@@ -58,6 +58,21 @@ export const looksLikeStockDecrementBuilder = (code: string): boolean => {
     return false
   }
   if (code.indexOf(STOCK_DECREMENT_MARKER) >= 0) {
+    // Already our rewrite. A prior rewriter version (the
+    // `GREATEST(0, COALESCE(quantity, 0) - …)` shape below) permanently
+    // floored an unlimited-stock (NULL quantity) product to 0 the first
+    // time an order touched it — turning "infinite stock" into
+    // "out of stock" forever. Re-match that legacy shape so the next
+    // regeneration upgrades already-rewritten projects to the current,
+    // NULL-preserving SQL (`buildStockDecrementBuilder` below). A rewrite
+    // that already carries the NULL guard is up to date — leave it alone.
+    if (
+      code.indexOf('teleport_products') >= 0 &&
+      /quantity\s*=\s*GREATEST\s*\(\s*\d+\s*,\s*COALESCE\s*\(\s*quantity/i.test(code) &&
+      code.indexOf('WHEN quantity IS NULL THEN NULL') < 0
+    ) {
+      return true
+    }
     return false
   }
   if (code.indexOf('teleport_products') < 0) {
@@ -188,31 +203,27 @@ ${STOCK_DECREMENT_HELPERS}
   //    the row AFTER the SET clause runs (so bare \`quantity\` would
   //    be the new value, not the old).
   //
-  //    Two SQL helpers do the heavy lifting:
-  //
-  //    1. \`COALESCE(quantity, 0)\` — every new project starts with
-  //       \`teleport_products.quantity\` seeded NULL, and the
-  //       cart-availability pre-flight tolerates NULL as "unlimited"
-  //       so those orders reach this UPDATE. Without COALESCE the
-  //       NULL row's arithmetic would be NULL (no decrement) and the
-  //       merchant would see "order placed, stock unchanged" and
-  //       assume the workflow is broken.
-  //    2. \`GREATEST(0, …)\` — clamps the post-update value at zero so
-  //       we never persist a negative quantity. Negative stock is a
-  //       confusing signal in the admin panel ("we sold more than we
-  //       have?"); the same "set your initial stock" feedback is
-  //       achieved by the row sitting at exactly 0 — subsequent
-  //       orders are then blocked by the cart-availability check
-  //       (which compares against 0 and finds insufficient stock).
-  var setClause = "quantity = GREATEST(0, COALESCE(quantity, 0) - CASE id" + caseExpr + " ELSE 0 END), updated_at = NOW()";
-  // \`old_quantity\` in RETURNING reconstructs the pre-update value.
-  // After the GREATEST clamp the SET value is no longer
-  // "old - delta" — it might be 0 because of the floor. So we can't
+  //    \`teleport_products.quantity\` is NULL for every product the
+  //    merchant hasn't given a finite count — that NULL means
+  //    "unlimited stock", not "zero stock waiting to be bootstrapped".
+  //    The SET clause's \`CASE WHEN quantity IS NULL THEN NULL …\` guard
+  //    leaves those rows untouched forever: an unlimited product must
+  //    stay unlimited across every order, not silently become
+  //    out-of-stock (0) the first time someone buys it. Only a row
+  //    that already carries a real, finite count is decremented, and
+  //    \`GREATEST(0, …)\` floors THAT arithmetic at zero so we never
+  //    persist a negative quantity for a tracked product.
+  var setClause = "quantity = CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity - (CASE id" + caseExpr + " ELSE 0 END)) END, updated_at = NOW()";
+  // \`old_quantity\` in RETURNING reconstructs the pre-update value. A
+  // row whose (post-update) \`new_quantity\` is NULL was NULL before too
+  // (the SET clause never changes a NULL row), so \`old_quantity\` is
+  // NULL as well. For a tracked row, the GREATEST clamp means the SET
+  // value is no longer "old - delta" once it floors at 0, so we can't
   // just invert the SET expression; instead we expose 0 as a
   // conservative lower bound for what was there before. Downstream
   // (low-stock SELECT) only uses \`new_quantity\` for the threshold
   // comparison, so this approximation is fine.
-  var returningClause = "RETURNING id, quantity AS new_quantity, GREATEST(0, COALESCE(quantity, 0) + (CASE id" + caseExpr + " ELSE 0 END)) AS old_quantity";
+  var returningClause = "RETURNING id, quantity AS new_quantity, (CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity + (CASE id" + caseExpr + " ELSE 0 END)) END) AS old_quantity";
 
   // When backorders are DISALLOWED we add a per-row guard:
   //   AND (quantity IS NULL OR quantity >= CASE id ... END)
@@ -223,17 +234,12 @@ ${STOCK_DECREMENT_HELPERS}
   // would otherwise allow two simultaneous orders to drive stock
   // below zero.
   //
-  // The "quantity IS NULL OR" clause is the new-project bootstrap:
-  // a freshly-seeded products table has NULL quantity everywhere,
-  // and the cart-availability pre-flight (which also tolerates NULL
-  // as "unlimited") lets those orders through. We MUST decrement
-  // those rows too, otherwise the user sees "order placed but stock
-  // unchanged" and concludes the workflow is broken. After the first
-  // decrement the row holds an integer (now floored at 0 by the
-  // GREATEST clamp in the SET clause) and from then on the normal
-  // \`quantity >= delta\` guard is enforced — so the merchant sees
-  // the zero value in the admin panel and gets a clear "set initial
-  // stock for this product" signal.
+  // The "quantity IS NULL OR" clause lets unlimited-stock products
+  // through the guard so the row is still touched (its RETURNING row
+  // still surfaces to the caller, e.g. for the low-stock SELECT) — the
+  // SET clause above then leaves the value itself untouched, so an
+  // unlimited product stays unlimited no matter how many orders are
+  // placed against it, with or without backorders enabled.
   var whereClause;
   if (ALLOW_BACKORDERS) {
     whereClause = "WHERE id IN (" + quotedIds + ")";
@@ -328,10 +334,12 @@ const looksLikeOrderDecrementCustomHandler = (code: string): boolean => {
     // Belt-and-braces: even when the marker is present, the code must
     // actually be a stock-decrement (not, say, an unrelated rewritten
     // node that happens to live next to teleport_products references).
-    // Accept BOTH the legacy concat shape (`quantity = quantity - CASE
-    // id …`) AND the current safety-wrapped shape (`quantity =
-    // GREATEST(0, COALESCE(quantity, 0) - CASE id …)`) — they're both
-    // emitted by `buildStockDecrementBuilder` across time.
+    // Accept every shape `buildStockDecrementBuilder` has emitted over
+    // time: the legacy concat shape (`quantity = quantity - CASE id …`),
+    // the COALESCE safety-wrapped shape (`quantity = GREATEST(0,
+    // COALESCE(quantity, 0) - CASE id …)`), and the current
+    // NULL-preserving shape (`quantity = CASE WHEN quantity IS NULL
+    // THEN NULL ELSE GREATEST(0, quantity - CASE id …) END`).
     if (code.indexOf('teleport_products') >= 0) {
       if (/quantity\s*=\s*quantity\s*-/.test(code)) {
         return true
@@ -339,6 +347,13 @@ const looksLikeOrderDecrementCustomHandler = (code: string): boolean => {
       if (/quantity\s*=\s*GREATEST\s*\(\s*\d+\s*,\s*COALESCE\s*\(\s*quantity/i.test(code)) {
         return true
       }
+      if (
+        /quantity\s*=\s*CASE\s+WHEN\s+quantity\s+IS\s+NULL\s+THEN\s+NULL\s+ELSE\s+GREATEST/i.test(
+          code
+        )
+      ) {
+        return true
+      }
     }
     return false
   }

package/src/nodes/payment/payment-charge-user.ts

@@ -1,31 +1,5 @@
 import { NodeHandlerGenerator, handlerToString } from '../types'
 
-// Stripe treats these currencies as zero-decimal (no fractional units). The
-// amount passed to the Stripe API must be the whole-currency integer, not
-// multiplied by 100. See https://stripe.com/docs/currencies#zero-decimal
-const STRIPE_ZERO_DECIMAL_CURRENCIES = [
-  'BIF',
-  'CLP',
-  'DJF',
-  'GNF',
-  'JPY',
-  'KMF',
-  'KRW',
-  'MGA',
-  'PYG',
-  'RWF',
-  'UGX',
-  'VND',
-  'VUV',
-  'XAF',
-  'XOF',
-  'XPF',
-]
-
-// Currencies where the smallest unit is 1/1000 of the major unit. Stripe
-// expects amounts in the smallest unit (e.g. 1.500 JOD -> 1500).
-const STRIPE_THREE_DECIMAL_CURRENCIES = ['BHD', 'IQD', 'JOD', 'KWD', 'LYD', 'OMR', 'TND']
-
 // Contract for the `amount` config field:
 //   A floating-point number in the MAJOR currency unit (e.g. 99.99 USD,
 //   9999 JPY). Individual line items use the same `unitAmount` semantics.
@@ -157,16 +131,54 @@ async function payment_charge_user(config: any, _context: Record<string, unknown
 // smallest-unit integer. Zero-decimal currencies pass through rounded;
 // three-decimal currencies multiply by 1000; everything else multiplies by
 // 100. Always returns a safe non-negative integer.
+//
+// The currency lists are declared LOCAL to this function rather than as
+// shared top-level consts. `generateHandler()` below assembles the final
+// handler by calling `.toString()` on several functions independently and
+// concatenating the source; a top-level const is fine in an unminified
+// build, but when this package itself is bundled + minified by a consumer
+// (e.g. teleport-gui's browser packer, built with webpack/Terser), the
+// minifier is free to rename the top-level const's declaration — nothing
+// in the bundle calls it by name, only this runtime `.toString()` read
+// does, which is invisible to the minifier. `toStripeMinorUnits.toString()`
+// would then embed a reference to a name (e.g. a mangled `Oo`) that is
+// never declared anywhere in the generated workflow segment file, throwing
+// "<mangled name> is not defined" the first time a Stripe charge runs.
+// Declaring the lists inside the function keeps the declaration and every
+// reference to it in the SAME `.toString()` snapshot, so a consistent
+// rename by the minifier can never separate them. See `resolveProviderSecret`
+// above for the same class of bug with the `process` global.
 function toStripeMinorUnits(major: any, currency: string): number {
+  const zeroDecimalCurrencies = [
+    'BIF',
+    'CLP',
+    'DJF',
+    'GNF',
+    'JPY',
+    'KMF',
+    'KRW',
+    'MGA',
+    'PYG',
+    'RWF',
+    'UGX',
+    'VND',
+    'VUV',
+    'XAF',
+    'XOF',
+    'XPF',
+  ]
+  // Currencies where the smallest unit is 1/1000 of the major unit. Stripe
+  // expects amounts in the smallest unit (e.g. 1.500 JOD -> 1500).
+  const threeDecimalCurrencies = ['BHD', 'IQD', 'JOD', 'KWD', 'LYD', 'OMR', 'TND']
   const amt = Number(major)
   if (!isFinite(amt) || amt <= 0) {
     return 0
   }
   const upper = String(currency || '').toUpperCase()
-  if (STRIPE_ZERO_DECIMAL_CURRENCIES.indexOf(upper) >= 0) {
+  if (zeroDecimalCurrencies.indexOf(upper) >= 0) {
     return Math.round(amt)
   }
-  if (STRIPE_THREE_DECIMAL_CURRENCIES.indexOf(upper) >= 0) {
+  if (threeDecimalCurrencies.indexOf(upper) >= 0) {
     return Math.round(amt * 1000)
   }
   return Math.round(amt * 100)
@@ -470,12 +482,6 @@ export const paymentChargeUser: NodeHandlerGenerator = {
   generateHandler(): string {
     return (
       handlerToString(payment_charge_user) +
-      '\nvar STRIPE_ZERO_DECIMAL_CURRENCIES = ' +
-      JSON.stringify(STRIPE_ZERO_DECIMAL_CURRENCIES) +
-      ';' +
-      '\nvar STRIPE_THREE_DECIMAL_CURRENCIES = ' +
-      JSON.stringify(STRIPE_THREE_DECIMAL_CURRENCIES) +
-      ';' +
       '\n' +
       resolveProviderSecret.toString() +
       '\n' +