@code-collective/booking-widget 1.0.0

package/src/lib/fake-api.ts

@@ -0,0 +1,282 @@
+import type {
+  CheckoutAddCartItemDto,
+  CheckoutSessionDto,
+  CheckoutProductDto,
+  CheckoutAvailabilityCalendarDto,
+  CheckoutAvailabilityDto,
+  CheckoutCartResult,
+  CheckoutCartDetailDto,
+  CheckoutCartItemDetailDto,
+  CheckoutCartItemAddedDto,
+  CheckoutCartPaymentInitiationDto,
+  CheckoutCartConfirmResultDto,
+  CheckoutCartConfirmItemResultDto,
+  OctoContact,
+} from './client-types';
+import type { BookingApi } from './api';
+import {
+  sampleProductData,
+  generateSampleAvailability,
+  generateSampleTimeSlots,
+} from './mock-data';
+
+function delay<T>(ms: number, fn: () => T): Promise<T> {
+  return new Promise((r) => setTimeout(() => r(fn()), ms));
+}
+
+function uuid(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+interface FakeCartItem {
+  id: string;
+  bookingUuid: string;
+  request: CheckoutAddCartItemDto;
+}
+
+const CART_STORAGE_KEY = 'morii-checkout-cart';
+const ITEMS_STORAGE_KEY = 'morii-checkout-cart-items';
+
+export class FakeApiClient implements BookingApi {
+  sessionToken = '';
+  private cartToken = '';
+  private cartItems: FakeCartItem[] = [];
+
+  constructor() {
+    this.loadCartFromStorage() || this.seedCart();
+  }
+
+  private seedCart(): void {
+    this.cartToken = `fake-cart-seeded`;
+
+    this.cartItems = [
+      {
+        id: '00000000-0000-0000-0000-000000000001',
+        bookingUuid: '00000000-0000-0000-0000-aaaaaaaaaaaa',
+        request: {
+          productId: sampleProductData.id,
+          optionId: 'option_blue_tram',
+          unitItems: [{ unitId: 'unit_adult' }, { unitId: 'unit_adult' }, { unitId: 'unit_child' }],
+          availabilityId: 'avail_seeded',
+          amount: 202500,
+          currencyCode: 'ZAR',
+          currencyPrecision: 2,
+        },
+      },
+    ];
+
+    this.saveCartToStorage();
+  }
+
+  private saveCartToStorage(): void {
+    try {
+      const now = new Date();
+      const absolute = new Date(now.getTime() + 60 * 60_000);
+      localStorage.setItem(CART_STORAGE_KEY, JSON.stringify({
+        cartToken: this.cartToken,
+        absoluteExpiresAt: absolute.toISOString(),
+      }));
+      localStorage.setItem(ITEMS_STORAGE_KEY, JSON.stringify(this.cartItems));
+    } catch {
+      // localStorage unavailable
+    }
+  }
+
+  private loadCartFromStorage(): boolean {
+    try {
+      const cartRaw = localStorage.getItem(CART_STORAGE_KEY);
+      const itemsRaw = localStorage.getItem(ITEMS_STORAGE_KEY);
+      if (!cartRaw || !itemsRaw) return false;
+
+      const cart = JSON.parse(cartRaw);
+      if (new Date(cart.absoluteExpiresAt).getTime() <= Date.now()) return false;
+
+      this.cartToken = cart.cartToken;
+      this.cartItems = JSON.parse(itemsRaw);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // --- Session ---
+
+  async startSession(_checkoutKey: string): Promise<CheckoutSessionDto> {
+    return delay(300, () => {
+      const now = new Date();
+      const expires = new Date(now.getTime() + 30 * 60_000);
+      const refresh = new Date(now.getTime() + 20 * 60_000);
+      this.sessionToken = `fake-session-${uuid().slice(0, 8)}`;
+      const session: CheckoutSessionDto = {
+        sessionToken: this.sessionToken,
+        issuedAt: now.toISOString(),
+        expiresAt: expires.toISOString(),
+        refreshAfter: refresh.toISOString(),
+        octo: {
+          basePath: '/v1/checkout/octo',
+          capabilities: 'pricing,content,pickups',
+        },
+        supplier: {
+          name: 'Franschhoek Wine Tram',
+        },
+      };
+      return session;
+    });
+  }
+
+  async refreshSession(): Promise<CheckoutSessionDto> {
+    return this.startSession('');
+  }
+
+  // --- Catalog ---
+
+  async getProduct(productId: string): Promise<CheckoutProductDto> {
+    return delay(500, () => ({ ...sampleProductData, id: productId }));
+  }
+
+  async getAvailabilityCalendar(
+    _productId: string,
+    _optionId: string,
+  ): Promise<Record<string, CheckoutAvailabilityCalendarDto>> {
+    return delay(600, () => generateSampleAvailability());
+  }
+
+  async getAvailability(
+    _productId: string,
+    _optionId: string,
+    localDate: string,
+  ): Promise<CheckoutAvailabilityDto[]> {
+    return delay(400, () => {
+      const parts = localDate.split('-').map(Number);
+      const date = new Date(parts[0], parts[1] - 1, parts[2]);
+      return generateSampleTimeSlots(date);
+    });
+  }
+
+  // --- Cart ---
+
+  async createCart(): Promise<CheckoutCartResult> {
+    return delay(300, () => {
+      const now = new Date();
+      const idle = new Date(now.getTime() + 15 * 60_000);
+      const absolute = new Date(now.getTime() + 60 * 60_000);
+
+      if (this.cartToken && this.cartItems.length > 0) {
+        return {
+          cartToken: this.cartToken,
+          issuedAt: now.toISOString(),
+          idleExpiresAt: idle.toISOString(),
+          absoluteExpiresAt: absolute.toISOString(),
+        };
+      }
+
+      this.cartToken = `fake-cart-${uuid().slice(0, 8)}`;
+      this.cartItems = [];
+      this.saveCartToStorage();
+      return {
+        cartToken: this.cartToken,
+        issuedAt: now.toISOString(),
+        idleExpiresAt: idle.toISOString(),
+        absoluteExpiresAt: absolute.toISOString(),
+      };
+    });
+  }
+
+  async getCart(): Promise<CheckoutCartDetailDto> {
+    return delay(300, () => {
+      const now = new Date();
+      const idle = new Date(now.getTime() + 15 * 60_000);
+      const absolute = new Date(now.getTime() + 60 * 60_000);
+      const detail: CheckoutCartDetailDto = {
+        cartToken: this.cartToken,
+        issuedAt: now.toISOString(),
+        idleExpiresAt: idle.toISOString(),
+        absoluteExpiresAt: absolute.toISOString(),
+        items: this.cartItems.map((item): CheckoutCartItemDetailDto => ({
+          id: item.id,
+          bookingUuid: item.bookingUuid,
+          productId: item.request.productId,
+          optionId: item.request.optionId,
+          unitItems: item.request.unitItems,
+          availabilityId: item.request.availabilityId,
+          localDate: item.request.localDate,
+          pickupPointId: item.request.pickupPointId,
+          amount: item.request.amount,
+          currencyCode: item.request.currencyCode,
+          currencyPrecision: item.request.currencyPrecision,
+        })),
+      };
+      return detail;
+    });
+  }
+
+  async addCartItem(request: CheckoutAddCartItemDto): Promise<CheckoutCartItemAddedDto> {
+    return delay(400, () => {
+      const item: FakeCartItem = {
+        id: uuid(),
+        bookingUuid: uuid(),
+        request,
+      };
+      this.cartItems.push(item);
+      this.saveCartToStorage();
+      return { id: item.id, bookingUuid: item.bookingUuid };
+    });
+  }
+
+  async updateCartItem(itemId: string, request: CheckoutAddCartItemDto): Promise<CheckoutCartItemAddedDto> {
+    return delay(400, () => {
+      const existing = this.cartItems.find((i) => i.id === itemId);
+      if (existing) {
+        existing.request = request;
+        this.saveCartToStorage();
+        return { id: existing.id, bookingUuid: existing.bookingUuid };
+      }
+      const item: FakeCartItem = { id: itemId, bookingUuid: uuid(), request };
+      this.cartItems.push(item);
+      this.saveCartToStorage();
+      return { id: item.id, bookingUuid: item.bookingUuid };
+    });
+  }
+
+  async removeCartItem(itemId: string): Promise<void> {
+    return delay(200, () => {
+      this.cartItems = this.cartItems.filter((i) => i.id !== itemId);
+      this.saveCartToStorage();
+    });
+  }
+
+  async payCart(_contact: OctoContact): Promise<CheckoutCartPaymentInitiationDto> {
+    return delay(800, () => ({
+      checkoutId: `fake-checkout-${uuid().slice(0, 8)}`,
+      redirectUrl: '',
+    }));
+  }
+
+  async confirmCart(): Promise<CheckoutCartConfirmResultDto> {
+    return delay(700, () => {
+      const result: CheckoutCartConfirmResultDto = {
+        items: this.cartItems.map((item): CheckoutCartConfirmItemResultDto => ({
+          bookingUuid: item.bookingUuid,
+          statusCode: 200,
+          body: JSON.stringify({
+            id: `booking-${item.bookingUuid.slice(0, 8)}`,
+            uuid: item.bookingUuid,
+            status: 'CONFIRMED',
+            productId: item.request.productId,
+            optionId: item.request.optionId,
+            unitItems: (item.request.unitItems ?? []).map((u) => ({
+              uuid: uuid(),
+              unitId: u.unitId,
+              status: 'CONFIRMED',
+            })),
+          }),
+        })),
+      };
+      return result;
+    });
+  }
+}