@simplelayer/graniteer-core 0.1.2 → 0.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/index.js +2 -2
- package/package.json +73 -2
- package/src/agreementCheckout.ts +250 -0
- package/src/agreementPortalEmail.ts +128 -0
- package/src/billingPortalLinkEmail.ts +117 -0
- package/src/bookingAgreementEmail.ts +149 -0
- package/src/bookingEffects.ts +388 -0
- package/src/busClient.ts +268 -0
- package/src/busSignature.ts +71 -0
- package/src/checkoutCoupon.test.ts +675 -0
- package/src/checkoutCoupon.ts +455 -0
- package/src/commonsDeposit.ts +298 -0
- package/src/commonsDepositWebhook.ts +237 -0
- package/src/dayPassConfirmation.ts +230 -0
- package/src/dunningEmails.test.ts +263 -0
- package/src/dunningEmails.ts +203 -0
- package/src/email-templates/brand.ts +93 -0
- package/src/email-templates/magic-link.tsx +59 -0
- package/src/email-templates/recovery.tsx +59 -0
- package/src/email-templates/signup.tsx +67 -0
- package/src/functions/admin-cancel-membership.ts +311 -311
- package/src/functions/admin-change-membership-plan.ts +312 -308
- package/src/functions/admin-charge-guest-print.ts +229 -229
- package/src/functions/admin-correct-booking.ts +333 -333
- package/src/functions/admin-create-booking.ts +460 -0
- package/src/functions/admin-create-commons-event.ts +244 -244
- package/src/functions/admin-debug-boldsign-doc.ts +93 -93
- package/src/functions/admin-door-write.ts +272 -272
- package/src/functions/admin-issue-day-pass.ts +231 -0
- package/src/functions/admin-mark-booking-paid.ts +203 -203
- package/src/functions/admin-mint-billing-portal-link.ts +168 -0
- package/src/functions/admin-mint-portal-link.ts +62 -0
- package/src/functions/admin-photo-upload.ts +128 -128
- package/src/functions/admin-remove-team-member.ts +150 -150
- package/src/functions/admin-request-trial.ts +366 -0
- package/src/functions/admin-resend-commons-deposit-link.ts +323 -0
- package/src/functions/admin-reset-mfa.ts +138 -138
- package/src/functions/admin-retry-invoice-payment.test.ts +567 -0
- package/src/functions/admin-retry-invoice-payment.ts +333 -0
- package/src/functions/admin-reverse-coupon-redemption.ts +98 -98
- package/src/functions/admin-revoke-agreement.ts +467 -0
- package/src/functions/admin-send-commons-agreement.ts +214 -214
- package/src/functions/admin-set-credit-amount.ts +123 -123
- package/src/functions/admin-skip-commons-contract.ts +165 -165
- package/src/functions/admin-undo-membership-cancel.ts +144 -144
- package/src/functions/admin-wall-photo-write.ts +141 -141
- package/src/functions/auth-email-hook.ts +259 -0
- package/src/functions/boldsign-sender-identity.ts +114 -114
- package/src/functions/booking-availability.ts +419 -419
- package/src/functions/booking-member-preview.ts +136 -136
- package/src/functions/booking-status.ts +149 -0
- package/src/functions/conductor.ts +505 -0
- package/src/functions/create-agreement.ts +537 -0
- package/src/functions/create-booking.ts +648 -0
- package/src/functions/create-day-pass-checkout.ts +218 -0
- package/src/functions/create-portal-session.ts +142 -0
- package/src/functions/create-subscription-checkout.test.ts +222 -0
- package/src/functions/create-subscription-checkout.ts +440 -0
- package/src/functions/day-pass-status.ts +89 -89
- package/src/functions/diag-webpush-test.ts +45 -45
- package/src/functions/event-access-admin.ts +277 -0
- package/src/functions/event-access-store.ts +334 -309
- package/src/functions/ezeep-print-webhook.ts +213 -213
- package/src/functions/ezeep-usage-reconcile.ts +299 -299
- package/src/functions/fetch-avatar-original.ts +457 -0
- package/src/functions/get-provider-sign-link.ts +155 -0
- package/src/functions/get-signing-link.ts +211 -211
- package/src/functions/guest-print-setup-confirm.ts +128 -128
- package/src/functions/guest-print-submit.ts +149 -149
- package/src/functions/luma-webhook.ts +165 -165
- package/src/functions/manage-booking.ts +472 -0
- package/src/functions/mcp.ts +67 -0
- package/src/functions/member-door-action.test.ts +1248 -0
- package/src/functions/member-door-action.ts +863 -0
- package/src/functions/member-unifi-mapping.test.ts +516 -0
- package/src/functions/member-unifi-mapping.ts +206 -0
- package/src/functions/membership-door-sync.ts +956 -0
- package/src/functions/migration-collision-alert.copy.ts +232 -232
- package/src/functions/migration-collision-alert.test.ts +349 -349
- package/src/functions/migration-collision-alert.ts +232 -232
- package/src/functions/office-assignment-end.ts +146 -146
- package/src/functions/portal-booking-access.ts +217 -95
- package/src/functions/portal-list-invoices.ts +99 -99
- package/src/functions/portal-request-login.ts +192 -0
- package/src/functions/portal-resend-invite.ts +248 -0
- package/src/functions/portal-submit-event.ts +168 -0
- package/src/functions/print-billing-recover.ts +97 -97
- package/src/functions/print-billing-run.ts +183 -183
- package/src/functions/public-facts.ts +168 -168
- package/src/functions/push-send.ts +348 -0
- package/src/functions/push-test.ts +234 -0
- package/src/functions/request-portal-link.ts +211 -0
- package/src/functions/reschedule-booking.ts +649 -0
- package/src/functions/review-ratings.ts +113 -0
- package/src/functions/space-availability-range.acceptance.test.ts +161 -161
- package/src/functions/space-availability-range.ts +142 -142
- package/src/functions/stripe-db-reconcile.ts +319 -0
- package/src/functions/stripe-webhook.moved-regression.test.ts +78 -0
- package/src/functions/stripe-webhook.ts +2595 -0
- package/src/functions/sync-gcal-blackouts.ts +298 -298
- package/src/functions/timetable-event-register.ts +162 -162
- package/src/functions/timetable-event-status.ts +90 -90
- package/src/functions/timetable-spaces.ts +219 -219
- package/src/functions/touch-pass-reconciler.ts +689 -689
- package/src/functions/touch-pass-signup.ts +478 -0
- package/src/functions/upload-booking-display-image.ts +179 -0
- package/src/functions/virtual-onboarding-purge.ts +134 -134
- package/src/functions/virtual-onboarding-submit.ts +315 -315
- package/src/functions/voice-booking.ts +453 -0
- package/src/functions/voice-day-pass.ts +346 -0
- package/src/functions/voice-inquiry.test.ts +301 -301
- package/src/functions/voice-inquiry.ts +198 -198
- package/src/functions/voice-membership-signup.ts +355 -0
- package/src/functions/voice-tour-availability.ts +204 -204
- package/src/functions/voice-tour-booking.ts +429 -0
- package/src/ghlEventInquiry.ts +143 -0
- package/src/mailArrivalEmail.ts +121 -0
- package/src/manageToken.ts +363 -0
- package/src/membershipBusClient.ts +537 -0
- package/src/membershipWelcome.ts +683 -0
- package/src/migrationCheckout.ts +366 -0
- package/src/pacificDate.ts +54 -0
- package/src/paymentLinkEmail.ts +123 -0
- package/src/signedUnpaidReminderEmail.test.ts +246 -0
- package/src/signedUnpaidReminderEmail.ts +132 -0
- package/src/stripeCoworkingPortal.ts +91 -0
- package/src/supabaseTestFakes.ts +131 -131
- package/src/supportTicketEmail.ts +119 -0
- package/src/unifiAccessPolicies.ts +228 -0
- package/src/unifiGroups.ts +129 -0
|
@@ -0,0 +1,675 @@
|
|
|
1
|
+
// Fully mocked. NO network: the Supabase client and the Stripe client are
|
|
2
|
+
// both hand-rolled stubs, so this can run against a live-only Stripe account
|
|
3
|
+
// with zero risk of touching it.
|
|
4
|
+
//
|
|
5
|
+
// Covers the two things that decide whether coupon-at-checkout is safe:
|
|
6
|
+
// 1. every coupon_validate / coupon_redeem outcome maps to the right
|
|
7
|
+
// user-facing 400 (or to a usable Stripe coupon id);
|
|
8
|
+
// 2. with NO coupon_code, the Checkout Session params are byte-identical to
|
|
9
|
+
// what the functions built before this change.
|
|
10
|
+
|
|
11
|
+
import { assertEquals, assert, assertMatch } from 'https://deno.land/std@0.224.0/assert/mod.ts';
|
|
12
|
+
import {
|
|
13
|
+
applyCheckoutCoupon,
|
|
14
|
+
buildStripeCouponParams,
|
|
15
|
+
couponErrorMessage,
|
|
16
|
+
couponFailureBody,
|
|
17
|
+
reverseCheckoutCoupon,
|
|
18
|
+
type CouponSupabaseClient,
|
|
19
|
+
type CouponStripeClient,
|
|
20
|
+
} from './checkoutCoupon.ts';
|
|
21
|
+
import {
|
|
22
|
+
buildSubscriptionSessionParams,
|
|
23
|
+
buildDayPassSessionParams,
|
|
24
|
+
} from './checkoutSessionParams.ts';
|
|
25
|
+
|
|
26
|
+
const PLAN_ID = '11111111-1111-1111-1111-111111111111';
|
|
27
|
+
const COUPON_ID = '22222222-2222-2222-2222-222222222222';
|
|
28
|
+
const REDEMPTION_ID = '33333333-3333-3333-3333-333333333333';
|
|
29
|
+
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
30
|
+
|
|
31
|
+
type RpcResult = { data: unknown; error: unknown };
|
|
32
|
+
|
|
33
|
+
interface StubOpts {
|
|
34
|
+
validate?: RpcResult;
|
|
35
|
+
redeem?: RpcResult;
|
|
36
|
+
/**
|
|
37
|
+
* Per-call coupon_redeem results, for the reversed-row retry path. Call N
|
|
38
|
+
* gets entry N; once exhausted every further call repeats the last entry
|
|
39
|
+
* (so "always returns reversed" is a one-element sequence).
|
|
40
|
+
*/
|
|
41
|
+
redeemSequence?: RpcResult[];
|
|
42
|
+
couponRow?: unknown;
|
|
43
|
+
/** What a `coupon_redemptions` row-read returns (reverseCheckoutCoupon's guard). */
|
|
44
|
+
redemptionRow?: unknown;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/** Records every rpc call so a test can assert what did (or didn't) happen. */
|
|
48
|
+
function makeSupabase(opts: StubOpts) {
|
|
49
|
+
const calls: Array<{ fn: string; args: Record<string, unknown> }> = [];
|
|
50
|
+
let redeemCalls = 0;
|
|
51
|
+
const client: CouponSupabaseClient & { calls: typeof calls } = {
|
|
52
|
+
calls,
|
|
53
|
+
rpc(fn: string, args: Record<string, unknown>) {
|
|
54
|
+
calls.push({ fn, args });
|
|
55
|
+
if (fn === 'coupon_validate') return Promise.resolve(opts.validate ?? { data: null, error: null });
|
|
56
|
+
if (fn === 'coupon_redeem') {
|
|
57
|
+
const i = redeemCalls++;
|
|
58
|
+
if (opts.redeemSequence) {
|
|
59
|
+
return Promise.resolve(opts.redeemSequence[Math.min(i, opts.redeemSequence.length - 1)]);
|
|
60
|
+
}
|
|
61
|
+
return Promise.resolve(opts.redeem ?? { data: null, error: null });
|
|
62
|
+
}
|
|
63
|
+
if (fn === 'coupon_reverse') return Promise.resolve({ data: null, error: null });
|
|
64
|
+
throw new Error(`unexpected rpc ${fn}`);
|
|
65
|
+
},
|
|
66
|
+
from(table: string) {
|
|
67
|
+
let row: unknown;
|
|
68
|
+
if (table === 'coupons') {
|
|
69
|
+
row = 'couponRow' in opts
|
|
70
|
+
? opts.couponRow
|
|
71
|
+
: { id: COUPON_ID, discount_type: 'percent', value: 100, duration: 'once', duration_in_months: null, applies_to: 'all' };
|
|
72
|
+
} else if (table === 'coupon_redemptions') {
|
|
73
|
+
// Default 'reserved' so the pre-existing reversal tests keep exercising
|
|
74
|
+
// the path where coupon_reverse actually fires.
|
|
75
|
+
row = 'redemptionRow' in opts
|
|
76
|
+
? opts.redemptionRow
|
|
77
|
+
: { id: REDEMPTION_ID, status: 'reserved' };
|
|
78
|
+
} else {
|
|
79
|
+
throw new Error(`unexpected table ${table}`);
|
|
80
|
+
}
|
|
81
|
+
const chain = {
|
|
82
|
+
select: () => chain,
|
|
83
|
+
eq: () => chain,
|
|
84
|
+
maybeSingle: () => Promise.resolve({ data: row, error: null }),
|
|
85
|
+
};
|
|
86
|
+
return chain;
|
|
87
|
+
},
|
|
88
|
+
};
|
|
89
|
+
return client;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
function makeStripe() {
|
|
93
|
+
const created: unknown[] = [];
|
|
94
|
+
const client: CouponStripeClient & { created: unknown[] } = {
|
|
95
|
+
created,
|
|
96
|
+
coupons: {
|
|
97
|
+
create(params) {
|
|
98
|
+
created.push(params);
|
|
99
|
+
return Promise.resolve({ id: params.id as string });
|
|
100
|
+
},
|
|
101
|
+
retrieve(id: string) {
|
|
102
|
+
return Promise.resolve({ id });
|
|
103
|
+
},
|
|
104
|
+
},
|
|
105
|
+
};
|
|
106
|
+
return client;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
const BASE_OPTS = {
|
|
110
|
+
code: 'GCSTAFFKYLE',
|
|
111
|
+
fnName: 'create-subscription-checkout',
|
|
112
|
+
planId: PLAN_ID,
|
|
113
|
+
planSlug: 'workday',
|
|
114
|
+
planName: 'Workday',
|
|
115
|
+
emailKey: 'kyle@simplelayer.io',
|
|
116
|
+
baseAmountCents: 17900,
|
|
117
|
+
appliedToType: 'membership' as const,
|
|
118
|
+
oneTime: false,
|
|
119
|
+
actorEmail: 'ops@example.com',
|
|
120
|
+
};
|
|
121
|
+
|
|
122
|
+
Deno.test('valid 100%-off coupon -> reserved + one-off Stripe coupon', async () => {
|
|
123
|
+
const supabase = makeSupabase({
|
|
124
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
125
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
126
|
+
});
|
|
127
|
+
const stripe = makeStripe();
|
|
128
|
+
|
|
129
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
130
|
+
|
|
131
|
+
assert(out.ok, 'expected ok outcome');
|
|
132
|
+
assertEquals(out.redemptionId, REDEMPTION_ID);
|
|
133
|
+
assertEquals(out.couponId, COUPON_ID);
|
|
134
|
+
assertEquals(out.discountCents, 17900);
|
|
135
|
+
assertEquals(out.stripeCouponId, `gcc-${REDEMPTION_ID}`);
|
|
136
|
+
|
|
137
|
+
// coupon_validate is called with a NULL membership id -- no membership row
|
|
138
|
+
// exists yet for a new signup -- and scoped by plan.
|
|
139
|
+
const v = supabase.calls.find((c) => c.fn === 'coupon_validate')!;
|
|
140
|
+
assertEquals(v.args.p_membership_id, null);
|
|
141
|
+
assertEquals(v.args.p_scope_type, 'plan');
|
|
142
|
+
assertEquals(v.args.p_scope_target_id, PLAN_ID);
|
|
143
|
+
assertEquals(v.args.p_base_amount_cents, 17900);
|
|
144
|
+
|
|
145
|
+
// Deterministic idempotency key -- a retried checkout must not double-redeem.
|
|
146
|
+
const r = supabase.calls.find((c) => c.fn === 'coupon_redeem')!;
|
|
147
|
+
assertEquals(r.args.p_idempotency_key, `workday:kyle@simplelayer.io:${COUPON_ID}`);
|
|
148
|
+
assertEquals(r.args.p_applied_to_type, 'membership');
|
|
149
|
+
// applied_to_id is a fresh per-attempt uuid, NEVER the plan id -- the partial
|
|
150
|
+
// unique index on (applied_to_type, applied_to_id) would otherwise cap the
|
|
151
|
+
// whole plan at one non-reversed redemption, forever.
|
|
152
|
+
assert(r.args.p_applied_to_id !== PLAN_ID, 'p_applied_to_id must not be the plan id');
|
|
153
|
+
assertEquals(r.args.p_applied_to_id, out.attemptId);
|
|
154
|
+
assertMatch(String(r.args.p_applied_to_id), UUID_RE);
|
|
155
|
+
|
|
156
|
+
assertEquals((stripe.created[0] as Record<string, unknown>).percent_off, 100);
|
|
157
|
+
assertEquals((stripe.created[0] as Record<string, unknown>).duration, 'once');
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
Deno.test('expired coupon -> 400 "That code has expired.", nothing reserved', async () => {
|
|
161
|
+
const supabase = makeSupabase({
|
|
162
|
+
validate: { data: [{ valid: false, coupon_id: null, discount_cents: 0, reason: 'COUPON_EXPIRED' }], error: null },
|
|
163
|
+
});
|
|
164
|
+
const stripe = makeStripe();
|
|
165
|
+
|
|
166
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
167
|
+
|
|
168
|
+
assert(!out.ok);
|
|
169
|
+
assertEquals(out.reason, 'COUPON_EXPIRED');
|
|
170
|
+
assertEquals(couponFailureBody(out), { error: 'That code has expired.', field: 'coupon_code' });
|
|
171
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_redeem').length, 0);
|
|
172
|
+
assertEquals(stripe.created.length, 0);
|
|
173
|
+
});
|
|
174
|
+
|
|
175
|
+
Deno.test('limit-reached coupon -> 400 "already been fully redeemed."', async () => {
|
|
176
|
+
const supabase = makeSupabase({
|
|
177
|
+
validate: { data: [{ valid: false, coupon_id: null, discount_cents: 0, reason: 'COUPON_LIMIT_REACHED' }], error: null },
|
|
178
|
+
});
|
|
179
|
+
const stripe = makeStripe();
|
|
180
|
+
|
|
181
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
182
|
+
|
|
183
|
+
assert(!out.ok);
|
|
184
|
+
assertEquals(couponFailureBody(out), {
|
|
185
|
+
error: 'That code has already been fully redeemed.',
|
|
186
|
+
field: 'coupon_code',
|
|
187
|
+
});
|
|
188
|
+
assertEquals(stripe.created.length, 0);
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
Deno.test('out-of-scope coupon -> 400 "isn\'t valid for this plan."', async () => {
|
|
192
|
+
const supabase = makeSupabase({
|
|
193
|
+
validate: { data: [{ valid: false, coupon_id: null, discount_cents: 0, reason: 'COUPON_OUT_OF_SCOPE' }], error: null },
|
|
194
|
+
});
|
|
195
|
+
const out = await applyCheckoutCoupon(supabase, makeStripe(), BASE_OPTS);
|
|
196
|
+
assert(!out.ok);
|
|
197
|
+
assertEquals(couponFailureBody(out), { error: "That code isn't valid for this plan.", field: 'coupon_code' });
|
|
198
|
+
});
|
|
199
|
+
|
|
200
|
+
Deno.test('coupon_redeem raising COUPON_ALREADY_APPLIED -> 400, not a 500', async () => {
|
|
201
|
+
const supabase = makeSupabase({
|
|
202
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
203
|
+
redeem: { data: null, error: { message: 'COUPON_ALREADY_APPLIED: membership 1111' } },
|
|
204
|
+
});
|
|
205
|
+
const stripe = makeStripe();
|
|
206
|
+
|
|
207
|
+
// The point of the assertion: this RESOLVES with ok:false rather than
|
|
208
|
+
// throwing, so the edge function answers 400 instead of falling into its
|
|
209
|
+
// outer catch and 500-ing.
|
|
210
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
211
|
+
|
|
212
|
+
assert(!out.ok);
|
|
213
|
+
assertEquals(out.reason, 'COUPON_ALREADY_APPLIED');
|
|
214
|
+
assertEquals(couponFailureBody(out), { error: "You've already used that code.", field: 'coupon_code' });
|
|
215
|
+
assertEquals(stripe.created.length, 0, 'no Stripe coupon minted for a failed reservation');
|
|
216
|
+
});
|
|
217
|
+
|
|
218
|
+
Deno.test('COUPON_ALREADY_APPLIED has its own message, not the generic fallback', () => {
|
|
219
|
+
assertEquals(couponErrorMessage('COUPON_ALREADY_APPLIED'), "You've already used that code.");
|
|
220
|
+
assert(
|
|
221
|
+
couponErrorMessage('COUPON_ALREADY_APPLIED') !== couponErrorMessage('SOMETHING_UNMAPPED'),
|
|
222
|
+
'COUPON_ALREADY_APPLIED must not fall through to the default',
|
|
223
|
+
);
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
// --- coupon_redeem handing back a SETTLED row via the stable idempotency key ---
|
|
227
|
+
// Its first statement returns any row matching the key regardless of status,
|
|
228
|
+
// and the key is eternal. Minting a fresh Stripe coupon against a settled row
|
|
229
|
+
// grants a real discount that redeemed_count no longer reflects -- but the two
|
|
230
|
+
// settled statuses are NOT the same situation, so they are handled apart:
|
|
231
|
+
// 'applied' -> the customer already paid with this code. Terminal.
|
|
232
|
+
// 'reversed' -> the redemption was already handed back, so the coupon is
|
|
233
|
+
// still usable; only the key is pinned to a dead row. Retried
|
|
234
|
+
// once under a freshened key.
|
|
235
|
+
|
|
236
|
+
Deno.test("coupon_redeem returning an 'applied' row -> COUPON_ALREADY_APPLIED, no retry", async () => {
|
|
237
|
+
const supabase = makeSupabase({
|
|
238
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
239
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'applied' }, error: null },
|
|
240
|
+
});
|
|
241
|
+
const stripe = makeStripe();
|
|
242
|
+
|
|
243
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
244
|
+
|
|
245
|
+
assert(!out.ok, "expected an 'applied' redemption row to be refused");
|
|
246
|
+
assertEquals(out.reason, 'COUPON_ALREADY_APPLIED');
|
|
247
|
+
assertEquals(couponFailureBody(out), { error: "You've already used that code.", field: 'coupon_code' });
|
|
248
|
+
// A paid redemption must never be retried -- that would reserve a SECOND one.
|
|
249
|
+
assertEquals(
|
|
250
|
+
supabase.calls.filter((c) => c.fn === 'coupon_redeem').length,
|
|
251
|
+
1,
|
|
252
|
+
'coupon_redeem must be called exactly once for an already-applied row',
|
|
253
|
+
);
|
|
254
|
+
assertEquals(stripe.created.length, 0, 'no Stripe coupon minted against a settled redemption');
|
|
255
|
+
// Nothing was reserved by THIS call, so nothing may be clawed back either --
|
|
256
|
+
// reversing here would flip a paid redemption to 'reversed'.
|
|
257
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_reverse').length, 0);
|
|
258
|
+
});
|
|
259
|
+
|
|
260
|
+
Deno.test("coupon_redeem 'reversed' then 'reserved' -> ok:true on a freshened key", async () => {
|
|
261
|
+
const supabase = makeSupabase({
|
|
262
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
263
|
+
redeemSequence: [
|
|
264
|
+
// Dead row from an earlier attempt that was reversed (abandoned session,
|
|
265
|
+
// or a transient Stripe failure in a previous request).
|
|
266
|
+
{ data: { id: 'dead-row-id', amount_applied_cents: 17900, status: 'reversed' }, error: null },
|
|
267
|
+
{ data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
268
|
+
],
|
|
269
|
+
});
|
|
270
|
+
const stripe = makeStripe();
|
|
271
|
+
|
|
272
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
273
|
+
|
|
274
|
+
assert(out.ok, 'a reversed redemption must not lock the customer out of a still-valid code');
|
|
275
|
+
assertEquals(out.redemptionId, REDEMPTION_ID);
|
|
276
|
+
assertEquals(out.stripeCouponId, `gcc-${REDEMPTION_ID}`);
|
|
277
|
+
|
|
278
|
+
const redeems = supabase.calls.filter((c) => c.fn === 'coupon_redeem');
|
|
279
|
+
assertEquals(redeems.length, 2, 'exactly one retry');
|
|
280
|
+
// Every argument identical EXCEPT the idempotency key, which must differ --
|
|
281
|
+
// reusing it would hit the same dead row again instead of INSERTing.
|
|
282
|
+
const stableKey = `workday:kyle@simplelayer.io:${COUPON_ID}`;
|
|
283
|
+
assertEquals(redeems[0].args.p_idempotency_key, stableKey);
|
|
284
|
+
assert(
|
|
285
|
+
redeems[1].args.p_idempotency_key !== stableKey,
|
|
286
|
+
'the retry must use a freshened idempotency key',
|
|
287
|
+
);
|
|
288
|
+
assertMatch(String(redeems[1].args.p_idempotency_key), new RegExp(`^${stableKey}:`));
|
|
289
|
+
for (const k of ['p_coupon_id', 'p_member_email', 'p_applied_to_type', 'p_applied_to_id', 'p_base_amount_cents']) {
|
|
290
|
+
assertEquals(redeems[1].args[k], redeems[0].args[k], `${k} must be unchanged on the retry`);
|
|
291
|
+
}
|
|
292
|
+
});
|
|
293
|
+
|
|
294
|
+
Deno.test("coupon_redeem 'reversed' twice -> fails closed, no loop", async () => {
|
|
295
|
+
// Defensive: if the retry ALSO comes back non-'reserved' (a race), fail
|
|
296
|
+
// closed rather than retry again.
|
|
297
|
+
const supabase = makeSupabase({
|
|
298
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
299
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reversed' }, error: null },
|
|
300
|
+
});
|
|
301
|
+
const stripe = makeStripe();
|
|
302
|
+
|
|
303
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
304
|
+
|
|
305
|
+
assert(!out.ok);
|
|
306
|
+
assertEquals(out.reason, 'COUPON_LIMIT_REACHED');
|
|
307
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_redeem').length, 2, 'one retry, then stop');
|
|
308
|
+
assertEquals(stripe.created.length, 0);
|
|
309
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_reverse').length, 0);
|
|
310
|
+
});
|
|
311
|
+
|
|
312
|
+
Deno.test('a retried coupon_redeem that ERRORS maps to the same reason vocabulary', async () => {
|
|
313
|
+
const supabase = makeSupabase({
|
|
314
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
315
|
+
redeemSequence: [
|
|
316
|
+
{ data: { id: 'dead-row-id', amount_applied_cents: 17900, status: 'reversed' }, error: null },
|
|
317
|
+
{ data: null, error: { message: 'COUPON_LIMIT_REACHED: per-member cap 1 reached' } },
|
|
318
|
+
],
|
|
319
|
+
});
|
|
320
|
+
const stripe = makeStripe();
|
|
321
|
+
|
|
322
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
323
|
+
|
|
324
|
+
assert(!out.ok, 'the retry re-checks both caps for real -- it can still refuse');
|
|
325
|
+
assertEquals(out.reason, 'COUPON_LIMIT_REACHED');
|
|
326
|
+
assertEquals(stripe.created.length, 0);
|
|
327
|
+
});
|
|
328
|
+
|
|
329
|
+
// --- coupons.applies_to enforcement (coupon_validate never checks it) ---
|
|
330
|
+
|
|
331
|
+
Deno.test("applies_to 'booking' is refused for a membership checkout, nothing reserved", async () => {
|
|
332
|
+
const supabase = makeSupabase({
|
|
333
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
334
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
335
|
+
couponRow: {
|
|
336
|
+
id: COUPON_ID, discount_type: 'percent', value: 100,
|
|
337
|
+
// A duration nobody vetted for subscription use -- the booking path
|
|
338
|
+
// ignores `duration` entirely.
|
|
339
|
+
duration: 'forever', duration_in_months: null, applies_to: 'booking',
|
|
340
|
+
},
|
|
341
|
+
});
|
|
342
|
+
const stripe = makeStripe();
|
|
343
|
+
|
|
344
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
345
|
+
|
|
346
|
+
assert(!out.ok, "a 'booking' coupon must not be redeemable against a subscription");
|
|
347
|
+
assertEquals(out.reason, 'COUPON_OUT_OF_SCOPE');
|
|
348
|
+
assertEquals(couponFailureBody(out), { error: "That code isn't valid for this plan.", field: 'coupon_code' });
|
|
349
|
+
// The check runs BEFORE the reservation, so nothing is on the books.
|
|
350
|
+
assertEquals(
|
|
351
|
+
supabase.calls.filter((c) => c.fn === 'coupon_redeem').length,
|
|
352
|
+
0,
|
|
353
|
+
'coupon_redeem must never be called for an out-of-category coupon',
|
|
354
|
+
);
|
|
355
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_reverse').length, 0);
|
|
356
|
+
assertEquals(stripe.created.length, 0);
|
|
357
|
+
});
|
|
358
|
+
|
|
359
|
+
Deno.test('applies_to matrix: membership accepts subscription/all, day_pass only all', async () => {
|
|
360
|
+
const run = async (appliesTo: string, appliedToType: 'membership' | 'day_pass') => {
|
|
361
|
+
const supabase = makeSupabase({
|
|
362
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
363
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
364
|
+
couponRow: {
|
|
365
|
+
id: COUPON_ID, discount_type: 'percent', value: 100,
|
|
366
|
+
duration: 'once', duration_in_months: null, applies_to: appliesTo,
|
|
367
|
+
},
|
|
368
|
+
});
|
|
369
|
+
const out = await applyCheckoutCoupon(supabase, makeStripe(), {
|
|
370
|
+
...BASE_OPTS,
|
|
371
|
+
appliedToType,
|
|
372
|
+
oneTime: appliedToType === 'day_pass',
|
|
373
|
+
});
|
|
374
|
+
return { out, redeems: supabase.calls.filter((c) => c.fn === 'coupon_redeem').length };
|
|
375
|
+
};
|
|
376
|
+
|
|
377
|
+
for (const appliesTo of ['all', 'subscription']) {
|
|
378
|
+
const { out } = await run(appliesTo, 'membership');
|
|
379
|
+
assert(out.ok, `applies_to '${appliesTo}' must pass for a membership checkout`);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
// A day pass is a one-time purchase: not a subscription, not a booking, not
|
|
383
|
+
// an office agreement. Only the universal 'all' covers it.
|
|
384
|
+
const dpAll = await run('all', 'day_pass');
|
|
385
|
+
assert(dpAll.out.ok, "applies_to 'all' must pass for a day pass");
|
|
386
|
+
|
|
387
|
+
for (const appliesTo of ['subscription', 'booking', 'office']) {
|
|
388
|
+
const { out, redeems } = await run(appliesTo, 'day_pass');
|
|
389
|
+
assert(!out.ok, `applies_to '${appliesTo}' must be refused for a day pass`);
|
|
390
|
+
assertEquals(out.reason, 'COUPON_OUT_OF_SCOPE');
|
|
391
|
+
assertEquals(redeems, 0, 'nothing reserved for an out-of-category day-pass coupon');
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
// 'office' against a membership is refused too -- offices are sign-before-pay
|
|
395
|
+
// and never reach this endpoint.
|
|
396
|
+
const officeMembership = await run('office', 'membership');
|
|
397
|
+
assert(!officeMembership.out.ok);
|
|
398
|
+
assertEquals(officeMembership.redeems, 0);
|
|
399
|
+
});
|
|
400
|
+
|
|
401
|
+
Deno.test('two checkouts on the same plan get DIFFERENT p_applied_to_id', async () => {
|
|
402
|
+
const run = async () => {
|
|
403
|
+
const supabase = makeSupabase({
|
|
404
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
405
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
406
|
+
});
|
|
407
|
+
await applyCheckoutCoupon(supabase, makeStripe(), BASE_OPTS);
|
|
408
|
+
return supabase.calls.find((c) => c.fn === 'coupon_redeem')!.args.p_applied_to_id;
|
|
409
|
+
};
|
|
410
|
+
|
|
411
|
+
const first = await run();
|
|
412
|
+
const second = await run();
|
|
413
|
+
|
|
414
|
+
assertMatch(String(first), UUID_RE);
|
|
415
|
+
assertMatch(String(second), UUID_RE);
|
|
416
|
+
assert(first !== second, 'each checkout attempt must mint a fresh applied_to_id');
|
|
417
|
+
assert(first !== PLAN_ID && second !== PLAN_ID, 'applied_to_id must never be the plan id');
|
|
418
|
+
});
|
|
419
|
+
|
|
420
|
+
// --- reverseCheckoutCoupon must not claw back a settled redemption ---
|
|
421
|
+
|
|
422
|
+
Deno.test("reverseCheckoutCoupon does NOT call coupon_reverse on an 'applied' row", async () => {
|
|
423
|
+
const supabase = makeSupabase({ redemptionRow: { id: REDEMPTION_ID, status: 'applied' } });
|
|
424
|
+
|
|
425
|
+
await reverseCheckoutCoupon(supabase, REDEMPTION_ID, 'checkout_error', 'test', 'ops@example.com');
|
|
426
|
+
|
|
427
|
+
assertEquals(
|
|
428
|
+
supabase.calls.filter((c) => c.fn === 'coupon_reverse').length,
|
|
429
|
+
0,
|
|
430
|
+
'an applied redemption funded a real payment and must never be reversed',
|
|
431
|
+
);
|
|
432
|
+
});
|
|
433
|
+
|
|
434
|
+
Deno.test("reverseCheckoutCoupon does NOT re-reverse an already-'reversed' row", async () => {
|
|
435
|
+
const supabase = makeSupabase({ redemptionRow: { id: REDEMPTION_ID, status: 'reversed' } });
|
|
436
|
+
await reverseCheckoutCoupon(supabase, REDEMPTION_ID, 'checkout_error', 'test', 'ops@example.com');
|
|
437
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_reverse').length, 0);
|
|
438
|
+
});
|
|
439
|
+
|
|
440
|
+
Deno.test("reverseCheckoutCoupon DOES call coupon_reverse on a 'reserved' row", async () => {
|
|
441
|
+
const supabase = makeSupabase({ redemptionRow: { id: REDEMPTION_ID, status: 'reserved' } });
|
|
442
|
+
|
|
443
|
+
await reverseCheckoutCoupon(supabase, REDEMPTION_ID, 'checkout_error', 'test', 'ops@example.com');
|
|
444
|
+
|
|
445
|
+
const rev = supabase.calls.find((c) => c.fn === 'coupon_reverse');
|
|
446
|
+
assert(rev, 'a live reservation must still be released');
|
|
447
|
+
assertEquals(rev.args.p_redemption_id, REDEMPTION_ID);
|
|
448
|
+
assertEquals(rev.args.p_reason, 'checkout_error');
|
|
449
|
+
});
|
|
450
|
+
|
|
451
|
+
Deno.test('reverseCheckoutCoupon still never throws when the row read fails', async () => {
|
|
452
|
+
const supabase = makeSupabase({});
|
|
453
|
+
supabase.from = () => ({
|
|
454
|
+
select: () => ({
|
|
455
|
+
eq: () => ({ maybeSingle: () => Promise.resolve({ data: null, error: { message: 'boom' } }) }),
|
|
456
|
+
}),
|
|
457
|
+
});
|
|
458
|
+
await reverseCheckoutCoupon(supabase, REDEMPTION_ID, 'checkout_error', 'test', 'ops@example.com');
|
|
459
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_reverse').length, 0);
|
|
460
|
+
});
|
|
461
|
+
|
|
462
|
+
Deno.test('coupon_validate RPC failure fails CLOSED (400, never a silent full-price charge)', async () => {
|
|
463
|
+
const supabase = makeSupabase({ validate: { data: null, error: { message: 'connection reset' } } });
|
|
464
|
+
const out = await applyCheckoutCoupon(supabase, makeStripe(), BASE_OPTS);
|
|
465
|
+
assert(!out.ok);
|
|
466
|
+
assertEquals(supabase.calls.filter((c) => c.fn === 'coupon_redeem').length, 0);
|
|
467
|
+
});
|
|
468
|
+
|
|
469
|
+
Deno.test('Stripe coupon create failure releases the reservation', async () => {
|
|
470
|
+
const supabase = makeSupabase({
|
|
471
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
472
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
473
|
+
});
|
|
474
|
+
const stripe = makeStripe();
|
|
475
|
+
stripe.coupons.create = () => Promise.reject(new Error('stripe down'));
|
|
476
|
+
|
|
477
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
478
|
+
|
|
479
|
+
assert(!out.ok);
|
|
480
|
+
const rev = supabase.calls.find((c) => c.fn === 'coupon_reverse');
|
|
481
|
+
assert(rev, 'expected the reservation to be reversed');
|
|
482
|
+
assertEquals(rev.args.p_redemption_id, REDEMPTION_ID);
|
|
483
|
+
});
|
|
484
|
+
|
|
485
|
+
Deno.test('buildStripeCouponParams: fixed / repeating / forever / day-pass forceOnce', () => {
|
|
486
|
+
assertEquals(
|
|
487
|
+
buildStripeCouponParams(
|
|
488
|
+
{ id: COUPON_ID, discount_type: 'fixed', value: 2500, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
489
|
+
{ id: 'gcc-x' },
|
|
490
|
+
),
|
|
491
|
+
{ id: 'gcc-x', max_redemptions: 1, amount_off: 2500, currency: 'usd', duration: 'once' },
|
|
492
|
+
);
|
|
493
|
+
|
|
494
|
+
assertEquals(
|
|
495
|
+
buildStripeCouponParams(
|
|
496
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 25, duration: 'repeating', duration_in_months: 3, applies_to: 'all' },
|
|
497
|
+
{ id: 'gcc-x' },
|
|
498
|
+
),
|
|
499
|
+
{ id: 'gcc-x', max_redemptions: 1, percent_off: 25, duration: 'repeating', duration_in_months: 3 },
|
|
500
|
+
);
|
|
501
|
+
|
|
502
|
+
assertEquals(
|
|
503
|
+
buildStripeCouponParams(
|
|
504
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 100, duration: 'forever', duration_in_months: null, applies_to: 'all' },
|
|
505
|
+
{ id: 'gcc-x' },
|
|
506
|
+
),
|
|
507
|
+
{ id: 'gcc-x', max_redemptions: 1, percent_off: 100, duration: 'forever' },
|
|
508
|
+
);
|
|
509
|
+
|
|
510
|
+
// A one-time (day-pass) checkout collapses any duration to 'once', and
|
|
511
|
+
// therefore never emits duration_in_months.
|
|
512
|
+
assertEquals(
|
|
513
|
+
buildStripeCouponParams(
|
|
514
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 100, duration: 'repeating', duration_in_months: 3, applies_to: 'all' },
|
|
515
|
+
{ id: 'gcc-x', forceOnce: true },
|
|
516
|
+
),
|
|
517
|
+
{ id: 'gcc-x', max_redemptions: 1, percent_off: 100, duration: 'once' },
|
|
518
|
+
);
|
|
519
|
+
|
|
520
|
+
// 'repeating' with no month count is a data error, not something to guess at.
|
|
521
|
+
let threw = false;
|
|
522
|
+
try {
|
|
523
|
+
buildStripeCouponParams(
|
|
524
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 25, duration: 'repeating', duration_in_months: null, applies_to: 'all' },
|
|
525
|
+
{ id: 'gcc-x' },
|
|
526
|
+
);
|
|
527
|
+
} catch { threw = true; }
|
|
528
|
+
assert(threw, 'expected repeating-without-months to throw');
|
|
529
|
+
});
|
|
530
|
+
|
|
531
|
+
Deno.test('buildStripeCouponParams rejects a percent value above 100', () => {
|
|
532
|
+
// Rows authored under the stale basis-points column comment (1000 = 10%)
|
|
533
|
+
// must never reach Stripe's percent_off.
|
|
534
|
+
let msg = '';
|
|
535
|
+
try {
|
|
536
|
+
buildStripeCouponParams(
|
|
537
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 150, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
538
|
+
{ id: 'gcc-x' },
|
|
539
|
+
);
|
|
540
|
+
} catch (e) { msg = (e as Error).message; }
|
|
541
|
+
assertMatch(msg, /COUPON_CONFIG_INVALID: percent value 150 exceeds 100/);
|
|
542
|
+
|
|
543
|
+
let bpsMsg = '';
|
|
544
|
+
try {
|
|
545
|
+
buildStripeCouponParams(
|
|
546
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 1000, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
547
|
+
{ id: 'gcc-x' },
|
|
548
|
+
);
|
|
549
|
+
} catch (e) { bpsMsg = (e as Error).message; }
|
|
550
|
+
assertMatch(bpsMsg, /exceeds 100/);
|
|
551
|
+
|
|
552
|
+
// 100 itself is a legitimate full-comp coupon.
|
|
553
|
+
assertEquals(
|
|
554
|
+
buildStripeCouponParams(
|
|
555
|
+
{ id: COUPON_ID, discount_type: 'percent', value: 100, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
556
|
+
{ id: 'gcc-x' },
|
|
557
|
+
).percent_off,
|
|
558
|
+
100,
|
|
559
|
+
);
|
|
560
|
+
|
|
561
|
+
// A 'fixed' coupon is in cents, so a large value is normal and must pass.
|
|
562
|
+
assertEquals(
|
|
563
|
+
buildStripeCouponParams(
|
|
564
|
+
{ id: COUPON_ID, discount_type: 'fixed', value: 15000, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
565
|
+
{ id: 'gcc-x' },
|
|
566
|
+
).amount_off,
|
|
567
|
+
15000,
|
|
568
|
+
);
|
|
569
|
+
});
|
|
570
|
+
|
|
571
|
+
Deno.test('a >100 percent coupon fails as a 400 and releases the reservation', async () => {
|
|
572
|
+
// Traces the real call site: the throw lands in applyCheckoutCoupon's mint
|
|
573
|
+
// try/catch, which reverses and returns ok:false -- not an uncaught 500.
|
|
574
|
+
const supabase = makeSupabase({
|
|
575
|
+
validate: { data: [{ valid: true, coupon_id: COUPON_ID, discount_cents: 17900, reason: 'OK' }], error: null },
|
|
576
|
+
redeem: { data: { id: REDEMPTION_ID, amount_applied_cents: 17900, status: 'reserved' }, error: null },
|
|
577
|
+
couponRow: { id: COUPON_ID, discount_type: 'percent', value: 1000, duration: 'once', duration_in_months: null, applies_to: 'all' },
|
|
578
|
+
});
|
|
579
|
+
const stripe = makeStripe();
|
|
580
|
+
|
|
581
|
+
const out = await applyCheckoutCoupon(supabase, stripe, BASE_OPTS);
|
|
582
|
+
|
|
583
|
+
assert(!out.ok);
|
|
584
|
+
assertEquals(out.reason, 'COUPON_STRIPE_FAILED');
|
|
585
|
+
assertEquals(stripe.created.length, 0, 'the bad percent must never reach Stripe');
|
|
586
|
+
const rev = supabase.calls.find((c) => c.fn === 'coupon_reverse');
|
|
587
|
+
assert(rev, 'expected the reservation to be released');
|
|
588
|
+
assertEquals(rev.args.p_redemption_id, REDEMPTION_ID);
|
|
589
|
+
});
|
|
590
|
+
|
|
591
|
+
// --- Session params: the no-coupon path must not have changed at all ---
|
|
592
|
+
|
|
593
|
+
const LINE_ITEM = { price: 'price_123', quantity: 1 } as const;
|
|
594
|
+
const SUB_METADATA = { checkout_type: 'membership', plan_slug: 'workday', plan_id: PLAN_ID };
|
|
595
|
+
|
|
596
|
+
Deno.test('subscription session params with NO coupon are unchanged from before', () => {
|
|
597
|
+
const params = buildSubscriptionSessionParams({
|
|
598
|
+
customerId: 'cus_123',
|
|
599
|
+
lineItem: { ...LINE_ITEM },
|
|
600
|
+
metadata: SUB_METADATA,
|
|
601
|
+
subscriptionData: { metadata: SUB_METADATA },
|
|
602
|
+
successUrl: 'https://granitecity.io/membership/success?session_id={CHECKOUT_SESSION_ID}',
|
|
603
|
+
cancelUrl: 'https://granitecity.io/pricing',
|
|
604
|
+
stripeCouponId: null,
|
|
605
|
+
});
|
|
606
|
+
|
|
607
|
+
// Exactly the object the function built before this change.
|
|
608
|
+
assertEquals(params, {
|
|
609
|
+
mode: 'subscription',
|
|
610
|
+
customer: 'cus_123',
|
|
611
|
+
line_items: [{ price: 'price_123', quantity: 1 }],
|
|
612
|
+
allow_promotion_codes: true,
|
|
613
|
+
metadata: SUB_METADATA,
|
|
614
|
+
subscription_data: { metadata: SUB_METADATA },
|
|
615
|
+
success_url: 'https://granitecity.io/membership/success?session_id={CHECKOUT_SESSION_ID}',
|
|
616
|
+
cancel_url: 'https://granitecity.io/pricing',
|
|
617
|
+
});
|
|
618
|
+
assert(!('discounts' in params), 'no discounts key when no coupon');
|
|
619
|
+
});
|
|
620
|
+
|
|
621
|
+
Deno.test('subscription session params WITH a coupon swap allow_promotion_codes for discounts', () => {
|
|
622
|
+
const params = buildSubscriptionSessionParams({
|
|
623
|
+
customerId: 'cus_123',
|
|
624
|
+
lineItem: { ...LINE_ITEM },
|
|
625
|
+
metadata: SUB_METADATA,
|
|
626
|
+
subscriptionData: { metadata: SUB_METADATA },
|
|
627
|
+
successUrl: 'https://granitecity.io/membership/success?session_id={CHECKOUT_SESSION_ID}',
|
|
628
|
+
cancelUrl: 'https://granitecity.io/pricing',
|
|
629
|
+
stripeCouponId: `gcc-${REDEMPTION_ID}`,
|
|
630
|
+
});
|
|
631
|
+
|
|
632
|
+
assertEquals(params.discounts, [{ coupon: `gcc-${REDEMPTION_ID}` }]);
|
|
633
|
+
// Stripe rejects a session that sets BOTH.
|
|
634
|
+
assert(!('allow_promotion_codes' in params), 'allow_promotion_codes must be absent alongside discounts');
|
|
635
|
+
});
|
|
636
|
+
|
|
637
|
+
const DP_METADATA = { checkout_type: 'day_pass', plan_slug: 'day-pass', plan_id: PLAN_ID, visit_date: '2026-09-10' };
|
|
638
|
+
|
|
639
|
+
Deno.test('day-pass session params with NO coupon are unchanged from before', () => {
|
|
640
|
+
const params = buildDayPassSessionParams({
|
|
641
|
+
customerId: 'cus_456',
|
|
642
|
+
priceId: 'price_dp',
|
|
643
|
+
metadata: DP_METADATA,
|
|
644
|
+
receiptEmail: 'kyle@simplelayer.io',
|
|
645
|
+
successUrl: 'https://granitecity.io/day-pass/success?session_id={CHECKOUT_SESSION_ID}',
|
|
646
|
+
cancelUrl: 'https://granitecity.io/pricing',
|
|
647
|
+
stripeCouponId: null,
|
|
648
|
+
});
|
|
649
|
+
|
|
650
|
+
assertEquals(params, {
|
|
651
|
+
mode: 'payment',
|
|
652
|
+
customer: 'cus_456',
|
|
653
|
+
line_items: [{ price: 'price_dp', quantity: 1 }],
|
|
654
|
+
allow_promotion_codes: true,
|
|
655
|
+
metadata: DP_METADATA,
|
|
656
|
+
payment_intent_data: { receipt_email: 'kyle@simplelayer.io' },
|
|
657
|
+
success_url: 'https://granitecity.io/day-pass/success?session_id={CHECKOUT_SESSION_ID}',
|
|
658
|
+
cancel_url: 'https://granitecity.io/pricing',
|
|
659
|
+
});
|
|
660
|
+
assert(!('discounts' in params), 'no discounts key when no coupon');
|
|
661
|
+
});
|
|
662
|
+
|
|
663
|
+
Deno.test('day-pass session params WITH a coupon drop allow_promotion_codes', () => {
|
|
664
|
+
const params = buildDayPassSessionParams({
|
|
665
|
+
customerId: 'cus_456',
|
|
666
|
+
priceId: 'price_dp',
|
|
667
|
+
metadata: DP_METADATA,
|
|
668
|
+
receiptEmail: 'kyle@simplelayer.io',
|
|
669
|
+
successUrl: 'https://granitecity.io/day-pass/success?session_id={CHECKOUT_SESSION_ID}',
|
|
670
|
+
cancelUrl: 'https://granitecity.io/pricing',
|
|
671
|
+
stripeCouponId: 'gcc-abc',
|
|
672
|
+
});
|
|
673
|
+
assertEquals(params.discounts, [{ coupon: 'gcc-abc' }]);
|
|
674
|
+
assert(!('allow_promotion_codes' in params));
|
|
675
|
+
});
|