order3000 0.16.0 → 0.17.0

package/dist/client.cjs

@@ -34,6 +34,24 @@ class TokenManager {
     }
     return this.defaultVenueId;
   }
+  /**
+   * Async counterpart to {@link getVenueId}. Fetches the token if it
+   * hasn't been loaded yet (which is what populates `defaultVenueId` via
+   * `setDefaultVenueId`), then returns the venue id.
+   *
+   * Prefer this over `getVenueId()` from request paths — a cold SDK
+   * instance will otherwise synchronously throw "No venue ID available"
+   * before the token has had a chance to load.
+   */
+  async getVenueIdAsync() {
+    if (this.userVenueId) {
+      return this.userVenueId;
+    }
+    if (!this.defaultVenueId) {
+      await this.getToken();
+    }
+    return this.getVenueId();
+  }
   async refreshToken() {
     if (this.refreshPromise) return this.refreshPromise;
     this.refreshPromise = fetch(this.tokenEndpoint, {
@@ -96,15 +114,71 @@ class BaseResource {
         "Content-Type": "application/json"
       },
       body: data ? JSON.stringify(data) : void 0,
+      cache: "no-store",
       signal: AbortSignal.timeout(36e4)
     });
     if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      let body = "";
+      try {
+        body = await response.text();
+      } catch {
+      }
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText}${body ? ` \u2014 ${body}` : ""}`
+      );
     }
     return response.json();
   }
 }
 
+class AreasResource extends BaseResource {
+  constructor(tokenManager, baseUrl) {
+    super(tokenManager, baseUrl, "/areas");
+  }
+  /**
+   * List bookable + public areas for the venue.
+   */
+  async list(options) {
+    const queryString = this.buildExpandQuery(options?.expand);
+    return this.request("GET", queryString);
+  }
+  /**
+   * Fetch a single area by id or accessor.
+   */
+  async getByAccessor(accessor, options) {
+    const queryString = this.buildExpandQuery(options?.expand);
+    return this.request("GET", `/${accessor}${queryString}`);
+  }
+  /**
+   * List occupied date/time windows for an area between `from` and `to`.
+   */
+  async getAvailability(accessor, options) {
+    const params = new URLSearchParams();
+    if (options?.from) params.set("from", options.from);
+    if (options?.to) params.set("to", options.to);
+    const qs = params.toString();
+    const query = qs ? `?${qs}` : "";
+    return this.request(
+      "GET",
+      `/${accessor}/availability${query}`
+    );
+  }
+  /**
+   * Submit a public booking request for an area.
+   */
+  async submitBookingRequest(accessor, payload) {
+    return this.request(
+      "POST",
+      `/${accessor}/booking-requests`,
+      payload
+    );
+  }
+  buildExpandQuery(expand) {
+    if (!expand?.length) return "";
+    return `?expand=${expand.join(",")}`;
+  }
+}
+
 class BasketsResource extends BaseResource {
   constructor(tokenManager, baseUrl) {
     super(tokenManager, baseUrl, "/baskets");
@@ -146,6 +220,51 @@ class BasketsResource extends BaseResource {
       `/items/${basketItemId}?${params.toString()}`
     );
   }
+  /**
+   * Canonical totals for a basket. Clients read every displayed monetary
+   * figure (effective total, deposit credit, cash refund) from this
+   * endpoint — they never multiply deposit counts by amounts locally.
+   *
+   * Pass `declaredReturns` as references to depositware templates plus a
+   * count. order3000 refuses deposit money amounts on input.
+   */
+  async getTotals(basketId, body = {}) {
+    return this.request(
+      "POST",
+      `/${basketId}/totals`,
+      { declaredReturns: body.declaredReturns ?? [] }
+    );
+  }
+  /**
+   * Mark every active basket for the session as `abandoned`.
+   *
+   * Used by thamarai's "Neu starten" flow: after a non-team order
+   * has been placed (its basket converted), the user might want to
+   * start a fresh order. A subsequent `add()` call would otherwise
+   * reuse any leftover active basket on the same session — which
+   * can happen if a prior compose flow left an active row behind.
+   * Calling `abandon()` first guarantees the next `add()` inserts a
+   * brand-new active basket with exactly one item.
+   */
+  async abandon(sessionId) {
+    return this.request("POST", "/abandon", {
+      sessionId
+    });
+  }
+  /**
+   * Persist per-template declared-return counts onto the basket.
+   *
+   * Used by team-order participants so the Lead's breakdown popover
+   * sees every member's intent in real time (the standard
+   * `useTeamOrderRealtime` postgres-changes subscription on
+   * `baskets` then propagates the change to the team).
+   *
+   * Server validates `sessionId === basket.session_id` — only the
+   * basket's owner can write to its declared returns.
+   */
+  async setDeclaredReturns(basketId, body) {
+    return this.request("POST", `/${basketId}/declared-returns`, body);
+  }
 }
 
 class EventsResource extends BaseResource {
@@ -266,6 +385,18 @@ class OrdersResource extends BaseResource {
   constructor(tokenManager, baseUrl) {
     super(tokenManager, baseUrl, "/orders");
   }
+  /**
+   * Most recent non-team order for the guest session, with captured
+   * basket items + totals + declared returns inlined. `null` when the
+   * session has no qualifying order yet (fresh session, or only team
+   * orders which go through `teamOrders` instead).
+   */
+  async getLatest(sessionId) {
+    return this.request(
+      "GET",
+      `/latest?sessionId=${encodeURIComponent(sessionId)}`
+    );
+  }
   /**
    * Place a new order.
    *
@@ -290,6 +421,14 @@ class OrdersResource extends BaseResource {
   async confirm(orderId, request) {
     return this.request("POST", `/${orderId}/confirm`, request);
   }
+  /**
+   * Record an additional cash handover amount for a team-order participant
+   * who has added items after their initial cash payment. No Stripe
+   * interaction — this updates the handover total the Lead will collect.
+   */
+  async addCashDelta(request) {
+    return this.request("POST", "/cash-delta", request);
+  }
 }
 
 class PaymentIntentsResource extends BaseResource {
@@ -305,6 +444,24 @@ class PaymentIntentsResource extends BaseResource {
   async create(request) {
     return this.request("POST", "", request);
   }
+  /**
+   * Create a delta PaymentIntent for a team-order participant who added
+   * items after paying. Reuses the saved card from the initial auth so the
+   * client only needs one tap (unless Stripe triggers 3DS).
+   */
+  async createDelta(request) {
+    return this.request("POST", "/delta", request);
+  }
+  /**
+   * Release part of a team-order participant's existing Stripe authorisation
+   * when they remove items from their basket. Walks payments newest-first,
+   * cancelling fully-consumed PIs and `update({ amount })`-ing the last
+   * partially-trimmed one. No client-side confirmation — lowering a
+   * `requires_capture` PI's amount is a single server round-trip.
+   */
+  async reduceDelta(request) {
+    return this.request("POST", "/delta-reduce", request);
+  }
 }
 
 class ReservationsResource extends BaseResource {
@@ -393,6 +550,205 @@ class SubscriptionsResource extends BaseResource {
   }
 }
 
+const paymentMethodEnum = {
+  enumValues: ["card", "cash", "voucher"]
+};
+const fulfillmentTypeEnum = {
+  enumValues: ["pickup", "delivery"]
+};
+const teamOrderStatusEnum = {
+  enumValues: [
+    "draft",
+    "collecting",
+    "locked",
+    "placed",
+    "ready",
+    "completed",
+    "cancelled"
+  ]
+};
+const participantStatusEnum = {
+  enumValues: [
+    "browsing",
+    "authorized",
+    "cash_pending",
+    "placed",
+    "completed",
+    "cancelled"
+  ]
+};
+class TeamOrdersResource {
+  constructor(tokenManager, baseUrl) {
+    this.tokenManager = tokenManager;
+    this.baseUrl = baseUrl;
+  }
+  async request(method, url, data) {
+    const token = await this.tokenManager.getToken();
+    const response = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: data ? JSON.stringify(data) : void 0,
+      // Bypass Next.js fetch cache — these are live reads/writes, never
+      // safe to memoise at the SDK layer.
+      cache: "no-store",
+      signal: AbortSignal.timeout(36e4)
+    });
+    if (!response.ok) {
+      let body = "";
+      try {
+        body = await response.text();
+      } catch {
+      }
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText}${body ? ` \u2014 ${body}` : ""}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Lead creates a team order from their active basket.
+   * Returns the unguessable `publicId` the lead shares with coworkers.
+   */
+  async create(request) {
+    const venueId = await this.tokenManager.getVenueIdAsync();
+    return this.request(
+      "POST",
+      `${this.baseUrl}/venues/${venueId}/team-orders`,
+      request
+    );
+  }
+  /**
+   * Public read by publicId. Pass the caller's sessionId so the response
+   * can set `isLead` correctly for UI gating.
+   */
+  async get(publicId, sessionId) {
+    const query = sessionId ? `?sessionId=${encodeURIComponent(sessionId)}` : "";
+    return this.request(
+      "GET",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}${query}`
+    );
+  }
+  /**
+   * Participant joins a team order. Idempotent: safe to call on every page
+   * mount of the shared URL.
+   */
+  async join(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/join`,
+      request
+    );
+  }
+  /**
+   * Lead submits the team order. Drops basket-only participants, captures
+   * every authorised Stripe PaymentIntent atomically, flips child orders to
+   * `pending`. The "Submit anyways" UX is a client-side confirmation dialog
+   * that calls the same endpoint — no server variant exists.
+   */
+  async submit(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/submit`,
+      request
+    );
+  }
+  /**
+   * Lead cancels pre-placement. Voids every authorised Stripe
+   * PaymentIntent (no refunds needed — nothing was captured).
+   */
+  async cancel(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/cancel`,
+      request
+    );
+  }
+  /**
+   * Lead pushes the deadline. A `locked` team flips back to `collecting`
+   * when the new deadline is in the future.
+   */
+  async extendDeadline(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/extend-deadline`,
+      request
+    );
+  }
+  /**
+   * Lead commits (or changes) the shared pickup/delivery time. Required
+   * before `submit` — which backfills each child order's `fulfillmentAt`
+   * from this value at capture time.
+   */
+  async setFulfillmentAt(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/set-fulfillment-at`,
+      request
+    );
+  }
+  /**
+   * Lead sets the free-form "where we'll eat" text on the team order.
+   * Broadcast to participants via the standard realtime refetch path.
+   */
+  async setDiningLocation(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/set-dining-location`,
+      request
+    );
+  }
+  /**
+   * Lead sets when the team will start eating. Client sends HH:MM; server
+   * computes the delta against `fulfillmentAt` and stores it as
+   * `dining_offset_minutes` so the intent survives any later pickup change.
+   */
+  async setDiningTime(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/set-dining-time`,
+      request
+    );
+  }
+  /**
+   * Any participant proposes an auto-extend when their local clock sees
+   * that `fulfillmentAt` has passed while the team order is still
+   * collecting. Idempotent on the server side: concurrent callers race
+   * but only one write lands.
+   */
+  async autoExtendFulfillmentIfExpired(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/auto-extend-fulfillment-if-expired`,
+      request
+    );
+  }
+  /**
+   * Lead flips pickup ↔ delivery. Pass `deliveryAddress` when switching
+   * TO delivery if no address is already set on the team order.
+   */
+  async switchFulfillment(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/switch-fulfillment`,
+      request
+    );
+  }
+  /**
+   * Lead replaces the delivery address (inserts a new row in the shared
+   * addresses table with type='PHYSICAL' and links it to the team order).
+   */
+  async updateDeliveryAddress(publicId, request) {
+    return this.request(
+      "POST",
+      `${this.baseUrl}/team-orders/${encodeURIComponent(publicId)}/update-delivery-address`,
+      request
+    );
+  }
+}
+
 var __defProp$2 = Object.defineProperty;
 var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -717,6 +1073,7 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 class Order3000Client {
   constructor(config) {
+    __publicField(this, "areas");
     __publicField(this, "baskets");
     __publicField(this, "events");
     __publicField(this, "menus");
@@ -724,6 +1081,7 @@ class Order3000Client {
     __publicField(this, "paymentIntents");
     __publicField(this, "reservations");
     __publicField(this, "subscriptions");
+    __publicField(this, "teamOrders");
     __publicField(this, "realtime");
     __publicField(this, "baseUrl");
     __publicField(this, "tokenManager");
@@ -735,6 +1093,7 @@ class Order3000Client {
       tokenUrl,
       config.venueId
     );
+    this.areas = new AreasResource(this.tokenManager, this.baseUrl);
     this.baskets = new BasketsResource(this.tokenManager, this.baseUrl);
     this.events = new EventsResource(this.tokenManager, this.baseUrl);
     this.menus = new MenusResource(this.tokenManager, this.baseUrl);
@@ -751,9 +1110,14 @@ class Order3000Client {
       this.tokenManager,
       this.baseUrl
     );
+    this.teamOrders = new TeamOrdersResource(this.tokenManager, this.baseUrl);
     this.realtime = new RealtimeManager(this.tokenManager, this.baseUrl);
   }
 }
 
 exports.Order3000Client = Order3000Client;
+exports.fulfillmentTypeEnum = fulfillmentTypeEnum;
 exports.getScheduleInfo = getScheduleInfo;
+exports.participantStatusEnum = participantStatusEnum;
+exports.paymentMethodEnum = paymentMethodEnum;
+exports.teamOrderStatusEnum = teamOrderStatusEnum;