@teleporthq/teleport-plugin-next-workflows 0.43.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 teleporthq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/_helpers/load-handler.ts

@@ -0,0 +1,82 @@
+import { nodeRegistry } from '../../src'
+
+// Shared loader for re-evaluating a runtime handler in the test process.
+//
+// Each entry in `nodeRegistry` exposes its handler via `generateHandler()`,
+// which returns the .toString() of a TS-compiled async function. ts-jest's
+// default ES5 emit downlevels async/await into calls to module-scope helpers
+// `__awaiter` and `__generator`. Those helpers are emitted at the top of
+// every compiled module that USES async syntax — but this helper file does
+// not, so ts-jest skips them here and the `new Function(...)` invocation
+// below would fail with "ReferenceError: __awaiter is not defined".
+//
+// We embed the canonical TS-emit polyfills inline so the helper is
+// self-contained: any caller, even from a file that doesn't trigger helper
+// emission, gets a working handler back.
+//
+// (The polyfills are the verbatim TS 4.x emit, kept in sync with the
+// upstream `__awaiter` / `__generator` definitions tslib ships.)
+const TS_EMIT_HELPERS = `var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+    function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+    function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+    step((generator = generator.apply(thisArg, _arguments)).next());
+  });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0: case 1: t = op; break;
+        case 4: _.label++; return { value: op[1], done: false };
+        case 5: _.label++; y = op[1]; op = [0]; continue;
+        case 7: op = _.ops.pop(); _.trys.pop(); continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+          if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+          if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+          if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+          if (t[2]) _.ops.pop();
+          _.trys.pop(); continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+`
+
+export type HandlerFn = (config: unknown, context: Record<string, unknown>) => Promise<unknown>
+
+/**
+ * Convert a kebab-case node type ("general-delay") into the underscore-cased
+ * symbol the handler is bound to in its compiled source ("general_delay").
+ * The codegen pipeline does the same transformation in api-route-generator.
+ */
+const handlerSymbolFor = (nodeType: string): string => nodeType.replace(/-/g, '_')
+
+/**
+ * Load a handler by node-type string and return it as a callable async fn.
+ * Throws if the type isn't registered. The returned function captures the
+ * eval scope, so `__awaiter`/`__generator` references inside it resolve to
+ * the helpers piped in here.
+ */
+export const loadHandler = (nodeType: string): HandlerFn => {
+  const generator = nodeRegistry[nodeType]
+  if (!generator) {
+    throw new Error(`No handler registered for node type: ${nodeType}`)
+  }
+  const src = generator.generateHandler()
+  const symbol = handlerSymbolFor(nodeType)
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const factory = new Function(`${TS_EMIT_HELPERS}\n${src}\nreturn ${symbol};`)
+  return factory() as HandlerFn
+}

package/__tests__/cart-availability-add-to-cart.test.ts

@@ -0,0 +1,591 @@
+import { __testables as cartAvailability } from '../src/ecommerce/cart-availability'
+import { STOCK_DECREMENT_MARKER } from '../src/ecommerce/stock-decrement'
+import { rewriteLowStockCustomHandlers } from '../src/ecommerce-customhandler-rewriter'
+
+const {
+  looksLikeAddToCartStockCheck,
+  looksLikeAddToCartLimitCheck,
+  buildAddToCartStockCheck,
+  buildAddToCartLimitCheck,
+} = cartAvailability
+
+// ====================================================================
+// AI VERBATIM customHandler code — pasted from the regenerated dist
+// so the detector matchers are validated against real input.
+// ====================================================================
+
+// Step 8 of add-product-to-cart-logic custom node (995fe692, seg-4).
+// Only checks `quantity <= 0` (binary) — does not consider the
+// REQUESTED add quantity vs stock.
+const AI_STEP_8 = `function customHandler(previousContext, params) {
+  var settingsCtx = params[2];
+  var checkResult = params[7];
+  var product = checkResult ? checkResult.product : null;
+  if (!product) {
+    return { available: false, message: "Product not found." };
+  }
+  var stockManagement = settingsCtx ? settingsCtx.stockManagement : false;
+  var allowBackorders = settingsCtx ? settingsCtx.allowBackorders : true;
+  if (stockManagement && !allowBackorders) {
+    var qty = product.quantity;
+    if (qty === null || qty === undefined || Number(qty) <= 0) {
+      return { available: false, message: "This product is currently out of stock." };
+    }
+  }
+  return { available: true, message: "" };
+}`
+
+// Step 11 of add-product-to-cart-logic custom node (seg-5). Only checks
+// the max-per-product cap — does NOT compare against actual DB stock.
+const AI_STEP_11 = `function customHandler(previousContext, params) {
+  var settingsCtx = params[2];
+  var extractCtx = params[0];
+  var cartItems = params[13];
+  var productId = extractCtx ? extractCtx.productId : "";
+  var items = cartItems && Array.isArray(cartItems) ? cartItems : [];
+  if (cartItems && cartItems.items) { items = cartItems.items; }
+  var existingItem = null;
+  var existingQuantity = 0;
+  for (var i = 0; i < items.length; i++) {
+    if (items[i].productId === productId) {
+      existingItem = items[i];
+      existingQuantity = Number(items[i].quantity) || 0;
+      break;
+    }
+  }
+  var maxQty = settingsCtx ? settingsCtx.maxQuantityPerProduct : null;
+  if (maxQty !== null && maxQty !== undefined && Number(maxQty) > 0) {
+    if (existingQuantity >= Number(maxQty)) {
+      return {
+        canAdd: false,
+        message: "You have reached the maximum quantity for this product (" + maxQty + ").",
+        existingItemId: existingItem ? existingItem.id : null,
+        shouldIncrement: false
+      };
+    }
+  }
+  return {
+    canAdd: true,
+    message: "",
+    existingItemId: existingItem ? existingItem.id : null,
+    shouldIncrement: existingItem !== null
+  };
+}`
+
+// ====================================================================
+// PATTERN B: step 8 stock check
+// ====================================================================
+describe('looksLikeAddToCartStockCheck — pattern detection', () => {
+  it('matches the AI verbatim step 8 handler', () => {
+    expect(looksLikeAddToCartStockCheck(AI_STEP_8)).toBe(true)
+  })
+
+  it('rejects already-rewritten code (marker present)', () => {
+    const rewritten = buildAddToCartStockCheck()
+    expect(rewritten).toContain(STOCK_DECREMENT_MARKER)
+    expect(looksLikeAddToCartStockCheck(rewritten)).toBe(false)
+  })
+
+  it('rejects a handler missing the params[2] / params[7] positional pattern', () => {
+    const generic = `function customHandler() { return { available: true, message: '' }; }`
+    expect(looksLikeAddToCartStockCheck(generic)).toBe(false)
+  })
+
+  it('rejects non-string code', () => {
+    expect(looksLikeAddToCartStockCheck(null as any)).toBe(false)
+    expect(looksLikeAddToCartStockCheck(123 as any)).toBe(false)
+  })
+})
+
+describe('buildAddToCartStockCheck — runtime semantics', () => {
+  const fn = (() => {
+    const code = buildAddToCartStockCheck()
+    return new Function(code + '\nreturn customHandler;')() as (prev: any, params: any[]) => any
+  })()
+
+  const baseSettings = (overrides: any = {}) => ({
+    stockManagement: true,
+    allowBackorders: false,
+    maxQuantityPerProduct: 5,
+    ...overrides,
+  })
+
+  it('returns available:false when the product was not found', () => {
+    const result = fn({}, [
+      {},
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: false, product: null },
+    ])
+    expect(result.available).toBe(false)
+    expect(result.message).toContain('no longer available')
+  })
+
+  it('returns available:true when stockManagement is off (no further checks)', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 1 },
+      null,
+      baseSettings({ stockManagement: false }),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 0 } },
+    ])
+    expect(result.available).toBe(true)
+  })
+
+  it('returns available:true when allowBackorders=true (merchant opted in)', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 1 },
+      null,
+      baseSettings({ allowBackorders: true }),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 0 } },
+    ])
+    expect(result.available).toBe(true)
+  })
+
+  it('returns available:true when stock is null (unlimited)', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 999 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: null } },
+    ])
+    expect(result.available).toBe(true)
+  })
+
+  it('returns available:false with product name when stock is 0', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 1 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 0 } },
+    ])
+    expect(result.available).toBe(false)
+    expect(result.message).toBe('"Apple" is out of stock.')
+  })
+
+  it('returns available:false with "Only N of X are in stock." when requested > stock', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 5 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 2 } },
+    ])
+    expect(result.available).toBe(false)
+    expect(result.message).toBe('Only 2 of "Apple" are in stock.')
+  })
+
+  it('uses singular grammar ("is") when only 1 unit remains', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 5 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 1 } },
+    ])
+    expect(result.message).toBe('Only 1 of "Apple" is in stock.')
+  })
+
+  it('returns available:true when requested <= stock', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 2 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 5 } },
+    ])
+    expect(result.available).toBe(true)
+    expect(result.message).toBe('')
+  })
+
+  it('coerces missing/invalid requested quantity to 1', () => {
+    const result = fn({}, [
+      { productId: 'a' }, // no quantity field
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { name: 'Apple', quantity: 5 } },
+    ])
+    expect(result.available).toBe(true)
+  })
+
+  it('falls back to "this product" when DB row has no name', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 5 },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { quantity: 1 } },
+    ])
+    expect(result.message).toContain('"this product"')
+  })
+
+  it('uses the trigger payload`s name when DB row has no name', () => {
+    const result = fn({}, [
+      { productId: 'a', quantity: 5, name: 'From-Cart Name' },
+      null,
+      baseSettings(),
+      null,
+      null,
+      null,
+      null,
+      { found: true, product: { quantity: 1 } },
+    ])
+    expect(result.message).toContain('"From-Cart Name"')
+  })
+})
+
+// ====================================================================
+// PATTERN C: step 11 cart-aware limit + stock check
+// ====================================================================
+describe('looksLikeAddToCartLimitCheck — pattern detection', () => {
+  it('matches the AI verbatim step 11 handler', () => {
+    expect(looksLikeAddToCartLimitCheck(AI_STEP_11)).toBe(true)
+  })
+
+  it('rejects already-rewritten code (marker present)', () => {
+    const rewritten = buildAddToCartLimitCheck()
+    expect(rewritten).toContain(STOCK_DECREMENT_MARKER)
+    expect(looksLikeAddToCartLimitCheck(rewritten)).toBe(false)
+  })
+
+  it('rejects a handler missing the distinguishing fields', () => {
+    const generic = `function customHandler() { return {}; }`
+    expect(looksLikeAddToCartLimitCheck(generic)).toBe(false)
+  })
+
+  it('rejects a handler that has canAdd but missing maxQuantityPerProduct', () => {
+    const partial = `function customHandler() {
+      var canAdd = true;
+      var shouldIncrement = false;
+      var existingItemId = null;
+      return { canAdd, shouldIncrement, existingItemId };
+    }`
+    expect(looksLikeAddToCartLimitCheck(partial)).toBe(false)
+  })
+})
+
+describe('buildAddToCartLimitCheck — runtime semantics', () => {
+  const fn = (() => {
+    const code = buildAddToCartLimitCheck()
+    return new Function(code + '\nreturn customHandler;')() as (prev: any, params: any[]) => any
+  })()
+
+  const baseSettings = (overrides: any = {}) => ({
+    stockManagement: true,
+    allowBackorders: false,
+    maxQuantityPerProduct: 5,
+    ...overrides,
+  })
+
+  // The AI workflow puts these at specific positional indices:
+  //   params[0] = extractCtx { productId, quantity }
+  //   params[2] = settingsCtx
+  //   params[6] = foundCtx { found, product }
+  //   params[13] = cartItems (array)
+  // We test with the AI's positional layout AND with shape-walking
+  // fallback (rearranged params).
+  const buildParams = (
+    productId: string,
+    quantity: number,
+    settings: any,
+    product: any,
+    cartItems: any[]
+  ): any[] => {
+    const arr: any[] = new Array(14).fill(null)
+    arr[0] = { productId, quantity }
+    arr[2] = settings
+    arr[6] = product ? { found: true, product } : { found: false, product: null }
+    arr[13] = cartItems
+    return arr
+  }
+
+  it('new item, no cart entry, under max + under stock → canAdd:true, shouldIncrement:false', () => {
+    const params = buildParams('a', 1, baseSettings(), { name: 'Apple', quantity: 5 }, [])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(false)
+    expect(result.existingItemId).toBe(null)
+  })
+
+  it('existing item, under max + under stock → canAdd:true, shouldIncrement:true', () => {
+    const params = buildParams('a', 1, baseSettings(), { name: 'Apple', quantity: 5 }, [
+      { id: 'cart-1', productId: 'a', quantity: 2 },
+    ])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-1')
+  })
+
+  it('new item would exceed maxQuantityPerProduct → canAdd:false, names product', () => {
+    const params = buildParams(
+      'a',
+      6,
+      baseSettings({ maxQuantityPerProduct: 5 }),
+      { name: 'Apple', quantity: 99 },
+      []
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(false)
+    expect(result.message).toBe('You can only have 5 of "Apple" in your cart.')
+    expect(result.shouldIncrement).toBe(false)
+  })
+
+  it('existing item already at max → canAdd:false, names product', () => {
+    const params = buildParams(
+      'a',
+      1,
+      baseSettings({ maxQuantityPerProduct: 5 }),
+      { name: 'Apple', quantity: 99 },
+      [{ id: 'cart-1', productId: 'a', quantity: 5 }]
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(false)
+    expect(result.message).toContain('"Apple"')
+  })
+
+  it('existing item + requested would exceed stock → canAdd:false, says "Only N more …"', () => {
+    // Stock 5, existing 3 in cart, requested 3 more → 6 total, only 2 more can be added
+    const params = buildParams(
+      'a',
+      3,
+      baseSettings({ maxQuantityPerProduct: 100 }),
+      { name: 'Apple', quantity: 5 },
+      [{ id: 'cart-1', productId: 'a', quantity: 3 }]
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(false)
+    expect(result.message).toBe(
+      'Only 2 more of "Apple" can be added (you have 3 in cart, 5 in stock).'
+    )
+  })
+
+  it('existing item exactly at stock cap → canAdd:false, "X is out of stock"', () => {
+    // Stock 3, existing 3 in cart, requested 1 more → 4 > 3, but existing >= stock so OUT-OF-STOCK message
+    const params = buildParams(
+      'a',
+      1,
+      baseSettings({ maxQuantityPerProduct: 100 }),
+      { name: 'Apple', quantity: 3 },
+      [{ id: 'cart-1', productId: 'a', quantity: 3 }]
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(false)
+    expect(result.message).toBe('"Apple" is out of stock.')
+  })
+
+  it('stock check skipped when stockManagement is off — only max enforced', () => {
+    const params = buildParams(
+      'a',
+      99,
+      baseSettings({ stockManagement: false, maxQuantityPerProduct: 100 }),
+      { name: 'Apple', quantity: 1 },
+      []
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+  })
+
+  it('stock check skipped when allowBackorders=true — only max enforced', () => {
+    const params = buildParams(
+      'a',
+      99,
+      baseSettings({ allowBackorders: true, maxQuantityPerProduct: 100 }),
+      { name: 'Apple', quantity: 1 },
+      []
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+  })
+
+  it('null product quantity (unlimited) → no stock blocking', () => {
+    // Disable max-per-product cap so we isolate the stock-check
+    // branch; otherwise the max cap fires first and the test no
+    // longer measures what it claims to measure.
+    const params = buildParams(
+      'a',
+      1000,
+      baseSettings({ maxQuantityPerProduct: null }),
+      { name: 'Apple', quantity: null },
+      []
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+  })
+
+  it('no maxQuantityPerProduct cap (null) and no stock issue → canAdd:true', () => {
+    const params = buildParams(
+      'a',
+      50,
+      baseSettings({ maxQuantityPerProduct: null }),
+      { name: 'Apple', quantity: 100 },
+      []
+    )
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+  })
+
+  it('coerces missing/invalid requested quantity to 1', () => {
+    const arr: any[] = new Array(14).fill(null)
+    arr[0] = { productId: 'a' } // no quantity
+    arr[2] = baseSettings()
+    arr[6] = { found: true, product: { name: 'Apple', quantity: 5 } }
+    arr[13] = []
+    const result = fn({}, arr)
+    expect(result.canAdd).toBe(true)
+  })
+
+  it('name resolution: prefers DB product name over cart/trigger names', () => {
+    const params = buildParams(
+      'a',
+      99,
+      baseSettings({ maxQuantityPerProduct: 1 }),
+      { name: 'DB Name', quantity: 100 },
+      []
+    )
+    params[0].name = 'Trigger Name'
+    const result = fn({}, params)
+    expect(result.message).toContain('"DB Name"')
+  })
+
+  it('name resolution: falls back to "this product" when nothing is available', () => {
+    const arr: any[] = new Array(14).fill(null)
+    arr[0] = { productId: 'a', quantity: 99 }
+    arr[2] = baseSettings({ maxQuantityPerProduct: 1 })
+    arr[6] = { found: true, product: { quantity: 100 } } // no name
+    arr[13] = []
+    const result = fn({}, arr)
+    expect(result.message).toContain('"this product"')
+  })
+
+  it('finds cartItems via shape-walking when not at positional index 13', () => {
+    // Build params with cart at a different index — handler must
+    // still find it via the shape walk.
+    const params: any[] = []
+    params[0] = { productId: 'a', quantity: 1 }
+    params[2] = baseSettings()
+    params[6] = { found: true, product: { name: 'Apple', quantity: 5 } }
+    params[7] = [{ id: 'cart-X', productId: 'a', quantity: 2 }] // cart at index 7 instead of 13
+    const result = fn({}, params)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-X')
+  })
+
+  it('accepts cart wrapped as { items: [...] }', () => {
+    const params: any[] = []
+    params[0] = { productId: 'a', quantity: 1 }
+    params[2] = baseSettings()
+    params[6] = { found: true, product: { name: 'Apple', quantity: 5 } }
+    params[8] = { items: [{ id: 'cart-Y', productId: 'a', quantity: 1 }] }
+    const result = fn({}, params)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-Y')
+  })
+
+  it('finds foundCtx via shape-walking when not at positional index 6', () => {
+    const params: any[] = []
+    params[0] = { productId: 'a', quantity: 1 }
+    params[2] = baseSettings()
+    params[4] = { found: true, product: { name: 'Apple', quantity: 5 } } // at index 4 not 6
+    params[13] = []
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+  })
+})
+
+// ====================================================================
+// Rewriter integration — both patterns
+// ====================================================================
+describe('rewriter integration — add-to-cart patterns', () => {
+  const buildUidl = (stockManagement: boolean = true) =>
+    ({
+      workflows: {
+        workflows: {},
+        customNodes: {
+          atc: {
+            id: 'atc',
+            name: 'Add Product To Cart Logic',
+            nodes: [
+              { id: 'step8', type: 'general-custom-js', config: { code: AI_STEP_8 } },
+              { id: 'step11', type: 'general-custom-js', config: { code: AI_STEP_11 } },
+            ],
+          },
+        },
+      },
+      ecommerceSettings: {
+        stockManagement,
+        stockManagementConfig: {
+          allowBackorders: false,
+          lowStockThreshold: 5,
+          lowStockAlerts: false,
+          maxQuantityPerProduct: 5,
+        },
+      },
+    } as any)
+
+  it('rewrites both step 8 AND step 11 customHandlers when stockManagement is on', () => {
+    const uidl = buildUidl(true)
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(summary.addToCartStockCheckRewrites).toBe(1)
+    expect(summary.addToCartLimitCheckRewrites).toBe(1)
+    expect(uidl.workflows.customNodes.atc.nodes[0].config.code).toContain(STOCK_DECREMENT_MARKER)
+    expect(uidl.workflows.customNodes.atc.nodes[1].config.code).toContain(STOCK_DECREMENT_MARKER)
+  })
+
+  it('SKIPS step 8 stock check rewrite when stockManagement is off', () => {
+    const uidl = buildUidl(false)
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(summary.addToCartStockCheckRewrites).toBe(0)
+    expect(uidl.workflows.customNodes.atc.nodes[0].config.code).toBe(AI_STEP_8)
+  })
+
+  it('STILL rewrites step 11 even when stockManagement is off (max-per-product cap is independent)', () => {
+    const uidl = buildUidl(false)
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(summary.addToCartLimitCheckRewrites).toBe(1)
+    expect(uidl.workflows.customNodes.atc.nodes[1].config.code).toContain(STOCK_DECREMENT_MARKER)
+  })
+
+  it('is idempotent — second run does NOT re-rewrite', () => {
+    const uidl = buildUidl(true)
+    rewriteLowStockCustomHandlers(uidl)
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(summary.addToCartStockCheckRewrites).toBe(0)
+    expect(summary.addToCartLimitCheckRewrites).toBe(0)
+  })
+})