ti2-tourplan 1.0.138 → 1.0.140

package/__snapshots__/index.test.js.snap

@@ -4151,6 +4151,7 @@ Object {
       "description": null,
       "options": Array [
         Object {
+          "chargeUnit": "day",
           "city": "London",
           "comment": "FIT- V- Class (1-5 Pax)",
           "country": "United Kingdom",

package/index.test.js

@@ -36,6 +36,11 @@ jest.mock('axios');
 
 // Default callTourplan mock: resolve HostConnect replies from __fixtures__.
 const defaultCallTourplanImplementation = async ({ model, endpoint }) => {
+  // Supplier notes are optional. Product search must not depend on a fixture
+  // for the unfiltered SupplierInfo request.
+  if (model.SupplierInfoRequest) {
+    return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+  }
   // Create a mock request object similar to what axios would receive
   const requestType = Object.keys(model)[0]; // Gets 'OptionInfoRequest'
 
@@ -339,6 +344,100 @@ describe('search tests', () => {
         expect(request.Remarks).toBe(`Passenger Notes: ${'A'.repeat(43)}`);
         expect(request.Remarks).toHaveLength(60);
       });
+
+      it.each([
+        ['an exact boundary reference', { reference: 'A'.repeat(60) }, 'A'.repeat(60)],
+        ['an overlong reference', { reference: 'B'.repeat(61) }, 'B'.repeat(60)],
+        ['a long itinerary description', {
+          reference: 'A detailed anniversary itinerary with transfers, hotels, touring, and extra arrangements',
+        }, 'A detailed anniversary itinerary with transfers, hotels, tou'],
+        ['the fallback reference', { reference: ' FALLBACK-REFERENCE ' }, 'FALLBACK-REFERENCE'],
+        ['the preferred agentRef', {
+          agentRef: ' AGENT-PICKED ',
+          reference: 'REFERENCE-IGNORED',
+        }, 'AGENT-PICKED'],
+        ['a value that expands during sanitization', { agentRef: 'Ä'.repeat(40) }, 'Ae'.repeat(30)],
+        ['invalid XML characters', { agentRef: '  REF\u0000WITH\u0001CONTROL  ' }, 'REFWITHCONTROL'],
+      ])('normalizes AgentRef from %s without changing the payload', async (
+        description,
+        sourceFields,
+        expected,
+      ) => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+        const payload = {
+          quoteName: `Agent reference test: ${description}`,
+          optionId: 'ABC123',
+          startDate: '2026-07-03',
+          paxConfigs: [{ roomType: 'Double', adults: 2 }],
+          notes: '',
+          ...sourceFields,
+        };
+        const originalPayload = { ...payload };
+
+        await app.addServiceToItinerary({ axios, token, payload });
+
+        const agentReference = mockCallTourplan.mock.calls[0][0].model.AddServiceRequest.AgentRef;
+        expect(agentReference).toBe(expected);
+        expect(Array.from(agentReference).length).toBeLessThanOrEqual(60);
+        expect(payload).toEqual(originalPayload);
+
+        const requestXml = js2xmlparser.parse(
+          'Request',
+          mockCallTourplan.mock.calls[0][0].model,
+          hostConnectXmlOptions,
+        );
+        expect(requestXml.indexOf('<SCUqty>')).toBeLessThan(requestXml.indexOf('<AgentRef>'));
+        expect(requestXml.indexOf('<AgentRef>')).toBeLessThan(requestXml.indexOf('<RoomConfigs>'));
+      });
+
+      it('omits AgentRef when the selected source sanitizes to empty', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+
+        await app.addServiceToItinerary({
+          axios,
+          token,
+          payload: {
+            quoteName: 'Empty agent reference',
+            optionId: 'ABC123',
+            startDate: '2026-07-03',
+            agentRef: ' \u0001 ',
+            reference: 'REFERENCE-IGNORED',
+            paxConfigs: [{ roomType: 'Double', adults: 2 }],
+            notes: '',
+          },
+        });
+
+        expect(mockCallTourplan.mock.calls[0][0].model.AddServiceRequest.AgentRef).toBeUndefined();
+      });
+
+      it('normalizes a direct-line AgentRef override without changing XML element order', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+
+        await app.addServiceToItinerary({
+          axios,
+          token,
+          payload: {
+            quoteName: 'Direct override agent reference',
+            optionId: 'ABC123',
+            startDate: '2026-07-03',
+            reference: 'REFERENCE-IGNORED',
+            paxConfigs: [{ roomType: 'Double', adults: 2 }],
+            notes: '',
+            directLinePayload: { AgentRef: 'D'.repeat(61) },
+          },
+        });
+
+        const model = mockCallTourplan.mock.calls[0][0].model;
+        expect(model.AddServiceRequest.AgentRef).toBe('D'.repeat(60));
+        const requestXml = js2xmlparser.parse('Request', model, hostConnectXmlOptions);
+        expect(requestXml.indexOf('<AgentRef>')).toBeLessThan(requestXml.indexOf('<RoomConfigs>'));
+      });
     });
 
     describe('cancelBooking', () => {
@@ -932,6 +1031,91 @@ describe('search tests', () => {
     expect(retVal).toMatchSnapshot();
   });
 
+  it('keeps class, charge unit, Other, infant cap, and supplier note on the stock schema', async () => {
+    mockCallTourplan.mockImplementation(async ({ model }) => {
+      if (model.AgentInfoRequest) {
+        return { AgentInfoReply: { Currency: 'GBP' } };
+      }
+      if (model.GetLocationsRequest) {
+        return { GetLocationsReply: { Locations: { Location: [] } } };
+      }
+      if (model.GetServicesRequest) {
+        return { GetServicesReply: { TPLServices: { TPLService: [] } } };
+      }
+      if (model.GetSystemSettingsRequest) {
+        return { GetSystemSettingsReply: { Countries: { Country: [] } } };
+      }
+      if (model.SupplierInfoRequest) {
+        return {
+          SupplierInfoReply: {
+            Suppliers: {
+              Supplier: {
+                SupplierId: '7318',
+                Name: 'Example Hotel',
+                SupplierNotes: {
+                  SupplierNote: { NoteText: '  Family owned hotel  ' },
+                },
+              },
+            },
+          },
+        };
+      }
+      if (model.OptionInfoRequest) {
+        return {
+          OptionInfoReply: {
+            Option: {
+              Opt: 'LONHOEXAMPLESTD',
+              OptGeneral: {
+                SupplierId: '7318',
+                SupplierName: 'Example Hotel',
+                Description: 'Standard Room',
+                Class: '3*',
+                ClassDescription: '3 Star',
+                SCU: 'Night',
+                SType: 'Y',
+                ButtonName: 'Accommodation',
+                Single_Avail: 'Y',
+                Single_Max: '0',
+                Single_Ad_Max: '2',
+                Single_Max_With_Infants: '1',
+                Other_Avail: 'Y',
+                Other_Max: '4',
+                Other_Ad_Max: '3',
+                Other_Max_With_Infants: '5',
+              },
+            },
+          },
+        };
+      }
+      return {};
+    });
+
+    const retVal = await app.searchProductsForItinerary({
+      axios,
+      token,
+      typeDefsAndQueries,
+      payload: { optionId: 'LONHOEXAMPLESTD' },
+    });
+    const option = retVal.products[0].options[0];
+    expect(retVal.products[0].description).toBe('Family owned hotel');
+    expect(option.optionClass).toBe('3 Star');
+    expect(option.chargeUnit).toBe('night');
+    expect(option.restrictions.Single.maxPax).toBe(0);
+    expect(option.restrictions.Single.maxPaxWithInfants).toBe(1);
+    expect(option.restrictions.Other).toEqual({
+      allowed: true,
+      maxPax: 4,
+      maxAdults: 3,
+      maxPaxWithInfants: 5,
+    });
+    expect(option.units.map(unit => unit.unitId)).toEqual([
+      'Single', 'Twin', 'Double', 'Triple', 'Quad', 'Other',
+    ]);
+    const single = option.units.find(unit => unit.unitId === 'Single');
+    expect(single.restrictions.maxPax).toBe(0);
+    expect(single.restrictions.maxPaxWithInfants).toBe(1);
+  });
+
   describe('searchProductsForItinerary pickupPoints', () => {
     const singlePickupPoint = {
       Point_ID: '504',
@@ -956,6 +1140,9 @@ describe('search tests', () => {
         if (model.GetSystemSettingsRequest) {
           return { GetSystemSettingsReply: { Countries: { Country: [] } } };
         }
+        if (model.SupplierInfoRequest) {
+          return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+        }
         if (model.OptionInfoRequest) {
           return {
             OptionInfoReply: {
@@ -1209,6 +1396,9 @@ describe('search tests', () => {
     const mockFullCatalog = ({ throwOnOpt } = {}) => {
       mockCallTourplan.mockImplementation(async ({ model }) => {
         if (model.GetServicesRequest) return getServicesReply;
+        if (model.SupplierInfoRequest) {
+          return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+        }
         const opt = model.OptionInfoRequest && model.OptionInfoRequest.Opt;
         if (throwOnOpt && throwOnOpt.includes(opt)) {
           throw new Error(`${opt} OptionInfo should have been skipped`);
@@ -1278,6 +1468,9 @@ describe('search tests', () => {
           if (model.GetSystemSettingsRequest) {
             return { GetSystemSettingsReply: { Countries: { Country: [] } } };
           }
+          if (model.SupplierInfoRequest) {
+            return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+          }
           if (model.GetServicesRequest) return getServicesReply;
           const opt = model.OptionInfoRequest && model.OptionInfoRequest.Opt;
           if (optionsByOpt[opt]) {
@@ -1523,6 +1716,9 @@ describe('search tests', () => {
               },
             };
           }
+          if (model.SupplierInfoRequest) {
+            return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+          }
           const opt = model.OptionInfoRequest && model.OptionInfoRequest.Opt;
           if (opt === '???SM????????????') {
             return {
@@ -1605,6 +1801,9 @@ describe('search tests', () => {
               },
             };
           }
+          if (model.SupplierInfoRequest) {
+            return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+          }
           if (model.OptionInfoRequest) {
             return {
               OptionInfoReply: {

package/itinerary-add-service.js

@@ -2,6 +2,7 @@ const R = require('ramda');
 const {
   getRoomConfigs,
   escapeInvalidXmlChars,
+  normalizeAgentReference,
   CUSTOM_RATE_ID_NAME,
   CUSTOM_NO_RATE_NAME,
   hostConnectXmlOptions,
@@ -15,6 +16,13 @@ const SERVICE_CANNOT_BE_ADDED_ERROR_MESSAGE = 'Service cannot be added to quote
 const getBookingName = quoteName => escapeInvalidXmlChars(quoteName)
   .substring(0, MAX_BOOKING_NAME_LENGTH);
 
+const buildAgentReference = ({ agentRef, reference }) => {
+  const source = typeof agentRef === 'string' && agentRef.trim() !== ''
+    ? agentRef
+    : reference;
+  return normalizeAgentReference(source);
+};
+
 const addServiceToItinerary = async ({
   axios,
   token: {
@@ -30,6 +38,7 @@ const addServiceToItinerary = async ({
     quoteId,
     optionId,
     startDate,
+    agentRef,
     reference,
     /*
     paxConfigs: [{ roomType: 'DB', adults: 2 }, { roomType: 'TW', children: 2 }]
@@ -66,6 +75,20 @@ const addServiceToItinerary = async ({
       return acc;
     }, {});
 
+  const directLinePayloadHasAgentReference = directLinePayload &&
+    Object.prototype.hasOwnProperty.call(directLinePayload, 'AgentRef');
+  const customFieldsHaveAgentReference = Object.prototype.hasOwnProperty.call(
+    cfvPerService,
+    'AgentRef',
+  );
+  const payloadAgentReference = buildAgentReference({ agentRef, reference });
+  let agentReferenceSource = payloadAgentReference;
+  if (directLinePayloadHasAgentReference) agentReferenceSource = directLinePayload.AgentRef;
+  if (customFieldsHaveAgentReference) agentReferenceSource = cfvPerService.AgentRef;
+  const agentReference = normalizeAgentReference(agentReferenceSource);
+  const directLinePayloadWithoutAgentReference = R.omit(['AgentRef'], directLinePayload || {});
+  const customFieldsWithoutAgentReference = R.omit(['AgentRef'], cfvPerService);
+
   const directHeaderPayloadHasName = directHeaderPayload &&
     Object.prototype.hasOwnProperty.call(directHeaderPayload, 'Name');
   const bookingNameSource = directHeaderPayloadHasName ? directHeaderPayload.Name : quoteName;
@@ -178,10 +201,10 @@ const addServiceToItinerary = async ({
         if (Number.isNaN(num) || num < 1) return 1;
         return num;
       })(),
-      AgentRef: escapeInvalidXmlChars(reference),
+      ...(agentReference ? { AgentRef: agentReference } : {}),
       RoomConfigs: getRoomConfigs(paxConfigs),
-      ...(directLinePayload || {}),
-      ...(cfvPerService || {}),
+      ...directLinePayloadWithoutAgentReference,
+      ...customFieldsWithoutAgentReference,
     },
   };
   const replyObj = await callTourplan({

package/itinerary-products-search.js

@@ -1,11 +1,16 @@
 const R = require('ramda');
 const Promise = require('bluebird');
-const { translateTPOption, getOptionCurrency } = require('./resolvers/product');
+const {
+  attachOptionCatalogFields,
+  translateTPOption,
+  getOptionCurrency,
+} = require('./resolvers/product');
 const { getAgentCurrencyCode } = require('./availability/itinerary-availability-helper');
 const { hostConnectXmlOptions } = require('./utils');
 const { getCachedLocations } = require('./tp-helpers/locations');
 const { getCachedServices } = require('./tp-helpers/services');
 const { getCachedDestinationCountries } = require('./tp-helpers/system-settings');
+const { getCachedSuppliers } = require('./tp-helpers/suppliers');
 const { enrichOptionWithCodeTables } = require('./tp-helpers/option-enrichment');
 const { addStructuredOptionMetadata } = require('./option-metadata');
 const {
@@ -167,7 +172,12 @@ const searchProductsForItinerary = async ({
       return {};
     }
   };
-  const [locationsByCode, resolvedServicesByCode, countriesByDestination] = await Promise.all([
+  const [
+    locationsByCode,
+    resolvedServicesByCode,
+    countriesByDestination,
+    suppliersById,
+  ] = await Promise.all([
     loadOptionalTable('locations', () => (
       getCachedLocations({
         callTourplan,
@@ -200,6 +210,16 @@ const searchProductsForItinerary = async ({
         hostConnectAgentPassword,
       })
     )),
+    loadOptionalTable('suppliers', () => (
+      getCachedSuppliers({
+        callTourplan,
+        cache,
+        axios,
+        hostConnectEndpoint,
+        hostConnectAgentID,
+        hostConnectAgentPassword,
+      })
+    )),
   ]);
   servicesByCode = resolvedServicesByCode;
 
@@ -217,14 +237,21 @@ const searchProductsForItinerary = async ({
   ), enrichedOptions);
   const products = await Promise.map(
     arrayOfOptionsGroupedBySupplierId,
-    optionsGroupedBySupplierId => translateTPOption({
-      rootValue: {
-        optionsGroupedBySupplierId,
-      },
-      agentCurrencyCode,
-      typeDefs: itineraryProductTypeDefs,
-      query: itineraryProductQuery,
-    }),
+    optionsGroupedBySupplierId => {
+      const supplierId = R.path([0, 'OptGeneral', 'SupplierId'], optionsGroupedBySupplierId);
+      const supplierKey = supplierId === undefined || supplierId === null
+        ? ''
+        : String(supplierId).trim();
+      return translateTPOption({
+        rootValue: {
+          optionsGroupedBySupplierId,
+          supplierRecord: suppliersById[supplierKey] || {},
+        },
+        agentCurrencyCode,
+        typeDefs: itineraryProductTypeDefs,
+        query: itineraryProductQuery,
+      });
+    },
     {
       concurrency: 10,
     },
@@ -232,7 +259,8 @@ const searchProductsForItinerary = async ({
   // Preserve raw OptRates / PickupPoints from Tourplan in product search response
   // when available (camelCase keys: optRates, pickupPoints; Tourplan field casing
   // inside). Re-attach after GraphQL because stock TI2 itinerary-product
-  // typeDefs/query omit these fields (same for city/country/currency).
+  // typeDefs/query omit these fields (same for city/country/currency,
+  // optionClass, chargeUnit, Other, and maxPaxWithInfants).
   // Also ensure city and currency are always on the option for product cache.
   const enrichedByOptionId = R.indexBy(R.prop('Opt'), enrichedOptions);
   const optionRatesByOptionId = options.reduce((acc, option) => {
@@ -261,7 +289,7 @@ const searchProductsForItinerary = async ({
             || R.path(['PickupPoints'], rawOption),
         )
         : undefined;
-      return addStructuredOptionMetadata({
+      return addStructuredOptionMetadata(attachOptionCatalogFields({
         ...R.omit(['city', 'country', 'rateContext'], currentOption),
         ...(city ? { city } : {}),
         ...(country ? { country } : {}),
@@ -270,7 +298,7 @@ const searchProductsForItinerary = async ({
         ...(R.path([currentOption.optionId], optionRatesByOptionId)
           ? { optRates: R.path([currentOption.optionId], optionRatesByOptionId) }
           : {}),
-      });
+      }, rawOption));
     }),
   }));
   return {