ti2-bokun 1.0.6 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-bokun",
-  "version": "1.0.6",
+  "version": "1.0.13",
   "description": "Bokun's TI2 Plugin",
   "main": "index.js",
   "scripts": {
@@ -53,6 +53,6 @@
     "jest-diff": "^27.4.2",
     "jest-environment-node": "27.4",
     "jest-util": "27.4",
-    "ti2": "latest"
+    "ti2": "file:../ti2"
   }
 }

package/resolvers/product.js

@@ -2,6 +2,70 @@ const { makeExecutableSchema } = require('@graphql-tools/schema');
 const R = require('ramda');
 const { graphql } = require('graphql');
 
+// Flatten currencies across every activityPriceCatalog on a product so we
+// don't miss currencies only offered by non-primary catalogs.
+const getCatalogCurrencies = o => R.chain(
+  c => R.propOr([], 'currencies', c),
+  R.pathOr([], ['activityPriceCatalogs'], o),
+);
+
+const REQUIRED_CUSTOMER_FIELDS_TYPE_DEF = `
+  extend type Query {
+    requiredCustomerFields: [String]
+  }
+`;
+
+const stripGraphqlComments = source => source
+  .split('\n')
+  .map(line => line.replace(/#.*$/, ''))
+  .join('\n');
+
+const hasRequiredCustomerFieldsDefinition = typeDef => (
+  typeof typeDef === 'string'
+  && /requiredCustomerFields\s*:\s*\[?\s*String/.test(stripGraphqlComments(typeDef))
+);
+
+/**
+ * `extend type Query` is only valid when the schema defines (or already extends) `Query`.
+ * Skip injection for SDL documents with no `Query` type to avoid invalid schemas.
+ */
+const typeDefsStringDefinesQuery = source => {
+  if (typeof source !== 'string') return false;
+  const stripped = stripGraphqlComments(source);
+  return /(^|[^\w.])(extend\s+type|type)\s+Query[\s\n]*\{/.test(stripped);
+};
+
+const hasQueryableRootType = typeDefs => {
+  if (typeof typeDefs === 'string') {
+    return typeDefsStringDefinesQuery(typeDefs);
+  }
+  if (Array.isArray(typeDefs)) {
+    return typeDefs.some(
+      t => typeof t === 'string' && typeDefsStringDefinesQuery(t),
+    );
+  }
+  return false;
+};
+
+const withRequiredCustomerFieldsTypeDef = typeDefs => {
+  if (!hasQueryableRootType(typeDefs)) {
+    return typeDefs;
+  }
+  if (typeof typeDefs === 'string') {
+    return hasRequiredCustomerFieldsDefinition(typeDefs)
+      ? typeDefs
+      : `${typeDefs}\n${REQUIRED_CUSTOMER_FIELDS_TYPE_DEF}`;
+  }
+
+  if (Array.isArray(typeDefs)) {
+    return typeDefs.some(hasRequiredCustomerFieldsDefinition)
+      ? typeDefs
+      : [...typeDefs, REQUIRED_CUSTOMER_FIELDS_TYPE_DEF];
+  }
+
+  return typeDefs;
+};
+
 const resolvers = {
   Query: {
     productId: o => {
@@ -10,10 +74,17 @@ const resolvers = {
     },
     productName: o => R.path(['title'], o) || R.path(['name'], o) || R.prop('internalName', o),
     availableCurrencies: o => {
-      const currencies = R.path(['currencies'], o);
-      return currencies || ['USD', 'EUR', 'GBP', 'ISK'];
+      const codes = getCatalogCurrencies(o).map(c => c.currency).filter(Boolean);
+      return codes.length ? [...new Set(codes)] : ['USD', 'EUR', 'GBP', 'ISK'];
+    },
+    requiredCustomerFields: o => {
+      const fields = R.pathOr([], ['requiredCustomerFields'], o);
+      return [...new Set((Array.isArray(fields) ? fields : []).filter(Boolean))];
+    },
+    defaultCurrency: o => {
+      const def = getCatalogCurrencies(o).find(c => c.default);
+      return (def && def.currency) || R.path(['defaultCurrency'], o) || 'USD';
     },
-    defaultCurrency: o => R.path(['defaultCurrency'], o) || 'USD',
     options: root => {
       const products = R.propOr([], 'products', root);
       const options = R.propOr([], 'options', root);
@@ -130,7 +201,7 @@ const resolvers = {
 
 const translateProduct = async ({ rootValue, typeDefs, query }) => {
   const schema = makeExecutableSchema({
-    typeDefs,
+    typeDefs: withRequiredCustomerFieldsTypeDef(typeDefs),
     resolvers,
   });
   const retVal = await graphql({

package/utils/bokunRequest.js

@@ -0,0 +1,80 @@
+const crypto = require('crypto');
+const moment = require('moment');
+
+/**
+ * Build full request URL and the path to use for signature (path the server sees).
+ * If baseUrl is https://api.bokun.io/rest-v2, pathForSigning must be
+ * /rest-v2/activity.json/... so the signature matches.
+ */
+const buildRequestUrlAndPath = (baseUrl, path) => {
+  const pathPart = path.startsWith('/') ? path : `/${path}`;
+  const url = `${baseUrl.replace(/\/$/, '')}${pathPart}`;
+  let pathForSigning = pathPart;
+  try {
+    const u = new URL(url);
+    pathForSigning = u.pathname + u.search;
+  } catch (_) {
+    // fallback: use pathPart if URL parse fails
+  }
+  return { url, pathForSigning };
+};
+
+/**
+ * Bókun signature per https://bokun.dev/booking-api-rest/vU6sCfxwYdJWd1QAcLt12i/configuring-the-platform-for-api-usage-and-authentication/sFiGRpo4detkmrZPcWtQPj
+ * String to sign = date + accessKey + HTTP method (uppercase) + path (including
+ * query string, no scheme/host). Then HMAC-SHA1 with secret key, then Base64.
+ */
+const generateBokunSignature = ({
+  secretKey,
+  accessKey,
+  date,
+  method,
+  path,
+}) => {
+  const stringToSign = `${date}${accessKey}${method.toUpperCase()}${path}`;
+  return crypto
+    .createHmac('sha1', secretKey)
+    .update(stringToSign)
+    .digest('base64');
+};
+
+const getHeaders = ({
+  accessKey,
+  secretKey,
+  method,
+  path,
+}) => {
+  if (typeof secretKey !== 'string' || !secretKey) {
+    throw new Error(
+      'Bokun API secretKey is required. Configure accessKey and secretKey in the integration token '
+      + 'or set ti2_bokun_accessKey and ti2_bokun_secretKey.',
+    );
+  }
+  if (typeof accessKey !== 'string' || !accessKey) {
+    throw new Error(
+      'Bokun API accessKey is required. Configure accessKey and secretKey in the integration token '
+      + 'or set ti2_bokun_accessKey and ti2_bokun_secretKey.',
+    );
+  }
+  const date = moment.utc().format('YYYY-MM-DD HH:mm:ss');
+  const signature = generateBokunSignature({
+    secretKey,
+    accessKey,
+    date,
+    method,
+    path,
+  });
+
+  return {
+    'X-Bokun-Date': date,
+    'X-Bokun-AccessKey': accessKey,
+    'X-Bokun-Signature': signature,
+    'Content-Type': 'application/json;charset=UTF-8',
+  };
+};
+
+module.exports = {
+  buildRequestUrlAndPath,
+  generateBokunSignature,
+  getHeaders,
+};

package/utils/bookingFields.js

@@ -0,0 +1,211 @@
+const moment = require('moment');
+const { extractQuestionSpecs, toAnswerValues } = require('./customFields');
+const { BOKUN_PASSENGER_FIELD_TO_UI_ID } = require('./customerFieldConstants');
+
+const TRAVEL_DATE_FORMAT = 'YYYY-MM-DD';
+
+const toDisplayTitle = raw => String(raw || '')
+  .trim()
+  .split(/[_\s-]+/)
+  .filter(Boolean)
+  .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+  .join(' ');
+
+const toFieldId = field => {
+  if (field == null) return '';
+  if (typeof field === 'string') return field.trim();
+  if (typeof field === 'object') return String(field.id || field.field || '').trim();
+  return '';
+};
+
+/**
+ * Apply Bokun's per-passenger contact-info requirements (productData.passengerFields)
+ * to the UI fields list. Every field is annotated with `visiblePerBooking: true`
+ * and defaults of `visiblePerParticipant: false` / `requiredPerParticipant: false`.
+ * Fields listed in Bokun's `passengerFields` are additionally tagged with
+ * `visiblePerParticipant: true` and `requiredPerParticipant: <required>` so the
+ * UI can distinguish which contact fields must be collected for each passenger.
+ * `visiblePerBooking` is always true so the lead passenger continues to enter
+ * the field at the booking root — `passengerFields` is additive, not exclusive.
+ *
+ * Unrecognised codes are logged once via `console.warn` and otherwise
+ * ignored, matching the rest of the plugin's best-effort enrichment style.
+ */
+const applyPassengerFieldsToUiFields = (leadPassengerContactInfo, passengerContactInfo) => {
+  const leadPassengerFields = Array.isArray(leadPassengerContactInfo)
+    ? leadPassengerContactInfo
+    : [leadPassengerContactInfo];
+  const otherPassengerFields = Array.isArray(passengerContactInfo) ? passengerContactInfo : [passengerContactInfo];
+
+  const leadPassengerFieldIds = new Set(leadPassengerFields.map(toFieldId).filter(Boolean));
+  const flagsByUiId = {};
+  const passthroughFieldMetaById = {};
+  otherPassengerFields.forEach(entry => {
+    if (!entry || typeof entry !== 'object') return;
+    const rawCode = typeof entry.field === 'string' ? entry.field.trim() : '';
+    const uiId = BOKUN_PASSENGER_FIELD_TO_UI_ID[rawCode] || rawCode;
+    const requiredPerParticipant = Boolean(entry.required);
+
+    const existingFlags = flagsByUiId[uiId] || {
+      visiblePerParticipant: false,
+      requiredPerParticipant: false,
+    };
+    flagsByUiId[uiId] = {
+      visiblePerParticipant: true,
+      requiredPerParticipant: existingFlags.requiredPerParticipant || requiredPerParticipant,
+    };
+
+    if (!leadPassengerFieldIds.has(uiId) && !passthroughFieldMetaById[uiId]) {
+      passthroughFieldMetaById[uiId] = {
+        id: uiId,
+        title: toDisplayTitle(entry.field || rawCode),
+        type: 'short',
+        visiblePerBooking: true,
+        requiredPerBooking: false,
+      };
+    }
+  });
+
+  const annotatedBaseFields = leadPassengerFields.map(entry => {
+    const rawCode = typeof entry.field === 'string' ? entry.field.trim() : '';
+    const uiId = BOKUN_PASSENGER_FIELD_TO_UI_ID[rawCode] || rawCode;
+    const requiredPerBooking = Boolean(entry.required);
+    const perParticipantFlags = flagsByUiId[uiId] || {
+      visiblePerBooking: true,
+      visiblePerParticipant: false,
+      requiredPerParticipant: false,
+    };
+    return {
+      id: uiId,
+      title: toDisplayTitle(uiId),
+      type: 'short',
+      visiblePerBooking: true,
+      requiredPerBooking: requiredPerBooking || perParticipantFlags.requiredPerParticipant,
+      ...perParticipantFlags,
+    };
+  });
+
+  const passthroughFields = Object.values(passthroughFieldMetaById).map(field => ({
+    ...field,
+    visiblePerBooking: true,
+    requiredPerBooking: field.requiredPerBooking || Boolean(flagsByUiId[field.id]?.requiredPerParticipant),
+    ...flagsByUiId[field.id],
+  }));
+
+  return [...annotatedBaseFields, ...passthroughFields];
+};
+
+/**
+ * Validate that all server-required questions have non-empty values in the
+ * main-contact details. Other answer collections (passenger/activity) are
+ * intentionally not consulted here so a passenger's `firstName` cannot
+ * satisfy a main-contact requirement.
+ */
+const validateRequiredContactFields = ({
+  requiredQuestions = [],
+  mainContactDetails = [],
+  sendNotificationToMainContact,
+}) => {
+  const answerValuesByQuestionId = {};
+  (Array.isArray(mainContactDetails) ? mainContactDetails : []).forEach(answer => {
+    if (!answer || typeof answer.questionId !== 'string') return;
+    const values = toAnswerValues(answer)
+      .map(value => (value == null ? '' : String(value).trim()))
+      .filter(Boolean);
+    if (values.length === 0) return;
+    answerValuesByQuestionId[answer.questionId] = values;
+  });
+
+  return requiredQuestions.reduce((error, question) => {
+    if (error) return error;
+
+    const questionId = question?.questionId;
+    if (!questionId) return null;
+    const label = question?.label || questionId;
+
+    if (questionId === 'sendNotificationToMainContact') {
+      return typeof sendNotificationToMainContact === 'boolean'
+        ? null
+        : 'Please specify whether to send notification to the main contact.';
+    }
+
+    const value = (answerValuesByQuestionId[questionId] || [])[0] || '';
+    if (value !== '') return null;
+
+    if (questionId === 'nationality') return 'Please select a country.';
+    if (questionId === 'phoneNumber') return 'Please enter a valid phone number.';
+    if (questionId === 'email') return 'Please enter a valid email address.';
+    return `${label} is required.`;
+  }, null);
+};
+
+/**
+ * Reformat a date-ish value to Bokun's travel-date format (YYYY-MM-DD).
+ * Strict-only parsing: tries the caller-supplied `inputDateFormat`, then
+ * ISO 8601. Anything else passes through unchanged so we never silently
+ * transform unrelated strings (e.g. "123" → today) that happen to be
+ * accepted by moment's loose parser.
+ */
+const formatToTravelDate = (value, inputDateFormat) => {
+  if (value == null) return value;
+  const raw = String(value).trim();
+  if (raw === '') return raw;
+
+  if (inputDateFormat) {
+    const parsed = moment(raw, inputDateFormat, true);
+    if (parsed.isValid()) return parsed.format(TRAVEL_DATE_FORMAT);
+  }
+
+  const parsedIso = moment(raw, moment.ISO_8601, true);
+  if (parsedIso.isValid()) return parsedIso.format(TRAVEL_DATE_FORMAT);
+
+  return value;
+};
+
+const normalizeCustomFieldValueForBooking = ({ field, value, inputDateFormat }) => {
+  if (String(field?.type || '').toLowerCase() !== 'date') return value;
+
+  const normalize = raw => {
+    if (raw == null) return raw;
+    if (Array.isArray(raw)) return raw.map(normalize);
+    if (typeof raw === 'object') {
+      if (raw.value != null) return { ...raw, value: formatToTravelDate(raw.value, inputDateFormat) };
+      if (raw.id != null) return { ...raw, id: formatToTravelDate(raw.id, inputDateFormat) };
+      return raw;
+    }
+    return formatToTravelDate(raw, inputDateFormat);
+  };
+
+  return normalize(value);
+};
+
+/**
+ * Pull required-question specs out of a Bokun checkout-options response.
+ * Prefer the documented shape `options[].questions` so nested structures
+ * (e.g. passenger answer trees) are not mis-read as main-contact questions.
+ * Falls back to a deep walk when that shape is empty or missing.
+ */
+const extractRequiredQuestions = optionsData => {
+  const root = optionsData && typeof optionsData === 'object' ? optionsData : {};
+  const optionGroups = Array.isArray(root.options) ? root.options : [];
+  const fromOptions = optionGroups.flatMap(group => {
+    if (!group || typeof group !== 'object') return [];
+    const { questions } = group;
+    return Array.isArray(questions) ? questions : [];
+  });
+  const requiredFromOptions = fromOptions.filter(q => q && q.required);
+  if (requiredFromOptions.length > 0) {
+    return requiredFromOptions;
+  }
+  return extractQuestionSpecs(optionsData).filter(q => q && q.required);
+};
+
+module.exports = {
+  TRAVEL_DATE_FORMAT,
+  BOKUN_PASSENGER_FIELD_TO_UI_ID,
+  applyPassengerFieldsToUiFields,
+  validateRequiredContactFields,
+  formatToTravelDate,
+  normalizeCustomFieldValueForBooking,
+  extractRequiredQuestions,
+};