ti2-bokun 1.0.0

package/index.js

@@ -0,0 +1,1026 @@
+const R = require('ramda');
+const Promise = require('bluebird');
+const assert = require('assert');
+const moment = require('moment');
+const jwt = require('jsonwebtoken');
+const crypto = require('crypto');
+const { translateProduct } = require('./resolvers/product');
+const { translateAvailability } = require('./resolvers/availability');
+const { translateBooking } = require('./resolvers/booking');
+
+const CONCURRENCY = 3;
+
+const isNilOrEmpty = R.either(R.isNil, R.isEmpty);
+
+const toStringSafe = value => (value === undefined || value === null ? null : value.toString());
+
+/** Derive sales UI base URL from API endpoint and tenant. e.g. api.bokun.io + tourconnect-llc -> https://tourconnect-llc.bokun.io/ */
+const getSalesBaseUrlFromEndpoint = (endpoint, tenantSlug) => {
+  if (!tenantSlug || !endpoint) return null;
+  try {
+    const url = new URL(endpoint);
+    const { hostname } = url;
+    const salesHost = hostname.replace(/^api\./, `${tenantSlug}.`);
+    return `https://${salesHost}/`;
+  } catch {
+    return null;
+  }
+};
+
+const normaliseOptionIds = (productIds, optionIds = []) => {
+  if (!Array.isArray(productIds) || productIds.length === 0) return [];
+
+  if (!Array.isArray(optionIds) || optionIds.length === 0) {
+    return productIds.map(() => null);
+  }
+
+  if (optionIds.length === 1 && productIds.length > 1) {
+    return productIds.map(() => optionIds[0]);
+  }
+
+  if (optionIds.length !== productIds.length) {
+    throw new Error('mismatched productIds/options length');
+  }
+
+  return optionIds;
+};
+
+const normaliseUnits = (productIds, units = []) => {
+  if (!Array.isArray(productIds) || productIds.length === 0) return [];
+
+  if (!Array.isArray(units) || units.length === 0) {
+    return productIds.map(() => []);
+  }
+
+  // Units might be provided as a single array of configs that should apply to every product
+  if (!Array.isArray(units[0])) {
+    if (units.length === productIds.length && units.every(u => typeof u === 'object' && u !== null)) {
+      return units.map(unitConfig => (Array.isArray(unitConfig) ? unitConfig : [unitConfig]));
+    }
+    return productIds.map(() => units);
+  }
+
+  if (units.length !== productIds.length) {
+    throw new Error('mismatched options/units length');
+  }
+
+  return units;
+};
+
+const withOriginalRetailNet = (obj, amount) => {
+  const value = amount !== undefined && amount !== null ? amount : (obj.price !== undefined && obj.price !== null ? obj.price : 0);
+  return {
+    ...obj,
+    original: obj.original !== undefined && obj.original !== null ? obj.original : value,
+    retail: obj.retail !== undefined && obj.retail !== null ? obj.retail : value,
+    net: obj.net !== undefined && obj.net !== null ? obj.net : value,
+  };
+};
+
+const extractMoney = (moneyValue, fallbackCurrency) => {
+  if (moneyValue === undefined || moneyValue === null) {
+    return withOriginalRetailNet({
+      price: 0,
+      currency: fallbackCurrency || 'USD',
+      currencyPrecision: 2,
+    });
+  }
+
+  if (typeof moneyValue === 'number') {
+    return withOriginalRetailNet({
+      price: moneyValue,
+      currency: fallbackCurrency || 'USD',
+      currencyPrecision: 2,
+    });
+  }
+
+  const rawAmount = typeof moneyValue.amount === 'number'
+    ? moneyValue.amount
+    : parseFloat(moneyValue.amount || 0);
+  const amount = Number.isFinite(rawAmount) ? rawAmount : 0;
+  let precision;
+  if (typeof moneyValue.currencyPrecision === 'number') {
+    precision = moneyValue.currencyPrecision;
+  } else if (typeof moneyValue.scale === 'number') {
+    precision = moneyValue.scale;
+  } else {
+    precision = null;
+  }
+  const currency = moneyValue.currency || fallbackCurrency || 'USD';
+
+  if (precision === null) {
+    return withOriginalRetailNet({
+      price: amount,
+      currency,
+      currencyPrecision: 2,
+    });
+  }
+
+  const scaledPrice = amount / (10 ** precision);
+  return withOriginalRetailNet({
+    price: Number.isFinite(scaledPrice) ? scaledPrice : 0,
+    currency,
+    currencyPrecision: precision,
+  });
+};
+
+const computeAvailabilityCount = availability => {
+  if (availability.availabilityCount != null) return availability.availabilityCount;
+  if (availability.capacity != null) return availability.capacity;
+  if (availability.remainingCapacity != null) return availability.remainingCapacity;
+  if (availability.vacancy != null) return availability.vacancy;
+  if (availability.vacancies != null) return availability.vacancies;
+  return 0;
+};
+
+const normalizeAvailabilityPricing = availability => {
+  if (!availability) return availability;
+  const rawPricing = availability.pricing;
+  const rawUnitPricing = availability.unitPricing || [];
+  let pricingArray = null;
+  if (Array.isArray(rawPricing)) {
+    pricingArray = rawPricing;
+  } else if (rawPricing != null && typeof rawPricing === 'object') {
+    const price = rawPricing.retail != null ? rawPricing.retail : (rawPricing.original != null ? rawPricing.original : (rawPricing.net != null ? rawPricing.net : rawPricing.price));
+    pricingArray = [{ ...rawPricing, price }];
+  }
+  const unitPricingArray = rawUnitPricing.map(unit => {
+    if (unit.pricing != null && (Array.isArray(unit.pricing) ? unit.pricing.length > 0 : true)) {
+      return unit;
+    }
+    const p = {
+      original: unit.original,
+      retail: unit.retail,
+      net: unit.net,
+      currency: unit.currency || 'USD',
+      currencyPrecision: unit.currencyPrecision != null ? unit.currencyPrecision : 2,
+      price: unit.retail != null ? unit.retail : (unit.original != null ? unit.original : (unit.net != null ? unit.net : unit.price)),
+    };
+    return { ...unit, pricing: [p] };
+  });
+  return {
+    ...availability,
+    pricing: pricingArray || availability.pricing,
+    unitPricing: unitPricingArray,
+  };
+};
+
+const mapOctoPricingToRate = availability => {
+  const normalized = normalizeAvailabilityPricing(availability);
+  const price = normalized && normalized.pricing && normalized.pricing[0] ? normalized.pricing[0] : null;
+  if (!price) return null;
+  const unitPricingList = (normalized && normalized.unitPricing) ? normalized.unitPricing : [];
+  const pricePerCategoryUnit = unitPricingList.map(unitPricing => ({
+    id: unitPricing.unitId,
+    amount: {
+      currency: price.currency,
+      amount: (unitPricing.pricing && unitPricing.pricing[0] ? unitPricing.pricing[0].retail : null) || (unitPricing.pricing && unitPricing.pricing[0] ? unitPricing.pricing[0].price : null) || price.retail,
+      currencyPrecision: price.currencyPrecision,
+    },
+  }));
+
+  return {
+    rateId: (normalized && normalized.optionId) || (normalized && normalized.rateId) || (normalized && normalized.rateReference) || null,
+    pricePerCategoryUnit,
+    pricePerBooking: {
+      amount: {
+        currency: price.currency,
+        amount: price.retail,
+        currencyPrecision: price.currencyPrecision,
+      },
+    },
+  };
+};
+
+const buildUnitPricing = ({ units, ratePricing, fallbackCurrency }) => {
+  if (!Array.isArray(units) || units.length === 0) return [];
+
+  const pricePerUnit = (ratePricing && ratePricing.pricePerCategoryUnit) || [];
+  const pricePerBooking = ratePricing && ratePricing.pricePerBooking;
+
+  return units.map(unit => {
+    const { unitId } = unit;
+    const matchingCategory = pricePerUnit.find(entry => toStringSafe(entry.id) === toStringSafe(unitId));
+    const pricingAmount = matchingCategory
+      ? extractMoney(matchingCategory.amount, fallbackCurrency)
+      : extractMoney((pricePerBooking && pricePerBooking.amount) || pricePerBooking, fallbackCurrency);
+
+    return {
+      unitId,
+      pricing: [pricingAmount],
+    };
+  });
+};
+
+const parseAvailabilityDate = availability => {
+  if (!availability) return null;
+
+  if (availability.localDateTimeStart) {
+    const localDateTime = moment(availability.localDateTimeStart);
+    if (localDateTime.isValid()) return localDateTime;
+  }
+
+  if (availability.localDate) {
+    const localMoment = moment(availability.localDate);
+    if (localMoment.isValid()) return localMoment;
+  }
+
+  if (availability.date) {
+    const dateValue = availability.date;
+    const parsed = typeof dateValue === 'number'
+      ? moment(dateValue)
+      : moment(dateValue, ['YYYY-MM-DD', moment.ISO_8601], true);
+    if (parsed.isValid()) return parsed;
+  }
+
+  if (availability.localizedDate) {
+    const parsed = moment(availability.localizedDate, moment.ISO_8601);
+    if (parsed.isValid()) return parsed;
+  }
+
+  return null;
+};
+
+const buildAvailabilityRoot = ({
+  availability,
+  productId,
+  rateId,
+  units,
+  currency,
+}) => {
+  const availabilityDate = parseAvailabilityDate(availability);
+  const localDate = availabilityDate ? availabilityDate.format('YYYY-MM-DD') : null;
+  const startMoment = availability.localDateTimeStart ? moment(availability.localDateTimeStart) : null;
+  const endMoment = availability.localDateTimeEnd ? moment(availability.localDateTimeEnd) : null;
+  const time = availability.startTime
+    || availability.time
+    || availability.startTimeLocal
+    || (startMoment ? startMoment.format('HH:mm') : '00:00');
+  let computedDuration;
+  if (startMoment && endMoment) {
+    computedDuration = Math.max(endMoment.diff(startMoment, 'minutes'), 0);
+  } else if (availability.allDay) {
+    computedDuration = 24 * 60;
+  } else {
+    computedDuration = 120;
+  }
+  const durationMinutes = availability.durationMinutes != null ? availability.durationMinutes : (availability.duration != null ? availability.duration : computedDuration);
+  const localStart = startMoment || (localDate ? moment(`${localDate}T${time}`) : null);
+  const localEnd = endMoment || (localStart ? moment(localStart).add(durationMinutes, 'minutes') : null);
+
+  const availabilityCount = computeAvailabilityCount(availability);
+
+  const isSoldOutExplicit = availability.soldOut === true
+    || availability.unavailable === true
+    || availability.status === 'SOLD_OUT';
+  const isAvailable = !isSoldOutExplicit && availabilityCount > 0;
+  const status = isAvailable ? 'AVAILABLE' : 'SOLD_OUT';
+
+  const fallbackCurrency = currency
+    || availability.currency
+    || (availability.pricing && availability.pricing[0] ? availability.pricing[0].currency : null)
+    || (availability.pricesByRate && availability.pricesByRate[0] && availability.pricesByRate[0].pricePerCategoryUnit && availability.pricesByRate[0].pricePerCategoryUnit[0] && availability.pricesByRate[0].pricePerCategoryUnit[0].amount ? availability.pricesByRate[0].pricePerCategoryUnit[0].amount.currency : null)
+    || 'USD';
+
+  const ratePricingSource = availability.ratePricing || mapOctoPricingToRate(availability);
+
+  let unitPricing = buildUnitPricing({
+    units,
+    ratePricing: ratePricingSource,
+    fallbackCurrency,
+  });
+
+  let resolvedPricing = (unitPricing[0] && unitPricing[0].pricing) || [];
+
+  const hasApiPricing = availability.pricing != null || (availability.unitPricing || []).length > 0;
+  if (hasApiPricing) {
+    const normalized = normalizeAvailabilityPricing(availability);
+    const fillPricingItem = p => ({
+      ...p,
+      price: p.price != null ? p.price : (p.retail != null ? p.retail : (p.original != null ? p.original : (p.net != null ? p.net : 0))),
+      original: p.original != null ? p.original : (p.retail != null ? p.retail : (p.price != null ? p.price : 0)),
+      retail: p.retail != null ? p.retail : (p.original != null ? p.original : (p.price != null ? p.price : 0)),
+      net: p.net != null ? p.net : (p.retail != null ? p.retail : (p.original != null ? p.original : (p.price != null ? p.price : 0))),
+    });
+    if (normalized.pricing && (Array.isArray(normalized.pricing) ? normalized.pricing.length > 0 : true)) {
+      const pricingArr = Array.isArray(normalized.pricing) ? normalized.pricing : [normalized.pricing];
+      resolvedPricing = pricingArr.map(fillPricingItem);
+    }
+    if ((normalized.unitPricing || []).length > 0) {
+      unitPricing = normalized.unitPricing.map(unit => {
+        const hasNested = unit.pricing != null && (Array.isArray(unit.pricing) ? unit.pricing.length > 0 : true);
+        if (hasNested) {
+          const arr = Array.isArray(unit.pricing) ? unit.pricing : [unit.pricing];
+          return { ...unit, pricing: arr.map(fillPricingItem) };
+        }
+        const price = unit.retail != null ? unit.retail : (unit.original != null ? unit.original : (unit.net != null ? unit.net : (unit.price != null ? unit.price : 0)));
+        const p = fillPricingItem({
+          original: unit.original != null ? unit.original : (unit.retail != null ? unit.retail : price),
+          retail: unit.retail != null ? unit.retail : (unit.original != null ? unit.original : price),
+          net: unit.net != null ? unit.net : (unit.retail != null ? unit.retail : (unit.original != null ? unit.original : price)),
+          currency: unit.currency || fallbackCurrency,
+          currencyPrecision: unit.currencyPrecision != null ? unit.currencyPrecision : 2,
+          price,
+        });
+        return { ...unit, pricing: [p] };
+      });
+      if (resolvedPricing.length === 0 && unitPricing[0] && unitPricing[0].pricing && unitPricing[0].pricing.length) {
+        resolvedPricing = unitPricing[0].pricing;
+      }
+    }
+  }
+
+  const availabilityId = availability.id || availability.availabilityId || availability.startTimeId;
+  const startTimeId = availability.startTimeId || availabilityId;
+
+  return {
+    id: availabilityId ? availabilityId.toString() : `${productId}-${localDate || ''}-${time}`,
+    availabilityId: availabilityId ? availabilityId.toString() : null,
+    startTimeId: startTimeId ? startTimeId.toString() : null,
+    productId: productId.toString(),
+    date: localDate,
+    time,
+    localDateTimeStart: localStart ? localStart.format() : null,
+    localDateTimeEnd: localEnd ? localEnd.format() : null,
+    utcDateTimeStart: localStart ? moment.utc(localStart).format() : null,
+    utcDateTimeEnd: localEnd ? moment.utc(localEnd).format() : null,
+    allDay: Boolean(availability.allDay),
+    available: isAvailable,
+    status,
+    availabilityCount,
+    vacancies: availabilityCount,
+    capacity: availabilityCount,
+    maxUnits: availabilityCount,
+    unitPricing,
+    pricing: resolvedPricing,
+    rateId,
+    currency: fallbackCurrency,
+    offers: availability.offers,
+    pickupAvailable: availability.pickupAvailable || availability.pickupAllotment || false,
+    pickupRequired: availability.pickupRequired || false,
+    pricingFrom: resolvedPricing,
+    unitPricingFrom: unitPricing,
+    ratePricing: availability.ratePricing,
+  };
+};
+
+const buildOctoUnitsPayload = units => (
+  (units || [])
+    .map(unit => {
+      if (!unit) return null;
+      const id = unit.unitId || unit.id;
+      if (!id) return null;
+      return {
+        id: id.toString(),
+        quantity: Number.isFinite(unit.quantity) ? unit.quantity : 1,
+      };
+    })
+    .filter(Boolean)
+);
+
+const getHeaders = ({
+  apiKey,
+}) => ({
+  Authorization: `Bearer ${apiKey}`,
+  'Content-Type': 'application/json',
+  'Octo-Capabilities': 'octo/pricing,octo/pickups,octo/cart,octo/offers,octo/questions',
+});
+
+const fetchAvailabilityForProduct = async ({
+  axios,
+  apiKey,
+  baseUrl,
+  productId,
+  startDate,
+  endDate,
+  currency,
+  optionId,
+  units,
+  availTypeDefs,
+  availQuery,
+  jwtKey,
+}) => {
+  const headers = getHeaders({
+    apiKey,
+  });
+
+  const payload = {
+    productId,
+    optionId,
+    localDateStart: startDate,
+    localDateEnd: endDate,
+    units: buildOctoUnitsPayload(units),
+  };
+  if (currency) payload.currency = currency;
+
+  try {
+    const response = await axios({
+      method: 'post',
+      url: `${baseUrl}/availability`,
+      data: payload,
+      headers,
+    });
+
+    const availabilities = R.pathOr([], ['data'], response);
+
+    const translated = await Promise.map(availabilities, async availability => {
+      const rootValue = buildAvailabilityRoot({
+        availability,
+        productId,
+        rateId: optionId,
+        units,
+        currency: (availability && availability.currency) || currency,
+      });
+
+      return translateAvailability({
+        rootValue,
+        typeDefs: availTypeDefs,
+        query: availQuery,
+        variableValues: {
+          productId: rootValue.productId,
+          optionId: rootValue.rateId,
+          currency: rootValue.currency,
+          unitsWithQuantity: units,
+          jwtKey,
+        },
+      });
+    }, { concurrency: CONCURRENCY });
+
+    return translated.filter(Boolean);
+  } catch (err) {
+    console.error(`Error fetching availability for product ${productId}:`, (err.response && err.response.data) || err.message);
+    return [];
+  }
+};
+
+class Plugin {
+  constructor(params) {
+    Object.entries(params).forEach(([attr, value]) => {
+      this[attr] = value;
+    });
+
+    // Use environment variables for testing if not provided
+    this.apiKey = this.apiKey || process.env.ti2_bokun_apiKey;
+    this.jwtKey = this.jwtKey
+      || process.env.TI2_BOKUN_JWT_KEY
+      || crypto.randomBytes(24).toString('hex');
+
+    this.tokenTemplate = () => ({
+      apiKey: {
+        type: 'text',
+        description: 'Bokun API key (Bearer token for OCTO API)',
+      },
+      endpoint: {
+        type: 'text',
+        // eslint-disable-next-line max-len
+        regExp: /^(?!mailto:)(?:(?:http|https|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]+-?)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]+-?)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))|localhost)(?::\d{2,5})?(?:(\/|\?|#)[^\s]*)?$/i,
+        default: 'https://api.bokun.io/octo/v1',
+        description: 'The Bokun API endpoint (use https://api.bokuntest.com/octo/v1 for testing)',
+      },
+      tenant: {
+        type: 'text',
+        // eslint-disable-next-line max-len
+        description: 'Bokun tenant subdomain for booking URL (e.g. tourconnect-llc). Enables privateUrl in booking information.',
+      },
+    });
+
+    this.errorPathsAxiosErrors = () => ([
+      ['response', 'data', 'message'],
+      ['response', 'data', 'error'],
+    ]);
+    this.errorPathsAxiosAny = () => ([]);
+  }
+
+  async validateToken({
+    axios,
+    token: {
+      endpoint,
+      apiKey,
+    },
+  }) {
+    assert(apiKey, 'apiKey is required for token validation');
+    assert(endpoint, 'endpoint is required for token validation');
+
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    const url = `${baseUrl}/supplier`;
+    const headers = getHeaders({ apiKey });
+    try {
+      const response = await axios({
+        method: 'get',
+        url,
+        headers,
+      });
+      // API returns a supplier object { id, name, endpoint, contact }, not an array
+      const { data } = response;
+      return Boolean(
+        data
+        && typeof data === 'object'
+        && !Array.isArray(data)
+        && (data.id != null || data.name != null),
+      );
+    } catch (err) {
+      console.error('Token validation error:', (err.response && err.response.data) || err.message);
+      return false;
+    }
+  }
+
+  async searchProducts({
+    axios,
+    token: {
+      apiKey,
+      endpoint,
+    },
+    typeDefsAndQueries: {
+      productTypeDefs,
+      productQuery,
+    },
+  }) {
+    assert(apiKey, 'apiKey is required for search products');
+    assert(endpoint, 'endpoint is required for search products');
+
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    const url = `${baseUrl}/products`;
+    const headers = getHeaders({ apiKey });
+
+    try {
+      const response = await axios({ method: 'get', url, headers });
+
+      let products = R.path(['data', 'products'], response) || R.path(['data'], response) || [];
+
+      if (!Array.isArray(products)) products = [products];
+
+      const translatedProducts = await Promise.map(products, async product => {
+        const translatedProduct = await translateProduct({
+          rootValue: product,
+          typeDefs: productTypeDefs,
+          query: productQuery,
+        });
+        return ({
+          ...translatedProduct,
+          supplierReference: product.id != null ? product.id.toString() : undefined,
+        });
+      }, { concurrency: CONCURRENCY });
+
+      return ({ products: translatedProducts });
+    } catch (err) {
+      console.error('Error searching products:', (err.response && err.response.data) || err.message);
+      return ({ products: [] });
+    }
+  }
+
+  async searchAvailability({
+    axios,
+    token: {
+      apiKey,
+      endpoint,
+    },
+    payload: {
+      productIds,
+      optionIds,
+      units,
+      startDate,
+      endDate,
+      dateFormat,
+      currency,
+    },
+    typeDefsAndQueries: {
+      availTypeDefs,
+      availQuery,
+    },
+  }) {
+    assert(apiKey, 'apiKey is required for search availability');
+    assert(endpoint, 'endpoint is required for search availability');
+    assert(this.jwtKey, 'jwtKey is required for search availability');
+
+    assert(Array.isArray(productIds) && productIds.length > 0, 'productIds are required');
+    const startMoment = moment(startDate, dateFormat).startOf('day');
+    const today = moment().startOf('day');
+    const effectiveStartMoment = startMoment.isBefore(today) ? today : startMoment;
+    const normalisedOptionIds = normaliseOptionIds(productIds, optionIds);
+    const normalisedUnits = normaliseUnits(productIds, units);
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    const startDateFormatted = effectiveStartMoment.format('YYYY-MM-DD');
+    const endDateFormatted = moment(endDate, dateFormat).format('YYYY-MM-DD');
+    const availabilityByProduct = await Promise.map(productIds, async (productId, index) => {
+      const optionId = normalisedOptionIds[index];
+      const productUnits = normalisedUnits[index] || [];
+
+      return fetchAvailabilityForProduct({
+        axios,
+        apiKey,
+        baseUrl,
+        productId,
+        startDate: startDateFormatted,
+        endDate: endDateFormatted,
+        currency,
+        optionId,
+        units: productUnits,
+        availTypeDefs,
+        availQuery,
+        jwtKey: this.jwtKey,
+      });
+    }, { concurrency: CONCURRENCY });
+
+    return ({ availability: availabilityByProduct });
+  }
+
+  async availabilityCalendar({
+    axios,
+    token: {
+      endpoint,
+      apiKey,
+    },
+    payload: {
+      productIds,
+      optionIds,
+      units,
+      startDate,
+      endDate,
+      currency,
+      dateFormat,
+    },
+    typeDefsAndQueries: {
+      availTypeDefs,
+      availQuery,
+    },
+  }) {
+    // Bokun API doesn't support calendar availability, so we need to use the
+    // search availability endpoint instead.
+    return this.searchAvailability({
+      axios,
+      token: { apiKey, endpoint },
+      payload: { productIds, optionIds, units, startDate, endDate, dateFormat, currency },
+      typeDefsAndQueries: { availTypeDefs, availQuery },
+    });
+  }
+
+  async getCreateBookingFields({ axios, token: { apiKey, endpoint }, query: { productId } }) {
+    const fields = [
+      { id: 'firstName', title: 'First name', type: 'short', required: true },
+      { id: 'lastName', title: 'Last name', type: 'short', required: true },
+      { id: 'emailAddress', title: 'Email', type: 'short', required: true },
+      { id: 'phoneNumber', title: 'Phone', type: 'short', required: false },
+      { id: 'country', title: 'Country', type: 'short', required: false },
+      { id: 'postalCode', title: 'Postal code', type: 'short', required: false },
+    ];
+    let customFields = [];
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    if (productId && apiKey && axios) {
+      try {
+        const productRes = await axios.get(`${baseUrl}/products/${productId}`, { headers: getHeaders({ apiKey }) });
+        const product = productRes && productRes.data;
+        const options = (product && product.options) || [];
+        const units = options.flatMap(opt => ((opt.units || []).map(u => ({ ...u, isPerUnitItem: true }))));
+        const allWithQuestions = [...options, ...units].filter(o => o.questions && o.questions.length);
+        const flattened = allWithQuestions.flatMap(
+          obj => (obj.questions || []).map(q => ({ ...q, isPerUnitItem: Boolean(obj.isPerUnitItem) })),
+        );
+        const byId = new Map();
+        flattened.forEach(q => {
+          const existing = byId.get(q.id);
+          const merged = !existing ? q : {
+            ...existing,
+            ...q,
+            isPerUnitItem: existing.isPerUnitItem || q.isPerUnitItem,
+          };
+          byId.set(q.id, merged);
+        });
+        customFields = Array.from(byId.values()).map(q => ({
+          id: String(q.id),
+          title: q.title || q.label || q.name || String(q.id),
+          type: (q.type === 'TEXTAREA' || q.inputType === 'textarea') ? 'long' : 'short',
+          required: Boolean(q.required),
+        }));
+      } catch (err) {
+        console.error('getCreateBookingFields: could not load product questions:', err.message);
+      }
+    }
+    return { fields, customFields };
+  }
+
+  async createBooking({
+    axios,
+    token: {
+      apiKey,
+      endpoint,
+      tenant,
+    },
+    payload: {
+      availabilityKey,
+      holder,
+      notes,
+      reference,
+      product,
+      unitItems,
+      currency,
+    },
+    typeDefsAndQueries: {
+      bookingTypeDefs,
+      bookingQuery,
+    },
+  }) {
+    assert(apiKey, 'apiKey is required for booking creation');
+    assert(endpoint, 'endpoint is required for booking creation');
+    assert(tenant, 'tenant is required for booking creation');
+    assert(this.jwtKey, 'JWT secret should be set for availability keys');
+    assert(holder.name, 'holder.name is required for booking creation');
+
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    let availabilityMetadata = {};
+
+    if (availabilityKey) {
+      try {
+        availabilityMetadata = jwt.verify(availabilityKey, this.jwtKey);
+      } catch (err) {
+        console.error('Error decoding availability key:', err.message);
+        throw new Error('Invalid availabilityKey');
+      }
+    }
+
+    // Extract required OCTO fields from availability metadata
+    const productId = (product && product.productId) || availabilityMetadata.productId;
+    const optionId = availabilityMetadata.optionId || availabilityMetadata.rateId;
+    const availabilityId = availabilityMetadata.availabilityId || availabilityMetadata.startTimeId;
+
+    if (!productId) {
+      throw new Error('productId is required for booking creation');
+    }
+    if (!optionId) {
+      throw new Error('optionId is required for booking creation');
+    }
+
+    // Build unitItems according to OCTO BookingUnitItem schema
+    const keyUnitItems = Array.isArray(availabilityMetadata.unitItems) ? availabilityMetadata.unitItems : [];
+    const finalUnitItems = Array.isArray(unitItems) && unitItems.length > 0
+      ? unitItems
+      : keyUnitItems;
+
+    // Transform unitItems to OCTO format: { unitId, uuid? }
+    const octoUnitItems = finalUnitItems.map(item => ({
+      unitId: item.unitId,
+      ...(item.uuid ? { uuid: item.uuid } : {}),
+    }));
+
+    if (octoUnitItems.length === 0) {
+      throw new Error('At least one unitItem is required for booking creation');
+    }
+
+    const bookingCurrency = currency
+      || availabilityMetadata.currency
+      || 'USD';
+
+    // Build OCTO BookingReservationBody per docs.octo.travel/octo-api-core/bookings
+    // Note: uuid (idempotency) and resellerReference are NOT in the reservation spec.
+    // resellerReference is sent in the confirm step only (POST /bookings/{uuid}/confirm).
+    const bookingReservationBody = {
+      productId,
+      optionId,
+      unitItems: octoUnitItems,
+      ...(availabilityId ? { availabilityId } : {}),
+      ...(notes ? { notes } : {}),
+      ...(bookingCurrency ? { currency: bookingCurrency } : {}),
+    };
+
+    // OCTO API endpoint: POST /api/octo/bookings/
+    // According to OCTO spec, the endpoint is /api/octo/bookings/ relative to base URL
+    // If TI2 adds /octo/v1 prefix, adjust path accordingly
+    const path = '/bookings';
+    const url = `${baseUrl}${path}`;
+    const headers = getHeaders({
+      apiKey,
+    });
+
+    try {
+      // Step 1: Create booking reservation (status: ON_HOLD)
+      // According to OCTO spec: POST /bookings/ creates a reservation
+      const bookingResponse = await axios({
+        method: 'post',
+        url,
+        headers,
+        data: bookingReservationBody,
+      });
+
+      if (bookingResponse.status < 200 || bookingResponse.status >= 300) {
+        const errorData = JSON.stringify(bookingResponse.data);
+        throw new Error(
+          `Booking reservation failed with status ${bookingResponse.status}: ${errorData}`,
+        );
+      }
+
+      const responseData = bookingResponse.data;
+      if (typeof responseData === 'string' && responseData.includes('<!DOCTYPE html>')) {
+        const htmlPreview = responseData.substring(0, 500);
+        console.error('Booking reservation returned HTML instead of JSON. Response:', htmlPreview);
+        throw new Error(
+          'Booking reservation failed: API returned HTML (likely authentication error or wrong endpoint)',
+        );
+      }
+
+      let booking = R.path(['data'], bookingResponse) || responseData;
+
+      if (!booking) {
+        console.error('Booking reservation response status:', bookingResponse.status);
+        console.error('Booking reservation response headers:', bookingResponse.headers);
+        const dataPreview = typeof responseData === 'string'
+          ? responseData.substring(0, 500)
+          : JSON.stringify(responseData, null, 2);
+        console.error('Booking reservation response data:', dataPreview);
+        throw new Error('Failed to create booking reservation: no booking data returned from API');
+      }
+
+      // Step 2: Confirm booking (if holder information is provided)
+      // According to OCTO spec: POST /bookings/{uuid}/confirm confirms the booking
+      if (holder && (holder.emailAddress || holder.name || holder.surname)) {
+        const bookingUuid = booking.uuid || booking.id;
+        if (!bookingUuid) {
+          console.warn('Booking created but no UUID found for confirmation');
+        } else {
+          const confirmPath = `/bookings/${bookingUuid}/confirm`;
+          const confirmUrl = `${baseUrl}${confirmPath}`;
+          const confirmHeaders = getHeaders({
+            apiKey,
+          });
+
+          // Build BookingConfirmationBody according to OCTO spec
+          const bookingConfirmationBody = {
+            contact: {
+              ...(holder.name ? { firstName: holder.name } : {}),
+              ...(holder.surname ? { lastName: holder.surname } : {}),
+              ...(holder.emailAddress ? { emailAddress: holder.emailAddress } : {}),
+              ...(holder.phoneNumber ? { phoneNumber: holder.phoneNumber } : {}),
+              ...(holder.country ? { country: holder.country } : {}),
+              ...(holder.postalCode ? { postalCode: holder.postalCode } : {}),
+              ...(holder.locales ? {
+                locales: Array.isArray(holder.locales) ? holder.locales : [holder.locales],
+              } : {}),
+              ...(notes ? { notes } : {}),
+            },
+            ...(reference ? { resellerReference: reference } : {}),
+            // Include unitItems if they need contact information per unit
+            ...(octoUnitItems.length > 0 ? {
+              unitItems: octoUnitItems.map(item => ({
+                unitId: item.unitId,
+                ...(item.uuid ? { uuid: item.uuid } : {}),
+              })),
+            } : {}),
+          };
+
+          try {
+            const confirmResponse = await axios({
+              method: 'post',
+              url: confirmUrl,
+              headers: confirmHeaders,
+              data: bookingConfirmationBody,
+            });
+
+            if (confirmResponse.status >= 200 && confirmResponse.status < 300) {
+              const confirmedBooking = R.path(['data'], confirmResponse) || confirmResponse.data;
+              if (confirmedBooking) {
+                booking = confirmedBooking;
+              }
+            } else {
+              const { status } = confirmResponse;
+              console.warn(
+                `Booking confirmation failed with status ${status}, but reservation was created`,
+              );
+            }
+          } catch (confirmErr) {
+            const errorMsg = (confirmErr.response && confirmErr.response.data) || confirmErr.message;
+            console.warn('Error confirming booking, but reservation was created:', errorMsg);
+            // Don't throw - reservation was successfully created, confirmation can be retried later
+          }
+        }
+      }
+
+      const baseUrlForSales = endpoint || this.endpoint || 'https://api.bokun.io/octo/v1';
+      const uiBaseUrl = getSalesBaseUrlFromEndpoint(baseUrlForSales, tenant || process.env.TI2_BOKUN_TENANT);
+      const translatedBooking = await translateBooking({
+        rootValue: { ...booking, uiBaseUrl },
+        typeDefs: bookingTypeDefs,
+        query: bookingQuery,
+      });
+      return ({ booking: translatedBooking });
+    } catch (err) {
+      console.error('Error creating booking:', (err.response && err.response.data) || err.message);
+      throw err;
+    }
+  }
+
+  // TODO: Verify with Bokun team on whether they have implemented this endpoint
+  // async cancelBooking({
+  //   axios,
+  //   token: {
+  //     apiKey,
+  //     endpoint,
+  //     tenant,
+  //   },
+  //   payload: {
+  //     bookingId,
+  //     id,
+  //     reason,
+  //   },
+  //   typeDefsAndQueries: {
+  //     bookingTypeDefs,
+  //     bookingQuery,
+  //   },
+  // }) {
+  //   assert(apiKey, 'apiKey is required for booking cancellation');
+  //   assert(endpoint, 'endpoint is required for booking cancellation');
+  //   assert(tenant, 'tenant is required for booking cancellation');
+
+  //   const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+  //   const bookingReference = bookingId || id;
+  //   const path = `/booking.json/${bookingReference}/cancel`;
+  //   const url = `${baseUrl}${path}`;
+  //   const headers = getHeaders({
+  //     apiKey,
+  //   });
+
+  //   try {
+  //     const response = await axios({
+  //       method: 'post',
+  //       url,
+  //       headers,
+  //       data: {
+  //         reason: reason || 'Customer requested cancellation',
+  //       },
+  //     });
+
+  //     const cancelledBooking = R.path(['data'], response);
+  //     const baseUrlForSales = endpoint || this.endpoint || 'https://api.bokun.io/octo/v1';
+  //     const uiBaseUrl = getSalesBaseUrlFromEndpoint(baseUrlForSales, tenant || process.env.TI2_BOKUN_TENANT);
+  //     const translatedBooking = await translateBooking({
+  //       rootValue: {
+  //         ...cancelledBooking,
+  //         status: 'CANCELLED',
+  //         uiBaseUrl,
+  //       },
+  //       typeDefs: bookingTypeDefs,
+  //       query: bookingQuery,
+  //     });
+
+  //     return ({ cancellation: translatedBooking });
+  //   } catch (err) {
+  //     console.error('Error cancelling booking:', (err.response && err.response.data) || err.message);
+  //     throw err;
+  //   }
+  // }
+
+  async searchBooking({
+    axios,
+    token: {
+      apiKey,
+      endpoint,
+      tenant,
+    },
+    payload: {
+      bookingId,
+      travelDateStart,
+      dateFormat,
+    },
+    typeDefsAndQueries: {
+      bookingTypeDefs,
+      bookingQuery,
+    },
+  }) {
+    assert(apiKey, 'apiKey is required for booking search');
+    assert(endpoint, 'endpoint is required for booking search');
+    assert(tenant, 'tenant is required for booking search');
+    assert(
+      !isNilOrEmpty(bookingId) || !isNilOrEmpty(travelDateStart),
+      'at least one of bookingId or travelDateStart is required',
+    );
+
+    const baseUrl = (endpoint || this.endpoint || 'https://api.bokun.io/octo/v1');
+    const queryParams = new URLSearchParams();
+    if (bookingId) queryParams.append('supplierReference', bookingId);
+
+    if (travelDateStart) {
+      const format = dateFormat || 'YYYY-MM-DD';
+      const travelDateFormatted = moment(travelDateStart, format).format('YYYY-MM-DD');
+      queryParams.append('localDate', travelDateFormatted);
+    }
+    const path = `/bookings?${queryParams.toString()}`;
+    const url = `${baseUrl}${path}`;
+    const headers = getHeaders({ apiKey });
+    try {
+      const response = await axios({ method: 'get', url, headers });
+      const data = R.path(['data'], response);
+      const rawBookings = Array.isArray(data) ? data : [].concat(data || []);
+      const baseUrlForSales = endpoint || this.endpoint || 'https://api.bokun.io/octo/v1';
+      const uiBaseUrl = getSalesBaseUrlFromEndpoint(baseUrlForSales, tenant || process.env.TI2_BOKUN_TENANT);
+      const translatedBookings = await Promise.map(rawBookings, async booking => translateBooking({
+        rootValue: { ...booking, uiBaseUrl },
+        typeDefs: bookingTypeDefs,
+        query: bookingQuery,
+      }));
+
+      return ({ bookings: translatedBookings });
+    } catch (err) {
+      console.error('Error searching booking:', (err.response && err.response.data) || err.message);
+      return ({ bookings: [] });
+    }
+  }
+}
+
+module.exports = Plugin;