ti2 1.0.94 → 1.0.96

package/.github/workflows/tests.yml

@@ -7,7 +7,7 @@ jobs:
     timeout-minutes: 10
     runs-on: ubuntu-latest
     container:
-      image: node:16.15.0
+      image: node:16.20.0
     services:
       mysql:
         image: mysql
@@ -31,13 +31,17 @@ jobs:
     - uses: actions/checkout@v2
     - uses: actions/setup-node@v1
       with:
-        node-version: 12
+        node-version: 16
     - name: install dependencies
       run: npm ci
     - name: create/migrate the database
       run: npx sequelize db:create && npx sequelize db:migrate
     - name: seed the database
       run: npx sequelize db:seed:all
-    - run: RUNNER_TRACKING_ID="" && (nohup node ./test/worker.js&)
+    - name: start worker process
+      run: RUNNER_TRACKING_ID="" node ./test/worker.js > worker.log 2>&1 &
     - name: run the tests
       run: npx jest -i --coverage --forceExit
+    - name: display worker logs
+      if: ${{ failure() }}
+      run: cat worker.log

package/api.yml

@@ -13,6 +13,78 @@ components:
       scheme: bearer
       bearerFormat: JWT
   schemas:
+    CronJob:
+      type: object
+      properties:
+        id:
+          type: string
+          description: uuid of the crojob to remove
+          example: '550e8400-e29b-41d4-a716-446655440000'
+        method:
+          type: string
+          description: HTTP method for the API call
+          example: 'POST'
+          enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']
+        url:
+          type: string
+          description: URL path for the API call
+          example: '/products/travelgate-hotelx/123/search'
+        cron:
+          type: string
+          description: Cron expression for job scheduling
+          example: '0 0 * * *'
+        userId:
+          type: string
+          description: User ID associated with the job
+        body:
+          type: object
+          description: body for the scheduled rquest
+        removeOnComplete:
+          type: boolean
+          description: Whether the job should be removed from the queue after successful completion (for one-off executions).
+          default: false
+    CronJobList:
+      type: object
+      properties:
+        jobs:
+          type: array
+          items:
+            $ref: '#/components/schemas/CronJob'
+    CronJobCreate:
+      type: object
+      required:
+        - method
+        - url
+        - cron
+      properties:
+        method:
+          type: string
+          description: HTTP method for the API call
+          example: 'POST'
+          enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']
+        url:
+          type: string
+          description: URL path for the API call
+          example: '/products/travelgate-hotelx/123/search'
+        cron:
+          type: string
+          description: Cron expression for job scheduling
+          example: '0 0 * * *'
+        callbackUrl:
+          type: string
+          description: Optional URL to call after job completion
+          example: 'https://example.com/callback'
+        payload:
+          type: object
+          description: Optional payload for the API call
+          example:
+            startDate: '01/01/2023'
+            endDate: '03/04/2023'
+            keyPath: 'MAGLUX|7CQLDACMAGLUXDELSUI'
+        removeOnComplete:
+          type: boolean
+          description: Whether the job should be removed from the queue after successful completion (for one-off executions).
+          default: false
     ServerInfo:
       type: object
       properties:
@@ -404,6 +476,93 @@ components:
         type: boolean
         default: false
 paths:
+  /cronjobs/{userId}:
+    get:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - cronjobs
+      summary: List cronjobs for a user
+      operationId: listCronjobs
+      parameters:
+        - name: userId
+          in: path
+          description: User ID to list cronjobs for
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: List of cronjobs
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/CronJobList'
+    post:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - cronjobs
+      summary: Create a new cronjob
+      operationId: createCronjob
+      parameters:
+        - name: userId
+          in: path
+          description: User ID to create cronjob for
+          required: true
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CronJobCreate'
+      responses:
+        '200':
+          description: Created cronjob
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/CronJob'
+  /cronjobs/{userId}/{id}:
+    delete:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - cronjobs
+      summary: Delete a cronjob
+      operationId: deleteCronjob
+      parameters:
+        - name: userId
+          in: path
+          description: User ID the cronjob belongs to
+          required: true
+          schema:
+            type: string
+        - name: id
+          in: path
+          description: Cron job ID (UUID) to delete
+          required: true
+          schema:
+            type: string
+      responses:
+        '404':
+          description: Cronjob not found
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+                    example: 'Cronjob not found'
+        '200':
+          description: Success status
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Status'
   /ping:
     get:
       tags:

package/cli.js

@@ -5,6 +5,7 @@ const { Command, Argument } = require('commander');
 const { migrateApp } = require('./controllers/app')();
 const { migrate } = require('./controllers/admin');
 const { decrypt, encrypt } = require('./lib/security');
+const { queue, redisResults } = require('./worker/queue');
 
 const program = new Command();
 
@@ -55,4 +56,109 @@ program.command('encrypt')
     process.exit(0);
   });
 
+program.command('queue:list [pattern]')
+  .description('List jobs in the queue, optionally filtering by ID pattern (e.g., "jobId*", "*suffix", "prefix*suffix")')
+  .action(async (pattern) => {
+    try {
+      await queue.isReady(); // Ensure queue is ready
+      const jobTypes = ['waiting', 'active', 'completed', 'failed', 'delayed', 'paused'];
+      let message = `Fetching jobs of types: ${jobTypes.join(', ')}...`;
+      if (pattern) {
+        message += ` matching pattern "${pattern}"`;
+      }
+      console.log(message);
+      let jobs = await queue.getJobs(jobTypes);
+
+      if (pattern) {
+        const regexPatternText = '^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$';
+        const regexPattern = new RegExp(regexPatternText);
+        console.log(`Using filter regex: ${regexPattern}`);
+        jobs = jobs.filter(job => regexPattern.test(job.id.toString()));
+      }
+
+      if (jobs.length === 0) {
+        if (pattern) {
+          console.log(`No jobs found matching pattern "${pattern}".`);
+        } else {
+          console.log('No jobs found in the queue.');
+        }
+      } else {
+        console.log(`Found ${jobs.length} jobs:`);
+        for (const job of jobs) {
+          const state = await job.getState();
+          const progress = job.progress();
+          const timestamp = new Date(job.timestamp).toISOString();
+          console.log(`\n- ID: ${job.id}`);
+          console.log(`  State: ${state}`);
+          console.log(`  Progress: ${progress}`);
+          console.log(`  Added: ${timestamp}`);
+          console.log(`  Name (Queue): ${job.name}`);
+          console.log(`  Data: ${JSON.stringify(job.data, null, 2)}`);
+          if (job.opts.repeat) {
+            console.log(`  Repeat Options: ${JSON.stringify(job.opts.repeat)}`);
+          }
+          if (state === 'failed' && job.failedReason) {
+            console.log(`  Failed Reason: ${job.failedReason}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error listing queue jobs:', error);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program.command('queue:remove')
+  .description('Remove job instances from the queue by ID or pattern (e.g., "jobId*", "*suffix", "prefix*suffix")')
+  .argument('<pattern>', 'Job ID or glob-like pattern for job IDs to remove')
+  .action(async (pattern) => {
+    try {
+      await queue.isReady(); // Ensure queue is ready
+      console.log(`Attempting to remove job instances matching pattern: "${pattern}"`);
+
+      const jobTypes = ['waiting', 'active', 'completed', 'failed', 'delayed', 'paused'];
+      const jobs = await queue.getJobs(jobTypes);
+      let removedCount = 0;
+      const removedJobIds = [];
+
+      const regexPatternText = '^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$';
+      const regexPattern = new RegExp(regexPatternText);
+
+      console.log(`Using regex: ${regexPattern}`);
+
+      for (const job of jobs) {
+        if (regexPattern.test(job.id.toString())) {
+          try {
+            await job.remove();
+            removedJobIds.push(job.id.toString());
+            removedCount++;
+            console.log(`Removed job ${job.id} from Bull queue.`);
+          } catch (e) {
+            console.error(`Failed to remove job ${job.id} from Bull queue:`, e.message);
+          }
+        }
+      }
+
+      if (removedCount > 0) {
+        console.log(`Successfully removed ${removedCount} job instance(s) from Bull queue.`);
+        if (removedJobIds.length > 0) {
+          console.log(`Attempting to remove ${removedJobIds.length} result(s) from Redis for the removed jobs...`);
+          try {
+            const delCount = await redisResults.del(removedJobIds);
+            console.log(`Removed ${delCount} result(s) from Redis.`);
+          } catch (e) {
+            console.error('Failed to remove results from Redis:', e.message);
+          }
+        }
+      } else {
+        console.log(`No job instances found matching pattern "${pattern}".`);
+      }
+    } catch (error) {
+      console.error('Error removing queue jobs:', error);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
 program.parse();

package/controllers/README.md

@@ -1 +1,70 @@
-Place your controllers in this directory.
+# Bookings Controller Caching and Locking Strategy
+
+The `$bookingsProductSearch` function in `controllers/bookings.js` implements a sophisticated caching and locking strategy to optimize product searches, manage stale data, and prevent redundant operations. This document outlines its core flow and the locking mechanisms involved.
+
+## Core Flow of `$bookingsProductSearch`
+
+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').
+    *   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.
+    *   Fetches the current cache content (`initialActualCacheContent`) and its `lastUpdated` timestamp.
+    *   Determines if the cache is stale (`isStaleByTTR`) based on the Time-To-Refresh (`ttr`) value from the token or plugin settings.
+    *   Checks for a `doNotCallPluginForProducts` flag (from token or plugin settings) and whether a `pluginExecutionLockKey` is currently active.
+
+2.  **Request Handling Logic (Simplified Order):**
+
+    *   **Condition 1: `doNotCallPluginForProducts` is true AND NOT `forceRefresh`**:
+        *   If this flag is set and the request is not a forced refresh, the system serves data directly from the cache if available.
+        *   If the cache is empty, it returns an empty product list.
+        *   No plugin calls are made, and no background jobs are queued in this path.
+
+    *   **Condition 2: `forceRefresh` is true**:
+        *   The system attempts to fetch fresh data directly from the plugin.
+        *   The `fetchFromPluginAndCache` helper function is invoked. This function:
+            *   Sets the `pluginExecutionLockKey` before calling the plugin to prevent other concurrent direct calls.
+            *   Calls the plugin's product search method.
+            *   If the plugin returns valid products, these are saved to the cache (both `cacheKey` for data and `${cacheKey}:lastUpdated` for timestamp).
+            *   Drops the `pluginExecutionLockKey` after completion.
+        *   The (potentially filtered) results from the plugin are returned to the client.
+
+    *   **Condition 3: Cache Exists AND NOT `forceRefresh`**:
+        *   **Sub-condition 3a: Cache is fresh OR `pluginExecutionLockKey` is active**:
+            *   If the cache is not stale according to its TTR, or if a direct plugin execution (like a `forceRefresh` or initial population) is already in progress (indicated by an active `pluginExecutionLockKey`), the system serves data from the existing cache.
+        *   **Sub-condition 3b: Cache is stale AND no `pluginExecutionLockKey` is active**:
+            *   The system checks for an active `jobQueueLockKey`.
+            *   If `jobQueueLockKey` IS active: It implies that another request very recently detected the stale cache and has already queued a background refresh job. The current request serves the stale data from the cache without queueing another job.
+            *   If `jobQueueLockKey` is NOT active: This request is the first (or among the first) to find the stale cache without an ongoing direct refresh or a recently queued job. It will:
+                1.  Set the `jobQueueLockKey` with a short TTL (e.g., 60 seconds).
+                2.  Queue a background job using `addJob`. This job will eventually call the plugin to refresh the data and then use `$updateProductSearchCache` to update the cache.
+                3.  Serve the stale data from the cache to the current client.
+
+    *   **Condition 4: No Cache Content AND NOT `forceRefresh` AND NOT `doNotCallPluginForProducts`**:
+        *   If there's no existing cache content and none of the preceding conditions (like `forceRefresh` or `doNotCallPluginForProducts`) were met, the system needs to populate the cache.
+        *   It calls `fetchFromPluginAndCache` (which sets `pluginExecutionLockKey`, calls the plugin, caches results, and drops the lock) to get initial data.
+        *   The (potentially filtered) results are returned to the client.
+
+## Locking Mechanisms Explained
+
+The system uses two types of locks, both based on the primary `cacheKey`, to manage concurrency and prevent redundant operations:
+
+1.  **`pluginExecutionLockKey` (derived from `${cacheKey}:lock`)**:
+    *   **Purpose**: To prevent multiple simultaneous *direct calls* to the external plugin for the same product search parameters. This is crucial during `forceRefresh` scenarios or when the cache is being populated for the first time by concurrent requests.
+    *   **Behavior**:
+        *   This lock is set by the `fetchFromPluginAndCache` helper function immediately before it makes an actual call to the plugin's `searchProducts` (or equivalent) method.
+        *   It is configured with a TTL (e.g., 120 seconds) to ensure it automatically expires if the process holding the lock crashes or fails to release it.
+        *   The lock is explicitly dropped by `fetchFromPluginAndCache` after the plugin call completes (whether successfully or with an error).
+        *   Other parts of the main logic (e.g., in Condition 3a) check for the presence of this lock (`hasPluginExecutionLock`). If active, it signals that a direct plugin data fetch is already in progress, prompting the current request to, for example, serve stale data or wait, rather than initiating another direct plugin call.
+
+2.  **`jobQueueLockKey` (derived from `${cacheKey}:jobLock`)**:
+    *   **Purpose**: To prevent the submission of multiple identical *background refresh jobs* by nearly simultaneous requests when the cache is found to be stale and no direct plugin execution (covered by `pluginExecutionLockKey`) is active.
+    *   **Behavior**:
+        *   This lock is checked specifically when the cache is determined to be effectively stale (`isEffectivelyStale`) and no `pluginExecutionLockKey` is currently active (Condition 3b).
+        *   If the `jobQueueLockKey` is NOT found in the cache, the current request assumes responsibility for queuing the refresh job. It sets this lock with a short TTL (e.g., 60 seconds) *before* calling `addJob`.
+        *   If the `jobQueueLockKey` IS found, it indicates that another request has very recently detected the stale state and has already taken action to queue the refresh job. The current request will then proceed to serve stale data without attempting to queue another job.
+        *   This mechanism ensures that even if numerous requests detect stale data at virtually the same moment, only one of them will succeed in setting the `jobQueueLockKey` and thereby be responsible for queueing the single background refresh task.
+
+These two locks work in tandem: `pluginExecutionLockKey` manages contention for direct, immediate plugin interactions, while `jobQueueLockKey` manages contention for initiating background refresh tasks when stale data is being served. This dual-lock strategy helps maintain system performance and avoids overwhelming external plugin services or the background job queue.

package/controllers/__tests__/admin.js

@@ -1,12 +1,12 @@
 /* globals beforeAll describe it expect */
 
 const chance = require('chance').Chance();
-const testUtils = require('../../test/utils');
 const slugify = require('../../test/slugify');
 
 const { env: { adminKey } } = process;
 
 describe('admin', () => {
+  const testUtils = require('../../test/utils');
   const appName = slugify(
     chance.company(),
   );

package/controllers/__tests__/allotments.js

@@ -3,11 +3,10 @@ const axios = require('axios');
 const MockAdapter = require('axios-mock-adapter');
 const chance = require('chance').Chance();
 
-const testUtils = require('../../test/utils');
-
 const { env: { adminKey } } = process;
 
 describe('allotment', () => {
+  const testUtils = require('../../test/utils');
   const newApp = {
     name: 'tourplantest',
     packageName: 'ti2-tourplanTest',

package/controllers/__tests__/app.js

@@ -3,13 +3,13 @@ const chance = require('chance').Chance();
 const jwt = require('jwt-promise');
 const R = require('ramda');
 
-const testUtils = require('../../test/utils');
 const slugify = require('../../test/slugify');
 let appController = require('../app');
 
 const { env: { adminKey, jwtSecret } } = process;
 
 describe('app', () => {
+  const testUtils = require('../../test/utils');
   const appName = slugify(
     chance.company(),
   );