ti2-bokun 1.0.6 → 1.0.13

package/utils/customFields.js

@@ -0,0 +1,249 @@
+const { DEFAULT_EXCLUDED_CUSTOMER_QUESTION_IDS } = require('./customerFieldConstants');
+
+const extractQuestionSpecs = root => {
+  const out = [];
+  const seen = new Set();
+  const stack = [root];
+
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) {
+      // no-op
+    } else if (Array.isArray(node)) {
+      node.forEach(item => stack.push(item));
+    } else if (typeof node === 'object') {
+      if (typeof node.questionId === 'string' && node.questionId.trim() !== '') {
+        const key = node.questionId.trim();
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push(node);
+        }
+      }
+
+      Object.values(node).forEach(value => {
+        if (value && (Array.isArray(value) || typeof value === 'object')) stack.push(value);
+      });
+    }
+  }
+
+  return out;
+};
+
+const toAnswerValues = answer => {
+  if (Array.isArray(answer.values)) return answer.values;
+  if (answer.values !== undefined && answer.values !== null) return [answer.values];
+  if (answer.value === undefined || answer.value === null) return [];
+  return [answer.value];
+};
+
+const toQuestionAnswer = ({ questionId, rawValue }) => {
+  if (!questionId) return null;
+  const rawValues = Array.isArray(rawValue) ? rawValue : [rawValue];
+  const values = rawValues
+    .map(value => {
+      if (value == null) return null;
+      if (typeof value === 'object') {
+        if (value.value != null) return value.value;
+        if (value.id != null) return value.id;
+      }
+      return value;
+    })
+    .filter(value => value !== null && value !== '');
+
+  if (values.length === 0) return null;
+  return { questionId: String(questionId), values };
+};
+
+const normalizeQuestionAnswerList = answers => (
+  (Array.isArray(answers) ? answers : [])
+    .map(answer => toQuestionAnswer({
+      questionId: answer?.questionId || answer?.id,
+      rawValue: toAnswerValues(answer),
+    }))
+    .filter(Boolean)
+);
+
+const mapCustomFieldValuesToAnswers = (customFieldValues, options = {}) => {
+  const normalizeFieldValue = options?.normalizeFieldValue;
+  const bookingAnswers = [];
+  const passengerAnswersByIndex = {};
+  const customerAnswers = [];
+
+  (Array.isArray(customFieldValues) ? customFieldValues : []).forEach(entry => {
+    if (!entry || typeof entry !== 'object') return;
+    const field = entry.field || {};
+    const rawId = field.questionId || field.id || field.fieldId || field.code || field.key;
+    if (!rawId) return;
+
+    const [baseQuestionId, maybeIndex] = String(rawId).split('|');
+    const rawValue = typeof normalizeFieldValue === 'function'
+      ? normalizeFieldValue({ field, value: entry.value })
+      : entry.value;
+    const answer = toQuestionAnswer({ questionId: baseQuestionId, rawValue });
+    if (!answer) return;
+
+    const passengerIndex = Number(maybeIndex);
+    const isPerPassenger = field.isPerUnitItem || Number.isInteger(passengerIndex);
+    if (isPerPassenger && Number.isInteger(passengerIndex) && passengerIndex >= 0) {
+      passengerAnswersByIndex[passengerIndex] = passengerAnswersByIndex[passengerIndex] || [];
+      passengerAnswersByIndex[passengerIndex].push(answer);
+      return;
+    }
+
+    if (field.isCustomerField) {
+      customerAnswers.push(answer);
+      return;
+    }
+
+    bookingAnswers.push(answer);
+  });
+
+  return { bookingAnswers, passengerAnswersByIndex, customerAnswers };
+};
+
+const normalizeQuestionOptions = question => {
+  const rawOptions = question?.options
+    || question?.choices
+    || question?.values
+    || question?.allowedValues
+    || [];
+
+  if (!Array.isArray(rawOptions)) return [];
+
+  return rawOptions
+    .map(option => {
+      if (typeof option === 'string') {
+        return {
+          label: option,
+          value: option,
+        };
+      }
+
+      if (option && typeof option === 'object') {
+        const value = option.value || option.id || option.code || option.key || option.label || option.title;
+        const label = option.label || option.title || option.name || option.value || option.id;
+        if (value == null || label == null) return null;
+        return {
+          label: String(label),
+          value: String(value),
+        };
+      }
+
+      return null;
+    })
+    .filter(Boolean);
+};
+
+/**
+ * Derive per-booking / per-participant visibility & requirement flags from
+ * a Bokun question/custom-field source.
+ *
+ * Bokun signals per-passenger questions via `context: 'PASSENGER'` (vs
+ * `'BOOKING'` for booking-level / lead-only). When the source object does
+ * not carry a `context`, treat it as booking-level (the safer default for
+ * legacy product-level customFields that historically appeared once per
+ * booking).
+ */
+const deriveQuestionContextFlags = source => {
+  const required = Boolean(source?.required);
+  const rawContext = typeof source?.context === 'string' ? source.context.toUpperCase() : '';
+  const isPassengerContext = rawContext === 'PASSENGER';
+
+  if (isPassengerContext) {
+    return {
+      visiblePerBooking: true,
+      visiblePerParticipant: true,
+      requiredPerBooking: required,
+      requiredPerParticipant: required,
+      isPerUnitItem: true,
+    };
+  }
+
+  return {
+    visiblePerBooking: true,
+    visiblePerParticipant: false,
+    requiredPerBooking: required,
+    requiredPerParticipant: false,
+    isPerUnitItem: false,
+  };
+};
+
+const mapQuestionTypeToFieldType = question => {
+  const typeToken = String(
+    question?.dataType
+    || question?.type
+    || question?.fieldType
+    || question?.answerType
+    || '',
+  ).toLowerCase();
+
+  if (typeToken.includes('options')) return 'extended-option';
+  if (typeToken.includes('bool') || typeToken.includes('yesno')) return 'yes-no';
+  if (typeToken.includes('checkbox')) return 'yes-no';
+  if (typeToken.includes('date') && typeToken.includes('time')) return 'short';
+  if (typeToken.includes('date')) return 'date';
+  if (typeToken.includes('long') || typeToken.includes('multiline') || typeToken.includes('textarea')) return 'long';
+  if (typeToken.includes('integer') || typeToken.includes('number') || typeToken.includes('count')) return 'count';
+  if (typeToken.includes('decimal') || typeToken.includes('float') || typeToken.includes('double')) return 'count';
+  if (typeToken.includes('select') || typeToken.includes('dropdown') || typeToken.includes('radio')) {
+    return 'extended-option';
+  }
+
+  const options = normalizeQuestionOptions(question);
+  if (options.length > 0) return 'extended-option';
+
+  return 'short';
+};
+
+const buildCustomFieldsFromQuestions = (questionSources, config = {}) => {
+  const excludedQuestionIds = Array.isArray(config.excludedQuestionIds)
+    ? config.excludedQuestionIds
+    : DEFAULT_EXCLUDED_CUSTOMER_QUESTION_IDS;
+  const excludedSet = new Set(excludedQuestionIds.map(String));
+  const questions = extractQuestionSpecs(questionSources)
+    .filter(question => !excludedSet.has(question.questionId));
+
+  return questions.map(question => {
+    const options = normalizeQuestionOptions(question);
+    const field = {
+      id: question.questionId,
+      title: question.label || question.title || question.question || question.questionId,
+      type: mapQuestionTypeToFieldType(question),
+      required: Boolean(question.required),
+      ...deriveQuestionContextFlags(question),
+      ...(question.placeholder ? { placeholder: String(question.placeholder) } : {}),
+    };
+
+    if (options.length > 0) {
+      field.options = options;
+      field.selectMultiple = Boolean(question.selectMultiple);
+    }
+    return field;
+  });
+};
+
+const normalizeBookingQuestions = questions => (
+  (Array.isArray(questions) ? questions : [])
+    .map(question => {
+      if (!question || typeof question !== 'object') return null;
+      const questionId = question.questionId
+        || question.questionCode
+        || (question.id != null ? String(question.id) : null);
+      if (!questionId) return null;
+      return {
+        ...question,
+        questionId: String(questionId),
+      };
+    })
+    .filter(Boolean)
+);
+
+module.exports = {
+  buildCustomFieldsFromQuestions,
+  deriveQuestionContextFlags,
+  mapCustomFieldValuesToAnswers,
+  extractQuestionSpecs,
+  normalizeBookingQuestions,
+  normalizeQuestionAnswerList,
+  toAnswerValues,
+};

package/utils/customerFieldConstants.js

@@ -0,0 +1,35 @@
+/**
+ * Map Bokun's product-level `passengerFields[].field` enum values onto the
+ * UI-side traveler field ids. Used to
+ * tag a contact field as `visiblePerParticipant` (and optionally
+ * `requiredPerParticipant`) when Bokun says it must be collected for every
+ * passenger.
+ *
+ * Keep keys upper-snake to mirror the wire format and ease diffing against
+ * Bokun's docs; alias variants (e.g. `POSTCODE` vs `POST_CODE`) are listed
+ * explicitly so we don't silently miss either spelling.
+ */
+const BOKUN_PASSENGER_FIELD_TO_UI_ID = {
+  FIRST_NAME: 'firstName',
+  FIRSTNAME: 'firstName',
+  LAST_NAME: 'lastName',
+  LASTNAME: 'lastName',
+  EMAIL: 'emailAddress',
+  EMAILADDRESS: 'emailAddress',
+  PHONE_NUMBER: 'phoneNumber',
+  PHONENUMBER: 'phoneNumber',
+  POST_CODE: 'postCode',
+  POSTCODE: 'postCode',
+  COUNTRY: 'country',
+};
+
+const DEFAULT_EXCLUDED_CUSTOMER_QUESTION_IDS = [
+  ...new Set([
+    ...Object.values(BOKUN_PASSENGER_FIELD_TO_UI_ID || {}),
+  ]),
+];
+
+module.exports = {
+  BOKUN_PASSENGER_FIELD_TO_UI_ID,
+  DEFAULT_EXCLUDED_CUSTOMER_QUESTION_IDS,
+};

package/utils/customerInfoFields.js

@@ -0,0 +1,321 @@
+const {
+  normalizePhoneWithCountryCode,
+  looksLikeValidPhone,
+} = require('./phone');
+const { buildCountryLookup } = require('./country');
+const {
+  BOKUN_PASSENGER_FIELD_TO_UI_ID,
+} = require('./customerFieldConstants');
+
+const COUNTRY_VALIDATION_ERROR = 'Please enter a valid country name.';
+const PHONE_VALIDATION_ERROR = 'Please enter a valid phone number.';
+
+const ADDRESS_REQUIRED_SUB_FIELDS = [
+  'address',
+  'postcode',
+  'city',
+  'country',
+];
+const CUSTOMER_QUESTION_ID_ALIASES = {
+  ...Object.entries(BOKUN_PASSENGER_FIELD_TO_UI_ID || {}).reduce((acc, [bokunCode, uiId]) => {
+    const normalizedBokunCode = String(bokunCode).toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (normalizedBokunCode) acc[normalizedBokunCode] = uiId;
+    return acc;
+  }, {}),
+};
+/**
+ * Aliases for outbound main-contact question IDs.
+ * Normalize UI/internal IDs to what Bokun expects.
+ */
+const MAIN_CONTACT_QUESTION_ID_ALIASES = {
+  city: 'place',
+  postCode: 'postcode',
+};
+
+/** Look up a key in `map` first as-is, then case-insensitively; fall back to raw. */
+const normalizeAliasKey = (map, rawKey) => {
+  if (rawKey == null) return rawKey;
+  const trimmed = String(rawKey).trim();
+  if (trimmed === '') return trimmed;
+  return map[trimmed] || map[trimmed.toLowerCase()] || trimmed;
+};
+
+const normalizeCustomerQuestionId = rawId => {
+  const id = rawId == null ? '' : String(rawId).trim();
+  if (id === '') return '';
+  const normalizedId = id.toLowerCase().replace(/[^a-z0-9]/g, '');
+  return CUSTOMER_QUESTION_ID_ALIASES[normalizedId] || id;
+};
+
+const expandRequiredCustomerQuestionIds = contactInfo => (
+  contactInfo.flatMap(entry => {
+    const normalizedId = normalizeCustomerQuestionId(entry.field);
+    if (String(normalizedId).toLowerCase() !== 'address') return [entry];
+
+    return ADDRESS_REQUIRED_SUB_FIELDS.map(subFieldId => ({
+      ...entry,
+      field: normalizeCustomerQuestionId(subFieldId),
+    }));
+  })
+);
+
+const validateContactFirstName = raw => {
+  const trimmed = raw == null ? '' : String(raw).trim();
+  if (trimmed === '') {
+    return { ok: false, error: 'Please enter a valid first name.' };
+  }
+  return { ok: true, firstName: trimmed };
+};
+
+const validateContactLastName = (raw, fallbackFirstName) => {
+  const trimmed = raw == null ? '' : String(raw).trim();
+  if (trimmed === '') {
+    const fallback = fallbackFirstName == null ? '' : String(fallbackFirstName).trim();
+    if (fallback !== '') {
+      return { ok: true, lastName: fallback };
+    }
+    return { ok: false, error: 'Please enter a valid last name.' };
+  }
+  return { ok: true, lastName: trimmed };
+};
+
+const validateContactEmail = raw => {
+  const trimmed = raw == null ? '' : String(raw).trim();
+  if (trimmed === '') {
+    return { ok: false, error: 'Please enter a valid email address.' };
+  }
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) {
+    return { ok: false, error: 'Please enter a valid email address.' };
+  }
+  return { ok: true, email: trimmed };
+};
+
+/**
+ * Unwrap a country/nationality value to a plain string.
+ *
+ * `extended-option` UI fields commonly hand the selection back as an option
+ * object (e.g. `{ value: 'US', label: 'United States', userInput: true }`)
+ * or as a single-element array (e.g. `['US']`). Older UI hosts and direct
+ * API callers send a plain string. We accept all three so a dropdown
+ * selection isn't silently coerced to `"[object Object]"` and dropped
+ * from `mainContactDetails`.
+ */
+const extractCountryInputString = raw => {
+  if (raw == null) return '';
+  if (typeof raw === 'string') return raw.trim();
+  if (typeof raw === 'number' || typeof raw === 'boolean') return String(raw).trim();
+  if (Array.isArray(raw)) {
+    return raw.reduce((acc, entry) => acc || extractCountryInputString(entry), '');
+  }
+  if (typeof raw === 'object') {
+    const candidate = raw.value
+      || raw.isoCode
+      || raw.code
+      || raw.id
+      || raw.label
+      || raw.title
+      || raw.name;
+    if (candidate == null) return '';
+    return String(candidate).trim();
+  }
+  return '';
+};
+
+const resolveCountryIsoCode = (raw, countryLookup) => {
+  const value = extractCountryInputString(raw);
+  if (value === '') return { ok: true, isoCode: '' };
+
+  const activeLookup = countryLookup || buildCountryLookup();
+
+  if (activeLookup.getByIso(value)) {
+    return { ok: true, isoCode: value.toUpperCase() };
+  }
+
+  const byName = activeLookup.getByName(value);
+  if (byName) {
+    return { ok: true, isoCode: String(byName.isoCode).toUpperCase() };
+  }
+
+  return {
+    ok: false,
+    error: COUNTRY_VALIDATION_ERROR,
+  };
+};
+
+const validateContactPhone = ({ phone, country, required = false } = {}) => {
+  const rawPhone = phone == null ? '' : String(phone).trim();
+  const normalizedCountry = country == null ? '' : String(country).trim().toUpperCase();
+
+  if (rawPhone === '') {
+    if (required) {
+      return { ok: false, error: PHONE_VALIDATION_ERROR };
+    }
+    return { ok: true, phone: null };
+  }
+  const normalizedPhone = normalizePhoneWithCountryCode({
+    phone: rawPhone,
+    country: normalizedCountry,
+  });
+  if (!normalizedPhone || !looksLikeValidPhone(normalizedPhone, normalizedCountry)) {
+    return { ok: false, error: PHONE_VALIDATION_ERROR };
+  }
+
+  return { ok: true, phone: normalizedPhone };
+};
+
+const validateContactInfo = (holder, { countryOptions } = {}) => {
+  if (!holder || Object.keys(holder).length === 0) {
+    return {
+      ok: false,
+      error: 'Contact information is required.',
+      errors: ['Contact information is required.'],
+      contact: {},
+    };
+  }
+  const errors = [];
+
+  const firstNameCheck = validateContactFirstName(holder.firstName || (holder.name ? holder.name.split(' ')[0] : ''));
+  if (!firstNameCheck.ok) errors.push(firstNameCheck.error);
+  const firstName = firstNameCheck.firstName || '';
+
+  const rawLastName = holder.surname || (holder.name ? holder.name.split(' ').slice(1).join(' ') : '');
+  const lastNameCheck = validateContactLastName(rawLastName, firstName);
+  if (!lastNameCheck.ok) errors.push(lastNameCheck.error);
+  const lastName = lastNameCheck.lastName || '';
+
+  const emailCheck = validateContactEmail(holder.email || holder.emailAddress);
+  if (!emailCheck.ok) errors.push(emailCheck.error);
+  const email = emailCheck.email || '';
+
+  // Build the country lookup once (dynamic list first, static fallback) so
+  // country and nationality share the same index.
+  const countryLookup = buildCountryLookup(countryOptions);
+  const countryCheck = resolveCountryIsoCode(holder.country, countryLookup);
+  if (!countryCheck.ok) errors.push(countryCheck.error);
+  const normalizedCountry = countryCheck.isoCode || '';
+  const nationalityCheck = resolveCountryIsoCode(holder.nationality, countryLookup);
+  if (!nationalityCheck.ok) errors.push(nationalityCheck.error);
+  const normalizedNationality = nationalityCheck.isoCode || '';
+  const normalizedPostCode = (
+    holder.postCode
+    || holder.postalCode
+    || holder.postcode
+    || holder.zipCode
+    || holder.pinCode
+    || ''
+  );
+  const normalizedCity = (
+    holder.place
+    || holder.city
+    || ''
+  );
+  const normalizedAddress = (
+    holder.address
+    || holder.addressLine1
+    || ''
+  );
+
+  const phoneNumberCheck = validateContactPhone({
+    phone: holder.phone || holder.phoneNumber,
+    country: normalizedCountry,
+  });
+
+  if (!phoneNumberCheck.ok) errors.push(phoneNumberCheck.error);
+  const phoneNumber = phoneNumberCheck.phone || null;
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    contact: {
+      firstName,
+      lastName,
+      email,
+      country: normalizedCountry || null,
+      nationality: normalizedNationality || null,
+      postCode: normalizedPostCode || null,
+      city: normalizedCity || null,
+      address: normalizedAddress || null,
+      phoneNumber: phoneNumber || null,
+    },
+  };
+};
+
+const getMainContactDetails = contact => {
+  if (!contact || Object.keys(contact).length === 0) {
+    return [];
+  }
+  const {
+    firstName,
+    lastName,
+    email,
+    country,
+    postCode,
+    city,
+    address,
+    phoneNumber,
+  } = contact;
+  const details = [
+    {
+      questionId: 'firstName',
+      values: [firstName],
+    },
+    {
+      questionId: 'lastName',
+      values: [lastName],
+    },
+    {
+      questionId: 'email',
+      values: [email],
+    },
+  ];
+  const includedQuestionIds = new Set(details.map(detail => detail.questionId));
+  const addMainContactDetail = (questionId, rawValue) => {
+    const value = rawValue == null ? '' : String(rawValue).trim();
+    if (!value || includedQuestionIds.has(questionId)) return;
+    details.push({ questionId, values: [value] });
+    includedQuestionIds.add(questionId);
+  };
+
+  addMainContactDetail('phoneNumber', phoneNumber);
+  addMainContactDetail('postCode', postCode);
+  addMainContactDetail('country', country);
+  addMainContactDetail('city', city);
+  addMainContactDetail('address', address);
+
+  if (address != null && String(address).trim() !== '') {
+    const addressFieldValues = {
+      address,
+      postcode: postCode,
+      city,
+      country,
+    };
+    ADDRESS_REQUIRED_SUB_FIELDS.forEach(fieldId => {
+      if (fieldId === 'postcode') {
+        addMainContactDetail('postCode', addressFieldValues.postcode);
+        return;
+      }
+      addMainContactDetail(fieldId, addressFieldValues[fieldId]);
+    });
+  }
+
+  return details;
+};
+
+const normalizeMainContactAnswer = answer => {
+  if (!answer || !answer.questionId) return answer;
+  const rawQuestionId = String(answer.questionId).trim();
+  if (!rawQuestionId) return answer;
+  const mapped = normalizeAliasKey(MAIN_CONTACT_QUESTION_ID_ALIASES, rawQuestionId);
+  if (mapped === rawQuestionId) return answer;
+  return { ...answer, questionId: mapped };
+};
+
+module.exports = {
+  validateContactInfo,
+  getMainContactDetails,
+  normalizeMainContactAnswer,
+  expandRequiredCustomerQuestionIds,
+  extractCountryInputString,
+  COUNTRY_VALIDATION_ERROR,
+  PHONE_VALIDATION_ERROR,
+};