ti2 1.0.94 → 1.0.96

package/worker/__tests__/job-callback.js

@@ -45,28 +45,6 @@ describe('worker: Callback job handling', () => {
     }));
   });
   
-  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');

package/worker/__tests__/job-plugin.js

@@ -0,0 +1,207 @@
+// Mock throng to directly execute the worker function
+jest.mock('throng', () => jest.fn(config => {
+  if (typeof config.worker === 'function') {
+    config.worker('test-worker-id-plugin', jest.fn());
+  } else {
+    console.error('Mocked throng (plugin test): config.worker is not a function or not provided.');
+  }
+}));
+
+// Mock the queue to avoid actual Redis operations and capture the handler
+jest.mock('../queue', () => {
+  const original = jest.requireActual('../queue');
+  return {
+    ...original,
+    queue: {
+      ...original.queue,
+      process: jest.fn(), // Used to capture the job handler
+    },
+    addJob: jest.fn().mockResolvedValue('test-plugin-job-id'), // Mock addJob
+    saveResult: jest.fn().mockResolvedValue(undefined), // Mock saveResult
+    // listJobs, jobStatus etc. can be original or mocked if needed by other tests
+  };
+});
+
+// Mock bookingsControllerFactory to provide a mock for postProcess actions
+const mockBookingsPostProcessAction = jest.fn();
+jest.mock('../../controllers/bookings', () => {
+  return jest.fn(() => ({
+    // This action name must match what's in job.data.postProcess.action
+    $updateProductSearchCache: mockBookingsPostProcessAction,
+    // Add other methods if the worker's initialization of bookingsCtrl calls them
+  }));
+});
+
+// Import the mocked queue and the actual worker module
+const { queue, addJob, saveResult } = require('../queue');
+const actualWorkerModule = require('../index'); // Actual worker module
+const testUtils = require('../../test/utils'); // For setting up plugins
+
+describe('worker: Plugin job handling', () => {
+  let instantiatedPlugins; // Array of instantiated mock plugins from testUtils
+  let actualJobHandler; // The job processing function from the worker
+
+  beforeAll(async () => {
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+
+
+    const utils = await testUtils({
+      plugins: ['mockPluginForWorker'], // Provide a name for our mock plugin
+      startServer: false, // Worker tests usually don't need a live server
+      worker: false,
+    });
+    instantiatedPlugins = utils.plugins; // These are already instantiated mock plugins
+
+    // Capture the job handler from queue.process
+    queue.process.mockImplementation((concurrency, handler) => {
+      if (typeof handler === 'function') {
+        actualJobHandler = handler;
+      } else if (typeof concurrency === 'function') { // Handle case where concurrency is omitted
+        actualJobHandler = concurrency;
+      } else {
+        throw new Error('queue.process mock in plugin test could not capture handler');
+      }
+    });
+
+    // Initialize the worker module. This should cause queue.process to be called.
+    await actualWorkerModule({ plugins: instantiatedPlugins });
+
+    if (!actualJobHandler) {
+      throw new Error('Job handler was not captured in plugin test. Worker might not have initialized queue processing correctly.');
+    }
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks(); // Clears all mocks, including plugin method spies and postProcess action
+    // Reset specific mocks if needed, e.g., return values for plugin methods
+    if (instantiatedPlugins && instantiatedPlugins.length > 0 && instantiatedPlugins[0].searchProducts) {
+        instantiatedPlugins[0].searchProducts.mockClear();
+    }
+    mockBookingsPostProcessAction.mockClear();
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+    actualJobHandler = null;
+  });
+
+  it('should call postProcess action after successful plugin method execution', async () => {
+    const mockPluginName = 'mockPluginForWorker'; // Must match plugin name used in testUtils setup
+    const mockPluginMethod = 'searchProducts'; // Method to be called on the plugin
+    const mockPluginPayload = { query: 'test query' };
+    const mockPluginToken = { apiKey: 'test-api-key-for-plugin' };
+    const mockPluginResult = { products: [{ id: 'prod123', name: 'Test Product' }] };
+    const jobId = 'plugin-job-with-pp-001';
+
+    // Ensure the target mock plugin and its method exist
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    if (!targetPlugin || typeof targetPlugin[mockPluginMethod] !== 'function') {
+      throw new Error(`Mock plugin ${mockPluginName} or method ${mockPluginMethod} not found or not a function.`);
+    }
+    // Mock the plugin method's return value for this specific test
+    targetPlugin[mockPluginMethod].mockResolvedValue(mockPluginResult);
+
+    const jobDataWithPostProcess = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: mockPluginPayload, // This is job.data.payload
+      token: mockPluginToken,     // This is job.data.token
+      inTesting: true,
+      postProcess: {
+        controller: 'bookings',
+        action: '$updateProductSearchCache', // Must match the mocked action name in bookings mock
+        args: { staticArg1: 'value1', appKey: mockPluginName }, // Static args for postProcess
+      },
+    };
+
+    const mockJob = {
+      data: jobDataWithPostProcess,
+      id: jobId,
+      log: jest.fn(), // Bull's job.log
+      progress: jest.fn(), // Bull's job.progress
+    };
+
+    await actualJobHandler(mockJob);
+
+    // 1. Verify the plugin method was called correctly
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledWith(expect.objectContaining({
+      ...mockPluginPayload, // job.data.payload is spread
+      token: mockPluginToken, // job.data.token is passed as 'token'
+      requestId: jobId,
+      // axios and typeDefsAndQueries are also injected by the worker
+    }));
+
+    // 2. Verify the postProcess action was called correctly
+    expect(mockBookingsPostProcessAction).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).toHaveBeenCalledWith(expect.objectContaining({
+      staticArg1: 'value1', // From postProcess.args
+      appKey: mockPluginName, // From postProcess.args
+      pluginResult: mockPluginResult, // The result from the plugin method
+      requestId: jobId,
+    }));
+
+    // 3. Verify saveResult was called (implicitly tests success path)
+    expect(saveResult).toHaveBeenCalledWith({ id: jobId, resultValue: mockPluginResult });
+  });
+
+  it('should still save result even if postProcess is not defined', async () => {
+    const mockPluginName = 'mockPluginForWorker';
+    const mockPluginMethod = 'searchProducts';
+    const mockPluginResult = { products: [{ id: 'prod456' }] };
+    const jobId = 'plugin-job-no-pp-002';
+
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    targetPlugin[mockPluginMethod].mockResolvedValue(mockPluginResult);
+
+    const jobDataNoPostProcess = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: { query: 'another query' },
+      token: { apiKey: 'key-for-no-pp' },
+      inTesting: true,
+      // No postProcess field
+    };
+
+    const mockJob = { data: jobDataNoPostProcess, id: jobId, log: jest.fn(), progress: jest.fn() };
+    await actualJobHandler(mockJob);
+
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).not.toHaveBeenCalled();
+    expect(saveResult).toHaveBeenCalledWith({ id: jobId, resultValue: mockPluginResult });
+  });
+
+  it('should throw error and not call postProcess if plugin method fails', async () => {
+    const mockPluginName = 'mockPluginForWorker';
+    const mockPluginMethod = 'searchProducts';
+    const jobId = 'plugin-job-fail-003';
+    const pluginError = new Error('Plugin method failed');
+
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    targetPlugin[mockPluginMethod].mockRejectedValue(pluginError);
+
+    const jobDataWithPpForFailure = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: {},
+      token: {},
+      inTesting: true,
+      postProcess: {
+        controller: 'bookings',
+        action: '$updateProductSearchCache',
+        args: { appKey: mockPluginName },
+      },
+    };
+    const mockJob = { data: jobDataWithPpForFailure, id: jobId, log: jest.fn(), progress: jest.fn() };
+
+    await expect(actualJobHandler(mockJob)).rejects.toThrow(pluginError.message);
+
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).not.toHaveBeenCalled();
+    expect(saveResult).not.toHaveBeenCalled(); // saveResult should not be called on failure
+  });
+});

package/worker/index.js

@@ -2,126 +2,209 @@ const throng = require('throng');
 require('util').inspect.defaultOptions.depth = null;
 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 workers = process.env.WEB_CONCURRENCY || 2;
 const maxJobsPerWorker = process.env.MAX_JOBS_PER_WORKER || 1;
 
-const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
-  console.log(`Started worker ${id}`);
+const worker = ({ plugins: pluginsParam }) => { // pluginsParam are instantiated plugins
+  // Initialize bookingsCtrl once per worker instance using the passed instantiated plugins.
+  const bookingsCtrl = bookingsControllerFactory(pluginsParam);
 
-  const bye = () => {
-    console.log(`Worker ${id} exiting`);
-    disconnect();
-    process.exit(0);
-  };
+  return (id, disconnect) => {
+    console.log(`Started worker ${id}`);
+
+    const bye = () => {
+      console.log(`Worker ${id} exiting`);
+      disconnect();
+      // Graceful shutdown of the queue connection
+      queue.close().then(() => process.exit(0)).catch(() => process.exit(1));
+    };
 
-  process.on('SIGTERM', bye);
-  process.on('SIGUSR2', bye);
-  process.on('SIGINT', bye);
-
-  queue.process(maxJobsPerWorker, async job => {
-    const {
-      data: {
-        type = 'plugin',
-        pluginName,
-        method,
-        userId,
-        inTesting,
-        payload = {}
-      },
-      id: jobId,
-      data: params,
-    } = job;
-    if (type === 'api') {
+    process.on('SIGTERM', bye);
+    process.on('SIGUSR2', bye);
+    process.on('SIGINT', bye); // Good for local development
+
+    queue.process(maxJobsPerWorker, async job => {
       const {
-        method,
-        url,
-        payload,
-        headers,
-      } = params;
-
-      let code, result, server;
-      const http = require('http');
-      const axios = require('axios');
+        data, // Full job.data object
+        id: jobId,
+      } = job;
+
+      // Destructure from data for clarity and to match existing patterns
+      const {
+        type = 'plugin',        // Default job type if not specified
+        pluginName,             // Name of the plugin context for the job
+        inTesting,              // Flag if running in a testing environment
+        payload: jobDataPayload, // This is job.data.payload (e.g., { methodName: '...', args: {...} } or other plugin args)
+        method: jobDataMethod,   // This is job.data.method (e.g., 'searchProducts' for generic plugin calls)
+                                // Note: 'token' can also be a top-level property in data (data.token)
+      } = data;
+
+      let resultValue; // This will be set by all job type handlers
+      const jobLog = msg => console.log(`job ${jobId} (type: ${type}, plugin: ${pluginName || 'N/A'}) > `, msg);
+      const jobErr = msg => console.error(`job ${jobId} (type: ${type}, plugin: ${pluginName || 'N/A'}) > `, msg);
+      jobLog(`started`);
+
       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.`);
+        if (type === 'api') {
+          // params is job.data, so data.method, data.url etc. are correct here
+          jobLog(`running method ${data.method} ${data.url}`);
+          let code, result, server;
+          const http = require('http');
+          const axios = require('axios'); // Local axios for API call type
+          try {
+            const app = await require('../index')({
+              pluginsInstantiated: pluginsParam, // Pass the already instantiated plugins
+              startServer: false,
+              worker: false,
+            });
+
+            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}`;
+            jobLog(`Worker internal server for job ${jobId} listening on: ${baseURL}`);
+
+            // data.payload is the payload for the API call job type
+            const { token: jwtTokenForHeader, ...requestBodyForWorker } = data.payload || {};
+
+            const requestHeaders = {
+              ...R.omit(['content-length', 'host', 'connection', 'accept-encoding'], data.headers),
+              ...(jwtTokenForHeader ? { Authorization: `Bearer ${jwtTokenForHeader}` } : {})
+            };
+
+            const response = await axios({
+              method: data.method.toLowerCase(),
+              url: `${baseURL}${data.url}`,
+              data: R.omit(['backgroundJob'], requestBodyForWorker),
+              headers: requestHeaders,
+              validateStatus: () => true,
+            });
+
+            code = response.status;
+            result = response.data;
+            jobLog(`Worker internal request for job ${jobId} completed with code ${code}`);
+          } catch (error) {
+            jobErr(`Worker internal request error for job ${jobId}: ${error.message}`);
+            code = R.pathOr(500, ['response', 'status'], error);
+            result = R.pathOr({ message: error.message }, ['response', 'data'], error);
+          } finally {
+            if (server) {
+              await new Promise(resolve => server.close(resolve));
+              jobLog(`Worker internal server for job ${jobId} closed.`);
+            }
+          }
+          resultValue = { code, result, success: code >= 200 && code < 300 };
+
+        } else if (type === 'callback') {
+          const { callbackUrl, request, result } = jobDataPayload; // jobDataPayload is job.data.payload
+          jobLog(`sending callback to ${callbackUrl}`);
+          await require('../lib/callback').sendCallback({
+            callbackUrl,
+            request,
+            result,
+          });
+          resultValue = { success: true };
+
+        } else if (type === 'plugin') {
+          // jobDataPayload is job.data.payload
+          // jobDataMethod is job.data.method (for generic plugin calls)
+
+          // Check for our specific controller-level background task
+          if (jobDataPayload && jobDataPayload.methodName === '$bookingsProductSearchInternal') {
+            jobLog(`Processing via bookingsCtrl.$bookingsProductSearchInternal`);
+            
+            const controllerArgs = jobDataPayload.args;
+            if (!controllerArgs) {
+              throw new Error('$bookingsProductSearchInternal job is missing "args" in its payload');
+            }
+
+            // Ensure appKey from args matches pluginName from job data if pluginName is used for context
+            if (pluginName && controllerArgs.appKey !== pluginName) {
+                jobErr(`Job data pluginName (${pluginName}) mismatch with args.appKey (${controllerArgs.appKey}). Using args.appKey for plugin context.`);
+            }
+            // If this job type implies a forced refresh, `forceRefresh: true` should be part of `controllerArgs`.
+            // The `backgroundJob` flag is removed from $bookingsProductSearch.
+            const executionPayload = {
+              ...controllerArgs, // Contains appKey, userId, hint, payload (for $bps), headers
+                                 // Potentially `forceRefresh: true` if needed for this job type.
+              axios: mainAxios,  // Provide the worker's generic axios instance
+              requestId: jobId,  // Use job ID for tracing
+              // plugins are already available to bookingsCtrl via its factory initialization
+            };
+            
+            resultValue = await bookingsCtrl.$bookingsProductSearch(executionPayload);
+            jobLog(`bookingsCtrl.$bookingsProductSearchInternal completed.`);
+
+          } else {
+            // Handle generic plugin method call
+            jobLog(`Processing plugin method: ${jobDataMethod} for plugin ${pluginName}`);
+            
+            const currentJobPlugins = await (async () => {
+              if (inTesting) {
+                const fakePlugin = require('../test/plugin');
+                const FakePluginClass = fakePlugin.default || fakePlugin;
+                return [...pluginsParam, new FakePluginClass({ name: pluginName })];
+              }
+              return pluginsParam;
+            })();
+
+            const thePlugin = currentJobPlugins.find(({ name }) => name === pluginName);
+
+            if (!thePlugin) {
+              throw new Error(`Plugin ${pluginName} not found for job ${jobId}.`);
+            }
+            if (!jobDataMethod || typeof thePlugin[jobDataMethod] !== 'function') {
+              throw new Error(`Method ${jobDataMethod} not found or not a function on plugin ${pluginName} for job ${jobId}.`);
+            }
+
+            // Execute the plugin method
+            const pluginMethodResult = await thePlugin[jobDataMethod]({
+              ...(jobDataPayload || {}), // Spread job.data.payload (e.g., contains inner 'payload' and 'userId')
+              token: data.token,         // Pass job.data.token
+              plugins: currentJobPlugins,
+              typeDefsAndQueries: bookingsControllerFactory.typeDefsAndQueries, // As per existing pattern
+              axios: mainAxios,          // Inject worker's axios instance
+              requestId: jobId,          // Inject job ID as requestId
+            });
+            
+            jobLog(`Plugin method ${jobDataMethod} for ${pluginName} completed.`);
+            resultValue = pluginMethodResult; // The primary result of the job is the plugin's output
+
+            // Post-processing step
+            if (data.postProcess) {
+              jobLog(`Initiating post-processing step: ${data.postProcess.controller}.${data.postProcess.action}`);
+              if (data.postProcess.controller === 'bookings' && bookingsCtrl[data.postProcess.action]) {
+                await bookingsCtrl[data.postProcess.action]({
+                  ...(data.postProcess.args || {}), // Spread static args from job data
+                  pluginResult: pluginMethodResult, // Pass the dynamic result from the plugin
+                  requestId: jobId,                 // Pass job ID for tracing in post-process
+                  // 'plugins' are already part of bookingsCtrl via its factory
+                });
+                jobLog(`Post-processing step ${data.postProcess.action} completed for job ${jobId}.`);
+              } else {
+                jobErr(`Post-processing action ${data.postProcess.action} on controller ${data.postProcess.controller} not found or controller not supported for job ${jobId}.`);
+                // Depending on requirements, this could throw an error to fail the job
+              }
+            }
+          }
+        } else {
+          jobErr(`Unknown job type: ${type} for job ${jobId}`);
+          throw new Error(`Unknown job type: ${type} for job ${jobId}`);
         }
-      }
 
-      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) {
-        const fakePlugin = require('../test/plugin');
-        return [...pluginsParam, await new fakePlugin({ name: pluginName })];
+        jobLog(`completed`);
+        await saveResult({ id: jobId, resultValue });
+
+      } catch (error) {
+        jobErr(`Processing failed: ${error.message}`);
+        if (error.stack) jobErr(error.stack); // Log full stack for debugging
+        throw new Error(error.message) // Re-throw to mark job as failed in Bull (use a summarized mesage)
       }
-      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`);
-    await saveResult({ id: jobId, resultValue });
-  });
+  };
 };
 
 module.exports = async args => throng({

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,13 +135,13 @@ const jobStatus = async ({ jobId }) => {
       status: state.toLowerCase(),
     };
   } catch (err) {
-    console.log(`could not get job status for ${jobId}`, err);
     return { // 500
       jobId,
       status: 'failed',
     };
   }
 };
+
 module.exports = {
   addJob,
   allDone,
@@ -85,4 +149,5 @@ module.exports = {
   queue,
   saveResult,
   redisResults,
+  removeJob,
 };