ti2-tourplan 1.0.134 → 1.0.136

package/__snapshots__/index.test.js.snap

@@ -4155,6 +4155,7 @@ Object {
           "country": "United Kingdom",
           "currency": "GBP",
           "extras": Array [],
+          "inclusions": Array [],
           "lastUpdateTimestamp": 1700750093,
           "optRates": Object {
             "CancelPolicies": Object {

package/index.test.js

@@ -867,6 +867,7 @@ describe('search tests', () => {
       },
     });
     expect(R.path(['products', 0, 'options', 0, 'city'], retVal)).toBe('London');
+    expect(R.path(['products', 0, 'options', 0, 'inclusions'], retVal)).toEqual([]);
     expect(retVal).toMatchSnapshot();
   });
 
@@ -1757,6 +1758,28 @@ describe('search tests', () => {
       expect(retVal.bookings[0].bookingId).toBe('316559');
     });
 
+    it('searchItineraries surfaces AgentRef HostConnect application failures', async () => {
+      const actualApp = new Plugin();
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const applicationErrorAxios = jest.fn(async () => ({
+        data: '<Reply><ErrorReply><Error>Invalid Agent credentials</Error></ErrorReply></Reply>',
+      }));
+
+      try {
+        await expect(actualApp.searchItineraries({
+          axios: applicationErrorAxios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            agentReferenceIds: ['AGENT-REF-1', 'AGENT-REF-2'],
+          },
+        })).rejects.toThrow('ListBookingsRequest failed: Invalid Agent credentials');
+        expect(applicationErrorAxios).toHaveBeenCalledTimes(2);
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
     it('searchItineraries bookingReferenceIds accepts a single string', async () => {
       axios.mockImplementation(getFixture);
       const retVal = await app.searchItineraries({

package/itinerary-products-search.js

@@ -7,6 +7,7 @@ const { getCachedLocations } = require('./tp-helpers/locations');
 const { getCachedServices } = require('./tp-helpers/services');
 const { getCachedDestinationCountries } = require('./tp-helpers/system-settings');
 const { enrichOptionWithCodeTables } = require('./tp-helpers/option-enrichment');
+const { addStructuredOptionMetadata } = require('./option-metadata');
 const {
   isEnabled,
   normalizePickupPoints,
@@ -260,7 +261,7 @@ const searchProductsForItinerary = async ({
             || R.path(['PickupPoints'], rawOption),
         )
         : undefined;
-      return {
+      return addStructuredOptionMetadata({
         ...R.omit(['city', 'country', 'rateContext'], currentOption),
         ...(city ? { city } : {}),
         ...(country ? { country } : {}),
@@ -269,7 +270,7 @@ const searchProductsForItinerary = async ({
         ...(R.path([currentOption.optionId], optionRatesByOptionId)
           ? { optRates: R.path([currentOption.optionId], optionRatesByOptionId) }
           : {}),
-      };
+      });
     }),
   }));
   return {

package/itinerary-search.js

@@ -5,6 +5,8 @@ const { translateItineraryBooking } = require('./resolvers/itinerary');
 
 /** Years to extend the travel window when start or end is missing. */
 const TRAVEL_WINDOW_SPAN_YEARS = 2;
+const LIST_BOOKINGS_CONCURRENCY = 10;
+const MAX_AGENT_REFERENCE_IDS = 20;
 
 /**
  * Extract the date prefix from a string in the format YYYY-MM-DD.
@@ -159,7 +161,10 @@ const searchItineraries = async ({
     itineraryBookingTypeDefs,
     itineraryBookingQuery,
   },
-  payload: {
+  payload,
+  callTourplan,
+}) => {
+  const {
     purchaseDateStart,
     purchaseDateEnd,
     travelDateStart,
@@ -167,9 +172,8 @@ const searchItineraries = async ({
     bookingReferenceIds,
     bookingId,
     name,
-  },
-  callTourplan,
-}) => {
+    agentReferenceIds,
+  } = payload;
   const getPayload = (RequestType, RequestInput) => ({
     model: {
       [RequestType]: {
@@ -188,11 +192,28 @@ const searchItineraries = async ({
   let baseSearchFilters = null;
 
   // Step1: Build search criterias based on the provided search criteria.
+  const hasAgentReferenceIds = Object.prototype.hasOwnProperty.call(payload, 'agentReferenceIds');
+  const rawAgentReferenceIds = (
+    Array.isArray(agentReferenceIds) ? agentReferenceIds : [agentReferenceIds]
+  );
+  if (hasAgentReferenceIds && rawAgentReferenceIds.length > MAX_AGENT_REFERENCE_IDS) {
+    return { bookings: [] };
+  }
+  const normalizedAgentReferenceIds = rawAgentReferenceIds
+    .filter(ref => typeof ref === 'string' || (typeof ref === 'number' && Number.isFinite(ref)))
+    .map(ref => escapeInvalidXmlChars(String(ref).trim()))
+    .filter(Boolean);
+  const uniqueAgentReferenceIds = R.uniq(normalizedAgentReferenceIds);
+  if (hasAgentReferenceIds && !uniqueAgentReferenceIds.length) {
+    return { bookings: [] };
+  }
   const normalizedBookingReferenceIds = (
     Array.isArray(bookingReferenceIds) ? bookingReferenceIds : [bookingReferenceIds]
   ).filter(v => v != null).map(v => escapeInvalidXmlChars(String(v).trim())).filter(Boolean);
 
-  if (normalizedBookingReferenceIds.length) {
+  if (uniqueAgentReferenceIds.length) {
+    searchCriterias = uniqueAgentReferenceIds.map(ref => ({ AgentRef: ref }));
+  } else if (normalizedBookingReferenceIds.length) {
     // if bookingReferenceIds are provided other search criteria are ignored
     searchCriterias = R.uniq(normalizedBookingReferenceIds).map(ref => ({ Ref: ref }));
   } else if (bookingId) {
@@ -230,10 +251,12 @@ const searchItineraries = async ({
   }
 
   // Step4: Fetch for bookings based on the search criterias.
-  const allSearches = searchCriterias.length
-    ? searchCriterias.map(keyObj => ({
-      keyObj,
-      promise: (async () => {
+  const allSearches = (searchCriterias.length ? searchCriterias : [baseSearchFilters])
+    .map(keyObj => ({ keyObj }));
+  const settledSearches = await Promise.map(
+    allSearches,
+    async ({ keyObj }) => {
+      try {
         let reply;
         try {
           reply = await callTourplan(getPayload('ListBookingsRequest', {
@@ -266,35 +289,24 @@ const searchItineraries = async ({
         */
         } catch (err) {
           const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
+          if (hasAgentReferenceIds) {
+            throw err instanceof Error ? err : Error(errMsg);
+          }
           if (errMsg.includes('Request failed with status code')) {
             throw Error(errMsg);
           }
           // if it's not server error, we just considered as no booking is found
           reply = { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
         }
-        return reply;
-      })(),
-    }))
-    : [
-      // Date-range-only search (no explicit criteria). Wrap in the same try/catch
-      // pattern as the map branch so a non-HTTP error is treated as zero results
-      // rather than crashing the entire search.
-      {
-        keyObj: baseSearchFilters,
-        promise: (async () => {
-          try {
-            return await callTourplan(getPayload('ListBookingsRequest', baseSearchFilters));
-          } catch (err) {
-            const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
-            if (errMsg.includes('Request failed with status code')) throw Error(errMsg);
-            return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
-          }
-        })(),
-      },
-    ];
+        return { status: 'fulfilled', value: reply };
+      } catch (reason) {
+        return { status: 'rejected', reason };
+      }
+    },
+    { concurrency: LIST_BOOKINGS_CONCURRENCY },
+  );
 
   // Step5: Get full booking details for each booking.
-  const settledSearches = await global.Promise.allSettled(allSearches.map(({ promise }) => promise));
   const replyObjs = [];
   const rejectedSearches = [];
 

package/itinerary-search.test.js

@@ -1,10 +1,17 @@
-/* globals describe, it, expect, beforeAll, afterAll */
+/* globals describe, it, expect, jest, beforeAll, afterAll */
+
+jest.mock('./resolvers/itinerary', () => ({
+  translateItineraryBooking: jest.fn(async ({ rootValue }) => rootValue),
+}));
 
 const {
+  searchItineraries,
   resolveTravelDateWindow,
   resolvePurchaseDateWindow,
 } = require('./itinerary-search');
 
+const realSetImmediate = setImmediate;
+
 /**
  * Freeze time so "today-based" default windows are deterministic.
  * TRAVEL_WINDOW_SPAN_YEARS = 2, so the full span is 24 months.
@@ -24,6 +31,321 @@ afterAll(() => {
   jest.useRealTimers();
 });
 
+describe('searchItineraries agentReferenceIds', () => {
+  const token = {
+    hostConnectAgentID: 'agent-id',
+    hostConnectAgentPassword: 'agent-password',
+    hostConnectEndpoint: 'https://example.test/hostconnect',
+  };
+
+  const runSearch = (payload, callTourplan) => searchItineraries({
+    token,
+    axios: jest.fn(),
+    typeDefsAndQueries: {
+      itineraryBookingTypeDefs: {},
+      itineraryBookingQuery: '',
+    },
+    payload,
+    callTourplan,
+  });
+
+  const listRequestsFrom = callTourplan => callTourplan.mock.calls
+    .map(([request]) => request.model.ListBookingsRequest)
+    .filter(Boolean);
+
+  it('treats a numeric agentReferenceIds value as an exact AgentRef with explicit precedence', async () => {
+    const callTourplan = jest.fn(async ({ model }) => {
+      if (model.ListBookingsRequest) {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: { BookingHeader: [{ BookingId: '777' }] },
+          },
+        };
+      }
+      return { GetBookingReply: { BookingId: '777' } };
+    });
+
+    const result = await runSearch({
+      agentReferenceIds: 501,
+      bookingReferenceIds: ['IGNORE-REF'],
+      bookingId: '501',
+      name: 'Ignore name',
+      travelDateStart: '2026-01-01',
+      travelDateEnd: '2026-12-31',
+      purchaseDateStart: '2026-02-01',
+      purchaseDateEnd: '2026-03-01',
+    }, callTourplan);
+
+    const listRequests = listRequestsFrom(callTourplan);
+    expect(listRequests).toEqual([{
+      AgentID: 'agent-id',
+      Password: 'agent-password',
+      AgentRef: '501',
+    }]);
+    expect(listRequests).not.toEqual(expect.arrayContaining([
+      expect.objectContaining({ BookingId: '501' }),
+    ]));
+    expect(listRequests).not.toEqual(expect.arrayContaining([
+      expect.objectContaining({ Ref: '501' }),
+    ]));
+    expect(result.bookings).toEqual([{
+      BookingId: '777',
+      agentId: 'agent-id',
+    }]);
+  });
+
+  it('normalizes a scalar string agentReferenceIds value', async () => {
+    const callTourplan = jest.fn(async () => ({
+      ListBookingsReply: { BookingHeaders: { BookingHeader: [] } },
+    }));
+
+    const result = await runSearch({ agentReferenceIds: ' REF-SCALAR ' }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan)).toEqual([{
+      AgentID: 'agent-id',
+      Password: 'agent-password',
+      AgentRef: 'REF-SCALAR',
+    }]);
+    expect(result).toEqual({ bookings: [] });
+  });
+
+  it('normalizes array values and deduplicates AgentRef searches and booking results', async () => {
+    const callTourplan = jest.fn(async ({ model }) => {
+      const listRequest = model.ListBookingsRequest;
+      if (listRequest && listRequest.AgentRef === 'REF-A') {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: {
+              BookingHeader: [{ BookingId: '601' }, { BookingId: '602' }],
+            },
+          },
+        };
+      }
+      if (listRequest && listRequest.AgentRef === '700') {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: { BookingHeader: [{ BookingId: '602' }] },
+          },
+        };
+      }
+      if (model.GetBookingRequest) {
+        return {
+          GetBookingReply: { BookingId: model.GetBookingRequest.BookingId },
+        };
+      }
+      throw new Error(`Unexpected request: ${JSON.stringify(model)}`);
+    });
+
+    const result = await runSearch({
+      agentReferenceIds: [' REF-A ', 700, 'REF-A', null, {}, true, Infinity],
+    }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan)).toEqual([
+      {
+        AgentID: 'agent-id',
+        Password: 'agent-password',
+        AgentRef: 'REF-A',
+      },
+      {
+        AgentID: 'agent-id',
+        Password: 'agent-password',
+        AgentRef: '700',
+      },
+    ]);
+    expect(result.bookings.map(booking => booking.BookingId)).toEqual(['601', '602']);
+    const getBookingIds = callTourplan.mock.calls
+      .map(([request]) => request.model.GetBookingRequest)
+      .filter(Boolean)
+      .map(request => request.BookingId);
+    expect(getBookingIds).toEqual(['601', '602']);
+  });
+
+  it('keeps successful AgentRef results when another fan-out request fails', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const callTourplan = jest.fn(async ({ model }) => {
+      const listRequest = model.ListBookingsRequest;
+      if (listRequest && listRequest.AgentRef === 'FAIL') {
+        throw new Error('Request failed with status code 500: failed AgentRef');
+      }
+      if (listRequest && listRequest.AgentRef === 'GOOD') {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: { BookingHeader: [{ BookingId: '801' }] },
+          },
+        };
+      }
+      return { GetBookingReply: { BookingId: model.GetBookingRequest.BookingId } };
+    });
+
+    try {
+      const result = await runSearch({ agentReferenceIds: ['FAIL', 'GOOD'] }, callTourplan);
+
+      expect(result.bookings.map(booking => booking.BookingId)).toEqual(['801']);
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[tourplan] ListBookingsRequest failed',
+        { AgentRef: 'FAIL' },
+        'Request failed with status code 500: failed AgentRef',
+      );
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('limits concurrent AgentRef ListBookings requests while attempting every reference', async () => {
+    const agentReferenceIds = Array.from({ length: 20 }, (_, idx) => `REF-${idx}`);
+    const pendingListRequests = [];
+    let activeListRequests = 0;
+    let maxActiveListRequests = 0;
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const callTourplan = jest.fn(({ model }) => {
+      if (model.GetBookingRequest) {
+        return global.Promise.resolve({
+          GetBookingReply: { BookingId: model.GetBookingRequest.BookingId },
+        });
+      }
+
+      const { AgentRef } = model.ListBookingsRequest;
+      activeListRequests += 1;
+      maxActiveListRequests = Math.max(maxActiveListRequests, activeListRequests);
+      return new global.Promise((resolve, reject) => {
+        pendingListRequests.push({
+          AgentRef,
+          settle: () => {
+            activeListRequests -= 1;
+            if (AgentRef === 'REF-7') {
+              reject(new Error('Request failed with status code 500: failed AgentRef'));
+              return;
+            }
+            resolve({
+              ListBookingsReply: {
+                BookingHeaders: {
+                  BookingHeader: AgentRef === 'REF-19' ? [{ BookingId: '901' }] : [],
+                },
+              },
+            });
+          },
+        });
+      });
+    });
+
+    try {
+      const searchPromise = runSearch({ agentReferenceIds }, callTourplan);
+      const flushAsyncWork = remainingTicks => (
+        new global.Promise(resolve => realSetImmediate(resolve))
+          .then(() => (remainingTicks > 1 ? flushAsyncWork(remainingTicks - 1) : undefined))
+      );
+      const settleStartedListRequests = async () => {
+        if (listRequestsFrom(callTourplan).length >= agentReferenceIds.length) return;
+        expect(activeListRequests).toBeLessThanOrEqual(10);
+        expect(pendingListRequests.length).toBeGreaterThan(0);
+        pendingListRequests.splice(0).forEach(({ settle }) => settle());
+        await flushAsyncWork(4);
+        await settleStartedListRequests();
+      };
+      await flushAsyncWork(4);
+      await settleStartedListRequests();
+      pendingListRequests.splice(0).forEach(({ settle }) => settle());
+      await flushAsyncWork(4);
+
+      const result = await searchPromise;
+
+      expect(maxActiveListRequests).toBeLessThanOrEqual(10);
+      expect(listRequestsFrom(callTourplan).map(request => request.AgentRef).sort())
+        .toEqual([...agentReferenceIds].sort());
+      expect(result.bookings.map(booking => booking.BookingId)).toEqual(['901']);
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[tourplan] ListBookingsRequest failed',
+        { AgentRef: 'REF-7' },
+        'Request failed with status code 500: failed AgentRef',
+      );
+    } finally {
+      pendingListRequests.splice(0).forEach(({ settle }) => settle());
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('fails closed when more than 20 AgentRef values are provided', async () => {
+    const callTourplan = jest.fn();
+    const agentReferenceIds = Array.from({ length: 21 }, (_, idx) => `REF-${idx}`);
+
+    const result = await runSearch({
+      agentReferenceIds,
+      bookingId: 'SHOULD-NOT-FALL-BACK',
+    }, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).not.toHaveBeenCalled();
+  });
+
+  it('counts duplicate AgentRef values toward the hard input limit', async () => {
+    const callTourplan = jest.fn();
+
+    const result = await runSearch({
+      agentReferenceIds: Array(21).fill('REF-DUPLICATE'),
+    }, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).not.toHaveBeenCalled();
+  });
+
+  it('counts malformed entries toward the raw AgentRef input limit', async () => {
+    const callTourplan = jest.fn();
+
+    const result = await runSearch({
+      agentReferenceIds: [
+        ...Array.from({ length: 20 }, (_, idx) => `REF-${idx}`),
+        null,
+      ],
+    }, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['an empty list', []],
+    ['blank and absent entries', [' ', null, undefined]],
+    ['malformed entries', [{}, true, false, NaN, Infinity]],
+    ['an explicit undefined scalar', undefined],
+  ])('returns empty without a HostConnect request for %s', async (description, agentReferenceIds) => {
+    const callTourplan = jest.fn();
+
+    const result = await runSearch({
+      agentReferenceIds,
+      bookingId: 'SHOULD-NOT-FALL-BACK',
+      bookingReferenceIds: ['SHOULD-NOT-FALL-BACK'],
+      name: 'Should not fall back',
+    }, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['bookingReferenceIds', { bookingReferenceIds: ['LEGACY-REF'] }, 1],
+    ['bookingId', { bookingId: '12345' }, 3],
+    ['name', { name: 'Legacy Booking' }, 1],
+    [
+      'travel dates',
+      { travelDateStart: '2026-01-01', travelDateEnd: '2026-01-31' },
+      1,
+    ],
+  ])('keeps legacy %s application failures as empty results', async (
+    description,
+    payload,
+    expectedRequests,
+  ) => {
+    const callTourplan = jest.fn(async () => {
+      throw new Error('ListBookingsRequest failed: No matching bookings');
+    });
+
+    const result = await runSearch(payload, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).toHaveBeenCalledTimes(expectedRequests);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // resolveTravelDateWindow
 // ---------------------------------------------------------------------------

package/option-metadata.js

@@ -0,0 +1,44 @@
+const BREAKFAST = 'breakfast';
+
+const normalizeText = value => String(value || '').toLowerCase();
+
+const hasNegatedBreakfast = value => {
+  const text = normalizeText(value);
+  return /\b(?:no|without|excluding|exclude|excludes)\s+breakfast\b/.test(text)
+    || /\b(?:no|without)\s+bed\s+(?:and|&)\s+breakfast\b/.test(text)
+    || /\b(?:do|does)\s+not\s+(?:include|includes)\s+breakfast\b/.test(text)
+    || /\bnot\s+including\s+breakfast\b/.test(text)
+    || /\bbreakfast\b\s+(?:is\s+)?(?:not\s+included|not\s+inclusive|excluded)\b/.test(text);
+};
+
+const includesBreakfast = value => {
+  if (hasNegatedBreakfast(value)) return false;
+  const text = normalizeText(value);
+  return /\bbreakfast\b\s+(?:is\s+)?(?:included|inclusive)\b/.test(text)
+    || /\b(?:including|includes|include|with)\s+breakfast\b/.test(text)
+    || /\bbed\s+(?:and|&)\s+breakfast\b/.test(text);
+};
+
+const getOptionInclusions = optionName => (
+  includesBreakfast(optionName) ? [BREAKFAST] : []
+);
+
+const getExtraCategory = extraName => {
+  if (hasNegatedBreakfast(extraName)) return null;
+  return /\bbreakfast\b/.test(normalizeText(extraName)) ? BREAKFAST : null;
+};
+
+const addStructuredOptionMetadata = option => ({
+  ...option,
+  inclusions: getOptionInclusions(option && option.optionName),
+  extras: (option && option.extras || []).map(extra => {
+    const category = getExtraCategory(extra && extra.name);
+    return category ? { ...extra, category } : extra;
+  }),
+});
+
+module.exports = {
+  addStructuredOptionMetadata,
+  getExtraCategory,
+  getOptionInclusions,
+};

package/option-metadata.test.js

@@ -0,0 +1,42 @@
+const {
+  addStructuredOptionMetadata,
+  getExtraCategory,
+  getOptionInclusions,
+} = require('./option-metadata');
+
+describe('structured option metadata', () => {
+  test.each([
+    ['Witherview Super King, Including Breakfast', ['breakfast']],
+    ['Bed and Breakfast', ['breakfast']],
+    ['Bed & Breakfast', ['breakfast']],
+    ['Breakfast not included', []],
+    ['No breakfast included', []],
+    ['Does not include breakfast', []],
+    ['Not including breakfast', []],
+    ['No bed and breakfast', []],
+    ['Room only', []],
+  ])('normalizes option inclusion text %s', (optionName, expected) => {
+    expect(getOptionInclusions(optionName)).toEqual(expected);
+  });
+
+  it('classifies selectable breakfast extras without changing unrelated extras', () => {
+    expect(addStructuredOptionMetadata({
+      optionName: 'Superior Room',
+      extras: [
+        { id: '1', name: 'Breakfast' },
+        { id: '2', name: 'Airport transfer' },
+      ],
+    })).toEqual({
+      optionName: 'Superior Room',
+      inclusions: [],
+      extras: [
+        { id: '1', name: 'Breakfast', category: 'breakfast' },
+        { id: '2', name: 'Airport transfer' },
+      ],
+    });
+  });
+
+  it('does not classify negated breakfast text as a selectable category', () => {
+    expect(getExtraCategory('No breakfast')).toBeNull();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-tourplan",
-  "version": "1.0.134",
+  "version": "1.0.136",
   "description": "Tourplan's TI2 Plugin",
   "main": "index.js",
   "scripts": {