@tellescope/sdk 1.256.6 → 1.256.7

package/lib/esm/tests/api_tests/stripe_webhook_triggers.test.js

@@ -58,7 +58,7 @@ require('source-map-support').install();
 import { Session } from "../../sdk";
 import { assert, log_header, wait } from "@tellescope/testing";
 import { setup_tests } from "../setup";
-import { invoice_payment_failed_event, item_with_expanded_price_product, item_with_plan_product, item_with_price_product, line_with_expanded_price_product, line_with_plan_product, line_with_price_product, PAUSE_COLLECTION, post_stripe_webhook, setup_stripe_test_integration, sign_stripe_payload, subscription_deleted_event, subscription_paused_event, subscription_resumed_event, subscription_updated_event, } from "../stripe_webhook_helpers";
+import { charge_succeeded_event, discount_with_coupon, discount_with_promo_code, discount_with_promo_code_ref, invoice_paid_event, invoice_paid_line, invoice_payment_failed_event, item_with_expanded_price_product, item_with_plan_product, item_with_price_product, line_with_expanded_price_product, line_with_plan_product, line_with_price_product, PAUSE_COLLECTION, post_stripe_webhook, setup_stripe_test_integration, sign_stripe_payload, subscription_deleted_event, subscription_paused_event, subscription_resumed_event, subscription_updated_event, } from "../stripe_webhook_helpers";
 var host = process.env.API_URL || "http://localhost:8080";
 /**
  * End-to-end coverage of the custom Stripe webhook -> automation trigger path, driven by synthetic
@@ -75,10 +75,10 @@ var host = process.env.API_URL || "http://localhost:8080";
 export var stripe_webhook_triggers_tests = function (_a) {
     var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
     return __awaiter(void 0, void 0, void 0, function () {
-        var RUN, tag, createdEnduserIds, createdTriggerIds, createdProductIds, _b, stripePublicKey, webhooksSecret, cleanup, new_enduser, new_trigger, new_product, poll_for_tag, expect_fired, expect_not_fired, B1_TAG, b1Enduser, b1Event, b1Res, b2Res, B3_TAG, b3Enduser, b3Res, B4_TAG, b4Enduser, b4Res, stripeProductA_1, stripeProductB, productA, productB, B5_TAG, b5Enduser, b5Res, B6_TAG, b6Enduser, B7_TAG, b7Enduser, B8_TAG, b8Enduser, run_scoped_payment_failed_case, f7Scoped, f7Fetched, rejectedInvalidProductId, e_1, run_pause_case, p14Scoped, p14Fetched, rejectedInvalidPausedProductId, e_2;
-        var _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var RUN, tag, createdEnduserIds, createdTriggerIds, createdProductIds, _b, stripePublicKey, webhooksSecret, cleanup, new_enduser, new_trigger, new_product, poll_for_tag, expect_fired, expect_not_fired, B1_TAG, b1Enduser, b1Event, b1Res, b2Res, B3_TAG, b3Enduser, b3Res, B4_TAG, b4Enduser, b4Res, stripeProductA_1, stripeProductB, productA, productB, B5_TAG, b5Enduser, b5Res, B6_TAG, b6Enduser, B7_TAG, b7Enduser, B8_TAG, b8Enduser, run_scoped_payment_failed_case, f7Scoped, f7Fetched, rejectedInvalidProductId, e_1, run_pause_case, p14Scoped, p14Fetched, rejectedInvalidPausedProductId, e_2, poll_for_purchase, run_coupon_invoice_case, c1Enduser, c1Purchases, c1bDiscount, c1bEnduser, c1bPurchases, c5Discount, C7_TAG, C7_SCOPED_TAG, c7Enduser, c7Res, c7Purchases, C8_TAG, c8Enduser, c8Res, c9Trigger, c9Fetched;
+        var _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
                     log_header("Stripe Webhook Triggers");
                     RUN = "".concat(Date.now());
@@ -90,7 +90,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         // Each enduser is matched by the handler on stripeCustomerId, so it must be unique per case.
                     ];
                 case 1:
-                    _b = _e.sent(), stripePublicKey = _b.stripePublicKey, webhooksSecret = _b.webhooksSecret, cleanup = _b.cleanup;
+                    _b = _f.sent(), stripePublicKey = _b.stripePublicKey, webhooksSecret = _b.webhooksSecret, cleanup = _b.cleanup;
                     new_enduser = function (label) { return __awaiter(void 0, void 0, void 0, function () {
                         var stripeCustomerId, enduser;
                         return __generator(this, function (_a) {
@@ -206,20 +206,20 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }
                         });
                     }); };
-                    _e.label = 2;
+                    _f.label = 2;
                 case 2:
-                    _e.trys.push([2, , 69, 72]);
+                    _f.trys.push([2, , 92, 95]);
                     B1_TAG = tag('b1-bad-signature');
                     return [4 /*yield*/, new_enduser('b1')];
                 case 3:
-                    b1Enduser = _e.sent();
+                    b1Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (bad signature) ".concat(RUN),
                             event: { type: 'Subscription Payment Failed', info: {} },
                             tags: [B1_TAG],
                         })];
                 case 4:
-                    _e.sent();
+                    _f.sent();
                     b1Event = invoice_payment_failed_event({ stripeCustomerId: b1Enduser.stripeCustomerId });
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
@@ -228,57 +228,57 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             signature: sign_stripe_payload('{"tampered":true}', webhooksSecret),
                         })];
                 case 5:
-                    b1Res = _e.sent();
+                    b1Res = _f.sent();
                     assert(b1Res.status === 400, "expected 400 for a mismatched signature, got ".concat(b1Res.status), 'invalid signature rejected');
                     return [4 /*yield*/, expect_not_fired(b1Enduser.id, B1_TAG, 'invalid signature does not fire triggers')
                         // B2: unknown public key in the URL -> no integration -> 404
                     ];
                 case 6:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: "pk_test_missing_".concat(RUN),
                             secret: webhooksSecret,
                             event: invoice_payment_failed_event({ stripeCustomerId: "cus_test_missing_".concat(RUN) }),
                         })];
                 case 7:
-                    b2Res = _e.sent();
+                    b2Res = _f.sent();
                     assert(b2Res.status === 404, "expected 404 for an unknown public key, got ".concat(b2Res.status), 'unknown integration rejected');
                     B3_TAG = tag('b3-unknown-customer');
                     return [4 /*yield*/, new_enduser('b3')];
                 case 8:
-                    b3Enduser = _e.sent();
+                    b3Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (unknown customer) ".concat(RUN),
                             event: { type: 'Subscription Payment Failed', info: {} },
                             tags: [B3_TAG],
                         })];
                 case 9:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
                             event: invoice_payment_failed_event({ stripeCustomerId: "cus_test_nobody_".concat(RUN) }),
                         })];
                 case 10:
-                    b3Res = _e.sent();
+                    b3Res = _f.sent();
                     assert(b3Res.status === 200, "expected 200 for an unmatched customer, got ".concat(b3Res.status), 'unmatched customer accepted');
                     return [4 /*yield*/, expect_not_fired(b3Enduser.id, B3_TAG, 'unmatched customer does not fire triggers')
                         // B4: the baseline behavior the productIds feature must preserve — a Subscription Payment Failed
                         // trigger with no product scoping fires for any failed invoice.
                     ];
                 case 11:
-                    _e.sent();
+                    _f.sent();
                     B4_TAG = tag('b4-unscoped');
                     return [4 /*yield*/, new_enduser('b4')];
                 case 12:
-                    b4Enduser = _e.sent();
+                    b4Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (unscoped) ".concat(RUN),
                             event: { type: 'Subscription Payment Failed', info: {} },
                             tags: [B4_TAG],
                         })];
                 case 13:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
@@ -288,35 +288,35 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }),
                         })];
                 case 14:
-                    b4Res = _e.sent();
+                    b4Res = _f.sent();
                     assert(b4Res.status === 200, "expected 200, got ".concat(b4Res.status, " (").concat(b4Res.data, ")"), 'payment failed webhook accepted');
                     return [4 /*yield*/, expect_fired(b4Enduser.id, B4_TAG, 'unscoped Subscription Payment Failed trigger fires')
                         /* ===================== customer.subscription.deleted ===================== */
                         // Products A and B exist to distinguish "the subscription's product" from "some other product".
                     ];
                 case 15:
-                    _e.sent();
+                    _f.sent();
                     stripeProductA_1 = "prod_test_a_".concat(RUN);
                     stripeProductB = "prod_test_b_".concat(RUN);
                     return [4 /*yield*/, new_product('A', stripeProductA_1)];
                 case 16:
-                    productA = _e.sent();
+                    productA = _f.sent();
                     return [4 /*yield*/, new_product('B', stripeProductB)
                         // B5: unscoped Subscription Ended fires
                     ];
                 case 17:
-                    productB = _e.sent();
+                    productB = _f.sent();
                     B5_TAG = tag('b5-ended-unscoped');
                     return [4 /*yield*/, new_enduser('b5')];
                 case 18:
-                    b5Enduser = _e.sent();
+                    b5Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription ended (unscoped) ".concat(RUN),
                             event: { type: 'Subscription Ended', info: {} },
                             tags: [B5_TAG],
                         })];
                 case 19:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
@@ -326,24 +326,24 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }),
                         })];
                 case 20:
-                    b5Res = _e.sent();
+                    b5Res = _f.sent();
                     assert(b5Res.status === 200, "expected 200, got ".concat(b5Res.status, " (").concat(b5Res.data, ")"), 'subscription deleted webhook accepted');
                     return [4 /*yield*/, expect_fired(b5Enduser.id, B5_TAG, 'unscoped Subscription Ended trigger fires')
                         // B6: an explicitly empty productIds list means "all products"
                     ];
                 case 21:
-                    _e.sent();
+                    _f.sent();
                     B6_TAG = tag('b6-ended-empty-list');
                     return [4 /*yield*/, new_enduser('b6')];
                 case 22:
-                    b6Enduser = _e.sent();
+                    b6Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription ended (empty productIds) ".concat(RUN),
                             event: { type: 'Subscription Ended', info: { productIds: [] } },
                             tags: [B6_TAG],
                         })];
                 case 23:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
@@ -353,25 +353,25 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }),
                         })];
                 case 24:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, expect_fired(b6Enduser.id, B6_TAG, 'Subscription Ended trigger with empty productIds fires')
                         // B7/B8 pin the existing product-matching semantics end-to-end, so any refactor of the
                         // productIds query clause is provably behavior-preserving.
                         // B7: productIds matching the subscription's product fires
                     ];
                 case 25:
-                    _e.sent();
+                    _f.sent();
                     B7_TAG = tag('b7-ended-matching');
                     return [4 /*yield*/, new_enduser('b7')];
                 case 26:
-                    b7Enduser = _e.sent();
+                    b7Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription ended (matching product) ".concat(RUN),
                             event: { type: 'Subscription Ended', info: { productIds: [productA.id] } },
                             tags: [B7_TAG],
                         })];
                 case 27:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
@@ -381,23 +381,23 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }),
                         })];
                 case 28:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, expect_fired(b7Enduser.id, B7_TAG, 'Subscription Ended trigger scoped to the matching product fires')
                         // B8: productIds naming a different product does not fire
                     ];
                 case 29:
-                    _e.sent();
+                    _f.sent();
                     B8_TAG = tag('b8-ended-nonmatching');
                     return [4 /*yield*/, new_enduser('b8')];
                 case 30:
-                    b8Enduser = _e.sent();
+                    b8Enduser = _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription ended (other product) ".concat(RUN),
                             event: { type: 'Subscription Ended', info: { productIds: [productB.id] } },
                             tags: [B8_TAG],
                         })];
                 case 31:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, post_stripe_webhook({
                             stripePublicKey: stripePublicKey,
                             secret: webhooksSecret,
@@ -407,14 +407,14 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             }),
                         })];
                 case 32:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, expect_not_fired(b8Enduser.id, B8_TAG, 'Subscription Ended trigger scoped to another product does not fire')
                         /* ============ invoice.payment_failed, scoped to products ============ */
                         // Shared shape for the cases below: a trigger scoped to productA, and an invoice whose line
                         // items are varied per case to cover how Stripe can reference a product.
                     ];
                 case 33:
-                    _e.sent();
+                    _f.sent();
                     run_scoped_payment_failed_case = function (_a) {
                         var label = _a.label, productIds = _a.productIds, lines = _a.lines, shouldFire = _a.shouldFire, title = _a.title;
                         return __awaiter(void 0, void 0, void 0, function () {
@@ -467,7 +467,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 34:
                     // F1: the feature — a trigger scoped to the product that actually failed fires
-                    _e.sent();
+                    _f.sent();
                     // F2: the point of the feature — a trigger scoped to a different product stays quiet
                     return [4 /*yield*/, run_scoped_payment_failed_case({
                             label: 'f2-nonmatching',
@@ -480,7 +480,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 35:
                     // F2: the point of the feature — a trigger scoped to a different product stays quiet
-                    _e.sent();
+                    _f.sent();
                     // F3: "leave blank for all" — an empty list is not a filter
                     return [4 /*yield*/, run_scoped_payment_failed_case({
                             label: 'f3-empty-list',
@@ -493,7 +493,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 36:
                     // F3: "leave blank for all" — an empty list is not a filter
-                    _e.sent();
+                    _f.sent();
                     // F4: price.product may arrive expanded as an object rather than a bare id
                     return [4 /*yield*/, run_scoped_payment_failed_case({
                             label: 'f4-expanded-product',
@@ -506,7 +506,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 37:
                     // F4: price.product may arrive expanded as an object rather than a bare id
-                    _e.sent();
+                    _f.sent();
                     // F5: subscription/proration lines can carry plan.product with no price
                     return [4 /*yield*/, run_scoped_payment_failed_case({
                             label: 'f5-plan-product',
@@ -519,7 +519,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 38:
                     // F5: subscription/proration lines can carry plan.product with no price
-                    _e.sent();
+                    _f.sent();
                     // F6: one matching line among several is enough
                     return [4 /*yield*/, run_scoped_payment_failed_case({
                             label: 'f6-multi-line',
@@ -534,17 +534,17 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 39:
                     // F6: one matching line among several is enough
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (validator round-trip) ".concat(RUN),
                             event: { type: 'Subscription Payment Failed', info: { productIds: [productA.id] } },
                             tags: [tag('f7')],
                         })];
                 case 40:
-                    f7Scoped = _e.sent();
+                    f7Scoped = _f.sent();
                     return [4 /*yield*/, sdk.api.automation_triggers.getOne(f7Scoped.id)];
                 case 41:
-                    f7Fetched = _e.sent();
+                    f7Fetched = _f.sent();
                     assert(JSON.stringify((_c = f7Fetched.event.info) === null || _c === void 0 ? void 0 : _c.productIds) === JSON.stringify([productA.id]), "expected productIds to round-trip, got ".concat(JSON.stringify(f7Fetched.event)), 'productIds round-trips through the validator');
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (empty info) ".concat(RUN),
@@ -552,7 +552,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             tags: [tag('f7-empty-info')],
                         })];
                 case 42:
-                    _e.sent();
+                    _f.sent();
                     assert(true, '', 'empty info accepted');
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (no info) ".concat(RUN),
@@ -560,22 +560,22 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             tags: [tag('f7-no-info')],
                         })];
                 case 43:
-                    _e.sent();
+                    _f.sent();
                     assert(true, '', 'omitted info still accepted');
                     rejectedInvalidProductId = false;
-                    _e.label = 44;
+                    _f.label = 44;
                 case 44:
-                    _e.trys.push([44, 46, , 47]);
+                    _f.trys.push([44, 46, , 47]);
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe payment failed (invalid productId) ".concat(RUN),
                             event: { type: 'Subscription Payment Failed', info: { productIds: ['not-a-mongo-id'] } },
                             tags: [tag('f7-invalid')],
                         })];
                 case 45:
-                    _e.sent();
+                    _f.sent();
                     return [3 /*break*/, 47];
                 case 46:
-                    e_1 = _e.sent();
+                    e_1 = _f.sent();
                     rejectedInvalidProductId = true;
                     return [3 /*break*/, 47];
                 case 47:
@@ -640,7 +640,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     // P1: the core pause path — pause_collection goes null -> set on customer.subscription.updated.
                     // This is how a pause from the billing portal or dashboard actually arrives; there is no
                     // dedicated event for it.
-                    _e.sent();
+                    _f.sent();
                     // P2: the mirror — pause_collection cleared is a resume
                     return [4 /*yield*/, run_pause_case({
                             label: 'p2-pause-collection-cleared',
@@ -658,7 +658,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 49:
                     // P2: the mirror — pause_collection cleared is a resume
-                    _e.sent();
+                    _f.sent();
                     // P3: a pause that is only *modified* (behavior or resumes_at changed) is neither a pause nor a
                     // resume — firing here would re-trigger every time a customer adjusts an existing pause
                     return [4 /*yield*/, run_pause_case({
@@ -679,7 +679,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                 case 50:
                     // P3: a pause that is only *modified* (behavior or resumes_at changed) is neither a pause nor a
                     // resume — firing here would re-trigger every time a customer adjusts an existing pause
-                    _e.sent();
+                    _f.sent();
                     // P4: the volume guard. customer.subscription.updated fires on every renewal, price change and
                     // cancel_at_period_end toggle; with no pause_collection key in previous_attributes the handler
                     // must do nothing (and, in the API, must not even reach the enduser lookup).
@@ -703,7 +703,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     // P4: the volume guard. customer.subscription.updated fires on every renewal, price change and
                     // cancel_at_period_end toggle; with no pause_collection key in previous_attributes the handler
                     // must do nothing (and, in the API, must not even reach the enduser lookup).
-                    _e.sent();
+                    _f.sent();
                     // P4b: the idempotency case. previous_attributes carries only what changed, so an unrelated
                     // update to an already-paused subscription has no pause_collection key even though
                     // pause_collection is currently set. Firing here would re-trigger on every renewal, quantity
@@ -728,7 +728,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     // pause_collection is currently set. Firing here would re-trigger on every renewal, quantity
                     // change and coupon edit for the whole duration of a pause — which is what would happen if the
                     // gate were ever "simplified" to read current state instead of the transition.
-                    _e.sent();
+                    _f.sent();
                     // P5/P6: the dedicated events, which Stripe emits for status='paused' transitions only
                     return [4 /*yield*/, run_pause_case({
                             label: 'p5-dedicated-paused',
@@ -739,7 +739,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         })];
                 case 53:
                     // P5/P6: the dedicated events, which Stripe emits for status='paused' transitions only
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, run_pause_case({
                             label: 'p6-dedicated-resumed',
                             type: 'Subscription Resumed',
@@ -750,7 +750,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
                     ];
                 case 54:
-                    _e.sent();
+                    _f.sent();
                     // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
                     return [4 /*yield*/, run_pause_case({
                             label: 'p7-wrong-direction',
@@ -765,7 +765,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     ];
                 case 55:
                     // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
-                    _e.sent();
+                    _f.sent();
                     // P8: the dedupe guard — the .updated that accompanies a status='paused' transition must not
                     // fire on top of the dedicated event. Stripe isn't expected to send this combination at all;
                     // the case pins the guard so a future refactor can't quietly drop it.
@@ -788,7 +788,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                     // P8: the dedupe guard — the .updated that accompanies a status='paused' transition must not
                     // fire on top of the dedicated event. Stripe isn't expected to send this combination at all;
                     // the case pins the guard so a future refactor can't quietly drop it.
-                    _e.sent();
+                    _f.sent();
                     /* ---- product scoping, over the pause_collection path ---- */
                     // P9-P12: the same matrix the payment-failed cases cover, applied to the new triggers
                     return [4 /*yield*/, run_pause_case({
@@ -807,7 +807,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                 case 57:
                     /* ---- product scoping, over the pause_collection path ---- */
                     // P9-P12: the same matrix the payment-failed cases cover, applied to the new triggers
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, run_pause_case({
                             label: 'p10-scoped-nonmatching',
                             type: 'Subscription Paused',
@@ -822,7 +822,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             title: 'Subscription Paused scoped to another product does not fire',
                         })];
                 case 58:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, run_pause_case({
                             label: 'p11-empty-list',
                             type: 'Subscription Paused',
@@ -839,7 +839,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         // plan.product and expanded price.product objects both have to resolve, same as the invoice path
                     ];
                 case 59:
-                    _e.sent();
+                    _f.sent();
                     // plan.product and expanded price.product objects both have to resolve, same as the invoice path
                     return [4 /*yield*/, run_pause_case({
                             label: 'p12-plan-product',
@@ -856,7 +856,7 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         })];
                 case 60:
                     // plan.product and expanded price.product objects both have to resolve, same as the invoice path
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, run_pause_case({
                             label: 'p13-expanded-product',
                             type: 'Subscription Resumed',
@@ -872,17 +872,17 @@ export var stripe_webhook_triggers_tests = function (_a) {
                         // P14: same round-trip guarantees as F7, for both new types
                     ];
                 case 61:
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription paused (validator round-trip) ".concat(RUN),
                             event: { type: 'Subscription Paused', info: { productIds: [productA.id] } },
                             tags: [tag('p14')],
                         })];
                 case 62:
-                    p14Scoped = _e.sent();
+                    p14Scoped = _f.sent();
                     return [4 /*yield*/, sdk.api.automation_triggers.getOne(p14Scoped.id)];
                 case 63:
-                    p14Fetched = _e.sent();
+                    p14Fetched = _f.sent();
                     assert(JSON.stringify((_d = p14Fetched.event.info) === null || _d === void 0 ? void 0 : _d.productIds) === JSON.stringify([productA.id]), "expected productIds to round-trip, got ".concat(JSON.stringify(p14Fetched.event)), 'Subscription Paused productIds round-trips through the validator');
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription resumed (no info) ".concat(RUN),
@@ -890,41 +890,304 @@ export var stripe_webhook_triggers_tests = function (_a) {
                             tags: [tag('p14-no-info')],
                         })];
                 case 64:
-                    _e.sent();
+                    _f.sent();
                     assert(true, '', 'Subscription Resumed with omitted info accepted');
                     rejectedInvalidPausedProductId = false;
-                    _e.label = 65;
+                    _f.label = 65;
                 case 65:
-                    _e.trys.push([65, 67, , 68]);
+                    _f.trys.push([65, 67, , 68]);
                     return [4 /*yield*/, new_trigger({
                             title: "Stripe subscription paused (invalid productId) ".concat(RUN),
                             event: { type: 'Subscription Paused', info: { productIds: ['not-a-mongo-id'] } },
                             tags: [tag('p14-invalid')],
                         })];
                 case 66:
-                    _e.sent();
+                    _f.sent();
                     return [3 /*break*/, 68];
                 case 67:
-                    e_2 = _e.sent();
+                    e_2 = _f.sent();
                     rejectedInvalidPausedProductId = true;
                     return [3 /*break*/, 68];
                 case 68:
                     assert(rejectedInvalidPausedProductId, 'expected a non-ObjectId productId to be rejected', 'invalid Subscription Paused productId rejected');
+                    poll_for_purchase = function (enduserId, iterations) {
+                        if (iterations === void 0) { iterations = 20; }
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var i, purchases;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        i = 0;
+                                        _a.label = 1;
+                                    case 1:
+                                        if (!(i < iterations)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, wait(undefined, 500)];
+                                    case 2:
+                                        _a.sent();
+                                        return [4 /*yield*/, sdk.api.purchases.getSome({ filter: { enduserId: enduserId } })];
+                                    case 3:
+                                        purchases = _a.sent();
+                                        if (purchases.length)
+                                            return [2 /*return*/, purchases];
+                                        _a.label = 4;
+                                    case 4:
+                                        i++;
+                                        return [3 /*break*/, 1];
+                                    case 5: return [2 /*return*/, []];
+                                }
+                            });
+                        });
+                    };
+                    run_coupon_invoice_case = function (_a) {
+                        var label = _a.label, couponCodes = _a.couponCodes, discounts = _a.discounts, discount = _a.discount, shouldFire = _a.shouldFire, title = _a.title;
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var caseTag, enduser, res;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        caseTag = tag(label);
+                                        return [4 /*yield*/, new_enduser(label)];
+                                    case 1:
+                                        enduser = _b.sent();
+                                        return [4 /*yield*/, new_trigger({
+                                                title: "Stripe purchase made (".concat(label, ") ").concat(RUN),
+                                                event: { type: 'Purchase Made', info: couponCodes !== undefined ? { couponCodes: couponCodes } : {} },
+                                                tags: [caseTag],
+                                            })];
+                                    case 2:
+                                        _b.sent();
+                                        return [4 /*yield*/, post_stripe_webhook({
+                                                stripePublicKey: stripePublicKey,
+                                                secret: webhooksSecret,
+                                                event: invoice_paid_event({
+                                                    stripeCustomerId: enduser.stripeCustomerId,
+                                                    lines: [invoice_paid_line({ description: "Coupon Test ".concat(label, " ").concat(RUN) })],
+                                                    discounts: discounts,
+                                                    discount: discount,
+                                                }),
+                                            })];
+                                    case 3:
+                                        res = _b.sent();
+                                        assert(res.status === 200, "expected 200, got ".concat(res.status, " (").concat(res.data, ")"), "".concat(label, " webhook accepted"));
+                                        if (!shouldFire) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, expect_fired(enduser.id, caseTag, title)];
+                                    case 4:
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 5: return [4 /*yield*/, expect_not_fired(enduser.id, caseTag, title)];
+                                    case 6:
+                                        _b.sent();
+                                        _b.label = 7;
+                                    case 7: return [2 /*return*/, enduser];
+                                }
+                            });
+                        });
+                    };
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c1-matching-promo',
+                            couponCodes: ['SUMMER20'],
+                            discounts: [discount_with_promo_code('SUMMER20')],
+                            shouldFire: true,
+                            title: 'coupon-scoped Purchase Made trigger fires for a matching promo code',
+                        })];
+                case 69:
+                    c1Enduser = _f.sent();
+                    return [4 /*yield*/, poll_for_purchase(c1Enduser.id)];
+                case 70:
+                    c1Purchases = _f.sent();
+                    assert(c1Purchases.some(function (p) { var _a; return (_a = p.couponCodes) === null || _a === void 0 ? void 0 : _a.includes('SUMMER20'); }), "expected a purchase with couponCodes containing SUMMER20, got ".concat(JSON.stringify(c1Purchases.map(function (p) { return p.couponCodes; }))), 'couponCodes persisted on the webhook-created purchase');
+                    c1bDiscount = discount_with_promo_code_ref({ couponId: "coupon_test_c1b_".concat(RUN), couponName: 'Test coupon' });
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c1b-real-shape',
+                            couponCodes: ['Test coupon'],
+                            discount: c1bDiscount,
+                            discounts: [c1bDiscount.id],
+                            shouldFire: true,
+                            title: 'real-shaped invoice.paid payload matches via coupon name',
+                        })];
+                case 71:
+                    c1bEnduser = _f.sent();
+                    return [4 /*yield*/, poll_for_purchase(c1bEnduser.id)];
+                case 72:
+                    c1bPurchases = _f.sent();
+                    assert(c1bPurchases.some(function (p) { var _a, _b; return ((_a = p.couponCodes) === null || _a === void 0 ? void 0 : _a.includes('Test coupon')) && ((_b = p.couponCodes) === null || _b === void 0 ? void 0 : _b.includes("coupon_test_c1b_".concat(RUN))); }), "expected couponCodes with the coupon name and id, got ".concat(JSON.stringify(c1bPurchases.map(function (p) { return p.couponCodes; }))), 'coupon name and id persisted from a real-shaped payload');
+                    // C2: matching is case-sensitive — Stripe sends the canonical merchant-defined code, so a
+                    // differently-cased trigger value must stay quiet (staff can list multiple variants if needed)
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c2-case-mismatch',
+                            couponCodes: ['summer20'],
+                            discounts: [discount_with_promo_code('SUMMER20')],
+                            shouldFire: false,
+                            title: 'coupon match is case-sensitive: a differently-cased code does not fire',
+                        })
+                        // C3: a different code stays quiet
+                    ];
+                case 73:
+                    // C2: matching is case-sensitive — Stripe sends the canonical merchant-defined code, so a
+                    // differently-cased trigger value must stay quiet (staff can list multiple variants if needed)
+                    _f.sent();
+                    // C3: a different code stays quiet
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c3-nonmatching',
+                            couponCodes: ['SUMMER20'],
+                            discounts: [discount_with_promo_code('WINTER10')],
+                            shouldFire: false,
+                            title: 'coupon-scoped trigger does not fire for a different code',
+                        })
+                        // C4: an undiscounted invoice never matches a coupon-scoped trigger
+                    ];
+                case 74:
+                    // C3: a different code stays quiet
+                    _f.sent();
+                    // C4: an undiscounted invoice never matches a coupon-scoped trigger
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c4-no-discounts',
+                            couponCodes: ['SUMMER20'],
+                            shouldFire: false,
+                            title: 'an invoice with no discounts does not fire a coupon-scoped trigger',
+                        })
+                        // C5: admin-applied coupons carry a name but no promotion code, and must still match. Built
+                        // once and referenced by id from `discounts`, mirroring the real single-discount payload shape.
+                    ];
+                case 75:
+                    // C4: an undiscounted invoice never matches a coupon-scoped trigger
+                    _f.sent();
+                    c5Discount = discount_with_coupon('Spring Promo');
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c5-coupon-name',
+                            couponCodes: ['Spring Promo'],
+                            discount: c5Discount,
+                            discounts: [c5Discount.id],
+                            shouldFire: true,
+                            title: 'coupon-scoped trigger matches via coupon name (no promotion code)',
+                        })
+                        // C6: backward compat — an unscoped Purchase Made trigger fires for discounted and
+                        // undiscounted invoices alike
+                    ];
+                case 76:
+                    _f.sent();
+                    // C6: backward compat — an unscoped Purchase Made trigger fires for discounted and
+                    // undiscounted invoices alike
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c6-unscoped-discounted',
+                            discounts: [discount_with_promo_code('SUMMER20')],
+                            shouldFire: true,
+                            title: 'unscoped Purchase Made trigger fires for a discounted invoice',
+                        })];
+                case 77:
+                    // C6: backward compat — an unscoped Purchase Made trigger fires for discounted and
+                    // undiscounted invoices alike
+                    _f.sent();
+                    return [4 /*yield*/, run_coupon_invoice_case({
+                            label: 'c6b-unscoped-undiscounted',
+                            shouldFire: true,
+                            title: 'unscoped Purchase Made trigger fires for an undiscounted invoice',
+                        })
+                        // C7: charge.succeeded with payment_intent null — the coupon lookup is skipped entirely, so
+                        // the purchase is created, the unscoped trigger fires, and the coupon-scoped one does not
+                    ];
+                case 78:
+                    _f.sent();
+                    C7_TAG = tag('c7-charge-unscoped');
+                    C7_SCOPED_TAG = tag('c7-charge-coupon-scoped');
+                    return [4 /*yield*/, new_enduser('c7')];
+                case 79:
+                    c7Enduser = _f.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe purchase made (c7 unscoped) ".concat(RUN),
+                            event: { type: 'Purchase Made', info: {} },
+                            tags: [C7_TAG],
+                        })];
+                case 80:
+                    _f.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe purchase made (c7 coupon-scoped) ".concat(RUN),
+                            event: { type: 'Purchase Made', info: { couponCodes: ['SUMMER20'] } },
+                            tags: [C7_SCOPED_TAG],
+                        })];
+                case 81:
+                    _f.sent();
+                    return [4 /*yield*/, post_stripe_webhook({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: charge_succeeded_event({
+                                customer: {
+                                    id: c7Enduser.stripeCustomerId,
+                                    email: "stripe-webhook-c7-".concat(RUN, "@tellescope.com"),
+                                    name: 'Stripe Webhook c7',
+                                },
+                            }),
+                        })];
+                case 82:
+                    c7Res = _f.sent();
+                    assert(c7Res.status === 200, "expected 200, got ".concat(c7Res.status, " (").concat(c7Res.data, ")"), 'charge.succeeded webhook accepted');
+                    return [4 /*yield*/, expect_fired(c7Enduser.id, C7_TAG, 'unscoped Purchase Made trigger fires for charge.succeeded')];
+                case 83:
+                    _f.sent();
+                    return [4 /*yield*/, expect_not_fired(c7Enduser.id, C7_SCOPED_TAG, 'coupon-scoped trigger does not fire for a charge with no coupon data')];
+                case 84:
+                    _f.sent();
+                    return [4 /*yield*/, poll_for_purchase(c7Enduser.id)];
+                case 85:
+                    c7Purchases = _f.sent();
+                    assert(c7Purchases.length > 0, 'expected charge.succeeded to create a purchase', 'charge.succeeded purchase created');
+                    C8_TAG = tag('c8-charge-failed-lookup');
+                    return [4 /*yield*/, new_enduser('c8')];
+                case 86:
+                    c8Enduser = _f.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe purchase made (c8 failed session lookup) ".concat(RUN),
+                            event: { type: 'Purchase Made', info: {} },
+                            tags: [C8_TAG],
+                        })];
+                case 87:
+                    _f.sent();
+                    return [4 /*yield*/, post_stripe_webhook({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: charge_succeeded_event({
+                                customer: {
+                                    id: c8Enduser.stripeCustomerId,
+                                    email: "stripe-webhook-c8-".concat(RUN, "@tellescope.com"),
+                                    name: 'Stripe Webhook c8',
+                                },
+                                payment_intent: "pi_test_".concat(RUN),
+                            }),
+                        })];
+                case 88:
+                    c8Res = _f.sent();
+                    assert(c8Res.status === 200, "expected 200, got ".concat(c8Res.status, " (").concat(c8Res.data, ")"), 'charge.succeeded with failing session lookup still accepted');
+                    return [4 /*yield*/, expect_fired(c8Enduser.id, C8_TAG, 'a failing checkout-session lookup does not block the purchase or its triggers')
+                        // C9: couponCodes must round-trip on the trigger's event.info
+                    ];
+                case 89:
+                    _f.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe purchase made (validator round-trip) ".concat(RUN),
+                            event: { type: 'Purchase Made', info: { couponCodes: ['SUMMER20'] } },
+                            tags: [tag('c9')],
+                        })];
+                case 90:
+                    c9Trigger = _f.sent();
+                    return [4 /*yield*/, sdk.api.automation_triggers.getOne(c9Trigger.id)];
+                case 91:
+                    c9Fetched = _f.sent();
+                    assert(JSON.stringify((_e = c9Fetched.event.info) === null || _e === void 0 ? void 0 : _e.couponCodes) === JSON.stringify(['SUMMER20']), "expected couponCodes to round-trip, got ".concat(JSON.stringify(c9Fetched.event)), 'couponCodes round-trips through the validator');
                     console.log("All Stripe webhook trigger tests passed!");
-                    return [3 /*break*/, 72];
-                case 69: 
+                    return [3 /*break*/, 95];
+                case 92: 
                 // Best-effort only: the harness exits the process on the first failed assertion, which skips
                 // this block. setup_stripe_test_integration clears integration residue on the next run.
                 return [4 /*yield*/, cleanup().catch(console.error)];
-                case 70:
+                case 93:
                     // Best-effort only: the harness exits the process on the first failed assertion, which skips
                     // this block. setup_stripe_test_integration clears integration residue on the next run.
-                    _e.sent();
+                    _f.sent();
                     return [4 /*yield*/, Promise.all(__spreadArray(__spreadArray(__spreadArray([], createdTriggerIds.map(function (id) { return sdk.api.automation_triggers.deleteOne(id).catch(console.error); }), true), createdProductIds.map(function (id) { return sdk.api.products.deleteOne(id).catch(console.error); }), true), createdEnduserIds.map(function (id) { return sdk.api.endusers.deleteOne(id).catch(console.error); }), true))];
-                case 71:
-                    _e.sent();
+                case 94:
+                    _f.sent();
                     return [7 /*endfinally*/];
-                case 72: return [2 /*return*/];
+                case 95: return [2 /*return*/];
             }
         });
     });