@jphil/bookwhen-client 0.4.2 → 0.6.0

package/dist/index.js

@@ -6481,7 +6481,8 @@ class EventService {
     }
   }
   /**
-   * Retrieves multiple events based on filtering and pagination parameters.
+   * Retrieves a single page of events based on filtering and pagination parameters.
+   * The Bookwhen API returns up to 20 events per page by default.
    *
    * @param {GetMultipleEventsParams} params - Optional parameters for filtering and pagination.
    * @return {Promise<EventsResponse>} A Promise that resolves to the full JSON:API response object.
@@ -6497,6 +6498,258 @@ class EventService {
       handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
     }
   }
+  /**
+   * Retrieves all events matching the given filters, automatically following
+   * pagination links to fetch every page of results.
+   *
+   * The returned response contains the combined `data` and deduplicated
+   * `included` arrays from all pages.
+   *
+   * @param {GetMultipleEventsParams} params - Optional parameters for filtering.
+   * @return {Promise<EventsResponse>} A Promise that resolves to the combined JSON:API response.
+   */
+  async getAll(params = {}) {
+    const firstPage = await this.getMultiple(params);
+    if (!firstPage?.data || !firstPage.links?.next) {
+      return firstPage;
+    }
+    const allData = [...firstPage.data];
+    const includedById = /* @__PURE__ */ new Map();
+    if (firstPage.included) {
+      for (const item of firstPage.included) {
+        includedById.set(`${item.type}:${item.id}`, item);
+      }
+    }
+    let nextUrl = firstPage.links.next;
+    while (nextUrl) {
+      try {
+        const page = (await this.axiosInstance.get(nextUrl)).data;
+        if (page.data) {
+          allData.push(...page.data);
+        }
+        if (page.included) {
+          for (const item of page.included) {
+            includedById.set(`${item.type}:${item.id}`, item);
+          }
+        }
+        nextUrl = page.links?.next;
+      } catch (error) {
+        handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+      }
+    }
+    return {
+      data: allData,
+      included: includedById.size > 0 ? Array.from(includedById.values()) : void 0
+    };
+  }
+}
+const TicketResourceSchema = z.enum([
+  "class_passes",
+  "events",
+  "events.location",
+  "events.tickets",
+  "events.attachments"
+]);
+const GetTicketByIdParamsSchema = z.object({
+  ticketId: z.string().min(1, "Invalid ticket ID"),
+  includes: TicketResourceSchema.array().optional()
+});
+const GetMultipleTicketsParamsSchema = z.object({
+  eventId: z.string().min(1, "Invalid event ID"),
+  includes: TicketResourceSchema.array().optional()
+});
+class TicketService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetTicketByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(`/tickets/${validParams.ticketId}`);
+      if (validParams.includes) {
+        query.addIncludes(validParams.includes);
+      }
+      const response = await this.axiosInstance.get(`${query}`);
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `tickets.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Ticket not found. Please check the ticket ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params) {
+    try {
+      const validParams = GetMultipleTicketsParamsSchema.parse(params);
+      const queryParts = [`event=${encodeURIComponent(validParams.eventId)}`];
+      if (validParams.includes?.length) {
+        queryParts.push(`include=${validParams.includes.join(",")}`);
+      }
+      const response = await this.axiosInstance.get(
+        `/tickets?${queryParts.join("&")}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `tickets.getMultiple: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetLocationByIdParamsSchema = z.object({
+  locationId: z.string().min(1, "Invalid location ID")
+});
+class LocationService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetLocationByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(`/locations/${validParams.locationId}`);
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `locations.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Location not found. Please check the location ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/locations");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetAttachmentByIdParamsSchema = z.object({
+  attachmentId: z.string().min(1, "Invalid attachment ID")
+});
+class AttachmentService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetAttachmentByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(
+        `/attachments/${validParams.attachmentId}`
+      );
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `attachments.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Attachment not found. Please check the attachment ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/attachments");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetClassPassByIdParamsSchema = z.object({
+  classPassId: z.string().min(1, "Invalid class pass ID")
+});
+class ClassPassService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetClassPassByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(
+        `/class_passes/${validParams.classPassId}`
+      );
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `classPasses.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Class pass not found. Please check the class pass ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/class_passes");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
 }
 class BookwhenClient {
   /**
@@ -6506,6 +6759,10 @@ class BookwhenClient {
    */
   constructor(axiosInstance) {
     __publicField(this, "eventService");
+    __publicField(this, "ticketService");
+    __publicField(this, "locationService");
+    __publicField(this, "attachmentService");
+    __publicField(this, "classPassService");
     __publicField(this, "isBrowser");
     this.axiosInstance = axiosInstance;
     this.isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -6528,6 +6785,30 @@ class BookwhenClient {
     }
     return this.eventService;
   }
+  get tickets() {
+    if (!this.ticketService) {
+      this.ticketService = new TicketService(this.axiosInstance);
+    }
+    return this.ticketService;
+  }
+  get locations() {
+    if (!this.locationService) {
+      this.locationService = new LocationService(this.axiosInstance);
+    }
+    return this.locationService;
+  }
+  get attachments() {
+    if (!this.attachmentService) {
+      this.attachmentService = new AttachmentService(this.axiosInstance);
+    }
+    return this.attachmentService;
+  }
+  get classPasses() {
+    if (!this.classPassService) {
+      this.classPassService = new ClassPassService(this.axiosInstance);
+    }
+    return this.classPassService;
+  }
 }
 function createBookwhenClient(options) {
   const {