ti2 1.0.121 → 1.0.122

package/api.yml

@@ -433,6 +433,15 @@ components:
           required: false
           description: Product Name wildcard match
           example: '*bus*'
+        omitServiceCodes:
+          required: false
+          description: Service codes to omit from the product catalog. When the integration has productSearchOmitServiceCodes, that list is used instead.
+          example: ['AC', 'SM']
+          oneOf:
+            - type: string
+            - type: array
+              items:
+                type: string
         credentials:
           required: false
           $ref: '#/components/schemas/integrationCredentials'

package/controllers/README.md

@@ -7,7 +7,8 @@ The `$bookingsProductSearch` function in `controllers/bookings.js` implements a
 1.  **Initialization**:
     *   Retrieves user, application (`appKey`), and token details (including `hint`).
     *   Determines the specific plugin function to call for product search (e.g., `searchProducts` or `searchProductsForItinerary`).
-    *   Calculates a `cacheKey` based on `userId`, `hint`, and a static `operationId` ('bookingsProductSearch').
+    *   Injects the integration's configured `productSearchOmitServiceCodes` into the plugin payload so every caller for that token omits the same service codes. When the setting is empty, the request body is unchanged.
+    *   Calculates a `cacheKey` based on `userId`, `hint`, and a static `operationId` (`bookingsProductSearch`). Changing the omit setting does not change the key; clear that integration's product-search cache and resync.
     *   Defines two distinct lock keys derived from this `cacheKey`:
         *   `pluginExecutionLockKey` (resolves to `${cacheKey}:lock`): Used to serialize direct calls to the plugin.
         *   `jobQueueLockKey` (resolves to `${cacheKey}:jobLock`): Used to prevent multiple submissions of background refresh jobs.

package/controllers/__tests__/bookings-searchProducts.js

@@ -271,6 +271,112 @@ describe('user: bookings controller - searchProducts', () => {
 
       });
     });
+    describe('configured productSearchOmitServiceCodes', () => {
+      const configuredOmitHint = 'configured-product-omit-service-codes';
+      let cacheKey;
+
+      beforeAll(async () => {
+        await globalUtils.appSetup({
+          appName: testAppName,
+          userId: testUserId,
+          tokenHint: configuredOmitHint,
+          token: {
+            endpoint: 'https://api.travelgatex.com/configured-omit',
+            apiKey: chance.guid(),
+            client: 'tourconnect-configured-omit',
+            productSearchOmitServiceCodes: ' sm, AC, ac ',
+          },
+        });
+        cacheKey = hash({
+          userId: testUserId,
+          hint: configuredOmitHint,
+          operationId: 'bookingsProductSearch',
+        });
+      });
+
+      beforeEach(async () => {
+        await Promise.all([
+          cache.drop({ pluginName: testAppName, key: cacheKey }),
+          cache.drop({ pluginName: testAppName, key: `${cacheKey}:lastUpdated` }),
+          cache.drop({ pluginName: testAppName, key: `${cacheKey}:lock` }),
+          cache.drop({ pluginName: testAppName, key: `${cacheKey}:jobLock` }),
+        ]);
+      });
+
+      it('sends configured omissions when the caller omits the field', async () => {
+        await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${configuredOmitHint}/search`,
+          token: userToken,
+          payload: {},
+        });
+
+        expect(travelgatePlugin.searchProducts).toHaveBeenCalledTimes(1);
+        expect(
+          travelgatePlugin.searchProducts.mock.calls[0][0].payload.omitServiceCodes,
+        ).toEqual(['AC', 'SM']);
+        expect(await cache.get({ pluginName: testAppName, key: cacheKey })).toBeTruthy();
+      });
+
+      it('keeps configured omissions during an empty-scope force refresh', async () => {
+        await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${configuredOmitHint}/search`,
+          token: userToken,
+          payload: { forceRefresh: true, omitServiceCodes: [] },
+        });
+
+        expect(travelgatePlugin.searchProducts).toHaveBeenCalledTimes(1);
+        expect(travelgatePlugin.searchProducts.mock.calls[0][0].payload).toEqual({
+          forceRefresh: true,
+          omitServiceCodes: ['AC', 'SM'],
+        });
+      });
+
+      it('ignores extra request omit codes once the integration is configured', async () => {
+        await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${configuredOmitHint}/search`,
+          token: userToken,
+          payload: { omitServiceCodes: ['TR'] },
+        });
+
+        expect(
+          travelgatePlugin.searchProducts.mock.calls[0][0].payload.omitServiceCodes,
+        ).toEqual(['AC', 'SM']);
+      });
+
+      it('preserves configured omissions in stale background refreshes', async () => {
+        await cache.save({
+          pluginName: testAppName,
+          key: cacheKey,
+          value: { products: [{ productId: 'stale-product' }] },
+          ttl: 60,
+        });
+        await cache.save({
+          pluginName: testAppName,
+          key: `${cacheKey}:lastUpdated`,
+          value: 1,
+          ttl: 60,
+        });
+
+        const result = await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${configuredOmitHint}/search`,
+          token: userToken,
+          payload: {},
+        });
+
+        expect(result.products).toEqual([{ productId: 'stale-product' }]);
+        expect(travelgatePlugin.searchProducts).not.toHaveBeenCalled();
+        expect(addJob).toHaveBeenCalledTimes(1);
+        expect(addJob.mock.calls[0][0].payload.payload).toEqual({
+          forceRefresh: false,
+          omitServiceCodes: ['AC', 'SM'],
+        });
+        expect(addJob.mock.calls[0][0].postProcess.args).toEqual({
+          appKey: testAppName,
+          userId: testUserId,
+          hint: configuredOmitHint,
+        });
+      });
+    });
     describe('cache TTR and lock mechanism', () => {
       const ttrTestHint = 'ttr-test'; // This hint is for UserAppKey within 'travelgate' appName
       const shortTTRToken = {

package/controllers/app.js

@@ -50,7 +50,6 @@ const tokenTemplate = async (req, res, next) => {
   try {
     const thePlugin = req.app.plugins.find(({ name }) => name === pluginName);
     assert(thePlugin);
-    let template = thePlugin.tokenTemplate();
     const safeRegExp = el => {
       if (!el || !(el.regExp instanceof RegExp)) {
         return el;
@@ -64,24 +63,28 @@ const tokenTemplate = async (req, res, next) => {
         },
       };
     };
-    template = R.map(safeRegExp, template);
-    return res.json({
-      template: {
-        ...template,
-        // ttlProducts and doNotCallPluginForProducts are being used at ti2 level
-        // hence we should just by default allow them for all ti2 plugins
-        ttlForProducts: {
-          type: 'number',
-          regExp: /.+/,
-          default: 60 * 60 * 24, // 1 day
-        },
-        doNotCallPluginForProducts: {
-          type: 'boolean',
-          regExp: /.+/,
-          default: false,
-        },
+    const template = R.map(safeRegExp, {
+      ...thePlugin.tokenTemplate(),
+      // ttlProducts and doNotCallPluginForProducts are being used at ti2 level
+      // hence we should just by default allow them for all ti2 plugins
+      ttlForProducts: {
+        type: 'number',
+        regExp: /.+/,
+        default: 60 * 60 * 24, // 1 day
+      },
+      doNotCallPluginForProducts: {
+        type: 'boolean',
+        regExp: /.+/,
+        default: false,
+      },
+      productSearchOmitServiceCodes: {
+        type: 'text',
+        regExp: /^[\sA-Za-z0-9,]*$/,
+        default: '',
+        description: 'Service codes that every product search for this integration must omit',
       },
     });
+    return res.json({ template });
   } catch (err) {
     return next(err);
   }

package/controllers/bookings.js

@@ -50,7 +50,19 @@ const legacyProductSearchCacheEvents = {
 };
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-const productSearchCacheKey = ({ userId, hint }) => hash({ userId, hint, operationId: productSearchOperationId });
+const normalizeOmitServiceCodes = (...values) => [...new Set(
+  values
+    .reduce((items, value) => items.concat(Array.isArray(value) ? value : [value]), [])
+    .reduce((items, value) => items.concat(String(value == null ? '' : value).split(',')), [])
+    .map(value => value.trim().toUpperCase())
+    .filter(Boolean),
+)].sort();
+
+const productSearchCacheKey = ({ userId, hint }) => hash({
+  userId,
+  hint,
+  operationId: productSearchOperationId,
+});
 
 const productSearchSelectorFields = [
   'searchInput',
@@ -58,7 +70,6 @@ const productSearchSelectorFields = [
   'productId',
   'productName',
   'lastUpdatedFrom',
-  'skipAccommodation',
 ];
 
 const hasProductSearchSelector = payload => productSearchSelectorFields.some(field => {
@@ -79,7 +90,17 @@ const hasProductCache = cacheContent => Boolean(cacheContent && cacheContent.pro
 
 const safeHash = value => (value === undefined || value === null ? undefined : hash(String(value)));
 
-const emitProductSearchCacheDecision = ({ app, cacheKey, userId, hint, requestId, searchInput, optionId, forceRefresh, startedAt }, action, extra = {}) => {
+const emitProductSearchCacheDecision = ({
+  app,
+  cacheKey,
+  userId,
+  hint,
+  requestId,
+  searchInput,
+  optionId,
+  forceRefresh,
+  startedAt,
+}, action, extra = {}) => {
   if (!app.events || !app.events.emit) return;
   const payload = {
     action,
@@ -303,27 +324,40 @@ const $bookingsProductSearch = plugins => async ({
   requestId,
   headers, // To pass original request headers for background job
 }) => {
+  const { app, token } = await getAppAndToken({ plugins, appKey, userId, hint });
+  assert(userId, 'userId is required');
+  assert(appKey, 'appKey is required');
+  assert(app.searchProducts || app.searchProductsForItinerary, `searchProducts or searchProductsForItinerary is not available for ${appKey}`);
+  const func = (app.searchProducts || app.searchProductsForItinerary).bind(app);
+
+  const configuredOmitServiceCodes = normalizeOmitServiceCodes(
+    R.path(['productSearchOmitServiceCodes'], token),
+  );
+  const normalizedRequestBody = {
+    ...originalRequestBody,
+    ...(configuredOmitServiceCodes.length ? {
+      omitServiceCodes: configuredOmitServiceCodes,
+    } : {}),
+  };
+
   // Extract controller-specific flags from originalRequestBody
   const {
     searchInput = '', // Provide defaults
     optionId = '',
     forceRefresh = false,
-  } = originalRequestBody;
+  } = normalizedRequestBody;
 
-  // Payload for the plugin function (func) - pass forceRefresh so plugins can trigger background cache rebuilds
-  const payloadForPlugin = { ...R.omit(['forceRefresh'], originalRequestBody), forceRefresh };
-  const isScopedSearch = hasProductSearchSelector(originalRequestBody);
+  // Keep forceRefresh in the plugin payload so plugins can trigger their own rebuilds.
+  const payloadForPlugin = {
+    ...R.omit(['forceRefresh'], normalizedRequestBody),
+    forceRefresh,
+  };
+  const isScopedSearch = hasProductSearchSelector(normalizedRequestBody);
   const payloadForBackgroundJob = R.omit(
     ['credentials', ...productSearchSelectorFields],
     payloadForPlugin,
   );
 
-  const { app, token } = await getAppAndToken({ plugins, appKey, userId, hint });
-  assert(userId, 'userId is required');
-  assert(appKey, 'appKey is required');
-  assert(app.searchProducts || app.searchProductsForItinerary, `searchProducts or searchProductsForItinerary is not available for ${appKey}`);
-  const func = (app.searchProducts || app.searchProductsForItinerary).bind(app);
-
   const cacheKey = productSearchCacheKey({ userId, hint });
   const telemetryContext = {
     app,
@@ -336,7 +370,11 @@ const $bookingsProductSearch = plugins => async ({
     forceRefresh,
     startedAt: Date.now(),
   };
-  const emitDecision = (action, extra = {}) => emitProductSearchCacheDecision(telemetryContext, action, extra);
+  const emitDecision = (action, extra = {}) => emitProductSearchCacheDecision(
+    telemetryContext,
+    action,
+    extra,
+  );
   const pluginExecutionLockKey = `${cacheKey}:lock`; // Lock for direct plugin execution
   const jobQueueLockKey = `${cacheKey}:jobLock`;   // Lock for preventing multiple job queues
 
@@ -349,6 +387,7 @@ const $bookingsProductSearch = plugins => async ({
   const hasPluginExecutionLock = await app.cache.get({ key: pluginExecutionLockKey });
   emitDecision(hasProductCache(initialActualCacheContent) ? 'cache_hit' : 'cache_miss', {
     cacheProductCount: productCount(initialActualCacheContent),
+    cacheOptionCount: optionCount(initialActualCacheContent),
     cacheAgeMs: lastUpdated ? Date.now() - lastUpdated : undefined,
     ttrMs: ttr * 1000,
     reason: hasPluginExecutionLock ? 'lockActive' : undefined,
@@ -416,6 +455,7 @@ const $bookingsProductSearch = plugins => async ({
           reason: 'waitedForLeader',
           lockWaitMs,
           cacheProductCount: productCount(cacheContent),
+          cacheOptionCount: optionCount(cacheContent),
         });
         return cacheContent;
       }
@@ -457,6 +497,7 @@ const $bookingsProductSearch = plugins => async ({
           reason,
           pluginElapsedMs,
           cacheProductCount: productCount(pluginResults),
+          cacheOptionCount: optionCount(pluginResults),
         });
       } else if (pluginResults && (pluginResults.catalogPartial || pluginResults.partial)) {
         emitDecision('partial_refresh_skipped', {
@@ -492,7 +533,9 @@ const $bookingsProductSearch = plugins => async ({
       emitDecision('cache_hit', {
         reason: 'doNotCallPluginForProducts',
         cacheProductCount: initialActualCacheContent.products.length,
+        cacheOptionCount: optionCount(initialActualCacheContent),
         returnedProductCount: searchResults.length,
+        returnedOptionCount: optionCount({ products: searchResults }),
       });
       return { ...initialActualCacheContent, products: searchResults, ...(token.configuration || {}) };
     }
@@ -522,7 +565,9 @@ const $bookingsProductSearch = plugins => async ({
         const searchResults = $searchProductList(initialActualCacheContent.products, searchInput, optionId);
         emitDecision(action, {
           cacheProductCount: initialActualCacheContent.products.length,
+          cacheOptionCount: optionCount(initialActualCacheContent),
           returnedProductCount: searchResults.length,
+          returnedOptionCount: optionCount({ products: searchResults }),
           cacheAgeMs: lastUpdated ? Date.now() - lastUpdated : undefined,
           ttrMs: ttr * 1000,
           ...extra,
@@ -879,7 +924,10 @@ const $updateProductSearchCache = plugins => async ({
   if (hasCacheableProductResults(pluginResult)) {
     await markRefreshAttempted();
     await app.cache.save({ key: cacheKey, value: pluginResult, ttl: productSearchCacheTtlSeconds });
-    emitCacheEvent('cache_saved', { cacheProductCount: productCount(pluginResult) });
+    emitCacheEvent('cache_saved', {
+      cacheProductCount: productCount(pluginResult),
+      cacheOptionCount: optionCount(pluginResult),
+    });
   } else {
     const isPartialRefresh = pluginResult && (pluginResult.catalogPartial || pluginResult.partial);
     const existingCacheContent = await app.cache.get({ key: cacheKey });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2",
-  "version": "1.0.121",
+  "version": "1.0.122",
   "description": "Tourist Industry Exchange (TI2)",
   "main": "index.js",
   "scripts": {