@teleporthq/teleport-plugin-next-workflows 0.43.38 → 0.43.40

package/__tests__/ecommerce-customhandler-rewriter.test.ts

@@ -1,4 +1,5 @@
 import { rewriteLowStockCustomHandlers, __testables } from '../src/ecommerce-customhandler-rewriter'
+import { STOCK_DECREMENT_MARKER } from '../src/ecommerce/stock-decrement'
 
 const {
   looksLikeLowStockSelectBuilder,
@@ -508,6 +509,22 @@ describe('looksLikeStockDecrementBuilder — pattern detection', () => {
     const rewritten = buildStockDecrementBuilder(false)
     expect(looksLikeStockDecrementBuilder(rewritten)).toBe(false)
   })
+
+  it('self-heals a legacy rewrite that permanently zeroes NULL (unlimited) stock', () => {
+    // A project generated before the NULL-preserving fix already carries
+    // the marker, so the marker check alone can't distinguish "already
+    // correct" from "already rewritten but still buggy". Detect the old
+    // `GREATEST(0, COALESCE(quantity, 0) - …)` shape specifically so the
+    // NEXT regeneration upgrades it to the NULL-preserving SQL instead of
+    // leaving an existing project's unlimited-stock products stuck at 0
+    // forever.
+    const legacyRewrite = `${STOCK_DECREMENT_MARKER}
+      function customHandler() {
+        var setClause = "quantity = GREATEST(0, COALESCE(quantity, 0) - CASE id" + caseExpr + " ELSE 0 END)";
+        return { query: "UPDATE teleport_products SET " + setClause, affected: ['a'] };
+      }`
+    expect(looksLikeStockDecrementBuilder(legacyRewrite)).toBe(true)
+  })
 })
 
 describe('buildStockDecrementBuilder — semantic behaviour', () => {
@@ -528,16 +545,19 @@ describe('buildStockDecrementBuilder — semantic behaviour', () => {
         },
       ])
       // Two semantic guards in the SET clause:
-      //   * \`COALESCE(quantity, 0)\` bootstraps NULL-quantity rows from
-      //     0 so freshly-seeded products in a new project decrement on
-      //     first order (instead of being silently skipped by the
-      //     legacy \`WHERE quantity IS NOT NULL\` filter).
-      //   * \`GREATEST(0, …)\` floors the post-decrement value at 0 so
-      //     we never persist a negative stock value — that would be a
-      //     confusing signal in the admin panel ("we sold more than we
-      //     have?"). Once a row sits at exactly 0 the cart-availability
-      //     pre-flight refuses further orders against it.
-      expect(r.query).toContain('SET quantity = GREATEST(0, COALESCE(quantity, 0) - CASE id')
+      //   * \`CASE WHEN quantity IS NULL THEN NULL …\` leaves an
+      //     unlimited-stock product (quantity never set by the
+      //     merchant) untouched forever — an order must never turn
+      //     "infinite stock" into a finite, trackable 0.
+      //   * \`GREATEST(0, …)\` floors a TRACKED row's post-decrement
+      //     value at 0 so we never persist a negative stock value —
+      //     that would be a confusing signal in the admin panel ("we
+      //     sold more than we have?"). Once a row sits at exactly 0
+      //     the cart-availability pre-flight refuses further orders
+      //     against it.
+      expect(r.query).toContain(
+        'SET quantity = CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity - (CASE id'
+      )
       expect(r.query).toContain("WHEN 'a' THEN 2")
       expect(r.query).toContain("WHEN 'b' THEN 3")
       expect(r.query).toContain('ELSE 0')
@@ -589,14 +609,16 @@ describe('buildStockDecrementBuilder — semantic behaviour', () => {
       const r = fn({}, [{ items: [{ productId: 'a', quantity: 2 }] }])
       expect(r.query).toContain('RETURNING id')
       expect(r.query).toContain('quantity AS new_quantity')
-      // \`old_quantity\` reconstructs an approximate pre-SET value. With
-      // the GREATEST(0, …) clamp in SET we can't perfectly invert the
-      // arithmetic (a row that decremented from 1 → 0 with delta 2 also
-      // would have shown 0 with delta 1), but for the downstream
+      // \`old_quantity\` reconstructs an approximate pre-SET value. A row
+      // whose (post-update) \`new_quantity\` is NULL was NULL before too
+      // (the SET clause never touches a NULL row); for a tracked row,
+      // the GREATEST(0, …) clamp in SET means we can't perfectly invert
+      // the arithmetic (a row that decremented from 1 → 0 with delta 2
+      // also would have shown 0 with delta 1), but for the downstream
       // low-stock SELECT only \`new_quantity\` matters, so a conservative
       // floored approximation is fine.
       expect(r.query).toMatch(
-        /GREATEST\(0,\s*COALESCE\(quantity, 0\)\s*\+\s*\(CASE id[\s\S]*?\)\)\s*AS old_quantity/
+        /\(CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST\(0,\s*quantity\s*\+\s*\(CASE id[\s\S]*?\)\)\s*END\)\s*AS old_quantity/
       )
     })
 
@@ -629,22 +651,30 @@ describe('buildStockDecrementBuilder — semantic behaviour', () => {
       expect(/(?<!')';/.test(r.query)).toBe(false)
     })
 
-    it('tolerates NULL quantity rows so freshly-seeded products still decrement', () => {
+    it('lets orders proceed against NULL-quantity (unlimited stock) rows WITHOUT ever making them finite', () => {
       // A new project's products table is seeded with NULL quantity
-      // everywhere; the cart-availability pre-flight lets those orders
-      // through as "unlimited", so the UPDATE MUST decrement them too
-      // — otherwise the buyer sees the order placed and the merchant
-      // sees stock standing still. The "quantity IS NULL OR quantity
-      // >= delta" guard lets NULL rows through; the SET-clause's
-      // \`GREATEST(0, COALESCE(quantity, 0) - delta)\` arithmetic
-      // bootstraps the row from 0 so subsequent reads see an integer,
-      // floored at 0 (never negative).
+      // everywhere, and the cart-availability pre-flight treats NULL as
+      // "unlimited stock" — so those orders reach this UPDATE. The
+      // WHERE guard's "quantity IS NULL OR …" lets the row through, but
+      // the SET clause's "CASE WHEN quantity IS NULL THEN NULL …" must
+      // leave the value untouched: an unlimited product decrementing on
+      // its first order would otherwise floor to 0 and become
+      // permanently out-of-stock, even though the merchant never set a
+      // finite count. Only rows that already carry a real, finite
+      // quantity are actually decremented.
       const r = fn({}, [{ items: [{ productId: 'a', quantity: 1 }] }])
       expect(r.query).toContain('quantity IS NULL OR quantity >=')
-      expect(r.query).toContain('GREATEST(0, COALESCE(quantity, 0) - CASE id')
+      expect(r.query).toContain(
+        'CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity - (CASE id'
+      )
       // The legacy "quantity IS NOT NULL" filter that used to skip NULL
-      // rows must be gone — otherwise the bootstrap can't happen.
+      // rows entirely must stay gone — the row still needs to be
+      // touched (so its RETURNING row is available to callers), just
+      // without changing its value.
       expect(r.query).not.toContain('quantity IS NOT NULL')
+      // The old (buggy) shape unconditionally bootstrapped a NULL row
+      // to 0 via COALESCE — that must be gone entirely now.
+      expect(r.query).not.toContain('COALESCE(quantity, 0)')
     })
 
     it('accepts a bare cart-items array (legacy callers pass [items] directly)', () => {
@@ -664,13 +694,16 @@ describe('buildStockDecrementBuilder — semantic behaviour', () => {
       const r = fn({}, [{ items: [{ productId: 'a', quantity: 3 }] }])
       expect(r.query).not.toContain('quantity >=')
       // The legacy "quantity IS NOT NULL" filter has been removed; the
-      // SET clause now uses GREATEST(0, COALESCE(...)) so NULL-quantity
-      // rows bootstrap from 0 (never negative) instead of being silently
-      // skipped. Even with backorders allowed we floor at 0 — backorders
-      // semantically mean "let the order through even if stock is short",
-      // not "let the stock counter go negative".
+      // SET clause now uses "CASE WHEN quantity IS NULL THEN NULL …" so
+      // NULL-quantity (unlimited-stock) rows stay untouched — even with
+      // backorders allowed, an unlimited product is never turned into a
+      // finite, trackable one. Tracked rows still floor at 0 —
+      // backorders semantically mean "let the order through even if
+      // stock is short", not "let the stock counter go negative".
       expect(r.query).not.toContain('quantity IS NOT NULL')
-      expect(r.query).toContain('GREATEST(0, COALESCE(quantity, 0) - CASE id')
+      expect(r.query).toContain(
+        'CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity - (CASE id'
+      )
     })
 
     it('still uses RETURNING so the low-stock SELECT sees what changed', () => {

package/__tests__/payment-charge-user-handler-serialization.test.ts

@@ -0,0 +1,94 @@
+import { paymentChargeUser } from '../src/nodes/payment/payment-charge-user'
+
+// Regression coverage for a production bug: clicking "Pay Now" on a
+// Stripe checkout failed with
+//   { "success": false, "error": "Oo is not defined", "provider": "stripe" }
+//
+// Root cause: `generateHandler()` builds the final server-route handler by
+// calling `.toString()` on several TypeScript functions independently and
+// concatenating the source text (see `../src/nodes/types.ts`'s
+// `handlerToString` docs). Two currency-code arrays
+// (STRIPE_ZERO_DECIMAL_CURRENCIES / STRIPE_THREE_DECIMAL_CURRENCIES) used
+// to be declared as top-level consts and referenced from inside
+// `toStripeMinorUnits`. That's fine in an unminified build, but this
+// package is itself bundled + minified by consumers (teleport-gui's
+// browser packer, via webpack/Terser) before `generateHandler()` ever
+// runs — the minifier is free to rename an unused-by-name top-level
+// const (nothing calls it by string, only a runtime `.toString()` read
+// does, which the minifier can't see), and it renamed the declaration
+// away from what the reconstructed `var STRIPE_ZERO_DECIMAL_CURRENCIES =
+// [...]` text in `generateHandler()` assumed. The result: the generated
+// workflow segment file declared the array under the ORIGINAL name but
+// `toStripeMinorUnits`'s serialized body referenced the MINIFIER-RENAMED
+// name (e.g. a mangled `Oo`), which was never declared anywhere in the
+// generated file — a `ReferenceError` the first time a Stripe charge ran
+// with a zero- or three-decimal currency.
+//
+// The fix moves both arrays to be declared LOCAL to `toStripeMinorUnits`
+// so the declaration and every reference to it live in the SAME
+// `.toString()` snapshot — a consistent rename can never separate them.
+describe('payment-charge-user handler serialization survives minification-style renaming', () => {
+  const handlerSource = paymentChargeUser.generateHandler()
+
+  it('does not reference the old top-level currency-array identifiers anywhere', () => {
+    // These names no longer exist ANYWHERE in the source — not as a
+    // declaration, not as a reference. If a future edit reintroduces a
+    // top-level const referenced only from inside a separately
+    // `.toString()`'d function, this is the shape of bug that comes back.
+    expect(handlerSource).not.toContain('STRIPE_ZERO_DECIMAL_CURRENCIES')
+    expect(handlerSource).not.toContain('STRIPE_THREE_DECIMAL_CURRENCIES')
+  })
+
+  it('declares the currency arrays INSIDE toStripeMinorUnits, not reconstructed separately', () => {
+    const fnStart = handlerSource.indexOf('function toStripeMinorUnits')
+    expect(fnStart).toBeGreaterThan(-1)
+    // The next function declaration marks the end of toStripeMinorUnits's
+    // body (functions are concatenated back-to-back by generateHandler()).
+    const nextFnStart = handlerSource.indexOf('function chargeWithStripe', fnStart)
+    expect(nextFnStart).toBeGreaterThan(fnStart)
+    const body = handlerSource.slice(fnStart, nextFnStart)
+    expect(body).toContain('JPY')
+    expect(body).toContain('BHD')
+  })
+
+  it('produces syntactically valid, runnable JavaScript end-to-end', () => {
+    // Evaluating the FULL concatenated handler source (not just one
+    // function in isolation) is what actually catches an orphaned
+    // free-variable reference — exactly like requiring the generated
+    // workflow segment .js file would in production.
+    expect(() => new Function(handlerSource + '\nreturn payment_charge_user;')()).not.toThrow()
+  })
+
+  describe('toStripeMinorUnits — extracted from the serialized handler source', () => {
+    const toStripeMinorUnits = (() => {
+      const fnStart = handlerSource.indexOf('function toStripeMinorUnits')
+      const nextFnStart = handlerSource.indexOf('function chargeWithStripe', fnStart)
+      const body = handlerSource.slice(fnStart, nextFnStart)
+      return new Function(body + '\nreturn toStripeMinorUnits;')() as (
+        major: unknown,
+        currency: string
+      ) => number
+    })()
+
+    it('converts a standard (2-decimal) currency to minor units', () => {
+      expect(toStripeMinorUnits(19.99, 'usd')).toBe(1999)
+    })
+
+    it('passes zero-decimal currencies through rounded, unmultiplied', () => {
+      // This is the exact code path that threw "Oo is not defined" in
+      // production — a JPY (zero-decimal) charge.
+      expect(toStripeMinorUnits(500, 'JPY')).toBe(500)
+      expect(toStripeMinorUnits(500.6, 'jpy')).toBe(501)
+    })
+
+    it('multiplies three-decimal currencies by 1000', () => {
+      expect(toStripeMinorUnits(1.5, 'BHD')).toBe(1500)
+    })
+
+    it('returns 0 for non-finite or non-positive amounts', () => {
+      expect(toStripeMinorUnits(0, 'usd')).toBe(0)
+      expect(toStripeMinorUnits(-5, 'usd')).toBe(0)
+      expect(toStripeMinorUnits(NaN, 'usd')).toBe(0)
+    })
+  })
+})

package/__tests__/resolve-handler-entry-name.test.ts

@@ -0,0 +1,130 @@
+import { resolveHandlerEntryName } from '../src/nodes/types'
+import { nodeRegistry } from '../src/nodes'
+
+/**
+ * Regression coverage for resolveHandlerEntryName, which exists because a
+ * handler's declared name at runtime can diverge from the
+ * `nodeType.replace(/-/g, '_')` convention name: when this package is bundled
+ * and minified by a consumer (e.g. teleport-gui's browser packer worker), the
+ * minifier freely renames a `handlerToString(fn)`-embedded function's
+ * declaration, since nothing in the bundle calls it by name — only the
+ * runtime `.toString()` read does, which is invisible to the minifier.
+ *
+ * Two real handlers exposed shapes the resolver initially got wrong:
+ *   - payment-charge-user.ts: entry declared FIRST, its own helpers after
+ *     (`handlerToString(payment_charge_user) + '\n' + chargeWithStripe.toString() + ...`).
+ *   - ai-custom-prompt.ts: shared AI-provider utils declared BEFORE the
+ *     entry, each wrapped in a `wrapWithGuard`-style re-declaration guard
+ *     (`var X = typeof X !== 'undefined' ? X : function Y() {...};` — a
+ *     function EXPRESSION embedded in a ternary, not a statement-level
+ *     declaration) — this crashed a real publish with "Could not resolve the
+ *     entry function for workflow node type "ai-custom-prompt"".
+ * A naive "first" or "last" positional heuristic breaks one of these two.
+ */
+
+function evalEntryWrapper(source: string, entryName: string): unknown {
+  return new Function(`${source}\nreturn ${entryName};`)()
+}
+
+describe('resolveHandlerEntryName', () => {
+  it('returns the convention name when the source declares it directly', () => {
+    const source = `async function my_node_type(config, context) { return {}; }`
+    expect(resolveHandlerEntryName(source, 'my-node-type')).toBe('my_node_type')
+  })
+
+  it('falls back to the actual declared name when the entry was renamed (single function)', () => {
+    const source = `async function e(config, context) { return {}; }`
+    expect(resolveHandlerEntryName(source, 'my-node-type')).toBe('e')
+  })
+
+  it('finds a renamed entry declared FIRST, before its own helpers (payment-charge-user shape)', () => {
+    const source = `
+async function zzz(config, context) {
+  return helper_one(config) + helper_two(context);
+}
+async function helper_one(config) { return config.x; }
+async function helper_two(context) { return context.y; }
+`
+    const resolved = resolveHandlerEntryName(source, 'payment-charge-user')
+    expect(resolved).toBe('zzz')
+    expect(typeof evalEntryWrapper(source, resolved)).toBe('function')
+  })
+
+  it('finds a renamed entry declared LAST, after ternary-guarded shared utils (ai-custom-prompt shape)', () => {
+    const source = `
+var util_one = typeof util_one !== 'undefined' ? util_one : function util_one(val) { return val; };
+var util_two = typeof util_two !== 'undefined' ? util_two : function util_two(val) { return val; };
+
+async function zzz(config, context, streamCallback) {
+  return util_one(config) + util_two(context);
+}
+`
+    const resolved = resolveHandlerEntryName(source, 'ai-custom-prompt')
+    expect(resolved).toBe('zzz')
+    expect(typeof evalEntryWrapper(source, resolved)).toBe('function')
+  })
+
+  it('prefers the entry-point arity (2-3 params) over a same-position helper with a different arity', () => {
+    // A helper positioned BEFORE the (renamed) entry, but with an arity that
+    // could never be a real handler entry point (1 param) — must not win.
+    const source = `
+function one_param_helper(x) { return x; }
+async function zzz(config, context) { return one_param_helper(config); }
+`
+    expect(resolveHandlerEntryName(source, 'my-node-type')).toBe('zzz')
+  })
+
+  it('throws a clear error when no declaration can be found at all', () => {
+    expect(() => resolveHandlerEntryName('var x = 1;', 'my-node-type')).toThrow(
+      /Could not resolve the entry function/
+    )
+  })
+
+  // Full-registry regression: every node type's generateHandler()/
+  // generateServerHandler() output must resolve to a real, callable function
+  // both normally AND after its entry function's declared name is renamed
+  // (simulating what a minifier does) — proves the resolver's fallback logic
+  // holds for every handler shape actually registered, not just hand-picked
+  // examples.
+  describe('every registered node type', () => {
+    const nodeTypes = Object.keys(nodeRegistry)
+
+    it.each(nodeTypes)(
+      '%s: generateHandler resolves normally and after entry rename',
+      (nodeType) => {
+        const gen = nodeRegistry[nodeType]
+        const source = gen.generateHandler().trim()
+        const conventionName = nodeType.replace(/-/g, '_')
+
+        const resolvedNormal = resolveHandlerEntryName(source, nodeType)
+        expect(typeof evalEntryWrapper(source, resolvedNormal)).toBe('function')
+
+        if (source.includes(conventionName)) {
+          const renamed = source.replace(new RegExp(`\\b${conventionName}\\b`, 'g'), 'zzz_renamed')
+          const resolvedRenamed = resolveHandlerEntryName(renamed, nodeType)
+          expect(resolvedRenamed).toBe('zzz_renamed')
+          expect(typeof evalEntryWrapper(renamed, resolvedRenamed)).toBe('function')
+        }
+      }
+    )
+
+    it.each(nodeTypes.filter((t) => nodeRegistry[t].generateServerHandler))(
+      '%s: generateServerHandler resolves normally and after entry rename',
+      (nodeType) => {
+        const gen = nodeRegistry[nodeType]
+        const source = gen.generateServerHandler!().trim()
+        const conventionName = nodeType.replace(/-/g, '_')
+
+        const resolvedNormal = resolveHandlerEntryName(source, nodeType)
+        expect(typeof evalEntryWrapper(source, resolvedNormal)).toBe('function')
+
+        if (source.includes(conventionName)) {
+          const renamed = source.replace(new RegExp(`\\b${conventionName}\\b`, 'g'), 'zzz_renamed')
+          const resolvedRenamed = resolveHandlerEntryName(renamed, nodeType)
+          expect(resolvedRenamed).toBe('zzz_renamed')
+          expect(typeof evalEntryWrapper(renamed, resolvedRenamed)).toBe('function')
+        }
+      }
+    )
+  })
+})

package/__tests__/stock-decrement-audit.test.ts

@@ -82,6 +82,25 @@ describe('classifyStockWriteSite — single-node categorisation', () => {
     expect(result.category).toBe('order-decrement')
   })
 
+  it('categorises the current NULL-preserving rewritten decrement as order-decrement', () => {
+    // This is the exact shape buildStockDecrementBuilder emits today —
+    // the SET clause guards NULL (unlimited-stock) rows with a CASE
+    // instead of the old COALESCE-based bootstrap. The auditor must not
+    // regress this to "unknown" and start spamming console.warn on
+    // every generation of a correctly-behaving project.
+    const currentRewrite = `${STOCK_DECREMENT_MARKER}
+      function customHandler() {
+        var setClause = "quantity = CASE WHEN quantity IS NULL THEN NULL ELSE GREATEST(0, quantity - (CASE id" + caseExpr + " ELSE 0 END)) END";
+        var query = "UPDATE teleport_products SET " + setClause + " WHERE id IN ('a')";
+        return { query: query, affected: ['a'] };
+      }`
+    const result = classifyStockWriteSite('Place Order 1', {
+      type: 'general-custom-js',
+      config: { code: currentRewrite },
+    })
+    expect(result.category).toBe('order-decrement')
+  })
+
   it('categorises our REWRITTEN decrement EVEN WHEN the SQL is split across string concatenation', () => {
     // This is the exact shape our buildStockDecrementBuilder emits:
     // the SQL is built up via "UPDATE teleport_products SET " + setClause

package/dist/cjs/ecommerce/stock-decrement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stock-decrement.d.ts","sourceRoot":"","sources":["../../../src/ecommerce/stock-decrement.ts"],"names":[],"mappings":"AAwCA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAKxD,eAAO,MAAM,sBAAsB,uCAAuC,CAAA;AAU1E,eAAO,MAAM,8BAA8B,SAAU,MAAM,KAAG,OAiB7D,CAAA;AAsBD,eAAO,MAAM,4BAA4B,q5BAsBrC,CAAA;AA8BJ,eAAO,MAAM,0BAA0B,oBAAqB,OAAO,KAAG,MAiHrE,CAAA;AAsBD,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,UAAU,GAAG,YAAY,CAAA;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,QAAQ,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAAA;IAGjD,UAAU,EAAE,MAAM,CAAA;CACnB;AAiED,eAAO,MAAM,sBAAsB,iBACnB,MAAM,QACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,KAClD;IAAE,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAuC5D,CAAA;AAID,eAAO,MAAM,mBAAmB,SAAU,WAAW,KAAG,cAAc,EAwErE,CAAA;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,cAAc,EAAE,cAAc,EAAE,CAAA;IAChC,OAAO,EAAE,cAAc,EAAE,CAAA;CAC1B;AAID,eAAO,MAAM,oBAAoB,SAAU,WAAW,KAAG,eAQxD,CAAA;AAMD,eAAO,MAAM,qBAAqB,SAAU,WAAW,KAAG,eAmEzD,CAAA;AAuMD,UAAU,YAAY;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,eAAO,MAAM,iCAAiC,SAAU,WAAW,KAAG,YA6BrE,CAAA"}
+{"version":3,"file":"stock-decrement.d.ts","sourceRoot":"","sources":["../../../src/ecommerce/stock-decrement.ts"],"names":[],"mappings":"AAwCA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAKxD,eAAO,MAAM,sBAAsB,uCAAuC,CAAA;AAU1E,eAAO,MAAM,8BAA8B,SAAU,MAAM,KAAG,OAgC7D,CAAA;AAsBD,eAAO,MAAM,4BAA4B,q5BAsBrC,CAAA;AA8BJ,eAAO,MAAM,0BAA0B,oBAAqB,OAAO,KAAG,MAwGrE,CAAA;AAsBD,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,UAAU,GAAG,YAAY,CAAA;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,QAAQ,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAAA;IAGjD,UAAU,EAAE,MAAM,CAAA;CACnB;AA0ED,eAAO,MAAM,sBAAsB,iBACnB,MAAM,QACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,KAClD;IAAE,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAuC5D,CAAA;AAID,eAAO,MAAM,mBAAmB,SAAU,WAAW,KAAG,cAAc,EAwErE,CAAA;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,cAAc,EAAE,cAAc,EAAE,CAAA;IAChC,OAAO,EAAE,cAAc,EAAE,CAAA;CAC1B;AAID,eAAO,MAAM,oBAAoB,SAAU,WAAW,KAAG,eAQxD,CAAA;AAMD,eAAO,MAAM,qBAAqB,SAAU,WAAW,KAAG,eAmEzD,CAAA;AAuMD,UAAU,YAAY;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,eAAO,MAAM,iCAAiC,SAAU,WAAW,KAAG,YA6BrE,CAAA"}

package/dist/cjs/ecommerce/stock-decrement.js

@@ -57,6 +57,19 @@ const looksLikeStockDecrementBuilder = (code) => {
         return false;
     }
     if (code.indexOf(exports.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) {
@@ -184,31 +197,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)
@@ -219,17 +228,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 + ")";
@@ -289,10 +293,12 @@ const looksLikeOrderDecrementCustomHandler = (code) => {
         // 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;
@@ -300,6 +306,9 @@ const looksLikeOrderDecrementCustomHandler = (code) => {
             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;
     }