@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,660 @@
1
+ // Unit tests for dynamic-pricing resolution. No network, no DB: the Supabase
2
+ // client is a small in-memory stub that answers each table with fixture rows.
3
+ import { assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts';
4
+ import {
5
+ resolveDynamicDiscount,
6
+ validateAndPriceForRoom,
7
+ type DynamicRuleRow,
8
+ type RoomForPricing,
9
+ } from './pricing.ts';
10
+
11
+ const ROOM_ID = '11111111-1111-1111-1111-111111111111';
12
+ const OTHER_ID = '22222222-2222-2222-2222-222222222222';
13
+
14
+ // 2026-08-12 10:00 PT (Wed) -> 17:00Z
15
+ const START = new Date('2026-08-12T17:00:00.000Z');
16
+ const END = new Date('2026-08-12T18:00:00.000Z');
17
+ const NOW = new Date('2026-08-12T16:00:00.000Z').getTime();
18
+ const RANGE = `[${START.toISOString()},${END.toISOString()})`;
19
+
20
+ interface Fixtures {
21
+ promotions?: string | null;
22
+ promotionsError?: boolean;
23
+ rules?: Partial<DynamicRuleRow>[];
24
+ rulesError?: boolean;
25
+ syncUpdatedAt?: string | null;
26
+ eligibleRooms?: string[];
27
+ busyRooms?: string[];
28
+ unparsedRooms?: string[];
29
+ hours?: { open_time: string; close_time: string } | null;
30
+ }
31
+
32
+ // deno-lint-ignore no-explicit-any
33
+ function stubClient(f: Fixtures): any {
34
+ const builder = (table: string) => {
35
+ const filters: Record<string, unknown> = {};
36
+ // deno-lint-ignore no-explicit-any
37
+ const self: any = {
38
+ select: () => self,
39
+ eq: (c: string, v: unknown) => { filters[c] = v; return self; },
40
+ in: () => self,
41
+ or: () => self,
42
+ filter: () => self,
43
+ maybeSingle: () => Promise.resolve(resolve(table, filters, true)),
44
+ then: (
45
+ // deno-lint-ignore no-explicit-any
46
+ res: (v: any) => unknown,
47
+ // deno-lint-ignore no-explicit-any
48
+ rej?: (e: any) => unknown,
49
+ ) => Promise.resolve(resolve(table, filters, false)).then(res, rej),
50
+ };
51
+ return self;
52
+ };
53
+ const resolve = (table: string, filters: Record<string, unknown>, single: boolean) => {
54
+ switch (table) {
55
+ case 'app_settings':
56
+ if (f.promotionsError) return { data: null, error: { message: 'boom' } };
57
+ return { data: f.promotions === undefined ? null : { value: f.promotions }, error: null };
58
+ case 'room_dynamic_pricing_rules':
59
+ if (f.rulesError) return { data: null, error: { message: 'boom' } };
60
+ return { data: f.rules ?? [], error: null };
61
+ case 'sync_state':
62
+ return {
63
+ data: f.syncUpdatedAt ? { updated_at: f.syncUpdatedAt } : null,
64
+ error: null,
65
+ };
66
+ case 'rooms':
67
+ return { data: (f.eligibleRooms ?? []).map((id) => ({ id })), error: null };
68
+ case 'bookings': {
69
+ const id = String(filters['room_id']);
70
+ if ((f.unparsedRooms ?? []).includes(id)) return { data: [{ during: 'garbage', status: 'paid', hold_expires_at: null }], error: null };
71
+ if ((f.busyRooms ?? []).includes(id)) {
72
+ return { data: [{ during: `["${START.toISOString()}","${END.toISOString()}")`, status: 'paid', hold_expires_at: null }], error: null };
73
+ }
74
+ return { data: [], error: null };
75
+ }
76
+ case 'blackouts':
77
+ return { data: [], error: null };
78
+ case 'business_hours':
79
+ return {
80
+ data: f.hours === null ? [] : [{ room_id: null, ...(f.hours ?? { open_time: '08:00:00', close_time: '18:00:00' }) }],
81
+ error: null,
82
+ };
83
+ case 'ops_events':
84
+ return { data: null, error: null };
85
+ default:
86
+ return single ? { data: null, error: null } : { data: [], error: null };
87
+ }
88
+ };
89
+ return {
90
+ from: (table: string) => ({
91
+ ...builder(table),
92
+ insert: () => Promise.resolve({ data: null, error: null }),
93
+ }),
94
+ };
95
+ }
96
+
97
+ function rule(over: Partial<DynamicRuleRow>): Partial<DynamicRuleRow> {
98
+ return {
99
+ room_id: null, pct: 10, flat_price_cents: null, starts_at: null, ends_at: null,
100
+ occupancy_threshold: null, day_of_week: null,
101
+ window_start: null, window_end: null, ...over,
102
+ };
103
+ }
104
+
105
+ const room = (over: Partial<RoomForPricing> = {}): RoomForPricing => ({
106
+ id: ROOM_ID, name: 'Test Room',
107
+ hourly_cents: 4100, day_cents: null, half_day_cents: null,
108
+ min_booking_minutes: 60, booking_mode: 'hourly', active: true,
109
+ dynamic_pricing_eligible: true, ...over,
110
+ });
111
+
112
+ const ctx = { startUtc: START, endUtc: END, rangeLiteral: RANGE, price_cents: 4100 };
113
+
114
+ Deno.test('flash_sale matches inside its window', async () => {
115
+ const c = stubClient({
116
+ promotions: 'true',
117
+ rules: [rule({ rule_type: 'flash_sale', pct: 20, starts_at: '2026-08-12T00:00:00Z', ends_at: '2026-08-13T00:00:00Z' })],
118
+ });
119
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 820, ruleType: 'flash_sale' });
120
+ });
121
+
122
+ Deno.test('flash_sale outside its window does not match', async () => {
123
+ const c = stubClient({
124
+ promotions: 'true',
125
+ rules: [rule({ rule_type: 'flash_sale', pct: 20, starts_at: '2026-08-01T00:00:00Z', ends_at: '2026-08-02T00:00:00Z' })],
126
+ });
127
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 0, ruleType: null });
128
+ });
129
+
130
+ Deno.test('same_day compares LA dates, not UTC dates', async () => {
131
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 10 })] });
132
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 410, ruleType: 'same_day' });
133
+ // 2026-08-13T05:00Z is still Aug 12 in LA -> same day as the booking start.
134
+ const laStillPrevDay = new Date('2026-08-13T05:00:00Z').getTime();
135
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, laStillPrevDay), { cents: 410, ruleType: 'same_day' });
136
+ // 2026-08-14T17:00Z is Aug 14 in LA -> different day.
137
+ const other = new Date('2026-08-14T17:00:00Z').getTime();
138
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, other), { cents: 0, ruleType: null });
139
+ });
140
+
141
+ Deno.test('time_of_day matches LA window and weekday', async () => {
142
+ const c = stubClient({
143
+ promotions: 'true',
144
+ rules: [rule({ rule_type: 'time_of_day', pct: 15, day_of_week: [3], window_start: '09:00', window_end: '11:00' })],
145
+ });
146
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 615, ruleType: 'time_of_day' });
147
+
148
+ const wrongDay = stubClient({
149
+ promotions: 'true',
150
+ rules: [rule({ rule_type: 'time_of_day', pct: 15, day_of_week: [1], window_start: '09:00', window_end: '11:00' })],
151
+ });
152
+ assertEquals(await resolveDynamicDiscount(wrongDay, room(), ctx, NOW), { cents: 0, ruleType: null });
153
+
154
+ const wrongWindow = stubClient({
155
+ promotions: 'true',
156
+ rules: [rule({ rule_type: 'time_of_day', pct: 15, window_start: '13:00', window_end: '15:00' })],
157
+ });
158
+ assertEquals(await resolveDynamicDiscount(wrongWindow, room(), ctx, NOW), { cents: 0, ruleType: null });
159
+ });
160
+
161
+ Deno.test('occupancy matches when few rooms are free', async () => {
162
+ const fresh = new Date(NOW - 60_000).toISOString();
163
+ const c = stubClient({
164
+ promotions: 'true',
165
+ rules: [rule({ rule_type: 'occupancy', pct: 25, occupancy_threshold: 1 })],
166
+ syncUpdatedAt: fresh,
167
+ eligibleRooms: [ROOM_ID, OTHER_ID],
168
+ busyRooms: [OTHER_ID],
169
+ });
170
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 1025, ruleType: 'occupancy' });
171
+
172
+ const roomy = stubClient({
173
+ promotions: 'true',
174
+ rules: [rule({ rule_type: 'occupancy', pct: 25, occupancy_threshold: 1 })],
175
+ syncUpdatedAt: fresh,
176
+ eligibleRooms: [ROOM_ID, OTHER_ID],
177
+ });
178
+ assertEquals(await resolveDynamicDiscount(roomy, room(), ctx, NOW), { cents: 0, ruleType: null });
179
+ });
180
+
181
+ Deno.test('occupancy treats unparsed rows as busy', async () => {
182
+ const c = stubClient({
183
+ promotions: 'true',
184
+ rules: [rule({ rule_type: 'occupancy', pct: 25, occupancy_threshold: 1 })],
185
+ syncUpdatedAt: new Date(NOW - 60_000).toISOString(),
186
+ eligibleRooms: [ROOM_ID, OTHER_ID],
187
+ unparsedRooms: [OTHER_ID],
188
+ });
189
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 1025, ruleType: 'occupancy' });
190
+ });
191
+
192
+ Deno.test('occupancy fails closed when gcal sync is stale or missing', async () => {
193
+ const stale = stubClient({
194
+ promotions: 'true',
195
+ rules: [rule({ rule_type: 'occupancy', pct: 25, occupancy_threshold: 8 })],
196
+ syncUpdatedAt: new Date(NOW - 12 * 60 * 1000).toISOString(),
197
+ eligibleRooms: [ROOM_ID, OTHER_ID],
198
+ });
199
+ assertEquals(await resolveDynamicDiscount(stale, room(), ctx, NOW), { cents: 0, ruleType: null });
200
+
201
+ const missing = stubClient({
202
+ promotions: 'true',
203
+ rules: [rule({ rule_type: 'occupancy', pct: 25, occupancy_threshold: 8 })],
204
+ eligibleRooms: [ROOM_ID],
205
+ });
206
+ assertEquals(await resolveDynamicDiscount(missing, room(), ctx, NOW), { cents: 0, ruleType: null });
207
+ });
208
+
209
+ Deno.test('flash_sale beats a larger automatic discount', async () => {
210
+ const c = stubClient({
211
+ promotions: 'true',
212
+ rules: [
213
+ rule({ rule_type: 'same_day', pct: 40 }),
214
+ rule({ rule_type: 'flash_sale', pct: 5, starts_at: '2026-08-12T00:00:00Z', ends_at: '2026-08-13T00:00:00Z' }),
215
+ ],
216
+ });
217
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 205, ruleType: 'flash_sale' });
218
+ });
219
+
220
+ Deno.test('largest pct wins among automatic rules', async () => {
221
+ const c = stubClient({
222
+ promotions: 'true',
223
+ rules: [
224
+ rule({ rule_type: 'same_day', pct: 10 }),
225
+ rule({ rule_type: 'time_of_day', pct: 30, window_start: '09:00', window_end: '11:00' }),
226
+ ],
227
+ });
228
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 1230, ruleType: 'time_of_day' });
229
+ });
230
+
231
+ Deno.test('room-specific rule beats a global rule at equal pct', async () => {
232
+ const c = stubClient({
233
+ promotions: 'true',
234
+ rules: [
235
+ rule({ rule_type: 'same_day', pct: 20, room_id: null }),
236
+ rule({ rule_type: 'time_of_day', pct: 20, room_id: ROOM_ID, window_start: '09:00', window_end: '11:00' }),
237
+ ],
238
+ });
239
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 820, ruleType: 'time_of_day' });
240
+ });
241
+
242
+ Deno.test('promotions_enabled off (or unreadable) yields zero', async () => {
243
+ const rules = [rule({ rule_type: 'same_day', pct: 50 })];
244
+ for (const f of [
245
+ { promotions: 'false', rules },
246
+ { rules },
247
+ { promotionsError: true, rules },
248
+ ]) {
249
+ assertEquals(await resolveDynamicDiscount(stubClient(f), room(), ctx, NOW), { cents: 0, ruleType: null });
250
+ }
251
+ });
252
+
253
+ Deno.test('malformed / unknown rules never match and never throw', async () => {
254
+ const c = stubClient({
255
+ promotions: 'true',
256
+ rules: [
257
+ rule({ rule_type: 'time_of_day', pct: 40, window_start: null, window_end: null }),
258
+ rule({ rule_type: 'flash_sale', pct: 40, starts_at: null, ends_at: null }),
259
+ rule({ rule_type: 'occupancy', pct: 40, occupancy_threshold: null }),
260
+ rule({ rule_type: 'does_not_exist', pct: 40 }),
261
+ rule({ rule_type: 'same_day', pct: 0 }),
262
+ ],
263
+ });
264
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 0, ruleType: null });
265
+ });
266
+
267
+ Deno.test('a pct above the ratified 50% ceiling is rejected even if it reaches the query result', async () => {
268
+ // Simulates the DB CHECK (room_dynamic_pricing_rules_pct_check, pct <= 50)
269
+ // having been loosened, dropped, or bypassed (e.g. a stale row from before
270
+ // the constraint existed, or a service-role write). The code-level filter
271
+ // in resolveDynamicDiscount's rule pool must not rely on the DB alone.
272
+ const c = stubClient({
273
+ promotions: 'true',
274
+ rules: [rule({ rule_type: 'same_day', pct: 75 })],
275
+ });
276
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 0, ruleType: null });
277
+ });
278
+
279
+ Deno.test('pct exactly at the 50% ceiling still matches (boundary is inclusive)', async () => {
280
+ const c = stubClient({
281
+ promotions: 'true',
282
+ rules: [rule({ rule_type: 'same_day', pct: 50 })],
283
+ });
284
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 2050, ruleType: 'same_day' });
285
+ });
286
+
287
+ // --- end-to-end through validateAndPriceForRoom ------------------------------
288
+
289
+ const hourlyInput = { start: START.toISOString(), end: END.toISOString() };
290
+
291
+ Deno.test('non-member discount is the same percentage off the public rate', async () => {
292
+ const c = stubClient({
293
+ promotions: 'true',
294
+ rules: [rule({ rule_type: 'same_day', pct: 50 })],
295
+ });
296
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { allowDynamic: true });
297
+ if (!res.ok) throw new Error(res.error);
298
+ assertEquals(res.price_cents, 4100);
299
+ assertEquals(res.dynamic_discount_cents, 2050);
300
+ assertEquals(res.dynamic_discount_rule_type, 'same_day');
301
+ });
302
+
303
+ Deno.test('the member-rate mechanism is retired -- isMember never changes the price', async () => {
304
+ // There is no separate member rate on the room anymore. Every booker,
305
+ // member or not, is priced off the room's public rate; `isMember` is
306
+ // accepted for caller compatibility only and has zero effect here.
307
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 50 })] });
308
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { isMember: true, allowDynamic: true });
309
+ if (!res.ok) throw new Error(res.error);
310
+ assertEquals(res.price_cents, 4100);
311
+ assertEquals(res.dynamic_discount_cents, 2050);
312
+ assertEquals(res.dynamic_discount_rule_type, 'same_day');
313
+ });
314
+
315
+ Deno.test('allowDynamic=false (default) always yields zero', async () => {
316
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 50 })] });
317
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, {});
318
+ if (!res.ok) throw new Error(res.error);
319
+ assertEquals(res.dynamic_discount_cents, 0);
320
+ });
321
+
322
+ Deno.test('allowFreshDynamic=false suppresses a fresh discount when there is no carryForward', async () => {
323
+ // This is the reschedule-booking shape: allowDynamic stays true (so the
324
+ // function doesn't early-return before evaluating any carryForward), but
325
+ // allowFreshDynamic:false means resolveDynamicDiscount is never called.
326
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 50 })] });
327
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, {
328
+ allowDynamic: true,
329
+ allowFreshDynamic: false,
330
+ });
331
+ if (!res.ok) throw new Error(res.error);
332
+ assertEquals(res.dynamic_discount_cents, 0);
333
+ assertEquals(res.dynamic_discount_rule_type, null);
334
+ });
335
+
336
+ Deno.test('allowFreshDynamic=false still honors carryForward even when a bigger fresh rule would match', async () => {
337
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 50 })] });
338
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, {
339
+ allowDynamic: true,
340
+ allowFreshDynamic: false,
341
+ carryForward: { list_cents: 4100, discount_cents: 410, rule_type: 'flash_sale' },
342
+ });
343
+ if (!res.ok) throw new Error(res.error);
344
+ // A fresh same_day match at 50% would be 2050 -- it must NOT be used.
345
+ // Only the carried 410 may be applied, proving reschedule can carry an
346
+ // existing discount forward but can never mint a fresh one.
347
+ assertEquals(res.dynamic_discount_cents, 410);
348
+ assertEquals(res.dynamic_discount_rule_type, 'flash_sale');
349
+ });
350
+
351
+ Deno.test('room not flagged dynamic_pricing_eligible yields zero', async () => {
352
+ const c = stubClient({ promotions: 'true', rules: [rule({ rule_type: 'same_day', pct: 50 })] });
353
+ const res = await validateAndPriceForRoom(
354
+ c, room({ dynamic_pricing_eligible: false }), hourlyInput, NOW, { allowDynamic: true },
355
+ );
356
+ if (!res.ok) throw new Error(res.error);
357
+ assertEquals(res.dynamic_discount_cents, 0);
358
+ });
359
+
360
+ Deno.test('a failing rules query drops the discount instead of throwing', async () => {
361
+ const c = stubClient({ promotions: 'true', rulesError: true });
362
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { allowDynamic: true });
363
+ if (!res.ok) throw new Error(res.error);
364
+ assertEquals(res.dynamic_discount_cents, 0);
365
+ assertEquals(res.dynamic_discount_rule_type, null);
366
+ });
367
+
368
+ // --- list-adjusting rules: premiums and flat blocks -------------------------
369
+ //
370
+ // These move price_cents (the LIST price) rather than producing a discount, so
371
+ // every assertion here also asserts dynamic_discount_cents stays 0 — that is
372
+ // the property that keeps bookings_amount_math_check and every "% off" badge
373
+ // working unchanged.
374
+
375
+ // Town Hall's real shape: $41/hr, 2-hour minimum, $295 day cap.
376
+ const townHall = (over: Partial<RoomForPricing> = {}): RoomForPricing =>
377
+ room({ name: 'Town Hall', hourly_cents: 4100, day_cents: 29500, min_booking_minutes: 120, ...over });
378
+
379
+ const premiumRule = (over: Partial<DynamicRuleRow> = {}) =>
380
+ rule({
381
+ rule_type: 'time_of_day_premium', pct: 12, room_id: ROOM_ID,
382
+ day_of_week: [3], window_start: '09:00', window_end: '11:00', ...over,
383
+ });
384
+
385
+ // Wed 2026-08-12, 10:00–16:00 PT — the "Offsite Day" block.
386
+ const BLOCK_START = new Date('2026-08-12T17:00:00.000Z');
387
+ const BLOCK_END = new Date('2026-08-12T23:00:00.000Z');
388
+ const blockRule = (over: Partial<DynamicRuleRow> = {}) =>
389
+ rule({
390
+ rule_type: 'flat_block', pct: null, flat_price_cents: 16400, room_id: ROOM_ID,
391
+ day_of_week: [3], window_start: '10:00', window_end: '16:00', ...over,
392
+ });
393
+
394
+ Deno.test('time_of_day_premium raises the list price and leaves the discount at zero', async () => {
395
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
396
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { allowDynamic: true });
397
+ if (!res.ok) throw new Error(res.error);
398
+ // 1h at $41/hr = 4,100 -> +12% -> 4,100 + round(4,100 x 12/100) = 4,592.
399
+ assertEquals(res.price_cents, 4592);
400
+ assertEquals(res.dynamic_discount_cents, 0);
401
+ assertEquals(res.dynamic_discount_rule_type, null);
402
+ assertEquals(res.list_rule_type, 'time_of_day_premium');
403
+ });
404
+
405
+ Deno.test('time_of_day_premium does NOT fire once the booking is at the day rate', async () => {
406
+ // day_cents === the computed 1-hour price, so isFullDayPrice is true. The
407
+ // customer bought the day; a peak-hour uplift must not stack on top of it.
408
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
409
+ const res = await validateAndPriceForRoom(c, room({ day_cents: 4100 }), hourlyInput, NOW, { allowDynamic: true });
410
+ if (!res.ok) throw new Error(res.error);
411
+ assertEquals(res.price_cents, 4100);
412
+ assertEquals(res.list_rule_type, null);
413
+ });
414
+
415
+ Deno.test('time_of_day_premium respects day_of_week and the half-open window', async () => {
416
+ const wrongDay = stubClient({ promotions: 'true', rules: [premiumRule({ day_of_week: [1] })] });
417
+ const a = await validateAndPriceForRoom(wrongDay, room(), hourlyInput, NOW, { allowDynamic: true });
418
+ if (!a.ok) throw new Error(a.error);
419
+ assertEquals(a.price_cents, 4100);
420
+ assertEquals(a.list_rule_type, null);
421
+
422
+ // Booking starts at 10:00 PT; a 08:00-10:00 window is [ws, we) so it must
423
+ // NOT match — this is the exact boundary the Town Hall premium sits on.
424
+ const endedWindow = stubClient({
425
+ promotions: 'true',
426
+ rules: [premiumRule({ window_start: '08:00', window_end: '10:00' })],
427
+ });
428
+ const b = await validateAndPriceForRoom(endedWindow, room(), hourlyInput, NOW, { allowDynamic: true });
429
+ if (!b.ok) throw new Error(b.error);
430
+ assertEquals(b.price_cents, 4100);
431
+ assertEquals(b.list_rule_type, null);
432
+ });
433
+
434
+ Deno.test('flat_block fires on an EXACT window match and replaces the computed price', async () => {
435
+ const c = stubClient({ promotions: 'true', rules: [blockRule()] });
436
+ const res = await validateAndPriceForRoom(
437
+ c, townHall(),
438
+ { start: BLOCK_START.toISOString(), end: BLOCK_END.toISOString() },
439
+ NOW, { allowDynamic: true },
440
+ );
441
+ if (!res.ok) throw new Error(res.error);
442
+ // Straight hourly would be round(4100/2 x 12) = 24,600. The block is $164.00.
443
+ assertEquals(res.price_cents, 16400);
444
+ assertEquals(res.dynamic_discount_cents, 0);
445
+ assertEquals(res.list_rule_type, 'flat_block');
446
+ });
447
+
448
+ Deno.test('flat_block does NOT fire on a contained or shifted window, or on the wrong day', async () => {
449
+ // Ends an hour early (10:00-15:00): 10 slots -> round(2050 x 10) = 20,500.
450
+ // Containment matching would have charged the flat 16,400 here, i.e. LESS
451
+ // than the customer's 5 hours are worth and MORE than 4 hours costs.
452
+ const shortEnd = stubClient({ promotions: 'true', rules: [blockRule()] });
453
+ const a = await validateAndPriceForRoom(
454
+ shortEnd, townHall(),
455
+ { start: BLOCK_START.toISOString(), end: new Date('2026-08-12T22:00:00.000Z').toISOString() },
456
+ NOW, { allowDynamic: true },
457
+ );
458
+ if (!a.ok) throw new Error(a.error);
459
+ assertEquals(a.price_cents, 20500);
460
+ assertEquals(a.list_rule_type, null);
461
+
462
+ // Starts half an hour late (10:30-16:00): 11 slots -> 22,550.
463
+ const lateStart = stubClient({ promotions: 'true', rules: [blockRule()] });
464
+ const b = await validateAndPriceForRoom(
465
+ lateStart, townHall(),
466
+ { start: new Date('2026-08-12T17:30:00.000Z').toISOString(), end: BLOCK_END.toISOString() },
467
+ NOW, { allowDynamic: true },
468
+ );
469
+ if (!b.ok) throw new Error(b.error);
470
+ assertEquals(b.price_cents, 22550);
471
+ assertEquals(b.list_rule_type, null);
472
+
473
+ // Same 10:00-16:00 window, but on Tuesday 2026-08-11 (weekday 2, not in {3}).
474
+ const wrongDay = stubClient({ promotions: 'true', rules: [blockRule()] });
475
+ const c = await validateAndPriceForRoom(
476
+ wrongDay, townHall(),
477
+ {
478
+ start: new Date('2026-08-11T17:00:00.000Z').toISOString(),
479
+ end: new Date('2026-08-11T23:00:00.000Z').toISOString(),
480
+ },
481
+ new Date('2026-08-11T16:00:00.000Z').getTime(), { allowDynamic: true },
482
+ );
483
+ if (!c.ok) throw new Error(c.error);
484
+ assertEquals(c.price_cents, 24600);
485
+ assertEquals(c.list_rule_type, null);
486
+ });
487
+
488
+ Deno.test('flat_block beats a premium matching the same window', async () => {
489
+ const c = stubClient({
490
+ promotions: 'true',
491
+ rules: [
492
+ blockRule(),
493
+ premiumRule({ pct: 50, window_start: '09:00', window_end: '17:00' }),
494
+ ],
495
+ });
496
+ const res = await validateAndPriceForRoom(
497
+ c, townHall(),
498
+ { start: BLOCK_START.toISOString(), end: BLOCK_END.toISOString() },
499
+ NOW, { allowDynamic: true },
500
+ );
501
+ if (!res.ok) throw new Error(res.error);
502
+ assertEquals(res.price_cents, 16400);
503
+ assertEquals(res.list_rule_type, 'flat_block');
504
+ });
505
+
506
+ Deno.test('the two list-adjusting rule types never leak into the DISCOUNT pool', async () => {
507
+ // matchDynamicRules' `default: break` (plus the pct-null guard) is the
508
+ // property the whole two-pass design rests on: a premium must never be read
509
+ // as a discount, and a flat_block row carries no pct to be read at all.
510
+ const c = stubClient({
511
+ promotions: 'true',
512
+ rules: [premiumRule({ pct: 40 }), blockRule()],
513
+ });
514
+ assertEquals(await resolveDynamicDiscount(c, room(), ctx, NOW), { cents: 0, ruleType: null });
515
+ });
516
+
517
+ Deno.test('a discount still applies on top of a premium-adjusted list price', async () => {
518
+ const c = stubClient({
519
+ promotions: 'true',
520
+ rules: [premiumRule(), rule({ rule_type: 'same_day', pct: 10, room_id: ROOM_ID })],
521
+ });
522
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { allowDynamic: true });
523
+ if (!res.ok) throw new Error(res.error);
524
+ // List moves to 4,592 FIRST; the 10% is then taken off that, not off 4,100.
525
+ assertEquals(res.price_cents, 4592);
526
+ assertEquals(res.dynamic_discount_cents, 459);
527
+ assertEquals(res.dynamic_discount_rule_type, 'same_day');
528
+ assertEquals(res.list_rule_type, 'time_of_day_premium');
529
+ });
530
+
531
+ Deno.test('promotions_enabled off makes a premium inert too (it LOWERS the price)', async () => {
532
+ // Documented coupling: the kill switch is named for promotions but gates
533
+ // premiums as well, so turning it off in an emergency drops Town Hall's
534
+ // peak-hour price back to base rather than raising anything.
535
+ const c = stubClient({ promotions: 'false', rules: [premiumRule()] });
536
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, { allowDynamic: true });
537
+ if (!res.ok) throw new Error(res.error);
538
+ assertEquals(res.price_cents, 4100);
539
+ assertEquals(res.list_rule_type, null);
540
+ });
541
+
542
+ Deno.test('an ineligible room is never repriced by a list-adjusting rule', async () => {
543
+ // dynamic_pricing_eligible is a CALLER-side gate — it is not checked inside
544
+ // loadDynamicPricingRules or either matcher, so resolveListAdjustment has to
545
+ // re-apply it itself.
546
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
547
+ const res = await validateAndPriceForRoom(
548
+ c, room({ dynamic_pricing_eligible: false }), hourlyInput, NOW, { allowDynamic: true },
549
+ );
550
+ if (!res.ok) throw new Error(res.error);
551
+ assertEquals(res.price_cents, 4100);
552
+ assertEquals(res.list_rule_type, null);
553
+ });
554
+
555
+ // --- reschedule interaction --------------------------------------------------
556
+
557
+ Deno.test('reschedule INTO a premium window reprices UP even with allowFreshDynamic=false', async () => {
558
+ // allowFreshDynamic:false stops a reschedule minting a new DISCOUNT. A list
559
+ // adjustment is not a discount — it is the list price — so it must still
560
+ // run, or rescheduling is a one-click premium bypass.
561
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
562
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, {
563
+ allowDynamic: true,
564
+ allowFreshDynamic: false,
565
+ });
566
+ if (!res.ok) throw new Error(res.error);
567
+ assertEquals(res.price_cents, 4592);
568
+ assertEquals(res.dynamic_discount_cents, 0);
569
+ assertEquals(res.list_rule_type, 'time_of_day_premium');
570
+ });
571
+
572
+ Deno.test('reschedule OUT of a premium window reprices DOWN', async () => {
573
+ // Same rule (Wed 09:00-11:00), new window 12:00-13:00 PT — outside it.
574
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
575
+ const res = await validateAndPriceForRoom(c, room(), {
576
+ start: new Date('2026-08-12T19:00:00.000Z').toISOString(),
577
+ end: new Date('2026-08-12T20:00:00.000Z').toISOString(),
578
+ }, NOW, {
579
+ allowDynamic: true,
580
+ allowFreshDynamic: false,
581
+ });
582
+ if (!res.ok) throw new Error(res.error);
583
+ assertEquals(res.price_cents, 4100);
584
+ assertEquals(res.list_rule_type, null);
585
+ });
586
+
587
+ Deno.test('carryForward is still bounded by the original absolute cents when the list moves UP', async () => {
588
+ // The carry-forward formula is Math.min(P, discount_cents, round(P x d/l)).
589
+ // With P rising from 4,100 to 4,592 the proportional bound rises to 459, so
590
+ // the ABSOLUTE original 410 is what binds — the customer keeps exactly the
591
+ // deal they bought and no more, which is the flash-sale-then-reschedule
592
+ // exploit staying closed.
593
+ const c = stubClient({ promotions: 'true', rules: [premiumRule()] });
594
+ const res = await validateAndPriceForRoom(c, room(), hourlyInput, NOW, {
595
+ allowDynamic: true,
596
+ allowFreshDynamic: false,
597
+ carryForward: { list_cents: 4100, discount_cents: 410, rule_type: 'flash_sale' },
598
+ });
599
+ if (!res.ok) throw new Error(res.error);
600
+ assertEquals(res.price_cents, 4592);
601
+ assertEquals(res.dynamic_discount_cents, 410);
602
+ assertEquals(res.dynamic_discount_rule_type, 'flash_sale');
603
+ });
604
+
605
+ // --- Commons: day-rate-only room with day-of-week discounts ------------------
606
+
607
+ Deno.test('Commons Monday prices at $698.10 and Saturday at the $895 anchor', async () => {
608
+ const commons = (): RoomForPricing => room({
609
+ name: 'The Commons', hourly_cents: 0, day_cents: 89500, half_day_cents: null,
610
+ booking_mode: 'day_block',
611
+ });
612
+ // Commons-specific business hours are 06:00-22:00 every day, so a full day
613
+ // starts at 06:00 and the all-day 00:00-23:59 rule window covers it.
614
+ const commonsHours = { open_time: '06:00:00', close_time: '22:00:00' };
615
+ const mondayRule = rule({
616
+ rule_type: 'time_of_day', pct: 22, room_id: ROOM_ID, day_of_week: [1],
617
+ window_start: '00:00', window_end: '23:59', day_block_only: true,
618
+ });
619
+
620
+ // 2026-08-17 is a Monday.
621
+ const mon = stubClient({ promotions: 'true', rules: [mondayRule], hours: commonsHours });
622
+ const a = await validateAndPriceForRoom(
623
+ mon, commons(), { date: '2026-08-17', day_mode: 'full' }, NOW, { allowDynamic: true },
624
+ );
625
+ if (!a.ok) throw new Error(a.error);
626
+ assertEquals(a.price_cents, 89500);
627
+ assertEquals(a.dynamic_discount_cents, 19690); // -> $698.10 charged
628
+ assertEquals(a.dynamic_discount_rule_type, 'time_of_day');
629
+ assertEquals(a.list_rule_type, null);
630
+
631
+ // 2026-08-15 is a Saturday — no rule, the untouched anchor.
632
+ const sat = stubClient({ promotions: 'true', rules: [mondayRule], hours: commonsHours });
633
+ const b = await validateAndPriceForRoom(
634
+ sat, commons(), { date: '2026-08-15', day_mode: 'full' }, NOW, { allowDynamic: true },
635
+ );
636
+ if (!b.ok) throw new Error(b.error);
637
+ assertEquals(b.price_cents, 89500);
638
+ assertEquals(b.dynamic_discount_cents, 0);
639
+ });
640
+
641
+ Deno.test('Commons rejects a half-day and rejects start/end instead of date/day_mode', async () => {
642
+ const commons = (): RoomForPricing => room({
643
+ name: 'The Commons', hourly_cents: 0, day_cents: 89500, half_day_cents: null,
644
+ booking_mode: 'day_block',
645
+ });
646
+ const c = stubClient({ promotions: 'true', hours: { open_time: '06:00:00', close_time: '22:00:00' } });
647
+
648
+ const half = await validateAndPriceForRoom(
649
+ c, commons(), { date: '2026-08-17', day_mode: 'half_am' }, NOW, { allowDynamic: true },
650
+ );
651
+ assertEquals(half.ok, false);
652
+
653
+ // A day_block room given an hourly-shaped payload must be REJECTED, never
654
+ // silently mispriced off hourly_cents (which is 0 for Commons).
655
+ const hourlyShaped = await validateAndPriceForRoom(
656
+ c, commons(), hourlyInput, NOW, { allowDynamic: true },
657
+ );
658
+ assertEquals(hourlyShaped.ok, false);
659
+ });
660
+