@simplelayer/graniteer-core 0.0.2 → 0.1.2

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.
Files changed (100) hide show
  1. package/index.js +2 -2
  2. package/package.json +98 -15
  3. package/src/adminBookingCredit.test.ts +451 -0
  4. package/src/adminBookingCredit.ts +239 -0
  5. package/src/availability.test.ts +25 -0
  6. package/src/availability.ts +201 -0
  7. package/src/bookingHoldReclaim.ts +94 -0
  8. package/src/checkoutSessionParams.ts +56 -0
  9. package/src/commonsContract.ts +175 -0
  10. package/src/conductorAdmin.ts +141 -0
  11. package/src/email-templates/email-change.tsx +92 -0
  12. package/src/email-templates/invite.tsx +79 -0
  13. package/src/email-templates/reauthentication.tsx +60 -0
  14. package/src/functions/admin-cancel-membership.ts +311 -0
  15. package/src/functions/admin-change-membership-plan.ts +308 -0
  16. package/src/functions/admin-charge-guest-print.ts +229 -0
  17. package/src/functions/admin-correct-booking.ts +333 -0
  18. package/src/functions/admin-create-commons-event.ts +244 -0
  19. package/src/functions/admin-debug-boldsign-doc.ts +93 -0
  20. package/src/functions/admin-door-write.ts +272 -0
  21. package/src/functions/admin-mark-booking-paid.ts +203 -0
  22. package/src/functions/admin-photo-upload.ts +128 -0
  23. package/src/functions/admin-remove-team-member.ts +150 -0
  24. package/src/functions/admin-reset-mfa.ts +138 -0
  25. package/src/functions/admin-reverse-coupon-redemption.ts +98 -0
  26. package/src/functions/admin-send-commons-agreement.ts +214 -0
  27. package/src/functions/admin-set-credit-amount.ts +123 -0
  28. package/src/functions/admin-skip-commons-contract.ts +165 -0
  29. package/src/functions/admin-undo-membership-cancel.ts +144 -0
  30. package/src/functions/admin-wall-photo-write.ts +141 -0
  31. package/src/functions/boldsign-sender-identity.ts +114 -0
  32. package/src/functions/booking-availability.ts +419 -0
  33. package/src/functions/booking-member-preview.ts +136 -0
  34. package/src/functions/day-pass-status.ts +89 -0
  35. package/src/functions/dayStatus.ts +71 -0
  36. package/src/functions/diag-webpush-test.ts +45 -0
  37. package/src/functions/event-access-store.ts +309 -0
  38. package/src/functions/ezeep-print-webhook.ts +213 -0
  39. package/src/functions/ezeep-usage-reconcile.ts +299 -0
  40. package/src/functions/get-signing-link.ts +211 -0
  41. package/src/functions/guest-print-setup-confirm.ts +128 -0
  42. package/src/functions/guest-print-submit.ts +149 -0
  43. package/src/functions/luma-webhook.ts +165 -0
  44. package/src/functions/migration-collision-alert.copy.ts +232 -0
  45. package/src/functions/migration-collision-alert.test.ts +349 -0
  46. package/src/functions/migration-collision-alert.ts +232 -0
  47. package/src/functions/office-assignment-end.ts +146 -0
  48. package/src/functions/portal-booking-access.ts +95 -0
  49. package/src/functions/portal-list-invoices.ts +99 -0
  50. package/src/functions/print-billing-recover.ts +97 -0
  51. package/src/functions/print-billing-run.ts +183 -0
  52. package/src/functions/public-facts.ts +168 -0
  53. package/src/functions/space-availability-range.acceptance.test.ts +161 -0
  54. package/src/functions/space-availability-range.ts +142 -0
  55. package/src/functions/sync-gcal-blackouts.ts +298 -0
  56. package/src/functions/timetable-event-register.ts +162 -0
  57. package/src/functions/timetable-event-status.ts +90 -0
  58. package/src/functions/timetable-spaces.ts +219 -0
  59. package/src/functions/touch-pass-reconciler.ts +689 -0
  60. package/src/functions/virtual-onboarding-purge.ts +134 -0
  61. package/src/functions/virtual-onboarding-submit.ts +315 -0
  62. package/src/functions/voice-inquiry.test.ts +301 -0
  63. package/src/functions/voice-inquiry.ts +198 -0
  64. package/src/functions/voice-tour-availability.ts +204 -0
  65. package/src/gcalSync.ts +142 -0
  66. package/src/ghlNote.ts +34 -0
  67. package/src/ghlTask.ts +48 -0
  68. package/src/ghlVoiceInquiry.ts +90 -0
  69. package/src/guestPrintCapture.test.ts +722 -0
  70. package/src/guestPrintCapture.ts +538 -0
  71. package/src/lumaGhl.ts +195 -0
  72. package/src/membership.ts +109 -0
  73. package/src/money.ts +36 -0
  74. package/src/ops.ts +97 -0
  75. package/src/pacificDate.ts +34 -0
  76. package/src/policyAcknowledgment.test.ts +50 -0
  77. package/src/policyAcknowledgment.ts +96 -0
  78. package/src/portalSession.ts +46 -0
  79. package/src/pricing.test.ts +660 -0
  80. package/src/pricing.ts +1025 -0
  81. package/src/printBilling.test.ts +750 -0
  82. package/src/printBilling.ts +891 -0
  83. package/src/printBillingAdapters.ts +169 -0
  84. package/src/printCorrections.test.ts +348 -0
  85. package/src/printCorrections.ts +496 -0
  86. package/src/rateLimit.ts +82 -0
  87. package/src/referralCredits.test.ts +31 -0
  88. package/src/referralCredits.ts +34 -0
  89. package/src/referralGrant.ts +321 -0
  90. package/src/rescheduleCredit.test.ts +521 -0
  91. package/src/rescheduleCredit.ts +337 -0
  92. package/src/reservationWifiCode.test.ts +69 -0
  93. package/src/reservationWifiCode.ts +81 -0
  94. package/src/retellCallAnalyzed.test.ts +167 -0
  95. package/src/retellCallAnalyzed.ts +113 -0
  96. package/src/retellSignature.test.ts +137 -0
  97. package/src/retellSignature.ts +82 -0
  98. package/src/slackAlert.ts +38 -0
  99. package/src/supabaseTestFakes.ts +131 -0
  100. package/src/tier1Agreement.ts +125 -0
@@ -0,0 +1,722 @@
1
+ // Tests for the D5 guest print-payment capture decision core.
2
+ //
3
+ // Run with:
4
+ // deno test --no-check --no-lock --allow-read \
5
+ // supabase/functions/_shared/guestPrintCapture.test.ts
6
+ //
7
+ // ZERO NETWORK, AND IN PARTICULAR ZERO LIVE STRIPE. globalThis.fetch is
8
+ // replaced with a throwing stub before anything else runs (same discipline
9
+ // as printBilling.test.ts), so any accidental outbound call fails loudly
10
+ // instead of reaching api.stripe.com with live keys. The Stripe client is a
11
+ // hand-rolled object with call counters; the database is an in-memory fake.
12
+ //
13
+ // Covers acceptance criteria (a) and (b) from the D5 backlog item:
14
+ // (a) a new guest can submit a print job -> SetupIntent created, card
15
+ // saved against a Stripe customer keyed by email (mocked transport)
16
+ // (b) once usage/cost is known, an off-session PaymentIntent successfully
17
+ // charges the saved card (mocked transport)
18
+ // plus the double-charge concurrency guard and the harness-is-not-vacuous
19
+ // proof required by money-path-dry-run-testing technique 1.
20
+
21
+ import { assert, assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts';
22
+ import {
23
+ chargeGuestPrintJob,
24
+ CLAIMABLE_CHARGE_STATUSES,
25
+ confirmGuestPrintSetup,
26
+ generateGuestBillingCode,
27
+ GUEST_BILLING_CODE_LENGTH,
28
+ guestPrintChargeKey,
29
+ guestPrintSetupIntentKey,
30
+ resolveGuestStripeCustomer,
31
+ submitGuestPrintJob,
32
+ type GpPaymentIntent,
33
+ type GpSetupIntent,
34
+ type GpStripeCustomer,
35
+ type GuestPrintDbLike,
36
+ type GuestPrintStripeLike,
37
+ type SubmissionRow,
38
+ } from './guestPrintCapture.ts';
39
+
40
+ // Any real outbound request from this point on is a test failure, not a
41
+ // silent live-Stripe call.
42
+ const NETWORK_ATTEMPTS: string[] = [];
43
+ globalThis.fetch = ((input: string | URL | Request) => {
44
+ const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
45
+ NETWORK_ATTEMPTS.push(url);
46
+ throw new Error(`BLOCKED: test attempted a real network call to ${url}`);
47
+ }) as typeof fetch;
48
+
49
+ const EMAIL = 'guest@example.com';
50
+ const SUBMISSION = '11111111-1111-1111-1111-111111111111';
51
+ const CUST = 'cus_guest_test';
52
+ const SI = 'seti_test_1';
53
+ const PM = 'pm_test_1';
54
+ const CODE = 'ABCDEF';
55
+
56
+ // --------------------------------------------------------------- the fakes --
57
+
58
+ interface StripeCalls {
59
+ customerSearch: number;
60
+ customerList: number;
61
+ customerCreate: { email: string }[];
62
+ setupIntentCreate: Record<string, unknown>[];
63
+ setupIntentRetrieve: string[];
64
+ paymentIntentCreate: Record<string, unknown>[];
65
+ paymentIntentRetrieve: string[];
66
+ idem: string[];
67
+ }
68
+
69
+ function mkStripe(opts: {
70
+ existingCustomer?: GpStripeCustomer | null; // found via search
71
+ existingCustomerViaList?: GpStripeCustomer | null;
72
+ searchThrows?: boolean;
73
+ setupIntentCreateThrows?: boolean;
74
+ setupIntentStatus?: string;
75
+ setupIntentPaymentMethod?: string | { id: string } | null;
76
+ paymentIntentCreateThrows?: boolean;
77
+ paymentIntentStatus?: string;
78
+ // [B4] controls for stripe.paymentIntents.retrieve, used when
79
+ // chargeGuestPrintJob finds a PRIOR PaymentIntent id on the row.
80
+ priorPaymentIntentStatus?: string;
81
+ priorPaymentIntentAmount?: number;
82
+ paymentIntentRetrieveThrows?: boolean;
83
+ } = {}): { stripe: GuestPrintStripeLike; calls: StripeCalls } {
84
+ const calls: StripeCalls = {
85
+ customerSearch: 0, customerList: 0, customerCreate: [],
86
+ setupIntentCreate: [], setupIntentRetrieve: [], paymentIntentCreate: [], paymentIntentRetrieve: [], idem: [],
87
+ };
88
+ const stripe: GuestPrintStripeLike = {
89
+ customers: {
90
+ search: () => {
91
+ calls.customerSearch++;
92
+ if (opts.searchThrows) return Promise.reject(new Error('search unavailable'));
93
+ return Promise.resolve({ data: opts.existingCustomer ? [opts.existingCustomer] : [] });
94
+ },
95
+ list: () => {
96
+ calls.customerList++;
97
+ return Promise.resolve({ data: opts.existingCustomerViaList ? [opts.existingCustomerViaList] : [] });
98
+ },
99
+ create: (p) => {
100
+ calls.customerCreate.push(p);
101
+ return Promise.resolve({ id: CUST });
102
+ },
103
+ },
104
+ setupIntents: {
105
+ create: (p, o) => {
106
+ calls.setupIntentCreate.push(p);
107
+ if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
108
+ if (opts.setupIntentCreateThrows) return Promise.reject(new Error('stripe down'));
109
+ const si: GpSetupIntent = {
110
+ id: SI, status: 'requires_payment_method', client_secret: `${SI}_secret`, payment_method: null,
111
+ };
112
+ return Promise.resolve(si);
113
+ },
114
+ retrieve: (id) => {
115
+ calls.setupIntentRetrieve.push(id);
116
+ const si: GpSetupIntent = {
117
+ id,
118
+ status: opts.setupIntentStatus ?? 'succeeded',
119
+ client_secret: `${id}_secret`,
120
+ payment_method: opts.setupIntentPaymentMethod === undefined ? PM : opts.setupIntentPaymentMethod,
121
+ };
122
+ return Promise.resolve(si);
123
+ },
124
+ },
125
+ paymentIntents: {
126
+ create: (p, o) => {
127
+ calls.paymentIntentCreate.push(p);
128
+ if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
129
+ if (opts.paymentIntentCreateThrows) return Promise.reject(new Error('stripe down'));
130
+ const pi: GpPaymentIntent = {
131
+ id: 'pi_test_1', status: opts.paymentIntentStatus ?? 'succeeded', amount: (p.amount as number) ?? 0,
132
+ };
133
+ return Promise.resolve(pi);
134
+ },
135
+ retrieve: (id) => {
136
+ calls.paymentIntentRetrieve.push(id);
137
+ if (opts.paymentIntentRetrieveThrows) return Promise.reject(new Error('stripe down'));
138
+ return Promise.resolve({
139
+ id, status: opts.priorPaymentIntentStatus ?? 'succeeded',
140
+ // Deliberately defaults to a DIFFERENT amount than any retry test
141
+ // passes (350), so a bug that writes back the CALLER's amountCents
142
+ // instead of the prior PI's actual amount is caught by assertion,
143
+ // not accidentally masked by both numbers happening to match.
144
+ amount: opts.priorPaymentIntentAmount ?? 500,
145
+ });
146
+ },
147
+ },
148
+ };
149
+ return { stripe, calls };
150
+ }
151
+
152
+ interface DbState {
153
+ rows: Record<string, SubmissionRow>;
154
+ failedReasons: string[];
155
+ chargeFailedReasons: string[];
156
+ chargeFailedPaymentIntentIds: (string | undefined)[];
157
+ chargedCalls: { amountCents: number; paymentIntentId: string }[];
158
+ claimAttempts: number;
159
+ attachStripeIdsThrows: boolean;
160
+ }
161
+
162
+ function mkDb(seed: Partial<SubmissionRow> = {}): { db: GuestPrintDbLike; st: DbState } {
163
+ const st: DbState = {
164
+ rows: {
165
+ [SUBMISSION]: {
166
+ id: SUBMISSION, email: EMAIL, status: 'pending_card',
167
+ stripe_customer_id: null, stripe_setup_intent_id: null, stripe_payment_method_id: null,
168
+ stripe_payment_intent_id: null,
169
+ guest_billing_code: CODE,
170
+ ...seed,
171
+ },
172
+ },
173
+ failedReasons: [], chargeFailedReasons: [], chargeFailedPaymentIntentIds: [],
174
+ chargedCalls: [], claimAttempts: 0, attachStripeIdsThrows: false,
175
+ };
176
+
177
+ const db: GuestPrintDbLike = {
178
+ insertPending: ({ email, guestBillingCode }) => {
179
+ st.rows[SUBMISSION] = {
180
+ id: SUBMISSION, email, status: 'pending_card',
181
+ stripe_customer_id: null, stripe_setup_intent_id: null, stripe_payment_method_id: null,
182
+ stripe_payment_intent_id: null,
183
+ guest_billing_code: guestBillingCode,
184
+ };
185
+ return Promise.resolve(SUBMISSION);
186
+ },
187
+ attachStripeIds: (id, customerId, setupIntentId) => {
188
+ if (st.attachStripeIdsThrows) return Promise.reject(new Error('db write failed'));
189
+ st.rows[id].stripe_customer_id = customerId;
190
+ st.rows[id].stripe_setup_intent_id = setupIntentId;
191
+ return Promise.resolve();
192
+ },
193
+ markCardSaved: (id, paymentMethodId) => {
194
+ st.rows[id].status = 'card_saved';
195
+ st.rows[id].stripe_payment_method_id = paymentMethodId;
196
+ return Promise.resolve();
197
+ },
198
+ markFailed: (id, reason) => {
199
+ st.rows[id].status = 'failed';
200
+ st.failedReasons.push(reason);
201
+ return Promise.resolve();
202
+ },
203
+ getById: (id) => Promise.resolve(st.rows[id] ?? null),
204
+ claimForCharge: (id) => {
205
+ st.claimAttempts++;
206
+ const row = st.rows[id];
207
+ // Mirrors the real UPDATE ... WHERE status IN CLAIMABLE_CHARGE_STATUSES
208
+ // CAS -- imported from the module under test (not hand-copied) per
209
+ // round 2 review's test-vacuity finding, so a change to the real SQL
210
+ // filter and this fake can never silently drift apart.
211
+ if (!row || !CLAIMABLE_CHARGE_STATUSES.includes(row.status)) return Promise.resolve(false);
212
+ row.status = 'charging';
213
+ return Promise.resolve(true);
214
+ },
215
+ writebackCharged: (id, amountCents, paymentIntentId) => {
216
+ st.rows[id].status = 'charged';
217
+ st.rows[id].stripe_payment_intent_id = paymentIntentId;
218
+ st.chargedCalls.push({ amountCents, paymentIntentId });
219
+ return Promise.resolve();
220
+ },
221
+ writebackChargeFailed: (id, reason, paymentIntentId) => {
222
+ st.rows[id].status = 'charge_failed';
223
+ if (paymentIntentId) st.rows[id].stripe_payment_intent_id = paymentIntentId;
224
+ st.chargeFailedReasons.push(reason);
225
+ st.chargeFailedPaymentIntentIds.push(paymentIntentId);
226
+ return Promise.resolve();
227
+ },
228
+ };
229
+ return { db, st };
230
+ }
231
+
232
+ // ============================================================ pure helpers ==
233
+
234
+ Deno.test('generateGuestBillingCode is deterministic given the same bytes, and uses the full length', () => {
235
+ const bytes = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);
236
+ const a = generateGuestBillingCode(bytes);
237
+ const b = generateGuestBillingCode(bytes);
238
+ assertEquals(a, b);
239
+ assertEquals(a.length, GUEST_BILLING_CODE_LENGTH);
240
+ });
241
+
242
+ Deno.test('generateGuestBillingCode never contains ambiguous chars (0/O/1/I)', () => {
243
+ const bytes = new Uint8Array(64).map((_, i) => i);
244
+ const code = generateGuestBillingCode(bytes);
245
+ for (const ch of code) assert(!'0O1I'.includes(ch), `unexpected ambiguous char: ${ch}`);
246
+ });
247
+
248
+ Deno.test('generateGuestBillingCode throws on too few random bytes rather than silently truncating', () => {
249
+ let threw = false;
250
+ try { generateGuestBillingCode(new Uint8Array(2)); } catch { threw = true; }
251
+ assert(threw);
252
+ });
253
+
254
+ // ==================================================== customer resolution ==
255
+
256
+ Deno.test('[a] resolveGuestStripeCustomer: search hit is used, list/create never called', async () => {
257
+ const { stripe, calls } = mkStripe({ existingCustomer: { id: 'cus_found_via_search' } });
258
+ const id = await resolveGuestStripeCustomer(stripe, EMAIL);
259
+ assertEquals(id, 'cus_found_via_search');
260
+ assertEquals(calls.customerSearch, 1);
261
+ assertEquals(calls.customerList, 0);
262
+ assertEquals(calls.customerCreate.length, 0);
263
+ });
264
+
265
+ Deno.test('[a] resolveGuestStripeCustomer: search miss falls back to list', async () => {
266
+ const { stripe, calls } = mkStripe({ existingCustomerViaList: { id: 'cus_found_via_list' } });
267
+ const id = await resolveGuestStripeCustomer(stripe, EMAIL);
268
+ assertEquals(id, 'cus_found_via_list');
269
+ assertEquals(calls.customerCreate.length, 0);
270
+ });
271
+
272
+ Deno.test('[a] resolveGuestStripeCustomer: search AND list miss -> creates a new customer keyed by email', async () => {
273
+ const { stripe, calls } = mkStripe();
274
+ const id = await resolveGuestStripeCustomer(stripe, EMAIL.toUpperCase());
275
+ assertEquals(id, CUST);
276
+ assertEquals(calls.customerCreate.length, 1);
277
+ assertEquals(calls.customerCreate[0].email, EMAIL); // lowercased
278
+ });
279
+
280
+ Deno.test('resolveGuestStripeCustomer: a throwing search still falls through to list/create', async () => {
281
+ const { stripe } = mkStripe({ searchThrows: true, existingCustomerViaList: { id: 'cus_via_list_after_search_fail' } });
282
+ const id = await resolveGuestStripeCustomer(stripe, EMAIL);
283
+ assertEquals(id, 'cus_via_list_after_search_fail');
284
+ });
285
+
286
+ // ========================================= [a] STEP 1: submission (SetupIntent) ==
287
+
288
+ Deno.test('[a] submitGuestPrintJob: a brand-new guest gets a SetupIntent + saved-card flow started', async () => {
289
+ const { stripe, calls } = mkStripe();
290
+ const { db, st } = mkDb();
291
+ const outcome = await submitGuestPrintJob(stripe, db, { email: EMAIL, guestName: 'Guest One', guestBillingCode: CODE });
292
+
293
+ assertEquals(outcome.ok, true);
294
+ assertEquals(outcome.submissionId, SUBMISSION);
295
+ assert(outcome.clientSecret?.startsWith(SI));
296
+ assertEquals(outcome.guestBillingCode, CODE);
297
+
298
+ // A Stripe customer was created, keyed by the guest's email.
299
+ assertEquals(calls.customerCreate.length, 1);
300
+ assertEquals(calls.customerCreate[0].email, EMAIL);
301
+
302
+ // A SetupIntent was created for that customer, off-session/card, with the
303
+ // idempotency key derived from the submission id.
304
+ assertEquals(calls.setupIntentCreate.length, 1);
305
+ assertEquals(calls.setupIntentCreate[0].customer, CUST);
306
+ assertEquals(calls.setupIntentCreate[0].usage, 'off_session');
307
+ assertEquals(calls.setupIntentCreate[0].payment_method_types, ['card']);
308
+ assert(calls.idem.includes(guestPrintSetupIntentKey(SUBMISSION)));
309
+
310
+ // The DB row exists (the "known contact" qualifying record) with the
311
+ // Stripe ids attached.
312
+ assertEquals(st.rows[SUBMISSION].stripe_customer_id, CUST);
313
+ assertEquals(st.rows[SUBMISSION].stripe_setup_intent_id, SI);
314
+ assertEquals(NETWORK_ATTEMPTS.length, 0);
315
+ });
316
+
317
+ Deno.test('the DB row is written BEFORE any Stripe call, so it survives a Stripe outage', async () => {
318
+ const { stripe } = mkStripe({ setupIntentCreateThrows: true });
319
+ const { db, st } = mkDb();
320
+ const outcome = await submitGuestPrintJob(stripe, db, { email: EMAIL, guestName: null, guestBillingCode: CODE });
321
+
322
+ assertEquals(outcome.ok, false);
323
+ assertEquals(outcome.submissionId, SUBMISSION);
324
+ // The row still exists -- it still qualifies the guest as a known contact
325
+ // per GATE-0194(B), even though the card was never saved.
326
+ assert(st.rows[SUBMISSION] !== undefined);
327
+ assertEquals(st.rows[SUBMISSION].status, 'failed');
328
+ });
329
+
330
+ Deno.test('a customer-resolution failure marks the row failed rather than throwing uncaught', async () => {
331
+ const { stripe } = mkStripe();
332
+ stripe.customers.create = () => Promise.reject(new Error('stripe customers.create down'));
333
+ const { db, st } = mkDb();
334
+ const outcome = await submitGuestPrintJob(stripe, db, { email: EMAIL, guestName: null, guestBillingCode: CODE });
335
+ assertEquals(outcome.ok, false);
336
+ assertEquals(outcome.detail, 'customer_resolve_failed');
337
+ assertEquals(st.rows[SUBMISSION].status, 'failed');
338
+ });
339
+
340
+ // ============================================== STEP 2: confirm (SetupIntent) ==
341
+
342
+ Deno.test('confirmGuestPrintSetup: a succeeded SetupIntent marks the row card_saved with its payment method', async () => {
343
+ const { stripe } = mkStripe({ setupIntentStatus: 'succeeded', setupIntentPaymentMethod: PM });
344
+ const { db, st } = mkDb({ stripe_setup_intent_id: SI, stripe_customer_id: CUST });
345
+ const outcome = await confirmGuestPrintSetup(stripe, db, SUBMISSION, SI);
346
+
347
+ assertEquals(outcome.ok, true);
348
+ assertEquals(outcome.status, 'card_saved');
349
+ assertEquals(st.rows[SUBMISSION].status, 'card_saved');
350
+ assertEquals(st.rows[SUBMISSION].stripe_payment_method_id, PM);
351
+ });
352
+
353
+ Deno.test('confirmGuestPrintSetup: never trusts a client claim -- an un-succeeded SetupIntent is refused', async () => {
354
+ const { stripe } = mkStripe({ setupIntentStatus: 'requires_payment_method' });
355
+ const { db, st } = mkDb({ stripe_setup_intent_id: SI });
356
+ const outcome = await confirmGuestPrintSetup(stripe, db, SUBMISSION, SI);
357
+
358
+ assertEquals(outcome.ok, false);
359
+ assertEquals(outcome.status, 'requires_payment_method');
360
+ assertEquals(st.rows[SUBMISSION].status, 'pending_card'); // unchanged
361
+ });
362
+
363
+ Deno.test('confirmGuestPrintSetup: a succeeded SetupIntent with no payment_method is refused, not silently accepted', async () => {
364
+ const { stripe } = mkStripe({ setupIntentStatus: 'succeeded', setupIntentPaymentMethod: null });
365
+ const { db, st } = mkDb({ stripe_setup_intent_id: SI });
366
+ const outcome = await confirmGuestPrintSetup(stripe, db, SUBMISSION, SI);
367
+
368
+ assertEquals(outcome.ok, false);
369
+ assertEquals(outcome.detail, 'succeeded_but_no_payment_method');
370
+ assertEquals(st.rows[SUBMISSION].status, 'pending_card');
371
+ });
372
+
373
+ Deno.test('confirmGuestPrintSetup: an EXPANDED payment_method object resolves to its id', async () => {
374
+ const { stripe } = mkStripe({ setupIntentStatus: 'succeeded', setupIntentPaymentMethod: { id: 'pm_expanded' } });
375
+ const { db, st } = mkDb({ stripe_setup_intent_id: SI });
376
+ await confirmGuestPrintSetup(stripe, db, SUBMISSION, SI);
377
+ assertEquals(st.rows[SUBMISSION].stripe_payment_method_id, 'pm_expanded');
378
+ });
379
+
380
+ // ===================================== [b] STEP 3: charge (off-session PaymentIntent) ==
381
+
382
+ Deno.test('[b] chargeGuestPrintJob: a card_saved submission is charged off-session once cost is known', async () => {
383
+ const { stripe, calls } = mkStripe({ paymentIntentStatus: 'succeeded' });
384
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
385
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
386
+
387
+ assertEquals(outcome.ok, true);
388
+ assertEquals(outcome.status, 'charged');
389
+ assertEquals(outcome.paymentIntentId, 'pi_test_1');
390
+
391
+ assertEquals(calls.paymentIntentCreate.length, 1);
392
+ assertEquals(calls.paymentIntentCreate[0].customer, CUST);
393
+ assertEquals(calls.paymentIntentCreate[0].payment_method, PM);
394
+ assertEquals(calls.paymentIntentCreate[0].amount, 350);
395
+ assertEquals(calls.paymentIntentCreate[0].off_session, true);
396
+ assertEquals(calls.paymentIntentCreate[0].confirm, true);
397
+ assertEquals(calls.paymentIntentCreate[0].receipt_email, EMAIL); // S3
398
+ assert(calls.idem.includes(guestPrintChargeKey(SUBMISSION, 350)));
399
+
400
+ assertEquals(st.rows[SUBMISSION].status, 'charged');
401
+ assertEquals(st.chargedCalls[0], { amountCents: 350, paymentIntentId: 'pi_test_1' });
402
+ assertEquals(NETWORK_ATTEMPTS.length, 0);
403
+ });
404
+
405
+ Deno.test('[double-charge guard] a second concurrent charge attempt is NOT claimed and NEVER calls Stripe again', async () => {
406
+ const { stripe, calls } = mkStripe();
407
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
408
+
409
+ // Simulate two "concurrent" invocations against the SAME in-memory row --
410
+ // the fake's claimForCharge is a single synchronous status check-and-flip,
411
+ // which is exactly what the real DB's atomic
412
+ // `UPDATE ... WHERE status = 'card_saved'` guarantees against real
413
+ // concurrent connections (see the D5 build report for why a single-row
414
+ // Postgres UPDATE is sufficient here without a separate lock/lease).
415
+ const first = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
416
+ const second = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
417
+
418
+ assertEquals(first.ok, true);
419
+ assertEquals(first.status, 'charged');
420
+ assertEquals(second.ok, true);
421
+ assertEquals(second.status, 'not_claimed');
422
+
423
+ // The critical assertion: Stripe's paymentIntents.create was called EXACTLY
424
+ // ONCE, not twice -- this is the actual double-charge guard proof.
425
+ assertEquals(calls.paymentIntentCreate.length, 1);
426
+ assertEquals(st.claimAttempts, 2);
427
+ });
428
+
429
+ Deno.test('chargeGuestPrintJob refuses a row that is still pending_card (card never saved)', async () => {
430
+ const { stripe, calls } = mkStripe();
431
+ const { db, st } = mkDb({ status: 'pending_card' });
432
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
433
+
434
+ assertEquals(outcome.ok, true);
435
+ assertEquals(outcome.status, 'not_claimed');
436
+ assertEquals(calls.paymentIntentCreate.length, 0);
437
+ assertEquals(st.rows[SUBMISSION].status, 'pending_card'); // unchanged
438
+ });
439
+
440
+ Deno.test('chargeGuestPrintJob refuses an already-charged row (idempotent no-op, not a re-charge)', async () => {
441
+ const { stripe, calls } = mkStripe();
442
+ const { db } = mkDb({ status: 'charged', stripe_customer_id: CUST, stripe_payment_method_id: PM });
443
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
444
+
445
+ assertEquals(outcome.status, 'not_claimed');
446
+ assertEquals(calls.paymentIntentCreate.length, 0);
447
+ });
448
+
449
+ Deno.test('chargeGuestPrintJob rejects a non-positive or non-integer amount BEFORE claiming the row', async () => {
450
+ const { stripe, calls } = mkStripe();
451
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
452
+
453
+ const zero = await chargeGuestPrintJob(stripe, db, SUBMISSION, 0);
454
+ assertEquals(zero.ok, false);
455
+ assertEquals(zero.status, 'invalid_amount');
456
+
457
+ const negative = await chargeGuestPrintJob(stripe, db, SUBMISSION, -100);
458
+ assertEquals(negative.ok, false);
459
+
460
+ const fractional = await chargeGuestPrintJob(stripe, db, SUBMISSION, 12.5);
461
+ assertEquals(fractional.ok, false);
462
+
463
+ assertEquals(st.claimAttempts, 0); // never even reached the claim
464
+ assertEquals(calls.paymentIntentCreate.length, 0);
465
+ assertEquals(st.rows[SUBMISSION].status, 'card_saved'); // untouched
466
+ });
467
+
468
+ Deno.test('a PaymentIntent left in requires_action (3DS) is NOT marked charged', async () => {
469
+ const { stripe } = mkStripe({ paymentIntentStatus: 'requires_action' });
470
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
471
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
472
+
473
+ assertEquals(outcome.ok, false);
474
+ assertEquals(outcome.status, 'requires_action');
475
+ assertEquals(outcome.paymentIntentId, 'pi_test_1');
476
+ // B3: 'charge_failed', not the pre-card 'failed' -- this row IS retryable.
477
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
478
+ assertEquals(st.chargedCalls.length, 0);
479
+ // B2: the live-but-non-succeeded PaymentIntent's id IS persisted, so a
480
+ // 3DS-stuck PI is findable from the DB afterward.
481
+ assertEquals(st.chargeFailedPaymentIntentIds, ['pi_test_1']);
482
+ });
483
+
484
+ Deno.test('a Stripe error on paymentIntents.create marks the charge failed (retryable), not charged', async () => {
485
+ const { stripe } = mkStripe({ paymentIntentCreateThrows: true });
486
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
487
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
488
+
489
+ assertEquals(outcome.ok, false);
490
+ assertEquals(outcome.status, 'payment_intent_failed');
491
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
492
+ assertEquals(st.chargedCalls.length, 0);
493
+ // No PI object was ever returned (the create call itself threw) -- there
494
+ // is genuinely nothing to persist.
495
+ assertEquals(st.chargeFailedPaymentIntentIds, [undefined]);
496
+ });
497
+
498
+ Deno.test('chargeGuestPrintJob refuses a card_saved row missing its payment method (defensive; should be unreachable)', async () => {
499
+ const { stripe, calls } = mkStripe();
500
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: null });
501
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
502
+
503
+ assertEquals(outcome.ok, false);
504
+ assertEquals(outcome.status, 'no_saved_payment_method');
505
+ assertEquals(calls.paymentIntentCreate.length, 0);
506
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
507
+ });
508
+
509
+ // ===================================== [B3] retry after a failed charge attempt ==
510
+
511
+ Deno.test('[B3] a charge_failed row IS reclaimable by a retry, and a corrected amount gets its own idempotency key', async () => {
512
+ // A genuinely DEAD-END decline (not a still-live 3DS challenge -- that
513
+ // case is covered separately below by the B4 tests, since B4 must refuse
514
+ // exactly that case rather than let a retry proceed).
515
+ const { stripe, calls } = mkStripe({
516
+ paymentIntentStatus: 'requires_payment_method',
517
+ priorPaymentIntentStatus: 'requires_payment_method',
518
+ });
519
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
520
+
521
+ // First attempt: staff enters the wrong amount, the card is declined
522
+ // outright, never charged -- row lands in 'charge_failed'.
523
+ const first = await chargeGuestPrintJob(stripe, db, SUBMISSION, 500);
524
+ assertEquals(first.ok, false);
525
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
526
+
527
+ // Second attempt: staff corrects the amount and retries with a NEW card.
528
+ // Must be reclaimable (not stuck forever); the B4 guard must retrieve the
529
+ // prior PI, see it's a dead end (requires_payment_method), and allow a new
530
+ // PI to be created; and the new attempt must NOT reuse the first attempt's
531
+ // idempotency key (a same-key retry within 24h would make Stripe replay
532
+ // the FIRST attempt's stored response instead of actually retrying).
533
+ stripe.paymentIntents.create = (p, o) => {
534
+ calls.paymentIntentCreate.push(p);
535
+ if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
536
+ return Promise.resolve({ id: 'pi_test_2', status: 'succeeded', amount: 350 });
537
+ };
538
+ const second = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
539
+ assertEquals(second.ok, true);
540
+ assertEquals(second.status, 'charged');
541
+ assertEquals(second.paymentIntentId, 'pi_test_2');
542
+ assertEquals(st.rows[SUBMISSION].status, 'charged');
543
+ assert(calls.paymentIntentRetrieve.includes('pi_test_1')); // B4: prior PI WAS checked
544
+
545
+ const key1 = guestPrintChargeKey(SUBMISSION, 500);
546
+ const key2 = guestPrintChargeKey(SUBMISSION, 350);
547
+ assert(key1 !== key2, 'idempotency keys for two different amounts must differ');
548
+ assert(calls.idem.includes(key1));
549
+ assert(calls.idem.includes(key2));
550
+ });
551
+
552
+ // ============================================ [B4] prior-PaymentIntent guard ==
553
+ //
554
+ // B3's amount-varying idempotency key makes a genuinely SECOND PaymentIntent
555
+ // creatable for one submission. B4 closes the double-charge window that
556
+ // opens if the FIRST one is still live when the second is attempted.
557
+
558
+ Deno.test('[B4] a retry is REFUSED (not charged again) while the prior PaymentIntent is still live (3DS pending)', async () => {
559
+ const { stripe, calls } = mkStripe({
560
+ paymentIntentStatus: 'requires_action',
561
+ priorPaymentIntentStatus: 'requires_action', // still live on retrieve -- guest has NOT completed 3DS yet
562
+ });
563
+ const { db, st } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
564
+
565
+ const first = await chargeGuestPrintJob(stripe, db, SUBMISSION, 500);
566
+ assertEquals(first.status, 'requires_action');
567
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
568
+ assertEquals(st.rows[SUBMISSION].stripe_payment_intent_id, 'pi_test_1');
569
+
570
+ const second = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
571
+ assertEquals(second.ok, false);
572
+ assertEquals(second.status, 'prior_payment_intent_still_live');
573
+ assertEquals(second.paymentIntentId, 'pi_test_1');
574
+ // The critical assertion: NO second PaymentIntent was ever created. This is
575
+ // the actual double-charge guard -- if the guest later completes the 3DS
576
+ // challenge on pi_test_1, there is no pi_test_2 sitting alongside it.
577
+ assertEquals(calls.paymentIntentCreate.length, 1);
578
+ assert(calls.paymentIntentRetrieve.includes('pi_test_1'));
579
+ });
580
+
581
+ Deno.test('[B4] a prior PI that already succeeded is recorded as charged (at ITS OWN amount, not the caller\'s), not re-charged', async () => {
582
+ // Simulates: Stripe confirmed pi_test_1 for $5.00, but our own
583
+ // writebackCharged call itself then failed/never ran (e.g. isolate
584
+ // evicted) -- an inconsistent state where the row says charge_failed but
585
+ // the PI actually succeeded. Staff, unaware, retries believing $3.50 is
586
+ // the correct (corrected) amount.
587
+ const { stripe, calls } = mkStripe({ priorPaymentIntentStatus: 'succeeded', priorPaymentIntentAmount: 500 });
588
+ const { db, st } = mkDb({
589
+ status: 'charge_failed', stripe_customer_id: CUST, stripe_payment_method_id: PM,
590
+ stripe_payment_intent_id: 'pi_test_1',
591
+ });
592
+
593
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350); // staff enters 350
594
+ assertEquals(outcome.ok, true);
595
+ assertEquals(outcome.status, 'charged');
596
+ assertEquals(outcome.paymentIntentId, 'pi_test_1');
597
+ assertEquals(st.rows[SUBMISSION].status, 'charged');
598
+ // No new PaymentIntent was created -- the prior one is recognized, not re-charged.
599
+ assertEquals(calls.paymentIntentCreate.length, 0);
600
+ // THE CRITICAL ASSERTION: the ledger records what Stripe ACTUALLY charged
601
+ // (500, the prior PI's real amount), NOT the caller's amountCents (350).
602
+ // Getting this backwards would silently corrupt the ledger with a number
603
+ // Stripe never actually charged.
604
+ assertEquals(st.chargedCalls[0], { amountCents: 500, paymentIntentId: 'pi_test_1' });
605
+ });
606
+
607
+ Deno.test('[B4] a prior PI that fails to retrieve fails CLOSED (refuses, does not risk a second charge)', async () => {
608
+ const { stripe, calls } = mkStripe({ paymentIntentRetrieveThrows: true });
609
+ const { db, st } = mkDb({
610
+ status: 'charge_failed', stripe_customer_id: CUST, stripe_payment_method_id: PM,
611
+ stripe_payment_intent_id: 'pi_test_1',
612
+ });
613
+
614
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
615
+ assertEquals(outcome.ok, false);
616
+ assertEquals(outcome.status, 'prior_payment_intent_unverifiable');
617
+ assertEquals(calls.paymentIntentCreate.length, 0); // never risked a second PI
618
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
619
+ });
620
+
621
+ Deno.test('[B4] a prior PI that is a genuine dead end (canceled) allows a fresh attempt', async () => {
622
+ const { stripe, calls } = mkStripe({ priorPaymentIntentStatus: 'canceled', paymentIntentStatus: 'succeeded' });
623
+ const { db, st } = mkDb({
624
+ status: 'charge_failed', stripe_customer_id: CUST, stripe_payment_method_id: PM,
625
+ stripe_payment_intent_id: 'pi_dead',
626
+ });
627
+
628
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
629
+ assertEquals(outcome.ok, true);
630
+ assertEquals(outcome.status, 'charged');
631
+ assertEquals(calls.paymentIntentCreate.length, 1); // a genuinely new PI WAS created
632
+ assertEquals(st.rows[SUBMISSION].status, 'charged');
633
+ });
634
+
635
+ // ===================================== [S9] recovery-branch amount mismatch ==
636
+
637
+ Deno.test('[S9] a recovery-branch charge at a DIFFERENT amount than requested reports the TRUE amount, not silently', async () => {
638
+ // Same underlying scenario as the [B4] "already succeeded" test above --
639
+ // the prior PI actually charged 500, staff's retry requested 350 -- but
640
+ // this test's focus is the OUTCOME/response carrying that true amount
641
+ // forward, not just the ledger write.
642
+ const { stripe } = mkStripe({ priorPaymentIntentStatus: 'succeeded', priorPaymentIntentAmount: 500 });
643
+ const { db, st } = mkDb({
644
+ status: 'charge_failed', stripe_customer_id: CUST, stripe_payment_method_id: PM,
645
+ stripe_payment_intent_id: 'pi_test_1',
646
+ });
647
+
648
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350); // staff enters 350
649
+ assertEquals(outcome.status, 'charged');
650
+ // THE CRITICAL ASSERTION: outcome.amountCents is the PRIOR PI's true amount
651
+ // (500), NOT the caller's requested amountCents (350) -- so a caller (e.g.
652
+ // admin-charge-guest-print) can detect the divergence and signal it rather
653
+ // than silently reporting success at the number staff typed.
654
+ assertEquals(outcome.amountCents, 500);
655
+ assert(outcome.amountCents !== 350, 'must not silently carry the caller\'s requested amount instead');
656
+ assertEquals(st.chargedCalls[0], { amountCents: 500, paymentIntentId: 'pi_test_1' });
657
+ });
658
+
659
+ Deno.test('[S9] the ordinary happy-path charge also reports amountCents on the outcome', async () => {
660
+ const { stripe } = mkStripe({ paymentIntentStatus: 'succeeded' });
661
+ const { db } = mkDb({ status: 'card_saved', stripe_customer_id: CUST, stripe_payment_method_id: PM });
662
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
663
+ assertEquals(outcome.status, 'charged');
664
+ assertEquals(outcome.amountCents, 350);
665
+ });
666
+
667
+ // ============================= [S10] prior-PI status guard fails CLOSED on unknown ==
668
+
669
+ Deno.test('[S10] an UNRECOGNIZED prior-PI status fails CLOSED (refuses) rather than falling through to a new charge', async () => {
670
+ // Not in DEAD_PRIOR_PI_STATUSES, and not one of the known-still-live
671
+ // statuses the old denylist enumerated either -- a status this function has
672
+ // simply never seen before (a future Stripe status, or a malformed value).
673
+ // The old code's denylist would have fallen through to create a NEW
674
+ // PaymentIntent here, exactly the double-charge risk B4 was meant to close.
675
+ const { stripe, calls } = mkStripe({ priorPaymentIntentStatus: 'some_future_status' });
676
+ const { db, st } = mkDb({
677
+ status: 'charge_failed', stripe_customer_id: CUST, stripe_payment_method_id: PM,
678
+ stripe_payment_intent_id: 'pi_test_1',
679
+ });
680
+
681
+ const outcome = await chargeGuestPrintJob(stripe, db, SUBMISSION, 350);
682
+ assertEquals(outcome.ok, false);
683
+ assertEquals(outcome.status, 'prior_payment_intent_still_live');
684
+ assertEquals(outcome.paymentIntentId, 'pi_test_1');
685
+ // THE CRITICAL ASSERTION: no new PaymentIntent was ever created.
686
+ assertEquals(calls.paymentIntentCreate.length, 0);
687
+ assertEquals(st.rows[SUBMISSION].status, 'charge_failed');
688
+ });
689
+
690
+ // ================================================== [S6] attachStripeIds fails ==
691
+
692
+ Deno.test('[S6] a live SetupIntent that fails to attach to the row is not silently lost', async () => {
693
+ const { stripe, calls } = mkStripe();
694
+ const { db, st } = mkDb();
695
+ st.attachStripeIdsThrows = true;
696
+
697
+ const outcome = await submitGuestPrintJob(stripe, db, { email: EMAIL, guestName: null, guestBillingCode: CODE });
698
+
699
+ assertEquals(outcome.ok, false);
700
+ assertEquals(outcome.detail, 'attach_stripe_ids_failed');
701
+ // The row is marked 'failed' (flags it for manual reconciliation) rather
702
+ // than silently staying 'pending_card' as if nothing had happened, and the
703
+ // live SetupIntent id that now exists in Stripe is recorded in last_error
704
+ // so it isn't lost outright even though it never reached
705
+ // stripe_setup_intent_id.
706
+ assertEquals(st.rows[SUBMISSION].status, 'failed');
707
+ assert(st.failedReasons[0].includes(SI));
708
+ // The SetupIntent WAS actually created in Stripe before the DB write
709
+ // failed -- that call really happened and is not itself the bug.
710
+ assertEquals(calls.setupIntentCreate.length, 1);
711
+ });
712
+
713
+ // ===================================================== harness-not-vacuous ==
714
+ //
715
+ // money-path-dry-run-testing technique 1, step 4: prove the harness can
716
+ // actually fail by deliberately breaking a guard and confirming the matching
717
+ // test fails. Not a permanent test -- exercised once here, then reverted; see
718
+ // the D5 build report for the literal before/after transcript.
719
+
720
+ Deno.test('NO NETWORK was attempted by any test in this file', () => {
721
+ assertEquals(NETWORK_ATTEMPTS, []);
722
+ });