ti2-tourplan 1.0.139 → 1.0.141

package/README.md

@@ -4,11 +4,34 @@
 
 ### Requirements
 
-Some environment variables are required for this plugin to run it's tests
-
-- apiKey
-- endpoint
-- DTD_DAYS (optional) - Number of days to cache DTD version detection results (default: 7). This helps reduce API calls by caching the correct DTD version for each endpoint.
+Live integration tests use `ti2_tourplan_endpoint`, `ti2_tourplan_username`,
+and `ti2_tourplan_password`; the test suite supplies fixture defaults when
+they are absent. Plugin credentials use the `endpoint`, `username`, and
+`password` token fields. The optional `DTD_DAYS` plugin setting controls how
+many days DTD version detection results are cached per endpoint (default: 7).
+
+## Itinerary product catalog fields
+
+Product search passes Ti2's itinerary product type definitions and query to
+`translateTPOption`. The query now returns the existing `city`, `country`, and
+`currency` values alongside these HostConnect fields:
+
+| Ti2 field | HostConnect source |
+| --- | --- |
+| `city` | Enriched destination, then `OptGeneral.LocalityDescription` or `Address3` |
+| `country` | Enriched destination country |
+| `currency` | Agent currency, then `OptRates.Currency` |
+| `description` | SupplierInfo notes or description, excluding the supplier name |
+| `optionClass` | `OptGeneral.ClassDescription`, then `OptGeneral.Class` |
+| `chargeUnit` | `OptGeneral.SCU`, lowercased |
+| Room `maxPaxWithInfants` | `OptGeneral.<room>_Max_With_Infants` |
+| `Other` room restriction | `OptGeneral.Other_*` fields, when present |
+
+For accommodation and package options, an `Other` unit is included only when
+the source has an `Other_*` value. If those fields are absent, the `Other`
+restriction is omitted. Optional source values omitted by the plugin appear as
+`null` in Ti2's shared query. Adult, Child, and Infant restrictions still
+select only `allowed`, `minAge`, and `maxAge`.
 
 ## Contributing
 

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'
 
@@ -1026,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',
@@ -1050,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: {
@@ -1303,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`);
@@ -1372,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]) {
@@ -1617,6 +1716,9 @@ describe('search tests', () => {
               },
             };
           }
+          if (model.SupplierInfoRequest) {
+            return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+          }
           const opt = model.OptionInfoRequest && model.OptionInfoRequest.Opt;
           if (opt === '???SM????????????') {
             return {
@@ -1699,6 +1801,9 @@ describe('search tests', () => {
               },
             };
           }
+          if (model.SupplierInfoRequest) {
+            return { SupplierInfoReply: { Suppliers: { Supplier: [] } } };
+          }
           if (model.OptionInfoRequest) {
             return {
               OptionInfoReply: {

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 {

package/package.json

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

package/resolvers/product.js

@@ -2,7 +2,7 @@
 const { makeExecutableSchema } = require('@graphql-tools/schema');
 const R = require('ramda');
 const { graphql } = require('graphql');
-const { firstPresent } = require('../tp-helpers/values');
+const { asArray, firstPresent, trimString } = require('../tp-helpers/values');
 
 // Prefer AgentInfo Currency (same source as validateToken); fall back to OptRates.
 const getOptionCurrency = (option, agentCurrencyCode) => firstPresent(
@@ -16,6 +16,182 @@ const getOptionCity = option => firstPresent(
   R.path(['OptGeneral', 'Address3'], option),
 );
 
+// Other (HostConnect OT) is included with the other room types only when
+// OptionInfo actually carries Other_* fields. A missing flag is not "unavailable".
+const RESTRICTION_ROOM_TYPES = ['Single', 'Twin', 'Double', 'Triple', 'Quad', 'Other'];
+const ACCOMMODATION_UNIT_TYPES = ['Single', 'Twin', 'Double', 'Triple', 'Quad'];
+const ROOM_SOURCE_SUFFIXES = ['Avail', 'Max', 'Ad_Max', 'Max_With_Infants', 'From', 'To'];
+
+const finiteInt = value => {
+  if (typeof value === 'boolean') return undefined;
+  if (value === undefined || value === null || value === '') return undefined;
+  const parsed = typeof value === 'number' ? value : parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+};
+
+const readRoomRaw = (option, roomType, suffix) => (
+  R.path(['OptGeneral', `${roomType}_${suffix}`], option)
+);
+
+const readRoomInt = (option, roomType, suffix) => finiteInt(readRoomRaw(option, roomType, suffix));
+
+const hasRoomSource = (option, roomType) => ROOM_SOURCE_SUFFIXES.some(suffix => {
+  const value = readRoomRaw(option, roomType, suffix);
+  return value !== undefined && value !== null && value !== '';
+});
+
+// Y and N are explicit. Anything else, including a missing element, is unknown.
+const roomAllowed = (option, roomType) => {
+  const avail = readRoomRaw(option, roomType, 'Avail');
+  if (avail === 'Y') return true;
+  if (avail === 'N') return false;
+  if (roomType === 'Other') return null;
+  return false;
+};
+
+// Max of 0 is a real cap. Ad_Max is only the fallback when Max is absent.
+const maxPaxForRoom = (option, roomType) => {
+  const maxPax = readRoomInt(option, roomType, 'Max');
+  if (maxPax !== undefined) return maxPax;
+  return readRoomInt(option, roomType, 'Ad_Max');
+};
+
+const roomRestriction = (option, roomType) => {
+  const maxPaxWithInfants = readRoomInt(option, roomType, 'Max_With_Infants');
+  return {
+    allowed: roomAllowed(option, roomType),
+    maxPax: maxPaxForRoom(option, roomType),
+    maxAdults: readRoomInt(option, roomType, 'Ad_Max'),
+    ...(maxPaxWithInfants !== undefined && { maxPaxWithInfants }),
+  };
+};
+
+const noteTexts = record => asArray(R.path(['SupplierNotes', 'SupplierNote'], record))
+  .map(note => (
+    typeof note === 'string' ? trimString(note) : trimString(R.path(['NoteText'], note))
+  ))
+  .filter(Boolean);
+
+// SupplierInfo notes, not OptGeneral.Description (that text is the option name).
+const supplierDescriptionFromRecord = (record, supplierName) => {
+  const source = record || {};
+  const name = trimString(supplierName)
+    || trimString(source.Name)
+    || trimString(source.SupplierName);
+  const notes = R.uniq([
+    trimString(source.Notes),
+    trimString(source.Note),
+    trimString(source.SupplierNote),
+    ...noteTexts(source),
+  ].filter(text => text && text !== name));
+  if (notes.length) return notes.join('\n');
+  const isOptionGeneral = source.SType !== undefined
+    || source.ButtonName !== undefined
+    || source.Class !== undefined
+    || source.ClassDescription !== undefined;
+  const description = trimString(source.Description);
+  if (!isOptionGeneral && description && description !== name) return description;
+  return null;
+};
+
+const optionClassFromGeneral = general => firstPresent(
+  trimString(R.path(['ClassDescription'], general)),
+  trimString(R.path(['Class'], general)),
+) || null;
+
+const chargeUnitFromGeneral = general => {
+  const scu = trimString(R.path(['SCU'], general));
+  return scu ? scu.toLowerCase() : null;
+};
+
+const intOrNull = value => (
+  value === undefined || value === null ? null : value
+);
+
+const accommodationUnit = (option, unitId) => {
+  const room = roomRestriction(option, unitId);
+  return {
+    unitId,
+    unitName: unitId,
+    restrictions: {
+      allowed: room.allowed,
+      maxPax: room.maxPax,
+      maxAdults: room.maxAdults,
+      minAge: readRoomInt(option, unitId, 'From'),
+      maxAge: readRoomInt(option, unitId, 'To'),
+      ...(room.maxPaxWithInfants !== undefined
+        && { maxPaxWithInfants: room.maxPaxWithInfants }),
+    },
+  };
+};
+
+const accommodationUnitTypes = option => (
+  hasRoomSource(option, 'Other')
+    ? [...ACCOMMODATION_UNIT_TYPES, 'Other']
+    : ACCOMMODATION_UNIT_TYPES
+);
+
+const publicRoomRestriction = room => ({
+  allowed: room.allowed,
+  maxPax: intOrNull(room.maxPax),
+  maxAdults: intOrNull(room.maxAdults),
+  ...(room.maxPaxWithInfants !== undefined && { maxPaxWithInfants: room.maxPaxWithInfants }),
+});
+
+// Stock TI2 product queries omit optionClass, chargeUnit, Other, and maxPaxWithInfants.
+const attachOptionCatalogFields = (currentOption, rawOption) => {
+  const general = R.pathOr({}, ['OptGeneral'], rawOption);
+  const optionClass = currentOption.optionClass || optionClassFromGeneral(general);
+  const chargeUnit = currentOption.chargeUnit || chargeUnitFromGeneral(general);
+  const restrictions = { ...(currentOption.restrictions || {}) };
+  RESTRICTION_ROOM_TYPES.forEach(roomType => {
+    const computed = roomRestriction(rawOption, roomType);
+    const existing = restrictions[roomType];
+    if (!existing) {
+      if (!hasRoomSource(rawOption, roomType)) return;
+      restrictions[roomType] = publicRoomRestriction(computed);
+      return;
+    }
+    if (
+      computed.maxPaxWithInfants !== undefined
+      && (existing.maxPaxWithInfants === undefined || existing.maxPaxWithInfants === null)
+    ) {
+      restrictions[roomType] = {
+        ...existing,
+        maxPaxWithInfants: computed.maxPaxWithInfants,
+      };
+    }
+  });
+  let units = R.pathOr([], ['units'], currentOption).map(unit => {
+    const computed = roomRestriction(rawOption, unit.unitId);
+    if (computed.maxPaxWithInfants === undefined) return unit;
+    const existingCap = R.path(['restrictions', 'maxPaxWithInfants'], unit);
+    if (existingCap !== undefined && existingCap !== null) return unit;
+    return {
+      ...unit,
+      restrictions: {
+        ...(unit.restrictions || {}),
+        maxPaxWithInfants: computed.maxPaxWithInfants,
+      },
+    };
+  });
+  const isAccommodation = ['Y', 'P'].includes(R.path(['OptGeneral', 'SType'], rawOption));
+  if (
+    isAccommodation
+    && hasRoomSource(rawOption, 'Other')
+    && !units.some(unit => unit.unitId === 'Other')
+  ) {
+    units = units.concat(accommodationUnit(rawOption, 'Other'));
+  }
+  return {
+    ...R.omit(['optionClass', 'chargeUnit'], currentOption),
+    ...(optionClass ? { optionClass } : {}),
+    ...(chargeUnit ? { chargeUnit } : {}),
+    restrictions,
+    units,
+  };
+};
+
 const typeDefinesField = (typeDefs, typeName, fieldName) => {
   const typeMatch = String(typeDefs || '').match(new RegExp(`type\\s+${typeName}\\s*{([\\s\\S]*?)}`));
   if (!typeMatch) return false;
@@ -28,6 +204,7 @@ const resolvers = {
     productId: rootValue => `${R.path(['supplierData', 'supplierId'], rootValue)}`,
     productName: rootValue => R.path(['supplierData', 'supplierName'], rootValue),
     address: rootValue => R.path(['supplierData', 'supplierAddress'], rootValue),
+    description: rootValue => R.path(['supplierData', 'supplierDescription'], rootValue) || null,
     serviceTypes: rootValue => R.path(['supplierData', 'serviceTypes'], rootValue),
     options: R.pathOr([], ['optionsGroupedBySupplierId']),
   },
@@ -59,6 +236,8 @@ const resolvers = {
       option,
       context && context.agentCurrencyCode,
     ),
+    optionClass: option => optionClassFromGeneral(R.path(['OptGeneral'], option)),
+    chargeUnit: option => chargeUnitFromGeneral(R.path(['OptGeneral'], option)),
     units: option => {
       /*
       SType: One character that specifies the service type of the
@@ -96,19 +275,7 @@ const resolvers = {
         } : null].filter(Boolean);
       }
       if (R.path(['OptGeneral', 'SType'], option) === 'Y' || R.path(['OptGeneral', 'SType'], option) === 'P') {
-        return ['Single', 'Twin', 'Double', 'Quad']
-          .map(unitId => ({
-            unitId,
-            unitName: unitId,
-            restrictions: {
-              allowed: R.path(['OptGeneral', `${unitId}_Avail`], option) === 'Y',
-              maxPax: R.path(['OptGeneral', `${unitId}_Max`], option)
-                || R.path(['OptGeneral', `${unitId}_Ad_Max`], option),
-              maxAdults: R.path(['OptGeneral', `${unitId}_Ad_Max`], option),
-              minAge: R.path(['OptGeneral', `${unitId}_From`], option),
-              maxAge: R.path(['OptGeneral', `${unitId}_To`], option),
-            },
-          }));
+        return accommodationUnitTypes(option).map(unitId => accommodationUnit(option, unitId));
       }
       return [];
     },
@@ -133,17 +300,11 @@ const resolvers = {
         minAge: R.path(['OptGeneral', 'Infant_From'], option),
         maxAge: R.path(['OptGeneral', 'Infant_To'], option),
       },
-      ...['Single', 'Twin', 'Triple', 'Double', 'Quad'].reduce((acc, roomType) => {
-        const unitAvail = R.path(['OptGeneral', `${roomType}_Avail`], option);
-        const unitMax = R.path(['OptGeneral', `${roomType}_Max`], option);
-        const unitAdMax = R.path(['OptGeneral', `${roomType}_Ad_Max`], option);
+      ...RESTRICTION_ROOM_TYPES.reduce((acc, roomType) => {
+        if (roomType === 'Other' && !hasRoomSource(option, roomType)) return acc;
         return {
           ...acc,
-          [roomType]: {
-            allowed: unitAvail === 'Y',
-            maxPax: unitMax,
-            maxAdults: unitAdMax,
-          },
+          [roomType]: roomRestriction(option, roomType),
         };
       }, {}),
     }),
@@ -190,6 +351,7 @@ const resolversForTypeDefs = typeDefs => {
 const translateTPOption = async ({
   rootValue: {
     optionsGroupedBySupplierId,
+    supplierRecord,
   },
   agentCurrencyCode,
   typeDefs,
@@ -204,6 +366,7 @@ const translateTPOption = async ({
     supplierId: R.path(['SupplierId'], OptGeneral),
     supplierName,
     supplierAddress: `${R.pathOr('', ['Address1'], OptGeneral)}, ${R.pathOr('', ['Address2'], OptGeneral)},  ${R.pathOr('', ['Address3'], OptGeneral)}, ${R.pathOr('', ['Address4'], OptGeneral)}, ${R.pathOr('', ['Address5'], OptGeneral)}`,
+    supplierDescription: supplierDescriptionFromRecord(supplierRecord || {}, supplierName),
     serviceTypes: R.uniq(optionsGroupedBySupplierId.map(R.path(['OptGeneral', 'ButtonName']))),
   };
   const schema = makeExecutableSchema({
@@ -228,4 +391,6 @@ module.exports = {
   translateTPOption,
   resolversForTypeDefs,
   getOptionCurrency,
+  attachOptionCatalogFields,
+  supplierDescriptionFromRecord,
 };

package/resolvers/product.test.js

@@ -6,6 +6,7 @@ const productTypeDefs = `
     productId: String
     productName: String
     address: String
+    description: String
     serviceTypes: [String]
     options: [ProductOption]
   }
@@ -19,6 +20,8 @@ const productTypeDefs = `
     city: String
     country: String
     currency: String
+    optionClass: String
+    chargeUnit: String
     units: [Unit]
     restrictions: Restrictions
     extras: [Extra]
@@ -36,6 +39,7 @@ const productTypeDefs = `
     allowed: Boolean
     maxPax: Int
     maxAdults: Int
+    maxPaxWithInfants: Int
   }
 
   type Restrictions {
@@ -48,6 +52,7 @@ const productTypeDefs = `
     Triple: RoomRestrictions
     Double: RoomRestrictions
     Quad: RoomRestrictions
+    Other: RoomRestrictions
   }
 
   type PaxRestrictions {
@@ -60,6 +65,7 @@ const productTypeDefs = `
     allowed: Boolean
     maxPax: Int
     maxAdults: Int
+    maxPaxWithInfants: Int
   }
 
   type Extra {
@@ -280,4 +286,196 @@ describe('product resolver enriched context', () => {
     });
     expect(retVal.options[0].rateContext).toBeUndefined();
   });
+
+  it('exposes the supplier note, Other room, and infant cap', async () => {
+    const retVal = await translateTPOption({
+      typeDefs: productTypeDefs,
+      query: `{
+        productId
+        description
+        options {
+          optionId
+          units { unitId restrictions { allowed maxPax maxAdults maxPaxWithInfants } }
+          restrictions {
+            Other { allowed maxPax maxAdults maxPaxWithInfants }
+            Single { allowed maxPax maxAdults maxPaxWithInfants }
+            Twin { maxPax }
+          }
+        }
+      }`,
+      rootValue: {
+        supplierRecord: {
+          SupplierId: '7318',
+          Name: 'Example Hotel',
+          SupplierNotes: {
+            SupplierNote: { NoteText: '  Family owned hotel  ' },
+          },
+        },
+        optionsGroupedBySupplierId: [{
+          Opt: 'LONHOHOTELSSTD',
+          OptGeneral: {
+            SupplierId: '7318',
+            SupplierName: 'Example Hotel',
+            Description: 'Standard Room',
+            SType: 'Y',
+            Single_Avail: 'Y',
+            Single_Max: '0',
+            Single_Ad_Max: '2',
+            Single_Max_With_Infants: '2',
+            Other_Avail: 'Y',
+            Other_Max: '4',
+            Other_Ad_Max: '3',
+            Other_Max_With_Infants: '5',
+            Twin_Ad_Max: '2',
+          },
+          RatePolicy: {
+            Single_Max: '9',
+            Other_Max: '9',
+          },
+        }],
+      },
+    });
+
+    expect(retVal.description).toBe('Family owned hotel');
+    expect(retVal.options[0].restrictions.Single).toEqual({
+      allowed: true,
+      maxPax: 0,
+      maxAdults: 2,
+      maxPaxWithInfants: 2,
+    });
+    expect(retVal.options[0].restrictions.Other).toEqual({
+      allowed: true,
+      maxPax: 4,
+      maxAdults: 3,
+      maxPaxWithInfants: 5,
+    });
+    expect(retVal.options[0].restrictions.Twin.maxPax).toBe(2);
+    const unitIds = retVal.options[0].units.map(unit => unit.unitId);
+    expect(unitIds).toEqual(['Single', 'Twin', 'Double', 'Triple', 'Quad', 'Other']);
+    const singleUnit = retVal.options[0].units.find(unit => unit.unitId === 'Single');
+    expect(singleUnit.restrictions.maxPax).toBe(0);
+    expect(singleUnit.restrictions.maxPaxWithInfants).toBe(2);
+    const otherUnit = retVal.options[0].units.find(unit => unit.unitId === 'Other');
+    expect(otherUnit.restrictions).toEqual({
+      allowed: true,
+      maxPax: 4,
+      maxAdults: 3,
+      maxPaxWithInfants: 5,
+    });
+  });
+
+  it('omits Other when OptionInfo has no Other room fields', async () => {
+    const retVal = await translateTPOption({
+      typeDefs: productTypeDefs,
+      query: `{
+        options {
+          units { unitId restrictions { allowed maxPax } }
+          restrictions { Other { allowed maxPax } Single { allowed } }
+        }
+      }`,
+      rootValue: {
+        optionsGroupedBySupplierId: [{
+          Opt: 'LONTRDAVIDSHDWBVD',
+          OptGeneral: {
+            SupplierId: '6489',
+            SupplierName: 'Davids of London Ltd',
+            Description: 'Half-Day Warner Bros Studios (6-Hours)',
+            SType: 'N',
+            SCU: 'day',
+          },
+        }, {
+          Opt: 'LONHOHOTELSSTD',
+          OptGeneral: {
+            SupplierId: '6489',
+            SupplierName: 'Davids of London Ltd',
+            Description: 'Standard Room',
+            SType: 'Y',
+            Single_Avail: 'Y',
+            Other_Max: '4',
+          },
+        }],
+      },
+    });
+
+    expect(retVal.options[0].restrictions.Other).toBeNull();
+    expect(retVal.options[0].units.map(unit => unit.unitId)).not.toContain('Other');
+    expect(retVal.options[1].restrictions.Other).toEqual({
+      allowed: null,
+      maxPax: 4,
+    });
+    expect(retVal.options[1].units.map(unit => unit.unitId)).toContain('Other');
+    const otherUnit = retVal.options[1].units.find(unit => unit.unitId === 'Other');
+    expect(otherUnit.restrictions.allowed).toBeNull();
+  });
+
+  it('ignores a supplier note that only repeats the supplier name', async () => {
+    const retVal = await translateTPOption({
+      typeDefs: productTypeDefs,
+      query: '{ description }',
+      rootValue: {
+        supplierRecord: {
+          Name: 'Example Hotel',
+          Description: 'Example Hotel',
+          SupplierNotes: { SupplierNote: { NoteText: 'Example Hotel' } },
+        },
+        optionsGroupedBySupplierId: [{
+          Opt: 'LONHOHOTELSSTD',
+          OptGeneral: {
+            SupplierId: '7318',
+            SupplierName: 'Example Hotel',
+            Description: 'Standard Room',
+            SType: 'Y',
+          },
+        }],
+      },
+    });
+
+    expect(retVal.description).toBeNull();
+  });
+
+  it('prefers the class description and stores a lowercased SCU', async () => {
+    const retVal = await translateTPOption({
+      typeDefs: productTypeDefs,
+      query: `{
+        options {
+          optionId
+          optionClass
+          chargeUnit
+        }
+      }`,
+      rootValue: {
+        optionsGroupedBySupplierId: [{
+          Opt: 'TESTVALIDATEMAXPAXPERCHARGE',
+          OptGeneral: {
+            SupplierId: '7318',
+            SupplierName: 'Instyle Chauffeured Limousines Australia',
+            Description: 'City Hotel to International Airport Transfer',
+            Class: 'PRI',
+            ClassDescription: 'Private',
+            SCU: 'Day',
+          },
+        }, {
+          Opt: 'LONTRDAVIDSHDWBVD',
+          OptGeneral: {
+            SupplierId: '6489',
+            SupplierName: 'Davids of London Ltd',
+            Description: 'Half-Day Warner Bros Studios (6-Hours)',
+            Class: 'PRI',
+            SCU: '',
+          },
+        }],
+      },
+    });
+
+    expect(retVal.options[0]).toMatchObject({
+      optionId: 'TESTVALIDATEMAXPAXPERCHARGE',
+      optionClass: 'Private',
+      chargeUnit: 'day',
+    });
+    expect(retVal.options[1]).toMatchObject({
+      optionId: 'LONTRDAVIDSHDWBVD',
+      optionClass: 'PRI',
+      chargeUnit: null,
+    });
+  });
 });

package/tp-helpers/suppliers.js

@@ -0,0 +1,72 @@
+const R = require('ramda');
+const { hostConnectXmlOptions } = require('../utils');
+const { asArray, trimString } = require('./values');
+
+/** Refresh SupplierInfo cache monthly after the first successful fetch. */
+const SUPPLIERS_CACHE_TTL_SECONDS = 60 * 60 * 24 * 30;
+
+const supplierKey = value => {
+  if (value === undefined || value === null) return undefined;
+  return trimString(String(value));
+};
+
+/**
+ * Normalize SupplierInfo rows to { supplierId: supplier, supplierCode: supplier }.
+ * Notes live at SupplierNotes/SupplierNote/NoteText, not on OptGeneral.
+ */
+const toSupplierMap = entries => (
+  asArray(entries).reduce((acc, entry) => {
+    if (!entry || typeof entry !== 'object') return acc;
+    const id = supplierKey(entry.SupplierId);
+    const code = supplierKey(entry.SupplierCode);
+    if (id) acc[id] = entry;
+    if (code) acc[code] = entry;
+    return acc;
+  }, {})
+);
+
+/**
+ * Fetch SupplierInfo once per agent/endpoint, then serve from cache for a month.
+ * An unfiltered request returns the company supplier list, including notes.
+ */
+const getCachedSuppliers = async ({
+  callTourplan,
+  cache,
+  axios,
+  hostConnectEndpoint,
+  hostConnectAgentID,
+  hostConnectAgentPassword,
+}) => {
+  const model = {
+    SupplierInfoRequest: {
+      AgentID: hostConnectAgentID,
+      Password: hostConnectAgentPassword,
+    },
+  };
+  const fetchSuppliers = async () => {
+    const reply = await callTourplan({
+      model,
+      endpoint: hostConnectEndpoint,
+      axios,
+      xmlOptions: hostConnectXmlOptions,
+    });
+    return toSupplierMap(
+      R.pathOr([], ['SupplierInfoReply', 'Suppliers', 'Supplier'], reply),
+    );
+  };
+
+  if (cache && cache.getOrExec) {
+    return cache.getOrExec({
+      fnParams: ['hostconnect:SupplierInfo', hostConnectEndpoint, hostConnectAgentID],
+      fn: fetchSuppliers,
+      ttl: SUPPLIERS_CACHE_TTL_SECONDS,
+    });
+  }
+  return fetchSuppliers();
+};
+
+module.exports = {
+  SUPPLIERS_CACHE_TTL_SECONDS,
+  getCachedSuppliers,
+  toSupplierMap,
+};

package/tp-helpers/suppliers.test.js

@@ -0,0 +1,53 @@
+/* globals describe, it, expect, jest */
+const {
+  getCachedSuppliers,
+  SUPPLIERS_CACHE_TTL_SECONDS,
+  toSupplierMap,
+} = require('./suppliers');
+
+describe('tp-helpers/suppliers', () => {
+  it('refreshes SupplierInfo cache monthly', () => {
+    expect(SUPPLIERS_CACHE_TTL_SECONDS).toBe(60 * 60 * 24 * 30);
+  });
+
+  it('indexes a supplier by id and code', () => {
+    const supplier = {
+      SupplierId: 7318,
+      SupplierCode: 'HOTELS',
+      Name: 'Example Hotel',
+      SupplierNotes: {
+        SupplierNote: { NoteText: 'Family owned hotel' },
+      },
+    };
+    const map = toSupplierMap(supplier);
+    expect(map['7318']).toBe(supplier);
+    expect(map.HOTELS).toBe(supplier);
+  });
+
+  it('caches SupplierInfo per endpoint and agent', async () => {
+    const callTourplan = jest.fn().mockResolvedValue({
+      SupplierInfoReply: { Suppliers: { Supplier: [] } },
+    });
+    const cache = { getOrExec: jest.fn(({ fn }) => fn()) };
+    await getCachedSuppliers({
+      callTourplan,
+      cache,
+      axios: {},
+      hostConnectEndpoint: 'endpoint',
+      hostConnectAgentID: 'agent',
+      hostConnectAgentPassword: 'password',
+    });
+    expect(cache.getOrExec).toHaveBeenCalledWith(expect.objectContaining({
+      fnParams: ['hostconnect:SupplierInfo', 'endpoint', 'agent'],
+      ttl: SUPPLIERS_CACHE_TTL_SECONDS,
+    }));
+    expect(callTourplan).toHaveBeenCalledWith(expect.objectContaining({
+      model: {
+        SupplierInfoRequest: {
+          AgentID: 'agent',
+          Password: 'password',
+        },
+      },
+    }));
+  });
+});

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh pr diff:*)",
-      "Bash(gh pr view:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}