ti2 1.0.90 → 1.0.91

package/controllers/__tests__/bookings.js

@@ -237,6 +237,126 @@ describe('user: bookings controller', () => {
       expect(Array.isArray(products)).toBeTruthy();
       expect(products.length).toBe(2);
     });
+
+    describe('cache TTR and lock mechanism', () => {
+      const shortTTRToken = {
+        endpoint: 'https://api.travelgatex.com',
+        apiKey: chance.guid(),
+        client: 'tourconnect',
+        ttlForProducts: 2, // 2 seconds TTR
+      };
+
+      beforeEach(async () => {
+        // Clear any existing integration
+        try {
+          await doApiDelete({
+            url: `/${appKey}/${userId}`,
+            token: adminKey,
+            payload: { tokenHint: 'ttr-test' },
+          });
+        } catch (err) {
+          console.debug(err);
+        }
+
+        // Create new integration with short TTR
+        await doApiPost({
+          url: `/${appKey}/${userId}`,
+          token: adminKey,
+          payload: {
+            token: shortTTRToken,
+            tokenHint: 'ttr-test',
+          },
+        });
+
+        // Clear mock calls
+        jest.clearAllMocks();
+      });
+
+      it('should use cache within TTR period', async () => {
+        // First call should hit the plugin
+        await doApiPost({
+          url: `/products/${appKey}/${userId}/ttr-test/search`,
+          token: userToken,
+          payload: {},
+        });
+        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1);
+
+        // Second immediate call should use cache
+        await doApiPost({
+          url: `/products/${appKey}/${userId}/ttr-test/search`,
+          token: userToken,
+          payload: {},
+        });
+        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1); // Still 1, used cache
+      });
+
+      it('should refresh cache after TTR expires', async () => {
+        // Wait for TTR to expire (2 seconds + buffer) so the cache from previous test is stale
+        await new Promise(resolve => {
+          setTimeout(resolve, 2100);
+        });
+
+        // First call to populate cache
+        await doApiPost({
+          url: `/products/${appKey}/${userId}/ttr-test/search`,
+          token: userToken,
+          payload: {},
+        });
+        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1);
+
+        // Wait for TTR to expire (2 seconds + buffer)
+        await new Promise(resolve => {
+          setTimeout(resolve, 2100);
+        });
+
+        // Call after TTR expired should hit the plugin again
+        await doApiPost({
+          url: `/products/${appKey}/${userId}/ttr-test/search`,
+          token: userToken,
+          payload: {},
+        });
+        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(2);
+      });
+
+      it('should use lock mechanism to prevent concurrent calls', async () => {
+        // Wait for TTR to expire (2 seconds + buffer) so the cache from previous test is stale
+        await new Promise(resolve => {
+          setTimeout(resolve, 2100);
+        });
+
+        // Make multiple requests with slight delays to simulate real-world concurrent requests
+        const makeRequest = () => doApiPost({
+          url: `/products/${appKey}/${userId}/ttr-test/search`,
+          token: userToken,
+          payload: {},
+        });
+
+        // Start first request
+        const request1 = makeRequest();
+        // Start second request after 10ms
+        await new Promise(resolve => {
+          setTimeout(resolve, 10);
+        });
+        const request2 = makeRequest();
+        // Start third request after another 10ms
+        await new Promise(resolve => {
+          setTimeout(resolve, 10);
+        });
+        const request3 = makeRequest();
+
+        // Wait for all requests to complete
+        const results = await Promise.all([request1, request2, request3]);
+
+        // All requests should return valid products
+        results.forEach(({ products }) => {
+          expect(Array.isArray(products)).toBeTruthy();
+          expect(products.length).toBe(2); // Based on existing test expectations
+        });
+
+        // Plugin should only be called once due to lock mechanism
+        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1);
+      });
+    });
   });
 
   it('should be able to search for availabiility', async () => {

package/controllers/bookings.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
 const hash = require('object-hash');
-const cache = require('../cache');
 const R = require('ramda');
+const cache = require('../cache');
 const { UserAppKey } = require('../models/index');
 const { typeDefs: productTypeDefs, query: productQuery } = require('./graphql-schemas/product');
 const { typeDefs: availTypeDefs, query: availQuery } = require('./graphql-schemas/availability');
@@ -136,7 +136,6 @@ const $bookingsProductSearch = plugins => async ({
   requestId,
 }) => {
   const app = plugins.find(({ name }) => name === appKey);
-  // const app = load(appKey);
   assert(userId, 'userId is required');
   assert(appKey, 'appKey is required');
   assert(app.searchProducts || app.searchProductsForItinerary, `searchProducts or searchProductsForItinerary is not available for ${appKey}`);
@@ -157,20 +156,36 @@ const $bookingsProductSearch = plugins => async ({
     hint,
     operationId: 'bookingsProductSearch',
   });
-  if (forceRefresh) {
-    // remove the cache
-    await cache.drop({
-      pluginName: appKey,
-      key: cacheKey,
-    });
-  }
-  const cacheValue = await cache.get({
+  // TODO: remove debugging console.logs after no related issues reported for a while
+  // Check cache first if not forcing refresh
+  const cacheValue = forceRefresh ? null : await cache.get({
     pluginName: appKey,
     key: cacheKey,
   });
-  if (cacheValue && cacheValue.products) {
+  const lastUpdated = await cache.get({
+    pluginName: appKey,
+    key: `${cacheKey}:lastUpdated`,
+  });
+  // refresh every 24 hours
+  const ttr = token.ttlForProducts || R.path(['cacheSettings', 'bookingsProductSearch', 'ttr'], app) || 60 * 60 * 24;
+  let isStale = lastUpdated && (Date.now() - lastUpdated > ttr * 1000);
+  const doNotCallPluginForProducts = token.doNotCallPluginForProducts
+    || R.path(['cacheSettings', 'bookingsProductSearch', 'doNotCall'], app);
+  // if a company says never to call the plugin (their booking system)
+  // we will never treat their cache as stale
+  if (doNotCallPluginForProducts) {
+    isStale = false;
+  }
+  const hasLock = await cache.get({
+    pluginName: appKey,
+    key: `${cacheKey}:lock`,
+  });
+  console.log(`${appKey}/${userId}/${hint}: lastUpdated: ${lastUpdated}, ttr: ${ttr}, isStale: ${isStale}, hasLock: ${hasLock}, foundCache: ${!!cacheValue}`);
+  // when there is a lock (meaning another request is already fetching the products)
+  // return stale cache during this short window
+  if (cacheValue && cacheValue.products && (hasLock || !isStale)) {
     const searchResults = $searchProductList(cacheValue.products, searchInput, optionId);
-    console.log(`${appKey}/${userId}/${hint}: found cache and returning cached products: ${searchResults.length}`);
+    console.log(`${appKey}/${userId}/${hint}: returning cached products: ${searchResults.length}`);
     return {
       ...cacheValue,
       products: searchResults,
@@ -178,13 +193,18 @@ const $bookingsProductSearch = plugins => async ({
       ...(token.configuration || {}),
     };
   }
-  const doNotCallPluginForProducts = token.doNotCallPluginForProducts
-    || R.path(['cacheSettings', 'bookingsProductSearch', 'doNotCall'], app);
   if (doNotCallPluginForProducts && !forceRefresh) {
-    console.log(`${appKey}/${userId}/${hint}: no cache found but not calling the plugin because doNotCallPluginForProducts is true and forceRefresh is false`);
+    console.log(`${appKey}/${userId}/${hint}:not calling the plugin because doNotCallPluginForProducts is true and forceRefresh is false`);
     return { products: [] };
   }
-  console.log(`${appKey}/${userId}/${hint}: no cache found(forceRefresh: ${forceRefresh}) and calling func`);
+  console.log(`${appKey}/${userId}/${hint}: (forceRefresh: ${forceRefresh}) so calling func to get fresh products`);
+  // create a lock with 2 minute TTL
+  await cache.save({
+    pluginName: appKey,
+    key: `${cacheKey}:lock`,
+    value: true,
+    ttl: 120,
+  });
   const funcResults = await func({
     axios,
     token,
@@ -195,17 +215,30 @@ const $bookingsProductSearch = plugins => async ({
   });
   // save cache if products are found
   if (funcResults && funcResults.products && funcResults.products.length > 0) {
-    // 25 hours, just to have some buffer
-    const ttl = token.ttlForProducts || R.path(['cacheSettings', 'bookingsProductSearch', 'ttl'], app) || 60 * 60 * 25;
-    console.log(`${appKey}/${userId}/${hint}: saving cache of ${funcResults.products.length} products for (ttl:${ttl})`);
+    console.log(`${appKey}/${userId}/${hint}: saving cache of ${funcResults.products.length} products`);
+    // I initially wanted to let the cache live forever
+    // but just in case user left TC or something, we don't want to keep the cache forever
+    // so we set the TTL to 30 days, within 30 days,
+    // we will refresh the cache every 24 hours(or specified by the user) without deleting the stale cache
+    const monthInSeconds = 30 * 24 * 60 * 60;
+    await cache.save({
+      pluginName: appKey,
+      key: `${cacheKey}:lastUpdated`,
+      value: Date.now(),
+      ttl: monthInSeconds,
+    });
     await cache.save({
       pluginName: appKey,
       key: cacheKey,
       value: funcResults,
-      ttl,
-      skipTTL: Boolean(doNotCallPluginForProducts),
+      ttl: monthInSeconds,
     });
   }
+  // release the lock
+  await cache.drop({
+    pluginName: appKey,
+    key: `${cacheKey}:lock`,
+  });
   const searchResults = $searchProductList(R.pathOr([], ['products'], funcResults), searchInput, optionId);
   return {
     ...funcResults,

package/package.json

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