ti2 1.0.94 → 1.0.95

package/worker/index.js

@@ -24,14 +24,16 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
       data: {
         type = 'plugin',
         pluginName,
-        method,
-        userId,
         inTesting,
         payload = {}
       },
       id: jobId,
       data: params,
     } = job;
+    let resultValue;
+    const jobLog = msg => console.log(`job ${jobId} > `, msg)
+    const jobErr = msg => console.error(`job ${jobId} > `, msg)
+    jobLog(`of type ${type} started`);
     if (type === 'api') {
       const {
         method,
@@ -39,6 +41,7 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
         payload,
         headers,
       } = params;
+      jobLog(`running method ${method} ${url}`)
 
       let code, result, server;
       const http = require('http');
@@ -55,23 +58,30 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
         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}`);
+        jobLog(`Worker internal server for job ${jobId} listening on: ${baseURL}`);
+
+        // Extract token and body from payload
+        const { token, body } = payload || {};
+        const requestHeaders = {
+          ...R.omit(['content-length'], headers),
+          ...(token ? { Authorization: `Bearer ${token}` } : {})
+        };
 
         // 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),
+          headers: requestHeaders,
           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}`);
+        jobLog(`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);
+        jobErr(`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);
@@ -79,47 +89,48 @@ const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
         // 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.`);
+          jobLog(`Worker internal server for job ${jobId} closed.`);
         }
       }
-
-      return {
+      resultValue = {
         code,
         result,
         success: code >= 200 && code < 300,
        };
-    }
-    if (type === 'callback') {
+    } else if (type === 'callback') {
       const {
         callbackUrl,
         request,
         result,
       } = payload;
-
-      console.log(`job ${jobId} > sending callback to ${callbackUrl}`);
+      jobLog(`job ${jobId} > sending callback to ${callbackUrl}`);
       await require('../lib/callback').sendCallback({
         callbackUrl,
         request,
         result,
       });
-      return { success: true };
+      resultValue = { success: true };
+    } else if (type === 'plugin') {
+      const {
+        method,
+        payload,
+      } = params;
+      const plugins = await (async () => {
+        if (inTesting) {
+          const fakePlugin = require('../test/plugin');
+          return [...pluginsParam, await new fakePlugin({ name: pluginName })];
+        }
+        return pluginsParam;
+      })();
+      const thePlugin = plugins.find(({ name }) => name === pluginName);
+      resultValue = await thePlugin[method]({
+        ...payload,
+        token: params.token,
+        plugins,
+        typeDefsAndQueries: require('../controllers/bookings').typeDefsAndQueries,
+      });
     }
-    console.log(`job ${jobId} > running ${pluginName}:${method} for ${userId}`);
-    const plugins = await (async () => {
-      if (inTesting) {
-        const fakePlugin = require('../test/plugin');
-        return [...pluginsParam, await new fakePlugin({ name: pluginName })];
-      }
-      return pluginsParam;
-    })();
-    const thePlugin = plugins.find(({ name }) => name === pluginName);
-    const resultValue = await thePlugin[method]({
-      ...params.payload,
-      token: params.token,
-      plugins,
-      typeDefsAndQueries: require('../controllers/bookings').typeDefsAndQueries,
-    });
-    console.log(`job ${jobId} > completed`);
+    jobLog(`job ${jobId} > completed`);
     await saveResult({ id: jobId, resultValue });
   });
 };

package/worker/queue.js

@@ -1,7 +1,8 @@
 const Queue = require('bull');
-const Redis = require('ioredis');
 const R = require('ramda');
-
+const Redis = require('ioredis');
+const sqldb = require('../models');
+const { env: { redisHost, redisPort } } = process;
 const REDIS_URL = process.env.REDIS_URL || 'redis://redis:6379';
 const itemsTTL = 3 * 60 * 60; // 3 hours
 
@@ -32,13 +33,15 @@ queue.on('failed', (job, err) => {
 const addJob = async (payload, paramsParam) => {
   const params = paramsParam || {};
   const inTesting = Boolean(process.env.JEST_WORKER_ID);
-  const id = R.path(['id'], await queue.add({
+  const job = await queue.add({
     ...payload,
     inTesting,
   }, {
     removeOnComplete: true,
     ...params,
-  }));
+  });
+  // For repeat jobs, we need to store the full repeat key
+  const id = job.opts.repeat ? job.opts.jobId : job.id;
   return id;
 };
 
@@ -46,6 +49,67 @@ const saveResult = async ({ id, resultValue }) => {
   await redisResults.set(id, JSON.stringify(resultValue), 'EX', itemsTTL);
 };
 
+const removeJob = async (jobId) => {
+  // For repeat jobs, the ID is in the format 'repeat:jobId:timestamp'
+  const jobIdParts = jobId.split(':');
+  const isRepeatJob = jobIdParts[0] === 'repeat';
+
+  if (isRepeatJob) {
+    // Get all repeatable jobs
+    const repeatableJobs = await queue.getRepeatableJobs();
+
+    // Find the job with matching cron pattern
+    const cronJob = await sqldb.CronJobs.findOne({
+      where: {
+        bullJobId: jobId,
+      },
+    });
+
+    if (cronJob) {
+      // First remove all repeatable jobs with matching cron pattern
+      for (const repeatableJob of repeatableJobs) {
+        if (repeatableJob.cron === cronJob.cron) {
+          await queue.removeRepeatableByKey(repeatableJob.key);
+        }
+      }
+
+      // Then remove all jobs with this pattern
+      const jobs = await queue.getJobs(['active', 'wait', 'delayed']);
+      for (const job of jobs) {
+        if (job.opts.repeat && job.opts.jobId === jobId) {
+          await job.remove();
+        }
+      }
+
+      // Wait for the queue to process the removals
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Clean up any remaining jobs
+      const remainingJobs = await queue.getJobs(['active', 'wait', 'delayed']);
+      for (const job of remainingJobs) {
+        if (job.opts.repeat && job.opts.jobId === jobId) {
+          await job.remove();
+        }
+      }
+
+      await redisResults.del(jobId);
+      return;
+    }
+
+    // If we couldn't find the repeatable job, just delete from the database
+    // This can happen if the job was already removed from Bull but still exists in our database
+    return;
+  }
+
+  // If not a repeatable job, try to remove as a regular job
+  const job = await queue.getJob(jobId);
+  if (!job) {
+    throw new Error('Job not found');
+  }
+  await job.remove();
+  await redisResults.del(jobId);
+};
+
 const jobStatus = async ({ jobId }) => {
   try {
     const job = await queue.getJob(jobId);
@@ -71,7 +135,6 @@ const jobStatus = async ({ jobId }) => {
       status: state.toLowerCase(),
     };
   } catch (err) {
-    console.log(`could not get job status for ${jobId}`, err);
     return { // 500
       jobId,
       status: 'failed',
@@ -85,4 +148,5 @@ module.exports = {
   queue,
   saveResult,
   redisResults,
+  removeJob,
 };