ti2-tourplan 1.0.123 → 1.0.125

package/README.md

@@ -105,3 +105,68 @@ The plugin returns both:
   - `status`: aggregate over all `ServiceStatus.Status` values:
     - same status on all lines => that status (e.g. `XX`)
     - mixed line statuses => `MIXED`
+
+## Confirm Booking (HostConnect)
+
+This plugin converts a quote to a confirmed booking using HostConnect `QuoteToBookRequest`. Inventory is allocated for each service line when the quote is confirmed; the returned `ServiceStatus` values indicate whether allocation succeeded per line.
+
+### HostConnect XML Request
+
+```xml
+<Request>
+  <QuoteToBookRequest>
+    <AgentID>YOUR_AGENT_ID</AgentID>
+    <Password>YOUR_AGENT_PASSWORD</Password>
+    <BookingId>14226</BookingId>
+  </QuoteToBookRequest>
+</Request>
+```
+
+Equivalent curl:
+
+```bash
+curl --location 'https://<HOSTCONNECT_ENDPOINT>/api/hostConnectApi' \
+--header 'Content-Type: application/xml; charset=utf-8' \
+--header 'requestId: <uuid>' \
+--header 'Accept: application/xml' \
+--data '<Request>
+  <QuoteToBookRequest>
+    <AgentID>YOUR_AGENT_ID</AgentID>
+    <Password>YOUR_AGENT_PASSWORD</Password>
+    <BookingId>14226</BookingId>
+  </QuoteToBookRequest>
+</Request>'
+```
+
+### HostConnect XML Response (example)
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE Reply SYSTEM "hostConnect_5_05_010.dtd">
+<Reply>
+  <QuoteToBookReply>
+    <BookingId>14226</BookingId>
+    <Ref>A2IN111975</Ref>
+    <ServiceStatuses>
+      <ServiceStatus>
+        <Ref>A2IN111975</Ref>
+        <ServiceLineId>61738</ServiceLineId>
+        <Date>2026-07-03</Date>
+        <SequenceNumber>10</SequenceNumber>
+        <Status>OK</Status>
+      </ServiceStatus>
+    </ServiceStatuses>
+  </QuoteToBookReply>
+</Reply>
+```
+
+### Plugin Return Shape
+
+The plugin returns both:
+
+- `confirmBookingReply`: raw parsed HostConnect `QuoteToBookReply` object
+- `booking`: normalized object
+  - `ref`: from `Ref`
+  - `id`: from `BookingId` (or the identifier sent in the request)
+  - `status`: aggregate over all `ServiceStatus.Status` values (same rules as cancel), with fallbacks to `BookingStatus`, `Status`, `payload.status`, then `'Confirmed'`
+  - `serviceLines`: array of `{ ref, serviceLineId, date, sequenceNumber, status }`

package/__fixtures__/OptionInfoRequest_4f8b93072db9a52be70dc1f563c4b374de4eb0e6.txt

@@ -0,0 +1,77 @@
+<!-- LONTRDAVIDSHDWBVD: Fixture for searchProductsForItinerary Test -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE Reply SYSTEM "http://localhost:8080/iCom_Test/hostConnect_4_06_009.dtd">
+<Reply>
+    <OptionInfoReply>
+        <Option>
+            <Opt>LONTRDAVIDSHDWBVD</Opt>
+            <OptionNumber>70820</OptionNumber>
+            <OptGeneral>
+                <SupplierId>6489</SupplierId>
+                <SupplierName>Davids of London Ltd</SupplierName>
+                <Description>Half-Day Warner Bros Studios (6-Hours)</Description>
+                <Comment>FIT- V- Class (1-5 Pax)</Comment>
+                <Locality>LON</Locality>
+                <LocalityDescription>London</LocalityDescription>
+                <SType>N</SType>
+                <MPFCU>5</MPFCU>
+                <SCU>day</SCU>
+                <MinSCU>1</MinSCU>
+                <MaxSCU>9999</MaxSCU>
+                <VoucherName>Davids of London Ltd</VoucherName>
+                <Address1>377 Fulham Palace Road</Address1>
+                <Address2></Address2>
+                <Address3>London</Address3>
+                <Address4>United Kingdom</Address4>
+                <Address5></Address5>
+                <PostCode>SW6 6TA</PostCode>
+                <InfantsAllowed>Y</InfantsAllowed>
+                <Infant_From>0</Infant_From>
+                <Infant_To>4</Infant_To>
+                <ChildrenAllowed>Y</ChildrenAllowed>
+                <Child_From>5</Child_From>
+                <Child_To>15</Child_To>
+                <AdultsAllowed>Y</AdultsAllowed>
+                <Adult_From>16</Adult_From>
+                <Adult_To>999</Adult_To>
+                <ButtonName>Transfers</ButtonName>
+                <DBAnalysisCode1>FI</DBAnalysisCode1>
+                <DBAnalysisDescription1>FIT</DBAnalysisDescription1>
+                <DBAnalysisCode2>GB</DBAnalysisCode2>
+                <DBAnalysisDescription2>United Kingdom</DBAnalysisDescription2>
+                <DBAnalysisCode3>20</DBAnalysisCode3>
+                <DBAnalysisDescription3>VAT 20%</DBAnalysisDescription3>
+                <DBAnalysisCode4></DBAnalysisCode4>
+                <DBAnalysisDescription4>Unassigned</DBAnalysisDescription4>
+                <DBAnalysisCode5></DBAnalysisCode5>
+                <DBAnalysisDescription5>Unassigned</DBAnalysisDescription5>
+                <DBAnalysisCode6></DBAnalysisCode6>
+                <DBAnalysisDescription6>Unassigned</DBAnalysisDescription6>
+                <LastUpdate>2023-11-23T14:34:53Z</LastUpdate>
+            </OptGeneral>
+            <OptRates>
+                <Currency>GBP</Currency>
+                <PaxBreaks>
+                    <PaxBreak>1</PaxBreak>
+                </PaxBreaks>
+                <CancelPolicies>
+                    <CancelPenalty>
+                        <CancelRuleType>Percent</CancelRuleType>
+                        <CancelRuleUnits>100.00</CancelRuleUnits>
+                    </CancelPenalty>
+                </CancelPolicies>
+                <SaleFrom>2026-01-01</SaleFrom>
+                <SaleTo>2026-12-31</SaleTo>
+                <OptRate>
+                    <Date>2026-06-01</Date>
+                    <RateName>STD</RateName>
+                    <RateText>Standard</RateText>
+                    <CommissionPercent>10.00</CommissionPercent>
+                    <PersonRates>
+                        <AdultRate>10000</AdultRate>
+                    </PersonRates>
+                </OptRate>
+            </OptRates>
+        </Option>
+    </OptionInfoReply>
+</Reply>

package/__snapshots__/index.test.js.snap

@@ -4153,6 +4153,29 @@ Object {
           "comment": "FIT- V- Class (1-5 Pax)",
           "extras": Array [],
           "lastUpdateTimestamp": 1700750093,
+          "optRates": Object {
+            "CancelPolicies": Object {
+              "CancelPenalty": Object {
+                "CancelRuleType": "Percent",
+                "CancelRuleUnits": 100,
+              },
+            },
+            "Currency": "GBP",
+            "OptRate": Object {
+              "CommissionPercent": 10,
+              "Date": "2026-06-01",
+              "PersonRates": Object {
+                "AdultRate": 10000,
+              },
+              "RateName": "STD",
+              "RateText": "Standard",
+            },
+            "PaxBreaks": Object {
+              "PaxBreak": 1,
+            },
+            "SaleFrom": "2026-01-01",
+            "SaleTo": "2026-12-31",
+          },
           "optionId": "LONTRDAVIDSHDWBVD",
           "optionName": "Half-Day Warner Bros Studios (6-Hours)-FIT- V- Class (1-5 Pax)",
           "restrictions": Object {

package/index.js

@@ -11,6 +11,7 @@ const Normalizer = require('./normalizer');
 const { searchAvailabilityForItinerary } = require('./availability/itinerary-availability');
 const { addServiceToItinerary } = require('./itinerary-add-service');
 const { cancelBooking } = require('./itinerary-cancel-booking');
+const { confirmBooking } = require('./itinerary-confirm-booking');
 const { searchProductsForItinerary } = require('./itinerary-products-search');
 const { searchItineraries } = require('./itinerary-search');
 const { hostConnectXmlOptions } = require('./utils');
@@ -680,6 +681,9 @@ class BuyerPlugin {
     });
   }
 
+  /**
+   * Cancel a booking.
+   */
   async cancelBooking({
     axios,
     token,
@@ -693,6 +697,22 @@ class BuyerPlugin {
     });
   }
 
+  /**
+   * Convert a quote to a confirmed booking.
+   */
+  async confirmBooking({
+    axios,
+    token,
+    payload,
+  }) {
+    return confirmBooking({
+      axios,
+      token,
+      payload,
+      callTourplan: this.callTourplan.bind(this),
+    });
+  }
+
   async searchItineraries({
     axios,
     typeDefsAndQueries,

package/index.test.js

@@ -274,6 +274,163 @@ describe('search tests', () => {
           },
         });
       });
+
+      it('requires a booking id or reference', async () => {
+        await expect(app.cancelBooking({
+          axios,
+          token,
+          payload: {},
+        })).rejects.toThrow('Must provide booking id or reference for cancellation');
+        expect(mockCallTourplan).not.toHaveBeenCalled();
+      });
+    });
+    describe('confirmBooking', () => {
+      it('converts a quote to a booking by id', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          QuoteToBookReply: {
+            BookingId: '14226',
+            Ref: 'A2IN111975',
+            ServiceStatuses: {
+              ServiceStatus: {
+                Ref: 'A2IN111975',
+                ServiceLineId: '61738',
+                Date: '2026-07-03',
+                SequenceNumber: '10',
+                Status: 'OK',
+              },
+            },
+          },
+        }));
+        const retVal = await app.confirmBooking({
+          axios,
+          token,
+          payload: {
+            bookingId: '14226',
+          },
+        });
+        expect(mockCallTourplan).toHaveBeenNthCalledWith(1, expect.objectContaining({
+          model: {
+            QuoteToBookRequest: expect.objectContaining({
+              BookingId: '14226',
+            }),
+          },
+        }));
+        expect(retVal).toEqual({
+          confirmBookingReply: {
+            BookingId: '14226',
+            Ref: 'A2IN111975',
+            ServiceStatuses: {
+              ServiceStatus: {
+                Ref: 'A2IN111975',
+                ServiceLineId: '61738',
+                Date: '2026-07-03',
+                SequenceNumber: '10',
+                Status: 'OK',
+              },
+            },
+          },
+          booking: {
+            ref: 'A2IN111975',
+            id: '14226',
+            status: 'OK',
+            serviceLines: [{
+              ref: 'A2IN111975',
+              serviceLineId: '61738',
+              date: '2026-07-03',
+              sequenceNumber: '10',
+              status: 'OK',
+            }],
+          },
+        });
+      });
+
+      it('converts a quote to a booking by ref', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          QuoteToBookReply: {
+            BookingId: '14226',
+            Ref: 'A2IN111975',
+            ServiceStatuses: {
+              ServiceStatus: [{
+                ServiceLineId: '61738',
+                Date: '2026-07-03',
+                SequenceNumber: '10',
+                Status: 'OK',
+              }],
+            },
+          },
+        }));
+        const retVal = await app.confirmBooking({
+          axios,
+          token,
+          payload: {
+            ref: 'A2IN111975',
+          },
+        });
+        expect(mockCallTourplan).toHaveBeenNthCalledWith(1, expect.objectContaining({
+          model: {
+            QuoteToBookRequest: expect.objectContaining({
+              Ref: 'A2IN111975',
+            }),
+          },
+        }));
+        expect(retVal.booking.id).toBe('14226');
+        expect(retVal.booking.ref).toBe('A2IN111975');
+        expect(retVal.booking.status).toBe('OK');
+      });
+
+      it('returns MIXED status when service line statuses differ', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          QuoteToBookReply: {
+            BookingId: '14226',
+            Ref: 'A2IN111975',
+            ServiceStatuses: {
+              ServiceStatus: [{
+                ServiceLineId: '61738',
+                Status: 'OK',
+              }, {
+                ServiceLineId: '61739',
+                Status: 'RQ',
+              }],
+            },
+          },
+        }));
+        const retVal = await app.confirmBooking({
+          axios,
+          token,
+          payload: {
+            bookingId: '14226',
+          },
+        });
+        expect(retVal.booking.status).toBe('MIXED');
+        expect(retVal.booking.serviceLines).toHaveLength(2);
+      });
+
+      it('requires a booking id or reference', async () => {
+        await expect(app.confirmBooking({
+          axios,
+          token,
+          payload: {},
+        })).rejects.toThrow('Must provide booking id or reference for confirm booking');
+        expect(mockCallTourplan).not.toHaveBeenCalled();
+      });
+
+      it('falls back to Confirmed when no service statuses are returned', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          QuoteToBookReply: {
+            BookingId: '14226',
+            Ref: 'A2IN111975',
+          },
+        }));
+        const retVal = await app.confirmBooking({
+          axios,
+          token,
+          payload: {
+            bookingId: '14226',
+          },
+        });
+        expect(retVal.booking.status).toBe('Confirmed');
+        expect(retVal.booking.serviceLines).toEqual([]);
+      });
     });
     describe('template tests', () => {
       let template;

package/itinerary-cancel-booking.js

@@ -2,49 +2,17 @@ const assert = require('assert');
 const R = require('ramda');
 const {
   hostConnectXmlOptions,
-  escapeInvalidXmlChars,
 } = require('./utils');
-
-const getIdentifier = payload => {
-  const bookingId = payload.bookingId || payload.id;
-  if (bookingId) {
-    return {
-      field: 'BookingId',
-      value: String(bookingId),
-    };
-  }
-  const bookingRef = payload.ref || payload.reference;
-  if (bookingRef) {
-    return {
-      field: 'Ref',
-      value: escapeInvalidXmlChars(String(bookingRef)),
-    };
-  }
-  return null;
-};
+const {
+  getBookingIdentifier,
+  getAggregateServiceStatus,
+} = require('./itinerary-hostconnect-helpers');
 
 const extractCancellationReply = replyObj => (
   R.path(['CancelServicesReply'], replyObj)
   || {}
 );
 
-const getServiceStatusList = cancellationReply => {
-  let serviceStatuses = R.pathOr([], ['ServiceStatuses', 'ServiceStatus'], cancellationReply);
-  if (!Array.isArray(serviceStatuses)) serviceStatuses = [serviceStatuses];
-  return serviceStatuses
-    .map(serviceStatus => R.path(['Status'], serviceStatus))
-    .filter(Boolean)
-    .map(status => String(status).toUpperCase());
-};
-
-const getAggregateServiceStatus = cancellationReply => {
-  const statuses = getServiceStatusList(cancellationReply);
-  if (!statuses.length) return null;
-  const uniqueStatuses = [...new Set(statuses)];
-  if (uniqueStatuses.length === 1) return uniqueStatuses[0];
-  return 'MIXED';
-};
-
 const normalizeCancellationResponse = (replyObj, payload, identifier) => {
   const cancellationReply = extractCancellationReply(replyObj);
   const aggregateServiceStatus = getAggregateServiceStatus(cancellationReply);
@@ -62,13 +30,7 @@ const normalizeCancellationResponse = (replyObj, payload, identifier) => {
 };
 
 /**
- * Cancels a booking by id or reference
- * @param {Object} params - The parameters for the cancellation
- * @param {Object} params.axios - The axios instance
- * @param {Object} params.token - The token for the cancellation
- * @param {Object} params.payload - The payload for the cancellation
- * @param {Object} params.callTourplan - The callTourplan function
- * @returns {Promise<Object>} The cancellation response
+ * Cancels a booking by id or reference via HostConnect CancelServicesRequest.
  */
 const cancelBooking = async ({
   axios,
@@ -83,7 +45,7 @@ const cancelBooking = async ({
   assert(hostConnectEndpoint, 'Must provide token.hostConnectEndpoint for booking cancellation');
   assert(hostConnectAgentID, 'Must provide token.hostConnectAgentID for booking cancellation');
   assert(hostConnectAgentPassword, 'Must provide token.hostConnectAgentPassword for booking cancellation');
-  const identifier = getIdentifier(payload);
+  const identifier = getBookingIdentifier(payload);
   assert(identifier, 'Must provide booking id or reference for cancellation');
 
   const baseRequest = {

package/itinerary-confirm-booking.js

@@ -0,0 +1,72 @@
+const assert = require('assert');
+const R = require('ramda');
+const { hostConnectXmlOptions } = require('./utils');
+const {
+  getBookingIdentifier,
+  getAggregateServiceStatus,
+  mapServiceStatusLines,
+} = require('./itinerary-hostconnect-helpers');
+
+const extractConfirmBookingReply = replyObj => (
+  R.path(['QuoteToBookReply'], replyObj)
+  || {}
+);
+
+const normalizeConfirmBookingResponse = (replyObj, payload, identifier) => {
+  const confirmBookingReply = extractConfirmBookingReply(replyObj);
+  const aggregateServiceStatus = getAggregateServiceStatus(confirmBookingReply);
+  return {
+    confirmBookingReply,
+    booking: {
+      ref: R.path(['Ref'], confirmBookingReply),
+      id: R.path(['BookingId'], confirmBookingReply) || identifier.value,
+      status: aggregateServiceStatus
+        || R.path(['BookingStatus'], confirmBookingReply)
+        || R.path(['Status'], confirmBookingReply)
+        || payload.status
+        || 'Confirmed',
+      serviceLines: mapServiceStatusLines(confirmBookingReply),
+    },
+  };
+};
+
+/**
+ * Converts a quote to a confirmed booking via HostConnect QuoteToBookRequest.
+ * Inventory is allocated for each service line; returned ServiceStatus values
+ * indicate whether allocation succeeded per line.
+ */
+const confirmBooking = async ({
+  axios,
+  token: {
+    hostConnectEndpoint,
+    hostConnectAgentID,
+    hostConnectAgentPassword,
+  },
+  payload = {},
+  callTourplan,
+}) => {
+  assert(hostConnectEndpoint, 'Must provide token.hostConnectEndpoint for confirm booking');
+  assert(hostConnectAgentID, 'Must provide token.hostConnectAgentID for confirm booking');
+  assert(hostConnectAgentPassword, 'Must provide token.hostConnectAgentPassword for confirm booking');
+  const identifier = getBookingIdentifier(payload);
+  assert(identifier, 'Must provide booking id or reference for confirm booking');
+
+  const baseRequest = {
+    AgentID: hostConnectAgentID,
+    Password: hostConnectAgentPassword,
+    [identifier.field]: identifier.value,
+  };
+  const replyObj = await callTourplan({
+    model: {
+      QuoteToBookRequest: baseRequest,
+    },
+    endpoint: hostConnectEndpoint,
+    axios,
+    xmlOptions: hostConnectXmlOptions,
+  });
+  return normalizeConfirmBookingResponse(replyObj, payload, identifier);
+};
+
+module.exports = {
+  confirmBooking,
+};

package/itinerary-hostconnect-helpers.js

@@ -0,0 +1,52 @@
+const R = require('ramda');
+const { escapeInvalidXmlChars } = require('./utils');
+
+const getBookingIdentifier = payload => {
+  const bookingId = payload.bookingId || payload.id;
+  if (bookingId) {
+    return {
+      field: 'BookingId',
+      value: String(bookingId),
+    };
+  }
+  const bookingRef = payload.ref || payload.reference;
+  if (bookingRef) {
+    return {
+      field: 'Ref',
+      value: escapeInvalidXmlChars(String(bookingRef)),
+    };
+  }
+  return null;
+};
+
+const toServiceStatusArray = reply => {
+  let serviceStatuses = R.pathOr([], ['ServiceStatuses', 'ServiceStatus'], reply);
+  if (!Array.isArray(serviceStatuses)) serviceStatuses = [serviceStatuses];
+  return serviceStatuses.filter(Boolean);
+};
+
+const getAggregateServiceStatus = reply => {
+  const statuses = toServiceStatusArray(reply)
+    .map(serviceStatus => R.path(['Status'], serviceStatus))
+    .filter(Boolean)
+    .map(status => String(status).toUpperCase());
+  if (!statuses.length) return null;
+  const uniqueStatuses = [...new Set(statuses)];
+  if (uniqueStatuses.length === 1) return uniqueStatuses[0];
+  return 'MIXED';
+};
+
+const mapServiceStatusLines = reply => toServiceStatusArray(reply).map(serviceStatus => ({
+  ref: R.path(['Ref'], serviceStatus),
+  serviceLineId: R.path(['ServiceLineId'], serviceStatus),
+  date: R.path(['Date'], serviceStatus),
+  sequenceNumber: R.path(['SequenceNumber'], serviceStatus),
+  status: R.path(['Status'], serviceStatus),
+}));
+
+module.exports = {
+  getBookingIdentifier,
+  toServiceStatusArray,
+  getAggregateServiceStatus,
+  mapServiceStatusLines,
+};

package/itinerary-products-search.js

@@ -18,7 +18,6 @@ const searchProductsForItinerary = async ({
   payload: {
     // single optionId or array of optionIds
     optionId,
-    forceRefresh,
     searchInput,
     // lastUpdatedFrom is used to get options that were updated after a certain date in Tourplan
     // example: lastUpdatedFrom: '2024-04-22 05:17:57.427Z'
@@ -26,55 +25,84 @@ const searchProductsForItinerary = async ({
   },
   callTourplan,
 }) => {
-  /*
-    Pseudo
-    1. getServiceCodes -> [AC, BD]
-    2. for each serviceCode getoptions
-    3. convert them to ti2 products structure
-    4. merge all products from all serviceCodes
-  */
-  // getServices
-  const getServicesModel = {
-    GetServicesRequest: {
-      AgentID: hostConnectAgentID,
-      Password: hostConnectAgentPassword,
-    },
-  };
-  const getServicesReply = await callTourplan({
-    model: getServicesModel,
-    endpoint: hostConnectEndpoint,
-    axios,
-    xmlOptions: hostConnectXmlOptions,
-  });
-  let serviceCodes = R.pathOr([], ['GetServicesReply', 'TPLServices', 'TPLService'], getServicesReply);
-  if (!Array.isArray(serviceCodes)) serviceCodes = [serviceCodes];
-  serviceCodes = serviceCodes.map(s => s.Code);
+  // Normalise optionId to an array (or empty)
+  const optionIds = optionId
+    ? (Array.isArray(optionId) ? optionId : [optionId]).filter(Boolean)
+    : [];
+
   let options = [];
-  await Promise.each(serviceCodes, async serviceCode => {
-    const getOptionsModel = {
-      OptionInfoRequest: {
-        Opt: `???${serviceCode}????????????`,
-        Info: 'G',
+
+  if (optionIds.length > 0) {
+    // Fast path: fetch only the requested option(s) by their exact Opt code,
+    // skipping the expensive full-catalog GetServices + wildcard OptionInfo calls.
+    await Promise.each(optionIds, async id => {
+      const getOptionsModel = {
+        OptionInfoRequest: {
+          Opt: id,
+          Info: 'GR',
+          AgentID: hostConnectAgentID,
+          Password: hostConnectAgentPassword,
+        },
+      };
+      const getOptionsReply = await callTourplan({
+        model: getOptionsModel,
+        endpoint: hostConnectEndpoint,
+        axios,
+        xmlOptions: hostConnectXmlOptions,
+      });
+      let thisOptions = R.pathOr([], ['OptionInfoReply', 'Option'], getOptionsReply);
+      if (!Array.isArray(thisOptions)) thisOptions = [thisOptions];
+      options = options.concat(thisOptions);
+    });
+  } else {
+    /*
+      Full catalog path:
+      1. getServiceCodes -> [AC, BD]
+      2. for each serviceCode getoptions
+      3. convert them to ti2 products structure
+      4. merge all products from all serviceCodes
+    */
+    // getServices
+    const getServicesModel = {
+      GetServicesRequest: {
         AgentID: hostConnectAgentID,
         Password: hostConnectAgentPassword,
-        ...(lastUpdatedFrom ? {
-          LastUpdateFrom: lastUpdatedFrom,
-        } : {}),
       },
     };
-    const getOptionsReply = await callTourplan({
-      model: getOptionsModel,
+    const getServicesReply = await callTourplan({
+      model: getServicesModel,
       endpoint: hostConnectEndpoint,
       axios,
       xmlOptions: hostConnectXmlOptions,
     });
-    let thisOptions = R.pathOr([], ['OptionInfoReply', 'Option'], getOptionsReply);
-    // due to the new parser, single option will be returned as an object
-    // instead of an array
-    if (!Array.isArray(thisOptions)) thisOptions = [thisOptions];
-    console.log(`got ${thisOptions.length} options for serviceCode ${serviceCode}`);
-    options = options.concat(thisOptions);
-  });
+    let serviceCodes = R.pathOr([], ['GetServicesReply', 'TPLServices', 'TPLService'], getServicesReply);
+    if (!Array.isArray(serviceCodes)) serviceCodes = [serviceCodes];
+    serviceCodes = serviceCodes.map(s => s.Code);
+    await Promise.each(serviceCodes, async serviceCode => {
+      const getOptionsModel = {
+        OptionInfoRequest: {
+          Opt: `???${serviceCode}????????????`,
+          Info: 'G',
+          AgentID: hostConnectAgentID,
+          Password: hostConnectAgentPassword,
+          ...(lastUpdatedFrom ? {
+            LastUpdateFrom: lastUpdatedFrom,
+          } : {}),
+        },
+      };
+      const getOptionsReply = await callTourplan({
+        model: getOptionsModel,
+        endpoint: hostConnectEndpoint,
+        axios,
+        xmlOptions: hostConnectXmlOptions,
+      });
+      let thisOptions = R.pathOr([], ['OptionInfoReply', 'Option'], getOptionsReply);
+      // due to the new parser, single option will be returned as an object
+      // instead of an array
+      if (!Array.isArray(thisOptions)) thisOptions = [thisOptions];
+      options = options.concat(thisOptions);
+    });
+  }
   if (!(options && options.length)) {
     throw new Error('No products found');
   }
@@ -95,8 +123,27 @@ const searchProductsForItinerary = async ({
       concurrency: 10,
     },
   );
+  // Preserve raw OptRates from Tourplan in product search response when available.
+  const optionRatesByOptionId = options.reduce((acc, option) => {
+    const currentOptionId = R.path(['Opt'], option);
+    const currentOptionRates = R.path(['OptRates'], option);
+    if (!currentOptionId || !currentOptionRates) return acc;
+    return {
+      ...acc,
+      [currentOptionId]: currentOptionRates,
+    };
+  }, {});
+  const productsWithOptRates = products.map(product => ({
+    ...product,
+    options: R.pathOr([], ['options'], product).map(currentOption => ({
+      ...currentOption,
+      ...(R.path([currentOption.optionId], optionRatesByOptionId)
+        ? { optRates: R.path([currentOption.optionId], optionRatesByOptionId) }
+        : {}),
+    })),
+  }));
   return {
-    products,
+    products: productsWithOptRates,
     productFields: [],
     ...(searchInput || optionId ? {} : configuration),
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-tourplan",
-  "version": "1.0.123",
+  "version": "1.0.125",
   "description": "Tourplan's TI2 Plugin",
   "main": "index.js",
   "scripts": {
@@ -39,7 +39,7 @@
     "jsonwebtoken": "^8.5.1",
     "moment": "^2.29.1",
     "ramda": "^0.27.1",
-    "ti2": "^1.0.111",
+    "ti2": "^1.0.118",
     "underscore": "^1.13.4",
     "xml-js": "^1.6.11",
     "xml2js": "^0.4.23"