ti2 1.0.92 → 1.0.93

package/api.yml

@@ -41,15 +41,13 @@ components:
           type: object
           description: The job app parameters
           required: true
-          example: '{
-            "method": "dailyReport"
-          }'
+          example:
+            method: dailyReport
         jobParams:
           type: object
           description: Additional bull job params
-          example: '{
-            "delay": "5000"
-          }'
+          example:
+            delay: 5000
     JobStatus:
       type: object
       properties:
@@ -388,6 +386,23 @@ components:
         settings:
           type: object
           description: an object with the app+user seettings
+  parameters:
+    CallbackUrl:
+      name: callbackUrl
+      in: query
+      description: Callback URL for asynchronous operations
+      required: false
+      schema:
+        type: string
+        format: url
+    BackgroundJob:
+      name: backgroundJob
+      in: query
+      description: Whether to run the job in the background
+      required: false
+      schema:
+        type: boolean
+        default: false
 paths:
   /ping:
     get:
@@ -1640,6 +1655,8 @@ paths:
           required: true
           schema:
             type: string
+        - $ref: '#/components/parameters/CallbackUrl'
+        - $ref: '#/components/parameters/BackgroundJob'
       requestBody:
         description: Search query
         required:  true
@@ -1683,6 +1700,8 @@ paths:
           example: 'travelgate-australia'
           schema:
             type: string
+        - $ref: '#/components/parameters/CallbackUrl'
+        - $ref: '#/components/parameters/BackgroundJob'
       requestBody:
         description: Search query
         required:  true

package/closeAll.js

@@ -1,8 +1,22 @@
 const { redisResults, queue } = require('./worker/queue');
 const { cache } = require('./cache');
+const { sequelize } = require('./models');
 
 module.exports = async () => {
+  // Close queue and redis connections
   await queue.close();
   await redisResults.quit();
   await cache.quit();
+  
+  // Close database connection if it exists and is open
+  if (sequelize && typeof sequelize.close === 'function') {
+    try {
+      await sequelize.close();
+    } catch (err) {
+      // If connection is already closed, ignore the error
+      if (!err.message.includes('Connection already closed')) {
+        console.error('Error closing sequelize connection:', err);
+      }
+    }
+  }
 };

package/controllers/__tests__/allotments.js

@@ -1,9 +1,8 @@
-/* globals beforeAll describe it expect */
+/* globals beforeAll describe it expect jest */
 const axios = require('axios');
 const MockAdapter = require('axios-mock-adapter');
 const chance = require('chance').Chance();
 
-
 const testUtils = require('../../test/utils');
 
 const { env: { adminKey } } = process;
@@ -15,7 +14,8 @@ describe('allotment', () => {
     adminEmail: 'engineering+tourplantest@tourconnect.com',
   };
   const appKey = newApp.name;
-  const userId = '551394be5ac58e5c76000019';
+  // Generate a random userId for better test isolation
+  const userId = `test-user-${chance.guid()}`;
   const token = {
     endpoint: 'https://someendpoint.com',
     username: chance.guid(),
@@ -25,14 +25,12 @@ describe('allotment', () => {
     tokenHint: 'testingToken',
     token,
   };
-  let doApiDelete;
   let doApiGet;
   let doApiPost;
   let plugins;
   let userToken;
   beforeAll(async () => {
     ({
-      doApiDelete,
       doApiGet,
       doApiPost,
       plugins,
@@ -40,18 +38,8 @@ describe('allotment', () => {
       plugins: [appKey],
     }));
 
-    // drop any existing user integrations
-    try {
-      await doApiDelete({
-        url: `/${appKey}/${userId}`,
-        token: adminKey,
-        payload: { tokenHint: newIntegration.tokenHint },
-      });
-    } catch (err) {
-      // console.debug(err);
-    }
-
-    // create the user
+    // Using random user IDs, so no need to drop existing integrations
+    // create the user - handle case where random user doesn't exist yet
     ({ value: userToken } = await doApiPost({
       url: '/user',
       token: adminKey,
@@ -59,20 +47,13 @@ describe('allotment', () => {
     }));
     expect(userToken).toBeTruthy();
 
-    // create the App+User setup
-    const { userAppKeys } = await doApiGet({
-      url: `/user/${userId}/apps`,
+    // create the App+User relation
+    const { value } = await doApiPost({
+      url: `/${appKey}/${userId}`,
       token: userToken,
+      payload: newIntegration,
     });
-    if (!userAppKeys.map(e => e.integrationId).includes(appKey)) {
-      // relation does not exits
-      const { value } = await doApiPost({
-        url: `/${appKey}/${userId}`,
-        token: userToken,
-        payload: newIntegration,
-      });
-      expect(value).toBeTruthy();
-    }
+    expect(value).toBeTruthy();
   });
   const payload = {
     dateFormat: 'DD-MM-YYYY',
@@ -106,10 +87,13 @@ describe('allotment', () => {
     expect(call.token).toEqual(token);
   });
   it('should be able to receive an axios error', async () => {
+    // Temporarily silence console.error for this test since we're expecting an error
+    const originalConsoleError = console.error;
+    console.error = jest.fn();
+    
     const mock = new MockAdapter(axios);
     mock.onGet('http://www.example.com').reply(500, { what: 'nothing here' });
     let urlParamsError = new URLSearchParams({
-
       ...payload,
       keyPath: 'errorAxios',
     }).toString();
@@ -120,8 +104,14 @@ describe('allotment', () => {
     });
     expect(returnValue.allotments).toBeFalsy();
     expect(returnValue.message).toBe('nothing here');
+    // Restore console.error even if the test fails
+    console.error = originalConsoleError;
   });
   it('should be able to receive an error from a regular response', async () => {
+    // Temporarily silence console.error for this test since we're expecting an error
+    const originalConsoleError = console.error;
+    console.error = jest.fn();
+
     const mock = new MockAdapter(axios);
     mock.onGet('http://www.example.com').reply(200, { error: 'something went wrong' });
     let urlParamsError = new URLSearchParams({
@@ -135,5 +125,7 @@ describe('allotment', () => {
     });
     expect(returnValue.allotments).toBeFalsy();
     expect(returnValue.message).toBe('something went wrong');
+    // Restore console.error even if the test fails
+    console.error = originalConsoleError;
   });
 });

package/controllers/__tests__/app.js

@@ -112,18 +112,20 @@ describe('app', () => {
       expect(jobId).toBeTruthy();
       expect(status).toBeTruthy();
     });
-    it('should be able to get the status of a ran job', async () => {
-      await global.sleep(5e3);
+    it('should be able to get the status of a job', async () => {
       const url = `/${appName}/${userId}/${jobId}/jobStatus`;
-      const jobStatus = await doApiGet({
-        url,
-        token: appKey,
-        payload: {},
-      });
-      expect(jobStatus.jobId).toBeTruthy();
+      let jobStatus;
+      do {
+        jobStatus = await doApiGet({
+          url,
+          token: appKey,
+          payload: {},
+        });
+        await global.sleep(1e3);
+      } while (['waiting', 'active'].includes(jobStatus.status));
       expect(jobStatus.status).toBe('success');
       expect(jobStatus.result).toEqual({ someVal: true });
-    }, 6e3);
+    }, 30e3);
   });
   it('should be able to get a list of all tokens related to the app', async () => {
     const { userAppKeys } = await doApiGet({

package/controllers/__tests__/bookings.js

@@ -14,7 +14,8 @@ describe('user: bookings controller', () => {
     adminEmail: 'engineering+travelgate@tourconnect.com',
   };
   const appKey = newApp.name;
-  const userId = '551394be5ac58e5c76000019';
+  // Generate a random userId for better test isolation
+  const userId = `test-user-${chance.guid()}`;
   const token = {
     endpoint: 'https://api.travelgatex.com',
     apiKey: chance.guid(),
@@ -28,6 +29,7 @@ describe('user: bookings controller', () => {
   let doApiGet;
   let doApiPost;
   let plugins;
+  let userToken;
   beforeAll(async () => {
     ({
       doApiDelete,
@@ -38,67 +40,69 @@ describe('user: bookings controller', () => {
       plugins: [newApp.name],
     }));
 
-    // drop all cache keys, clean slate
-    const cacheKeys = await cache.keys();
-    cacheKeys.forEach(key => cache.drop({
-      pluginName: key.split(':')[0],
-      key: key.split(':')[1],
-    }));
-  });
-  beforeEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  let userToken;
-  it('drop any existing travelgateapp integration', async () => {
-    try {
-      await doApiDelete({
-        url: `/travelgate/${userId}`,
-        token: adminKey,
-        payload: { tokenHint: 'testingToken' },
-      });
-    } catch (err) {
-      console.debug(err);
-    }
-    try {
-      await doApiDelete({
-        url: '/app/travelgate',
-        token: adminKey,
-      });
-    } catch (err) {
-      console.debug(err);
-    }
-  });
-  it('create the travelgate app', async () => {
+    // drop all related cache keys, clean slate for this user
+    const cacheKey = hash({
+      appKey,
+      userId,
+      hint: 'testingToken',
+      operationId: 'bookingsProductSearch',
+    });
+    await cache.drop({
+      pluginName: appKey,
+      key: cacheKey,
+    });
+    await cache.drop({
+      pluginName: appKey,
+      key: `${cacheKey}:lock`,
+    });
+    // create the travelgate app and user
     const { value: apiKey } = await doApiPost({
       url: '/app',
       token: adminKey,
       payload: newApp,
     });
     expect(apiKey).toBeTruthy();
-    // create the user token
+
+    // Create the user token
     ({ value: userToken } = await doApiPost({
       url: '/user',
       token: adminKey,
       payload: { userId },
     }));
     expect(userToken).toBeTruthy();
-  });
-  it('create the travelGage+User setup', async () => {
-    const { userAppKeys } = await doApiGet({
+    // Create the user first, then get the token
+    await doApiPost({
+      url: '/user',
+        token: adminKey,
+        payload: { userId, email: `${userId}@example.com` },
+      });
+      // Now get the token
+      ({ value: userToken } = await doApiPost({
+        url: '/user',
+        token: adminKey,
+        payload: { userId },
+      }));
+      expect(userToken).toBeTruthy();
+    // create the travelGage+User setup
+    let userAppKeys = [];
+    ({ userAppKeys } = await doApiGet({
       url: `/user/${userId}/apps`,
       token: userToken,
-    });
+    }));
+    // Check if we need to create the integration
     if (!userAppKeys.find(e => e.hint === newIntegration.tokenHint
-        && e.integrationId === newApp.name)) {
-      // relation does not exits
+      && e.integrationId === newApp.name)) {
+      // relation does not exist
       const { value } = await doApiPost({
         url: `/${appKey}/${userId}`,
         token: userToken,
-        payload: newIntegration,
-      });
-      expect(value).toBeTruthy();
-    }
+          payload: newIntegration,
+        });
+        expect(value).toBeTruthy();
+      }
+  });
+  beforeEach(async () => {
+    jest.clearAllMocks();
   });
   it('should be able to search a for a booking', async () => {
     const payload = {
@@ -173,6 +177,7 @@ describe('user: bookings controller', () => {
       expect(products[1].options.length).toBe(2);
     });
     it('should be able to get booking products with searchInput', async () => {
+
       const payload = {
         searchInput: 'Transfer from Sydney Harbor to Hilton Hotel',
       };
@@ -245,35 +250,21 @@ describe('user: bookings controller', () => {
         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
+      beforeAll(async () => {
         await doApiPost({
           url: `/${appKey}/${userId}`,
-          token: adminKey,
+          token: userToken,
           payload: {
-            token: shortTTRToken,
             tokenHint: 'ttr-test',
+            token: shortTTRToken,
           },
         });
-
-        // Clear mock calls
+      });
+      beforeEach(async () => {
         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,

package/controllers/__tests__/productsSearch-background.js

@@ -0,0 +1,111 @@
+/* globals beforeAll describe it expect jest beforeEach */
+
+const chance = require('chance').Chance();
+const testUtils = require('../../test/utils');
+
+describe('user: bookings controller - productSearch background job', () => {
+  const newApp = {
+    name: `travelgate-${chance.guid()}`,
+    packageName: 'ti2-travelgate',
+    adminEmail: 'engineering+travelgate@tourconnect.com',
+  };
+  const appKey = newApp.name;
+  const userId = `testUser-${chance.guid()}`;
+  const token = {
+    endpoint: 'https://api.travelgatex.com',
+    apiKey: chance.guid(),
+    client: 'tourconnect',
+  };
+  const tokenHint = 'testingToken';
+  const newIntegration = {
+    tokenHint,
+    token,
+  };
+  let doApiDelete;
+  let doApiGet;
+  let doApiPost;
+  let plugins;
+  let userToken;
+
+  beforeAll(async () => {
+    // Setup test utilities with mocked plugins
+    ({
+      doApiDelete,
+      doApiGet,
+      doApiPost,
+      plugins,
+    } = await testUtils({
+      plugins: [newApp.name],
+    }));
+    
+    const { env: { adminKey } } = process;
+    // create the user
+    await doApiPost({
+      url: '/user',
+      token: adminKey,
+      payload: { userId, email: `${userId}@example.com` },
+    });
+    // Clean slate - Drop potential existing app/user integration
+    await doApiPost({
+      url: '/app',
+      token: adminKey,
+      payload: newApp,
+    });
+
+    // Create the test user and get token
+    ({ value: userToken } = await doApiPost({
+      url: '/user',
+      token: adminKey,
+      payload: { userId },
+    }));
+
+    // Create the user integration
+    await doApiPost({
+      url: `/${appKey}/${userId}`,
+      token: userToken,
+      payload: newIntegration,
+    });
+  });
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  it('should create a background job when calling bookingsProductSearch with backgroundJob in payload', async () => {
+    // Payload with backgroundJob flag set to true
+    const payload = {
+      backgroundJob: true
+    };
+
+    // Call the endpoint with backgroundJob in the payload
+    const response = await doApiPost({
+      url: `/products/${appKey}/${userId}/${tokenHint}/search`,
+      token: userToken,
+      payload,
+      // Expect 200 OK with a jobId in the response
+      expectStatusCode: 200,
+    });
+
+    // Check if jobId is returned in the response body
+    expect(response.jobId).toBeTruthy();
+    expect(typeof response.jobId).toBe('string');
+  });
+
+  it('should return products directly when not using backgroundJob flag', async () => {
+    // Payload without backgroundJob flag
+    const payload = {};
+
+    // Call the endpoint without backgroundJob flag
+    const response = await doApiPost({
+      url: `/products/${appKey}/${userId}/${tokenHint}/search`,
+      token: userToken,
+      payload,
+      // Expect 200 OK, as the endpoint returns results directly
+      expectStatusCode: 200,
+    });
+
+    // Check if products array is returned in the response body
+    expect(Array.isArray(response.products)).toBeTruthy();
+    expect(response.products.length).toBeGreaterThan(0);
+  });
+});

package/controllers/bookings.js

@@ -1,7 +1,6 @@
 const assert = require('assert');
 const hash = require('object-hash');
 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');
@@ -151,19 +150,15 @@ const $bookingsProductSearch = plugins => async ({
   const func = (app.searchProducts || app.searchProductsForItinerary).bind(app);
   // NOTE: this is intend to cache the entire product list
   const cacheKey = hash({
-    appKey,
     userId,
     hint,
     operationId: 'bookingsProductSearch',
   });
-  // 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,
+  const cacheValue = forceRefresh ? null : await app.cache.get({
     key: cacheKey,
   });
-  const lastUpdated = await cache.get({
-    pluginName: appKey,
+  const lastUpdated = await app.cache.get({
     key: `${cacheKey}:lastUpdated`,
   });
   // refresh every 24 hours
@@ -176,16 +171,13 @@ const $bookingsProductSearch = plugins => async ({
   if (doNotCallPluginForProducts) {
     isStale = false;
   }
-  const hasLock = await cache.get({
-    pluginName: appKey,
+  const hasLock = await app.cache.get({
     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}: returning cached products: ${searchResults.length}`);
     return {
       ...cacheValue,
       products: searchResults,
@@ -194,13 +186,10 @@ const $bookingsProductSearch = plugins => async ({
     };
   }
   if (doNotCallPluginForProducts && !forceRefresh) {
-    console.log(`${appKey}/${userId}/${hint}:not calling the plugin because doNotCallPluginForProducts is true and forceRefresh is false`);
     return { products: [] };
   }
-  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,
+  await app.cache.save({
     key: `${cacheKey}:lock`,
     value: true,
     ttl: 120,
@@ -215,28 +204,32 @@ const $bookingsProductSearch = plugins => async ({
   });
   // save cache if products are found
   if (funcResults && funcResults.products && funcResults.products.length > 0) {
-    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,
+    await app.cache.save({
       key: `${cacheKey}:lastUpdated`,
       value: Date.now(),
       ttl: monthInSeconds,
     });
-    await cache.save({
-      pluginName: appKey,
+    await app.cache.save({
       key: cacheKey,
       value: funcResults,
       ttl: monthInSeconds,
     });
+    app.events.emit('bookingsProductSearch:cache:save', {
+      cacheKey,
+      userId,
+      hint,
+      operationId: 'bookingsProductSearch',
+      requestId,
+      pluginName: app.name,
+    });
   }
   // release the lock
-  await cache.drop({
-    pluginName: appKey,
+  await app.cache.drop({
     key: `${cacheKey}:lock`,
   });
   const searchResults = $searchProductList(R.pathOr([], ['products'], funcResults), searchInput, optionId);

package/index.js

@@ -14,6 +14,7 @@ const { v4: uuidv4 } = require('uuid');
 const EventEmitter = require('eventemitter2');
 const axios = require('axios');
 const curlirize = require('axios-curlirize');
+const { addJob } = require('./worker/queue');
 
 const cacheSettings = {
   '*': [
@@ -58,13 +59,14 @@ const axiosSafeResponse = response => {
 module.exports = async ({
   apiDocs = true,
   plugins: pluginsParam = {},
+  pluginsInstantiated = false,
   port: portParam,
   startServer = true,
   worker = false,
 }) => {
   const port = portParam || process.env.PORT || 10010;
   // create the plugin instances
-  const plugins = await bb.map(Object.entries(pluginsParam), async ([pluginName, Plugin]) => {
+  const plugins = pluginsInstantiated || await bb.map(Object.entries(pluginsParam), async ([pluginName, Plugin]) => {
     // pass all env variables
     const pluginEnv = pickBy(
       (_val, key) => key.substring(0, `ti2_${pluginName}`.length)
@@ -83,6 +85,7 @@ module.exports = async ({
         getOrExec: args => cache.getOrExec({ ...args, pluginName }),
         save: args => cache.save({ ...args, pluginName }),
       },
+      axios,
       events: ti2Events,
       name: pluginName,
       ...params,
@@ -277,6 +280,44 @@ module.exports = async ({
             },
           }
         */
+       // check if the operation is supposed to be ran in the background
+        const backgroundJob = R.pathOr(
+          false, ['backgroundJob'], req.body,
+        );
+       if (backgroundJob) {
+        const job = await addJob({
+          type: 'api',
+          method: req.method,
+          url: req.url,
+          headers: req.headers,
+          payload: {
+            ...req.body,
+            requestId: req.requestId,
+          },
+        });
+        return res.json({ jobId: job });
+       }
+       // intercept res.json
+        const callbackUrl = R.pathOr(
+          false, ['callbackUrl'], req.body);
+        if (callbackUrl) {
+          // send callback
+          const originalJson = res.json;
+          res.json = function (data) {
+            const callbackBody = {
+              callbackUrl,
+              request: body,
+              result: data,
+            };
+            addJob({
+              type: 'callback',
+              payload: callbackBody,
+            }).then(jobId => {
+              console.debug('created callback job', jobId);
+            });
+            return originalJson.call(this, data);
+          };
+        }
         const pluginCacheSettings = R.pathOr({}, ['cacheSettings'], currentPlugin);
         // Filter plugin cache settings to only include those with cacheInMiddleware: true
         const filteredPluginCacheSettings = R.pickBy(

package/jest.setup.js

@@ -1,8 +1,22 @@
-/* global afterAll */
+/* global beforeAll afterAll */
 
 const closeAll = require('./closeAll');
+const models = require('./models');
 
+// Setup global beforeAll and afterAll hooks
+beforeAll(async () => {
+  // Ensure database connection is established before tests
+  if (models.sequelize && typeof models.sequelize.authenticate === 'function') {
+    await models.sequelize.authenticate();
+  }
+});
+
+// Make sure all connections are properly closed after tests
 afterAll(async () => {
+  // Wait a bit to ensure all pending operations are completed
+  await global.sleep(100);
+  
+  // Then close all connections
   await closeAll();
 });
 

package/lib/__tests__/callback.js

@@ -0,0 +1,131 @@
+/* globals beforeAll describe it expect jest afterAll beforeEach */
+
+const axios = require('axios');
+const MockAdapter = require('axios-mock-adapter');
+const { sendCallback } = require('../callback');
+
+describe('callback', () => {
+  let mock;
+
+  beforeAll(() => {
+    mock = new MockAdapter(axios);
+  });
+
+  afterAll(() => {
+    mock.restore();
+  });
+
+  beforeEach(() => {
+    mock.reset();
+    jest.clearAllMocks();
+  });
+
+  describe('sendCallback', () => {
+    it('should not do anything if callbackUrl is not provided', async () => {
+      const consoleSpy = jest.spyOn(console, 'error');
+      await sendCallback({
+        request: {
+          operationId: 'test',
+          payload: { test: true },
+          userId: '123',
+          integrationId: 'test-integration',
+          hint: 'test-hint'
+        },
+        result: { success: true },
+      });
+      expect(consoleSpy).not.toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+
+    it('should send a POST request to the callback URL with correct payload', async () => {
+      const callbackUrl = 'https://api.example.com/callback';
+      const params = {
+        callbackUrl,
+        request: {
+          operationId: 'bookingsProductSearch',
+          payload: { searchInput: 'test' },
+          userId: '123',
+          integrationId: 'test-integration',
+          hint: 'test-hint'
+        },
+        result: { products: [] }
+      };
+
+      mock.onPost(callbackUrl).reply((config) => {
+        const data = JSON.parse(config.data);
+        expect(data).toMatchObject({
+          request: params.request,
+          result: params.result,
+          timestamp: expect.any(String)
+        });
+        return [200];
+      });
+
+      await sendCallback(params);
+      expect(mock.history.post.length).toBe(1);
+      expect(mock.history.post[0].url).toBe(callbackUrl);
+    });
+
+    it('should log error when callback request fails', async () => {
+      const callbackUrl = 'https://api.example.com/callback';
+      const params = {
+        callbackUrl,
+        request: {
+          operationId: 'bookingsProductSearch',
+          payload: { searchInput: 'test' },
+          userId: '123',
+          integrationId: 'test-integration',
+          hint: 'test-hint'
+        },
+        result: { products: [] }
+      };
+
+      mock.onPost(callbackUrl).reply(500);
+
+      // Mock console.error but prevent actual logging
+      const originalError = console.error;
+      console.error = jest.fn();
+      
+      await sendCallback(params);
+      
+      expect(mock.history.post.length).toBe(1);
+      expect(console.error).toHaveBeenCalledWith(
+        `Error sending callback to ${callbackUrl}: Request failed with status code 500`
+      );
+      
+      // Restore original console.error
+      console.error = originalError;
+    });
+
+    it('should log error when network error occurs', async () => {
+      const callbackUrl = 'https://api.example.com/callback';
+      const params = {
+        callbackUrl,
+        request: {
+          operationId: 'bookingsProductSearch',
+          payload: { searchInput: 'test' },
+          userId: '123',
+          integrationId: 'test-integration',
+          hint: 'test-hint'
+        },
+        result: { products: [] }
+      };
+
+      mock.onPost(callbackUrl).networkError();
+
+      // Mock console.error but prevent actual logging
+      const originalError = console.error;
+      console.error = jest.fn();
+      
+      await sendCallback(params);
+      
+      expect(mock.history.post.length).toBe(1);
+      expect(console.error).toHaveBeenCalledWith(
+        `Error sending callback to ${callbackUrl}: Network Error`
+      );
+      
+      // Restore original console.error
+      console.error = originalError;
+    });
+  });
+});

package/lib/callback.js

@@ -0,0 +1,55 @@
+const axios = require('axios');
+
+/**
+ * Send operation results to a callback URL
+ * @param {Object} params - Parameters for the callback
+ * @param {string} params.callbackUrl - URL to send the callback to
+ * @param {string} params.operationId - ID of the operation that was performed
+ * @param {Object} params.payload - The payload that was received
+ * @param {Object} params.result - The result of the operation
+ * @param {string} params.userId - User ID associated with the request
+ * @param {string} params.integrationId - Integration ID associated with the request
+ * @param {string} params.hint - Hint used in the request
+ * @returns {Promise<void>}
+ */
+async function sendCallback({
+  callbackUrl,
+  request,
+  result,
+}) {
+  if (!callbackUrl) {
+    return;
+  }
+
+  const callbackPayload = {
+    request,
+    result,
+    timestamp: new Date().toISOString()
+  };
+
+  try {
+    await axios.post(callbackUrl, callbackPayload, {
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity
+    });
+  } catch (error) {
+    let errorMessage = `Error sending callback to ${callbackUrl}: ${error.message}`;
+    if (error.code) {
+      errorMessage += ` (Code: ${error.code})`;
+    }
+    if (error.syscall) {
+      errorMessage += ` (Syscall: ${error.syscall})`;
+    }
+    if (error.address && error.port) {
+      errorMessage += ` (Address: ${error.address}:${error.port})`;
+    }
+    console.error(errorMessage);
+  }
+}
+
+module.exports = {
+  sendCallback
+};

package/package.json

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

package/worker/__tests__/job-api.js

@@ -0,0 +1,173 @@
+const axios = require('axios');
+require('../../test/utils');
+
+// Mock throng to directly execute the worker function
+jest.mock('throng', () => jest.fn(config => {
+  if (typeof config.worker === 'function') {
+    // Provide dummy id and disconnect function, similar to how throng would call it
+    config.worker('test-worker-id', jest.fn()); 
+  } else {
+    console.error('Mocked throng: config.worker is not a function or not provided.');
+    // Optionally, throw an error or handle as appropriate for your tests
+    // throw new Error('Throng mock expected a worker function in config.');
+  }
+  // throng can return a promise or be void, depending on usage. Here, we don't need to return.
+}));
+
+// Mock axios
+jest.mock('axios');
+
+// Mock the queue to avoid actual Redis operations
+jest.mock('../queue', () => {
+  const original = jest.requireActual('../queue');
+  return {
+    ...original,
+    queue: {
+      ...original.queue,
+      process: jest.fn(),
+      getJob: jest.fn(),
+    },
+  };
+});
+
+// Mock the queue module
+jest.mock('../queue', () => {
+  const original = jest.requireActual('../queue');
+  return {
+    ...original,
+    queue: {
+      ...original.queue,
+      process: jest.fn(),
+      getJob: jest.fn().mockResolvedValue({
+        id: 'test-job-id',
+        data: {
+          type: 'api',
+          method: 'POST',
+          url: '/products/testAppKey/testUserId/testTokenHint/search',
+          headers: { 'content-type': 'application/json' },
+          payload: { backgroundJob: true },
+          inTesting: true
+        },
+        remove: jest.fn().mockResolvedValue(true)
+      })
+    },
+    addJob: jest.fn().mockResolvedValue('test-job-id'),
+    allDone: jest.fn().mockResolvedValue(true)
+  };
+});
+
+// Import the mocked queue and the actual worker module
+const { addJob, queue, allDone } = require('../queue');
+const actualWorkerModule = require('../index'); // Actual worker module
+
+describe('worker: API job handling', () => {
+  let serverUrl;
+  let plugins;
+  let doApiPost;
+
+  let actualJobHandler;
+
+  beforeAll(async () => {
+    // Silence console.log for tests
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+
+    // Setting up test environment
+    
+    const testUtilsResult = await require('../../test/utils')({
+      plugins: ['mockPlugin'],
+      startServer: false,
+      worker: false,
+    });
+    
+    plugins = testUtilsResult.plugins;
+    // doApiPost might not be used directly if worker uses supertest
+    serverUrl = 'http://127.0.0.1:3000'; // This might be for constructing expected URLs
+    
+    axios.mockImplementation(config => {
+      // This mock is for the internal axios call made by the worker
+      if (config.url && config.url.includes('/products/testAppKey/testUserId/testTokenHint/search')) {
+        return Promise.resolve({ status: 200, data: { success: true, message: 'Mocked internal success' } });
+      }
+      console.error('Unexpected axios call to mock:', config);
+      return Promise.reject(new Error(`Unexpected axios call in mock for URL: ${config.url}`));
+    });
+
+    // Mock queue.process to capture the handler passed by the actual worker
+    queue.process.mockImplementation((...args) => {
+      let handlerCallback;
+      if (typeof args[args.length - 1] === 'function') {
+        handlerCallback = args[args.length - 1];
+      } else {
+        console.error('queue.process mock called without a handler function', args);
+        throw new Error('queue.process mock called without a handler function');
+      }
+      const queueName = typeof args[0] === 'string' ? args[0] : 'default';
+      actualJobHandler = handlerCallback;
+    });
+    
+    // Initializing actual worker module
+    actualWorkerModule({ plugins }); // Initialize the actual worker, it should call the mocked queue.process
+    // Actual worker module initialized
+    
+    // Test environment setup complete
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks(); // Restores all mocks, including console.log spy
+    actualJobHandler = null; // Clear captured handler
+  });
+
+  it('should create a job of type "api" for the product search endpoint and send it to the API server', async () => {
+    
+    // 1. Test that we can create a job
+    const jobData = {
+      type: 'api',
+      method: 'POST',
+      url: '/products/testAppKey/testUserId/testTokenHint/search',
+      headers: { 'content-type': 'application/json' },
+      payload: { backgroundJob: true },
+    };
+    
+    // Adding job to queue...
+    const jobId = await addJob(jobData);
+    
+    // Basic assertions
+    expect(jobId).toBeTruthy();
+    expect(typeof jobId).toBe('string');
+    
+    // Verify addJob was called correctly
+    expect(addJob).toHaveBeenCalledWith(jobData);
+    
+    // Simulate job processing by invoking the captured handler
+   // Simulating job processing with captured handler...
+    if (!actualJobHandler) {
+      throw new Error('Job handler was not captured from queue.process. Worker might not have initialized queue processing correctly.');
+    }
+    // Construct a mock Bull job object
+    const mockJob = {
+      data: jobData,
+      id: jobId,
+      log: jest.fn(),
+      progress: jest.fn(),
+      update: jest.fn(),
+    };
+    await actualJobHandler(mockJob);
+    // Job processing simulation complete.
+    
+    // Verify queue.process was called (to capture the handler)
+    expect(queue.process).toHaveBeenCalled();
+    
+    // Verify the internal API call was made by the worker correctly
+    expect(axios).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: jobData.method.toLowerCase(), // Ensure method matches job data
+        url: expect.stringMatching(/^http:\/\/127\.0\.0\.1:\d+\/products\/testAppKey\/testUserId\/testTokenHint\/search$/),
+        data: {}, // Payload after R.omit(['backgroundJob'], { backgroundJob: true }) is an empty object
+        headers: expect.objectContaining({
+          // Axios might add/remove/modify some headers, so be specific about what must be there
+          // 'content-type': 'application/json' // This might be set by axios default or omitted if data is empty
+        }),
+      })
+    );
+  });
+});

package/worker/__tests__/job-callback.js

@@ -0,0 +1,104 @@
+/* globals describe it expect jest beforeAll afterAll */
+
+// Import queue module directly to avoid reference issues
+const queueModule = require('../queue');
+
+// Create a mock for axios that will be used by the callback module
+jest.mock('axios', () => ({
+  post: jest.fn().mockResolvedValue({ status: 200 })
+}));
+
+describe('worker: Callback job handling', () => {
+  it('should create a job of type "callback" with the correct structure', async () => {
+    // Create a job to send a callback
+    const callbackData = {
+      callbackUrl: 'https://example.com/callback',
+      request: { id: '123', method: 'GET' },
+      result: { status: 'success', data: { message: 'Operation completed' } }
+    };
+    
+    const jobData = {
+      type: 'callback',
+      payload: callbackData
+    };
+
+    // Add the job to the queue
+    const jobId = await queueModule.addJob(jobData);
+    
+    // Verify job was created with a valid ID
+    expect(jobId).toBeTruthy();
+    expect(typeof jobId).toBe('string');
+    
+    // Get the job from the queue to verify its data
+    const job = await queueModule.queue.getJob(jobId);
+    
+    // Verify the job exists and has the correct data
+    expect(job).toBeTruthy();
+    expect(job.data).toEqual(expect.objectContaining({
+      type: 'callback',
+      payload: expect.objectContaining({
+        callbackUrl: 'https://example.com/callback',
+        request: expect.any(Object),
+        result: expect.any(Object)
+      }),
+      inTesting: true // This is added by addJob function
+    }));
+  });
+  
+  it('should include the correct structure for callback jobs', () => {
+    // This test verifies the worker/index.js handles callback jobs correctly
+    // by checking the code structure without actually running it
+    
+    // Read the worker code
+    const workerCode = require('fs').readFileSync(require('path').resolve(__dirname, '../index.js'), 'utf8');
+    
+    // Verify the worker code includes handling for callback jobs
+    expect(workerCode).toContain('if (type === \'callback\')');
+    
+    // Verify it extracts the necessary parameters
+    expect(workerCode).toContain('callbackUrl,');
+    expect(workerCode).toContain('request,');
+    expect(workerCode).toContain('result,');
+    
+    // Verify it calls the sendCallback function
+    expect(workerCode).toContain('sendCallback');
+    
+    // Verify it returns the expected result structure
+    expect(workerCode).toContain('return { success: true }');
+  });
+  
+  it('should use the callback module to send callbacks', async () => {
+    // Get a reference to the mocked axios.post function
+    const axios = require('axios');
+    
+    // Reset mock call history
+    axios.post.mockClear();
+    
+    // Create a job with callback data
+    const callbackData = {
+      callbackUrl: 'https://example.com/callback',
+      request: { id: '123', method: 'GET' },
+      result: { status: 'success', data: { message: 'Operation completed' } }
+    };
+    
+    // Directly call the sendCallback function to verify it works as expected
+    const { sendCallback } = require('../../lib/callback');
+    await sendCallback(callbackData);
+    
+    // Verify axios.post was called with the correct parameters
+    expect(axios.post).toHaveBeenCalledTimes(1);
+    expect(axios.post).toHaveBeenCalledWith(
+      callbackData.callbackUrl,
+      expect.objectContaining({
+        request: callbackData.request,
+        result: callbackData.result,
+        timestamp: expect.any(String)
+      }),
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Content-Type': 'application/json'
+        })
+      })
+    );
+  });
+});

package/worker/index.js

@@ -1,11 +1,10 @@
 const throng = require('throng');
 require('util').inspect.defaultOptions.depth = null;
-
+const R = require('ramda');
 const { queue, saveResult } = require('./queue');
 
 const workers = process.env.WEB_CONCURRENCY || 2;
-
-const maxJobsPerWorker = 1;
+const maxJobsPerWorker = process.env.MAX_JOBS_PER_WORKER || 1;
 
 const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
   console.log(`Started worker ${id}`);
@@ -23,14 +22,88 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
   queue.process(maxJobsPerWorker, async job => {
     const {
       data: {
+        type = 'plugin',
         pluginName,
         method,
         userId,
         inTesting,
+        payload = {}
       },
       id: jobId,
       data: params,
     } = job;
+    if (type === 'api') {
+      const {
+        method,
+        url,
+        payload,
+        headers,
+      } = params;
+
+      let code, result, server;
+      const http = require('http');
+      const axios = require('axios');
+      try {
+        const app = await require('../index')({
+          pluginsInstantiated: pluginsParam,
+          startServer: false,
+          worker: false,
+        });
+
+        // Manually start server on random port
+        server = http.createServer(app);
+        await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); 
+        const { address, port } = server.address();
+        const baseURL = `http://${address}:${port}`;
+        console.log(`Worker internal server for job ${jobId} listening on: ${baseURL}`);
+
+        // Use axios to make the request
+        const response = await axios({
+          method: method.toLowerCase(),
+          url: `${baseURL}${url}`,
+          data: R.omit(['backgroundJob'], payload),
+          headers: R.omit(['content-length'], headers),
+          validateStatus: () => true, // Prevent axios from throwing on non-2xx status
+        });
+
+        code = response.status;
+        result = response.data;
+        console.log(`Worker internal request for job ${jobId} completed with code ${code}`);
+      } catch (error) {
+        // Handle errors during app init or axios request
+        console.error(`Worker internal request error for job ${jobId}:`, error.message);
+        // If axios error has response, use its status
+        code = R.pathOr(500, ['response', 'status'], error);
+        result = R.pathOr({ message: error.message }, ['response', 'data'], error);
+      } finally {
+        // Ensure server is closed if it was created
+        if (server) {
+          await new Promise(resolve => server.close(resolve));
+          console.log(`Worker internal server for job ${jobId} closed.`);
+        }
+      }
+
+      return {
+        code,
+        result,
+        success: code >= 200 && code < 300,
+       };
+    }
+    if (type === 'callback') {
+      const {
+        callbackUrl,
+        request,
+        result,
+      } = payload;
+
+      console.log(`job ${jobId} > sending callback to ${callbackUrl}`);
+      await require('../lib/callback').sendCallback({
+        callbackUrl,
+        request,
+        result,
+      });
+      return { success: true };
+    }
     console.log(`job ${jobId} > running ${pluginName}:${method} for ${userId}`);
     const plugins = await (async () => {
       if (inTesting) {
@@ -41,8 +114,10 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
     })();
     const thePlugin = plugins.find(({ name }) => name === pluginName);
     const resultValue = await thePlugin[method]({
-      ...params,
+      ...params.payload,
+      token: params.token,
       plugins,
+      typeDefsAndQueries: require('../controllers/bookings').typeDefsAndQueries,
     });
     console.log(`job ${jobId} > completed`);
     await saveResult({ id: jobId, resultValue });