@peektravel/app-utilities 0.7.4 → 0.8.1

package/dist/index.cjs

@@ -1061,6 +1061,107 @@ function toBookingAddon(item) {
   return { addonId, addonName, total: item.total, addonOptions };
 }
 
+// src/internal/peek/bookings/custom-question-answer.ts
+var QUESTION_TYPE_CHECK_BOX = "CHECK_BOX";
+var QUESTION_TYPE_TEXT = "TEXT";
+var QUESTION_TYPE_SELECT_ONE = "SELECT_ONE";
+var QUESTION_TYPE_LOCATION = "LOCATION";
+var QUESTION_ID_REGEX = /^cq_[a-z0-9]+$/;
+var OPTION_ID_REGEX = /^cqao_[a-z0-9]+$/;
+var CHECKBOX_TRUE = /* @__PURE__ */ new Set(["yes", "true"]);
+var CHECKBOX_VALID = /* @__PURE__ */ new Set(["yes", "no", "true", "false"]);
+var CHECKBOX_TEXT_TRUE = "Yes";
+var CHECKBOX_TEXT_FALSE = "No";
+var errUnknownQuestionId = (v) => `No custom question matches id "${v}" for this activity`;
+var errNoTextMatch = (v) => `No custom question matches text "${v}" for this activity`;
+var errAmbiguousText = (v) => `Custom question text "${v}" matches more than one question`;
+var errPerGuestUnsupported = (id) => `Per-guest custom question "${id}" is not yet supported`;
+var errUnsupportedType = (type, id) => `Custom question "${id}" has unsupported type "${type}"`;
+var errInvalidCheckbox = (v, id) => `Checkbox answer for question "${id}" must be yes/no/true/false, got "${v}"`;
+var errUnknownOptionId = (v, id) => `No option matches id "${v}" for question "${id}"`;
+var errNoOptionMatch = (v, id) => `No option matches "${v}" for question "${id}"`;
+var errAmbiguousOption = (v, id) => `Option "${v}" matches more than one option for question "${id}"`;
+var errMissingRequired = (text, id) => `Custom question "${text}" (${id}) is required but was not answered`;
+function normalize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function resolveQuestion(idOrText, questions) {
+  if (QUESTION_ID_REGEX.test(idOrText)) {
+    const byId = questions.find((question) => question.id === idOrText);
+    if (!byId) throw new Error(errUnknownQuestionId(idOrText));
+    return byId;
+  }
+  const target = normalize(idOrText);
+  const matches = questions.filter(
+    (question) => normalize(question.questionText) === target
+  );
+  if (matches.length === 0) throw new Error(errNoTextMatch(idOrText));
+  if (matches.length > 1) throw new Error(errAmbiguousText(idOrText));
+  return matches[0];
+}
+function resolveOption(value, question) {
+  if (OPTION_ID_REGEX.test(value)) {
+    const byId = question.options.find((option) => option.id === value);
+    if (!byId) throw new Error(errUnknownOptionId(value, question.id));
+    return byId;
+  }
+  const target = normalize(value);
+  const matches = question.options.filter(
+    (option) => normalize(option.value) === target
+  );
+  if (matches.length === 0) throw new Error(errNoOptionMatch(value, question.id));
+  if (matches.length > 1) throw new Error(errAmbiguousOption(value, question.id));
+  return matches[0];
+}
+function resolveOne(answer, questions) {
+  const question = resolveQuestion(answer.questionIdOrText, questions);
+  if (question.perGuest) {
+    throw new Error(errPerGuestUnsupported(question.id));
+  }
+  switch (question.questionType) {
+    case QUESTION_TYPE_CHECK_BOX: {
+      const normalized = answer.value.trim().toLowerCase();
+      if (!CHECKBOX_VALID.has(normalized)) {
+        throw new Error(errInvalidCheckbox(answer.value, question.id));
+      }
+      const isChecked = CHECKBOX_TRUE.has(normalized);
+      return {
+        questionId: question.id,
+        isChecked,
+        questionAnswerText: isChecked ? CHECKBOX_TEXT_TRUE : CHECKBOX_TEXT_FALSE
+      };
+    }
+    case QUESTION_TYPE_TEXT:
+      return { questionId: question.id, questionAnswerText: answer.value };
+    case QUESTION_TYPE_SELECT_ONE:
+    case QUESTION_TYPE_LOCATION: {
+      const option = resolveOption(answer.value, question);
+      return {
+        questionId: question.id,
+        questionAnswerOptionId: option.id,
+        questionAnswerText: option.value
+      };
+    }
+    default:
+      throw new Error(errUnsupportedType(question.questionType, question.id));
+  }
+}
+function resolveCustomQuestionAnswers(answers, questions, options) {
+  const resolved = answers.map((answer) => resolveOne(answer, questions));
+  if (options?.requireRequired) {
+    assertRequiredAnswered(resolved, questions);
+  }
+  return resolved;
+}
+function assertRequiredAnswered(resolved, questions) {
+  const answered = new Set(resolved.map((answer) => answer.questionId));
+  for (const question of questions) {
+    if (question.isRequired && !question.perGuest && !answered.has(question.id)) {
+      throw new Error(errMissingRequired(question.questionText, question.id));
+    }
+  }
+}
+
 // src/internal/peek/bookings/booking-service.ts
 var DEFAULT_PAGE_SIZE2 = 50;
 var DEFAULT_CANCEL_NOTE = "Canceled";
@@ -1575,11 +1676,13 @@ ${note}`;
    *
    * @throws {Error} when `activityId`, `availabilityTimeId`, a ticket
    * `resourceOptionId`/positive `quantity`, or the guest `name` is missing; when
-   * `markAsPaid` is set without an `idempotencyKey`; or when the quote/order
-   * mutations fail.
+   * `markAsPaid` is set without an `idempotencyKey`; when
+   * `requireRequiredQuestions` is set and a required custom question is left
+   * unanswered; or when the quote/order mutations fail.
    */
   async create(input) {
     validateCreateInput(input);
+    const questionAnswers = await this.buildQuestionAnswers(input);
     const tickets = input.tickets.flatMap(
       (ticket) => Array.from({ length: ticket.quantity }, () => ({
         resourceOptionId: ticket.resourceOptionId,
@@ -1606,6 +1709,9 @@ ${note}`;
     if (input.operatorNotes) {
       bookingQuote.operatorNotes = input.operatorNotes;
     }
+    if (questionAnswers) {
+      bookingQuote.questionAnswers = questionAnswers;
+    }
     const quoteInput = { bookingQuotes: [bookingQuote] };
     if (input.parentOrderId) {
       quoteInput.source = { clonedFromId: input.parentOrderId };
@@ -1645,6 +1751,32 @@ ${note}`;
     }
     return created;
   }
+  /**
+   * Resolves the input's custom-question answers into the quote's
+   * `questionAnswers` payload (each tagged with a fresh `refid`), or `null` when
+   * none were supplied. Fetches the activity's custom questions to validate
+   * against; throws on the first unmatched/ambiguous/invalid answer.
+   */
+  async buildQuestionAnswers(input) {
+    const answers = input.customQuestionAnswers ?? [];
+    const requireRequired = input.requireRequiredQuestions ?? false;
+    if (answers.length === 0 && !requireRequired) {
+      return null;
+    }
+    const questions = await this.deps.productService.getCustomQuestions(
+      input.activityId
+    );
+    const resolved = resolveCustomQuestionAnswers(answers, questions, {
+      requireRequired
+    });
+    if (resolved.length === 0) {
+      return null;
+    }
+    return resolved.map((answer) => ({
+      ...answer,
+      refid: crypto.randomUUID()
+    }));
+  }
   async markCreatedBookingPaid(booking, input) {
     const parsedPartial = input.markAsPaidAmount ? parseFloat(input.markAsPaidAmount) : NaN;
     const amount = !Number.isNaN(parsedPartial) && parsedPartial > 0 ? parsedPartial.toFixed(2) : booking.balanceAmount;
@@ -2957,6 +3089,33 @@ function fromItemOptionNodes(nodes) {
   return Array.from(grouped.values());
 }
 
+// src/internal/peek/products/custom-question-converter.ts
+function fromQuestionConfigurations(configs) {
+  return configs.map(fromQuestionConfiguration);
+}
+function fromQuestionConfiguration(config) {
+  const question = config.question;
+  return {
+    id: question.id,
+    order: config.order ?? 0,
+    isRequired: config.isRequired ?? false,
+    questionText: question.text,
+    hintText: question.hint ?? null,
+    questionType: question.questionType,
+    internalLabel: question.internalLabel ?? null,
+    perGuest: question.perGuest ?? false,
+    defaultValue: question.answerDefaultValue ?? null,
+    options: (question.options ?? []).map(fromQuestionOption)
+  };
+}
+function fromQuestionOption(option) {
+  return {
+    id: option.id,
+    order: option.order,
+    value: option.text
+  };
+}
+
 // src/internal/peek/products/product-queries.ts
 var PRODUCTS_QUERY = `
   query Sales {
@@ -3015,7 +3174,38 @@ var ITEM_OPTIONS_QUERY = `
   }
 `;
 
+// src/internal/peek/products/custom-question-queries.ts
+var CUSTOM_QUESTIONS_QUERY = `
+  query Sales($id: ID!) {
+    activity(id: $id) {
+      id
+      name
+      questionActivityConfigurations {
+        isRequired
+        order
+        question {
+          id
+          questionType
+          text
+          answerDefaultValue
+          hint
+          internalLabel
+          perGuest
+          ... on ChoiceQuestion {
+            options {
+              id
+              text
+              order
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
 // src/internal/peek/products/product-service.ts
+var ERROR_PRODUCT_ID_REQUIRED2 = "A non-empty product id is required.";
 var DEFAULT_ITEM_OPTIONS_PAGE_SIZE = 50;
 var ProductService = class {
   constructor(client, options = {}) {
@@ -3060,6 +3250,32 @@ var ProductService = class {
     const nodes = await this.fetchAllItemOptionNodes();
     return fromItemOptionNodes(nodes);
   }
+  /**
+   * Returns every custom question configured on a single activity, in the order
+   * Peek reports them. Choice-style questions (`SELECT_ONE`, `LOCATION`, …)
+   * carry their selectable {@link CustomQuestion.options}; free-text/checkbox
+   * questions return an empty option list.
+   *
+   * These are question **definitions**, not customer answers — no PII is
+   * involved, so the result is unaffected by `fullCustomerAccess`.
+   *
+   * @param productId The activity's id.
+   * @returns The activity's custom questions, or an empty list when the activity
+   *   has none or is not found.
+   * @throws Error when `productId` is missing or blank.
+   */
+  async getCustomQuestions(productId) {
+    if (!productId?.trim()) {
+      throw new Error(ERROR_PRODUCT_ID_REQUIRED2);
+    }
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      CUSTOM_QUESTIONS_QUERY,
+      { id: productId }
+    );
+    const configs = body.data?.activity?.questionActivityConfigurations ?? [];
+    return fromQuestionConfigurations(configs);
+  }
   async fetchActivities() {
     const body = await this.client.request(
       SALES_ENDPOINT,
@@ -3773,6 +3989,10 @@ var PeekAccessService = class {
   getAllAddons() {
     return this.getProductService().getAllAddons();
   }
+  /** An activity's custom questions. Delegates to {@link ProductService.getCustomQuestions}. */
+  getCustomQuestions(productId) {
+    return this.getProductService().getCustomQuestions(productId);
+  }
   // ─── Account-user short-forms ─────────────────────────────────────────────
   /** All active account users. Delegates to {@link AccountUserService.getAll}. */
   getAllAccountUsers() {