feat: register cron jobs at runtime instead of a generic cron job that runs every minute (#216)

Author: boazpoolman

server/config/cron-tasks.js

@@ -1,28 +1,58 @@
 import getPluginService from '../utils/getPluginService';
+import logMessage from '../utils/logMessage';
 
-const registerCronTasks =  ({ strapi }) => {
-	const settings = getPluginService('settingsService').get();
-	// create cron check
-	strapi.cron.add({
-		publisherCronTask: {
-			options: settings.actions.syncFrequency,
-			task: async () => {
-				// fetch all actions that have passed
-				const records = await getPluginService('action').find({
-					filters: {
-						executeAt: {
-							$lte: new Date(Date.now()),
-						},
-					},
-				});
-
-				// process action records
-				for (const record of records.results) {
-					getPluginService('publicationService').toggle(record, record.mode);
+const registerCronTasks = ({ strapi }) => {
+	// On startup, schedule cron jobs for all existing actions that are in the future
+	// and execute actions that should have already been executed
+	const scheduleExistingActions = async () => {
+		try {
+			// Find all pending actions
+			const allActions = await getPluginService('action').find({
+				pagination: {
+					pageSize: 1000, // Get all actions
+				},
+			});
+
+			const now = new Date();
+			const futureActions = [];
+			const pastActions = [];
+
+			// Separate actions into past and future
+			for (const record of allActions.results) {
+				const executeAt = new Date(record.executeAt);
+				if (executeAt > now) {
+					futureActions.push(record);
+				} else {
+					pastActions.push(record);
 				}
-			},
-		},
+			}
+
+			strapi.log.info(logMessage(`Found ${pastActions.length} past actions to execute and ${futureActions.length} future actions to schedule on startup.`));
+
+			// Execute past actions immediately
+			for (const record of pastActions) {
+				try {
+					await getPluginService('publicationService').toggle(record, record.mode);
+					strapi.log.info(logMessage(`Executed overdue action ${record.documentId}`));
+				} catch (error) {
+					strapi.log.error(logMessage(`Error executing overdue action ${record.documentId}: ${error.message}`));
+				}
+			}
+
+			// Schedule cron jobs for all future actions
+			for (const record of futureActions) {
+				getPluginService('action').scheduleCronJob(record);
+			}
+		} catch (error) {
+			strapi.log.error(logMessage(`Error scheduling existing actions on startup: ${error.message}`));
+		}
+	};
+
+	// Schedule existing actions after Strapi is fully started
+	// Using setImmediate to ensure all services are initialized
+	setImmediate(() => {
+		scheduleExistingActions();
 	});
-}
+};
 
 export default registerCronTasks;

server/services/action-service.js

@@ -3,5 +3,105 @@
  */
 
 import { factories } from '@strapi/strapi';
+import getPluginService from '../utils/getPluginService';
+import logMessage from '../utils/logMessage';
 
-export default factories.createCoreService('plugin::publisher.action');
+export default factories.createCoreService('plugin::publisher.action', ({ strapi }) => ({
+	/**
+	 * Schedule a cron job for a specific action
+	 */
+	scheduleCronJob(action) {
+		const taskName = `publisherAction_${action.documentId}`;
+		const executeAt = new Date(action.executeAt);
+
+		// Check if the execution time is in the future
+		if (executeAt <= new Date()) {
+			strapi.log.warn(logMessage(`Action ${action.documentId} has an executeAt time in the past, skipping cron job creation.`));
+			return;
+		}
+
+		strapi.log.info(logMessage(`Scheduling cron job for action ${action.documentId} at ${executeAt.toISOString()}`));
+
+		strapi.cron.add({
+			[taskName]: {
+				async task() {
+					try {
+						// Fetch the action again to ensure it still exists
+						const currentAction = await strapi.documents('plugin::publisher.action').findOne({
+							documentId: action.documentId,
+						});
+
+						if (!currentAction) {
+							strapi.log.warn(logMessage(`Action ${action.documentId} no longer exists, skipping execution.`));
+							return;
+						}
+
+						// Execute the publication action
+						await getPluginService('publicationService').toggle(currentAction, currentAction.mode);
+						
+						strapi.log.info(logMessage(`Successfully executed action ${action.documentId}`));
+					} catch (error) {
+						strapi.log.error(logMessage(`Error executing action ${action.documentId}: ${error.message}`));
+					} finally {
+						// Remove the cron job after execution
+						strapi.cron.remove(taskName);
+					}
+				},
+				options: executeAt,
+			},
+		});
+	},
+
+	/**
+	 * Remove a scheduled cron job
+	 */
+	removeCronJob(actionDocumentId) {
+		const taskName = `publisherAction_${actionDocumentId}`;
+		
+		try {
+			strapi.cron.remove(taskName);
+			strapi.log.info(logMessage(`Removed cron job for action ${actionDocumentId}`));
+		} catch (error) {
+			strapi.log.warn(logMessage(`Could not remove cron job ${taskName}: ${error.message}`));
+		}
+	},
+
+	/**
+	 * Override create to schedule cron job
+	 */
+	async create(...args) {
+		const result = await super.create(...args);
+		
+		// Schedule the cron job for this action
+		this.scheduleCronJob(result);
+		
+		return result;
+	},
+
+	/**
+	 * Override update to reschedule cron job
+	 */
+	async update(documentId, ...args) {
+		// Remove the old cron job
+		this.removeCronJob(documentId);
+		
+		const result = await super.update(documentId, ...args);
+		
+		// Schedule a new cron job with updated data
+		this.scheduleCronJob(result);
+		
+		return result;
+	},
+
+	/**
+	 * Override delete to remove cron job
+	 */
+	async delete(documentId, ...args) {
+		// Remove the cron job before deleting
+		this.removeCronJob(documentId);
+		
+		const result = await super.delete(documentId, ...args);
+		
+		return result;
+	},
+}));