ti2 1.0.97 → 1.0.98

package/controllers/__tests__/cronjobs.js

@@ -1,6 +1,7 @@
 /* globals beforeAll describe it expect */
 const yaml = require('js-yaml');
-const fs = require('fs');
+const fs = require('fs')
+const R = require('ramda')
 
 // Load environment variables and API schema
 const { env: { adminKey } } = process;
@@ -315,28 +316,24 @@ describe('scheduled cronjob execution', () => {
           const url = require('url');
 
           server = http.createServer((req, res) => {
-            let body = '';
-            req.on('data', chunk => body += chunk);
+            let callbackPayload = '';
+            req.on('data', chunk => callbackPayload += chunk);
             req.on('end', () => {
               const requestUrl = url.parse(req.url, true);
               const receivedUniqueId = requestUrl.query.date;
+              const receivedJobId = R.path(['result', 'bullJobId'], JSON.parse(callbackPayload))
 
               if (receivedUniqueId === uniqueId) {
                 // Check if response and response.bullJobId are available
-                if (response && response.bullJobId) {
-                  res.writeHead(200, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ success: true }));
-                  // server.close() will be handled in afterAll or if explicitly resolved/rejected
-                  resolve({ id: response.bullJobId });
-                } else {
-                  // This case handles if callback arrives but job creation might have failed or response not processed
-                  res.writeHead(500, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ success: false, message: 'Callback received but job details unavailable.' }));
-                  reject(new Error('Callback processed but original job details (response.bullJobId) were missing.'));
-                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true }));
+                // Close the server after sending the response
+                server.close(() => {
+                  resolve({ receivedJobId });
+                });
               } else {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, message: 'Callback ID mismatch' }));
+                return res.end(JSON.stringify({ success: false, message: 'Callback ID mismatch' }));
                 // Do not resolve or reject here, let the test timeout if correct callback never comes.
                 // Or, optionally, reject:
                 // reject(new Error('Callback ID mismatch.'));
@@ -366,12 +363,12 @@ describe('scheduled cronjob execution', () => {
         });
 
         expect(response.bullJobId).toBeTruthy();
+        bullJobId = response.bullJobId;
         expect(response.id).toBeTruthy();
         cronJobIdToCleanup = response.id;
 
-        const callBackInstance = await callBackServerPromise;
-        expect(callBackInstance.id).toBe(response.bullJobId);
-        bullJobId = response.bullJobId;
+        const { receivedJobId } = await callBackServerPromise;
+        expect(receivedJobId).toBe(bullJobId);
 
       }, 120e3); // Timeout for the cronjob to be executed
 
@@ -380,7 +377,7 @@ describe('scheduled cronjob execution', () => {
       expect(bullJobId).toBeTruthy();
       const { queue } = require('../../worker/queue');
       let jobInQueue;
-      const maxRetries = 60;
+      const maxRetries = 120;
       const retryInterval = 1e3;
 
       for (let i = 0; i < maxRetries; i++) {
@@ -389,6 +386,6 @@ describe('scheduled cronjob execution', () => {
         await new Promise(resolveDelay => setTimeout(resolveDelay, retryInterval));
       }
       expect(jobInQueue).toBeNull();
-    }, 60e3) // timeout for bull  to remove the queue Job once executed (removeOnComplete)
+    }, 120e3) // timeout for bull  to remove the queue Job once executed (removeOnComplete)
   });
 });

package/index.js

@@ -15,6 +15,7 @@ const EventEmitter = require('eventemitter2');
 const axios = require('axios');
 const curlirize = require('axios-curlirize');
 const { addJob } = require('./worker/queue');
+const { configureAxiosSSL } = require('./lib/sslConfig');
 
 const cacheSettings = {
   '*': [
@@ -78,6 +79,10 @@ module.exports = async ({
       const nuName = attr.replace(/_/g, '-').replace(`ti2-${pluginName}-`, '');
       params[nuName] = value;
     });
+    // Create a new axios instance for this plugin and configure SSL if needed
+    const pluginAxios = axios.create();
+    configureAxiosSSL(pluginAxios, process.env.SSL_INSECURE_ALLOWED_DOMAINS);
+    
     const pluginInstance = await new Plugin({
       cache: {
         drop: args => cache.drop({ ...args, pluginName }),
@@ -85,7 +90,7 @@ module.exports = async ({
         getOrExec: args => cache.getOrExec({ ...args, pluginName }),
         save: args => cache.save({ ...args, pluginName }),
       },
-      axios,
+      axios: pluginAxios,
       events: ti2Events,
       name: pluginName,
       ...params,

package/lib/__tests__/sslConfig.js

@@ -0,0 +1,112 @@
+const axios = require('axios');
+const { configureAxiosSSL, isDomainAllowedInsecure } = require('../sslConfig');
+
+describe('SSL Configuration', () => {
+  describe('isDomainAllowedInsecure', () => {
+    it('should return false when no domains are allowed', () => {
+      expect(isDomainAllowedInsecure('https://example.com', '')).toBe(false);
+      expect(isDomainAllowedInsecure('https://example.com', null)).toBe(false);
+      expect(isDomainAllowedInsecure('https://example.com', undefined)).toBe(false);
+    });
+
+    it('should match exact domain', () => {
+      const allowedDomains = 'localhost|staging.example.com';
+      expect(isDomainAllowedInsecure('https://localhost/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://staging.example.com/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://production.example.com/api', allowedDomains)).toBe(false);
+    });
+
+    it('should match subdomain', () => {
+      const allowedDomains = 'example.com';
+      expect(isDomainAllowedInsecure('https://api.example.com/endpoint', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://staging.api.example.com/endpoint', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://example.com/endpoint', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://different.com/endpoint', allowedDomains)).toBe(false);
+    });
+
+    it('should handle IP addresses', () => {
+      const allowedDomains = '192.168.1.100|10.0.0.1';
+      expect(isDomainAllowedInsecure('https://192.168.1.100:8080/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://10.0.0.1/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://192.168.1.101/api', allowedDomains)).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      const allowedDomains = 'EXAMPLE.COM|LocalHost';
+      expect(isDomainAllowedInsecure('https://example.com/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://EXAMPLE.COM/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://localhost/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://LOCALHOST/api', allowedDomains)).toBe(true);
+    });
+
+    it('should handle invalid URLs gracefully', () => {
+      const allowedDomains = 'example.com';
+      expect(isDomainAllowedInsecure('not-a-url', allowedDomains)).toBe(false);
+      expect(isDomainAllowedInsecure('', allowedDomains)).toBe(false);
+      expect(isDomainAllowedInsecure(null, allowedDomains)).toBe(false);
+    });
+
+    it('should handle whitespace in domain list', () => {
+      const allowedDomains = ' localhost | staging.example.com | 192.168.1.100 ';
+      expect(isDomainAllowedInsecure('https://localhost/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://staging.example.com/api', allowedDomains)).toBe(true);
+      expect(isDomainAllowedInsecure('https://192.168.1.100/api', allowedDomains)).toBe(true);
+    });
+  });
+
+  describe('configureAxiosSSL', () => {
+    it('should not modify axios when no domains are configured', () => {
+      const axiosInstance = axios.create();
+      const originalInterceptors = axiosInstance.interceptors.request.handlers.length;
+      
+      configureAxiosSSL(axiosInstance, '');
+      expect(axiosInstance.interceptors.request.handlers.length).toBe(originalInterceptors);
+      
+      configureAxiosSSL(axiosInstance, null);
+      expect(axiosInstance.interceptors.request.handlers.length).toBe(originalInterceptors);
+    });
+
+    it('should add request interceptor when domains are configured', () => {
+      const axiosInstance = axios.create();
+      const originalInterceptors = axiosInstance.interceptors.request.handlers.length;
+      
+      configureAxiosSSL(axiosInstance, 'localhost|example.com');
+      expect(axiosInstance.interceptors.request.handlers.length).toBe(originalInterceptors + 1);
+    });
+
+    it('should set httpsAgent for allowed domains', async () => {
+      const axiosInstance = axios.create();
+      configureAxiosSSL(axiosInstance, 'localhost|staging.example.com');
+      
+      // Test the interceptor by creating a mock config
+      const config = { url: 'https://localhost/api' };
+      const interceptor = axiosInstance.interceptors.request.handlers[0];
+      
+      if (interceptor && interceptor.fulfilled) {
+        const modifiedConfig = await interceptor.fulfilled(config);
+        expect(modifiedConfig.httpsAgent).toBeDefined();
+        expect(modifiedConfig.httpsAgent.options.rejectUnauthorized).toBe(false);
+      }
+    });
+
+    it('should not set httpsAgent for non-allowed domains', async () => {
+      const axiosInstance = axios.create();
+      configureAxiosSSL(axiosInstance, 'localhost|staging.example.com');
+      
+      // Test the interceptor by creating a mock config
+      const config = { url: 'https://production.example.com/api' };
+      const interceptor = axiosInstance.interceptors.request.handlers[0];
+      
+      if (interceptor && interceptor.fulfilled) {
+        const modifiedConfig = await interceptor.fulfilled(config);
+        expect(modifiedConfig.httpsAgent).toBeUndefined();
+      }
+    });
+
+    it('should return the same axios instance', () => {
+      const axiosInstance = axios.create();
+      const result = configureAxiosSSL(axiosInstance, 'localhost');
+      expect(result).toBe(axiosInstance);
+    });
+  });
+});

package/lib/sslConfig.js

@@ -0,0 +1,63 @@
+const https = require('https');
+const { URL } = require('url');
+
+/**
+ * Creates an HTTPS agent with SSL verification disabled
+ */
+const createInsecureAgent = () => new https.Agent({
+  rejectUnauthorized: false,
+});
+
+/**
+ * Checks if a URL's domain is in the allowed insecure domains list
+ * @param {string} url - The URL to check
+ * @param {string} allowedDomains - Pipe-separated list of allowed domains
+ * @returns {boolean} True if the domain is allowed to skip SSL verification
+ */
+const isDomainAllowedInsecure = (url, allowedDomains) => {
+  if (!allowedDomains || !url) return false;
+  
+  try {
+    const parsedUrl = new URL(url);
+    const hostname = parsedUrl.hostname.toLowerCase();
+    const domains = allowedDomains.split('|').map(d => d.trim().toLowerCase()).filter(Boolean);
+    
+    return domains.some(domain => {
+      // Exact match or subdomain match
+      return hostname === domain || hostname.endsWith(`.${domain}`);
+    });
+  } catch (error) {
+    // Invalid URL, don't allow insecure
+    return false;
+  }
+};
+
+/**
+ * Configures an axios instance to allow insecure SSL for specific domains
+ * @param {Object} axiosInstance - The axios instance to configure
+ * @param {string} allowedDomains - Pipe-separated list of allowed domains (from env var)
+ * @returns {Object} The configured axios instance
+ */
+const configureAxiosSSL = (axiosInstance, allowedDomains) => {
+  if (!allowedDomains) return axiosInstance;
+  
+  const insecureAgent = createInsecureAgent();
+  
+  // Add request interceptor to conditionally apply insecure agent
+  axiosInstance.interceptors.request.use(
+    (config) => {
+      if (config.url && isDomainAllowedInsecure(config.url, allowedDomains)) {
+        config.httpsAgent = insecureAgent;
+      }
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  
+  return axiosInstance;
+};
+
+module.exports = {
+  configureAxiosSSL,
+  isDomainAllowedInsecure,
+};

package/package.json

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

package/tutorials/setup-your-instance.md

@@ -29,6 +29,7 @@ A MySQl instance is required and the following environment variables are require
 - jwtKey (a key to encrypt user sessions request)
 - frontendKey (an additional optional key to validate the origin of the requests)
 - PORT (an optional port to run the http server, in case a port is not specified as a parameter)
+- SSL_INSECURE_ALLOWED_DOMAINS (optional, pipe-separated list of domains where SSL certificate verification is skipped)
 
 ```
 DB_URL=mysql://root:@mysqlserver/ti2development
@@ -39,6 +40,25 @@ frontendKey=IpOiLahrGQxsQimwoK7Z
 adminKey=bCviyz7iKyuEBoOVlODn
 ```
 
+#### SSL Configuration for Development/Testing
+
+For development or testing environments where you need to connect to APIs with self-signed or invalid SSL certificates, you can use the `SSL_INSECURE_ALLOWED_DOMAINS` environment variable:
+
+```bash
+# Skip SSL verification for specific domains
+SSL_INSECURE_ALLOWED_DOMAINS="localhost|staging.api.com|192.168.1.100"
+
+# Multiple domains separated by pipe
+SSL_INSECURE_ALLOWED_DOMAINS="dev.example.com|test.example.com"
+```
+
+This configuration will:
+- Skip SSL certificate verification for the specified domains
+- Apply only to plugin axios instances (external API calls)
+- Maintain normal SSL verification for all other domains
+
+**⚠️ Warning**: Only use this in development/testing environments. Never skip SSL verification in production for security reasons.
+
 ### Initialize a new NodeJS project
 
 We suggest creating a folder with your instance name+i2 (i.e acme-ti2); then initialize an node's npm package and install ti2 along with any plugins to be used.

package/worker/index.js

@@ -4,6 +4,10 @@ const R = require('ramda');
 const { queue, saveResult } = require('./queue');
 const bookingsControllerFactory = require('../controllers/bookings');
 const mainAxios = require('axios'); // Generic axios instance for direct calls
+const { configureAxiosSSL } = require('../lib/sslConfig');
+
+// Configure SSL for the main axios instance
+configureAxiosSSL(mainAxios, process.env.SSL_INSECURE_ALLOWED_DOMAINS);
 
 const workers = process.env.WEB_CONCURRENCY || 2;
 const maxJobsPerWorker = process.env.MAX_JOBS_PER_WORKER || 1;