@cocreate/cron-jobs 1.2.1 → 1.4.0

package/.github/workflows/automated.yml

@@ -1,8 +1,10 @@
 name: Automated Workflow
+
 on:
   push:
     branches:
       - master
+
 jobs:
   about:
     runs-on: ubuntu-latest
@@ -18,52 +20,37 @@ jobs:
         with:
           direction: overwrite-github
           githubToken: "${{ secrets.GITHUB }}"
+
   release:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
+        uses: actions/checkout@v4
         with:
-          node-version: 14
-      - name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v3
-        id: semantic
+          fetch-depth: 0 # Required so semantic-release can trace git tags/history
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
         with:
-          extra_plugins: |
-            @semantic-release/changelog
+          node-version: 22
+
+      - name: Install Semantic Release & Plugins
+        # Installs semantic-release and its plugins on the runner
+        run: |
+          npm install -g semantic-release \
+            @semantic-release/changelog \
+            @semantic-release/npm \
+            @semantic-release/github \
             @semantic-release/git
-            @semantic-release/github
+
+      - name: Run Semantic Release (Native)
+        id: semantic
+        # This will automatically pick up your export default config file in the repository root
+        run: npx semantic-release
         env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB }}"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
           NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
+
     outputs:
       new_release_published: "${{ steps.semantic.outputs.new_release_published }}"
-      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"
-  upload:
-    runs-on: ubuntu-latest
-    needs: release
-    if: needs.release.outputs.new_release_published == 'true'
-    env:
-      VERSION: "${{ needs.release.outputs.new_release_version }}"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - name: Set npm registry auth
-        run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc
-      - name: Install dependencies
-        run: yarn install
-
-      - name: Set Environment Variables
-        run: |
-          echo "organization_id=${{ secrets.COCREATE_ORGANIZATION_ID }}" >> $GITHUB_ENV
-          echo "key=${{ secrets.COCREATE_KEY }}" >> $GITHUB_ENV
-          echo "host=${{ secrets.COCREATE_HOST }}" >> $GITHUB_ENV
-      - name: CoCreate Upload
-        run: coc upload
-
+      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+# [1.4.0](https://github.com/CoCreate-app/CoCreate-cron-jobs/compare/v1.3.0...v1.4.0) (2026-07-17)
+
+
+### Features
+
+* update automated workflow and release configuration for improved semantic release handling ([25d37c4](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/25d37c4fd2d2fb3ed40de34556fe13db627baa3a))
+
+# [1.3.0](https://github.com/CoCreate-app/CoCreate-cron-jobs/compare/v1.2.1...v1.3.0) (2026-07-14)
+
+
+### Bug Fixes
+
+* remove unnecessary console logs in init function for cleaner output ([50dac43](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/50dac43f973b7b90144233522d8a950ec6ce5057))
+* removed post install ([101e9b3](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/101e9b379fba70b711b46bb4a046c892bdf21c2a))
+* semantic version handling. Reorganize .gitignore for improved clarity and structure ([f211fa3](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/f211fa30c0c6dc3f90576ad28e15856f5abc45bd))
+* update .gitignore to include package-lock.json and pnpm-lock.yaml ([4ca6545](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/4ca65451c8bd2f9d3c6562fc4908f54c69f3e1f5))
+* update module export to ES6 syntax in release.config.js ([96909f4](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/96909f4deff179f2cb02170816680a8248fcf96e))
+
+
+### Features
+
+* add cron-parser dependency and implement cron job scheduling logic ([b80a44d](https://github.com/CoCreate-app/CoCreate-cron-jobs/commit/b80a44d0dd2ec4b7f7d41e171b9babacb0a1e13a))
+
 ## [1.2.1](https://github.com/CoCreate-app/CoCreate-cron-jobs/compare/v1.2.0...v1.2.1) (2025-05-01)
 
 

package/package.json

@@ -1,18 +1,10 @@
 {
   "name": "@cocreate/cron-jobs",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "A simple cron-jobs component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "cron-jobs",
-    "cocreate",
-    "low-code-framework",
-    "no-code-framework",
-    "cocreatejs",
-    "cocreatejs-component",
-    "cocreate-framework",
-    "no-code",
     "low-code",
-    "collaborative-framework",
     "realtime",
     "realtime-framework",
     "collaboration",
@@ -26,8 +18,7 @@
   "scripts": {
     "start": "npx webpack --config webpack.config.js",
     "build": "npx webpack --mode=production --config webpack.config.js",
-    "dev": "npx webpack --config webpack.config.js --watch",
-    "postinstall": "node -e \"const { execSync } = require('child_process'); try { execSync('coc --version', { stdio: 'ignore' }); } catch (error) { try { execSync('npm install -g @cocreate/cli', { stdio: 'inherit' }); console.log('Installed \"@cocreate/cli\" globally.'); } catch (error) { console.error('Failed to install \"@cocreate/cli\" globally:', error); } }\""
+    "dev": "npx webpack --config webpack.config.js --watch"
   },
   "repository": {
     "type": "git",
@@ -43,8 +34,10 @@
     "type": "GitHub Sponsors ❤",
     "url": "https://github.com/sponsors/CoCreate-app"
   },
+  "type": "module",
   "main": "./src/index.js",
   "dependencies": {
+    "cron-parser": "^4.9.0",
     "node-html-parser": "^6.1.13"
   }
 }

package/release.config.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   dryRun: false,
   branches: ["master"],
   plugins: [
@@ -10,12 +10,20 @@ module.exports = {
         changelogFile: "CHANGELOG.md",
       },
     ],
-    "@semantic-release/npm",
-    "@semantic-release/github",
+    "@semantic-release/npm", 
     [
-      "@semantic-release/git",
+      "@semantic-release/github", 
       {
+        successComment: false,
+        failTitle: false,
+      },
+    ],
+    [
+      "@semantic-release/git", 
+      {
+        // Only stage and commit the changelog and package.json
         assets: ["CHANGELOG.md", "package.json"],
+        message: "chore(release): ${nextRelease.version} [skip ci]",
       },
     ],
   ],

package/src/index.js

@@ -13,6 +13,7 @@
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
  ********************************************************************************/
 
 // Commercial Licensing Information:
@@ -20,281 +21,264 @@
 // you must obtain a commercial license from CoCreate LLC.
 // For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app.
 
+import cronParser from 'cron-parser';
+import server from '@cocreate/server';
+
+// ==========================================
+// Module-Level Sandbox State (ESM Singleton)
+// ==========================================
+let crud = null;
+let wsManager = null;
+const scheduledJobs = {};
+
 /**
- * CoCreateCronJobs class is responsible for managing cron jobs for organizations.
- * It listens to CRUD events and polls the platform DB to schedule and execute cron jobs.
- * 
- * Example Object:
- * 
- * @typedef {Object} CronJobEvent
- * @property {string} organization_id - The ID of the organization for which the cron job is scheduled.
- * @property {string} nextExecutionTime - The ISO 8601 timestamp for the next time the cron job is scheduled to execute.
- * @property {Object} [schedule] - The scheduling information, including cronExpression, interval, and time-related settings.
- * @property {string} [status] - The current status of the cron job, e.g., 'assigned', 'completed', 'failed'.
- * @property {boolean} [active] - Whether the cron job is active or paused.
- * @property {Object} [job] - The job that is to be executed, which could be $crud, $api, or other specific operations.
- * @property {Object} [retryPolicy] - Retry settings for failed jobs, including retries and backoff strategy.
- * @property {Object} [log] - An optional log of the cron job's last execution details, including status and message.
- *
- * Example Object:
- * 
- * @example
- * {
- *   "organization_id": "652c8d62679eca03e0b116a7",
- *   "nextExecutionTime": "2024-09-10T02:00:00Z",
- *   "active": true,                      // Whether the cron job is active or paused
- *   "status": "assigned",
- *   "schedule": {
- *     "cronExpression": "0 2 * * *",        // Standard cron expression (for Unix-based scheduling)
- *     "startBoundary": "2024-09-10T02:00:00Z",  // The first scheduled execution time
- *     "endBoundary": "2025-09-10T02:00:00Z",    // The end time after which no further executions will occur
- *     "interval": "P1D",                   // ISO 8601 format for repeating interval (e.g., repeat every day)
- *     "daysOfWeek": ["Monday", "Wednesday"], // Days of the week when the job should run
- *     "daysOfMonth": [1, 15],              // Specific days of the month for execution
- *     "months": ["January", "July"],       // Specific months for execution
- *     "skipDates": ["2024-12-25"],         // Dates to skip execution
- *     "timezone": "UTC",                   // Timezone for scheduling
- *     "time": "02:00:00"                  // Specific time of day when the job should run
- *   }, 
- *   "job": {
- *     "$crud": {
- *       "method": "object.update",
- *       "array": "users",
- *       "query": { "stripe.account_id": "acc_123456" },
- *       "object": { "stripe.balance": 1000 }
- *     }
- *   },
- *   "retryPolicy": {
- *     "retries": 3,                      // Number of retries for failed jobs
- *     "retryInterval": "PT10M"           // Interval between retries in ISO 8601 format
- *   },
- *   "backoffStrategy": {
- *     "type": "exponential",             // Type of backoff strategy (exponential, linear, etc.)
- *     "initialDelay": "PT5M"             // Initial delay before the first retry
- *   },
- *   "executionTimeout": "PT2H",           // Timeout for job execution (ISO 8601 format)
- *   "log": {
- *     "timestamp": "2024-09-09T02:00:00Z",
- *     "status": "completed",
- *     "message": "Job executed successfully"
- *   }
- * }
- * 
- * @class CoCreateCronJobs
+ * Parses the schedule object and calculates the next execution time.
+ * Takes into account cronExpression, startTime, skipDates, time, daysOfWeek, daysOfMonth, months, endTime, etc.
+ * @param {Object} schedule - The schedule object containing cronExpression, startTime, etc.
+ * @returns {string|null} nextExecutionTime - Calculated execution timestamp in ISO format, or null if endTime has passed.
  */
-class CoCreateCronJobs {
-    /**
-     * Creates an instance of CoCreateCronJobs.
-     * @param {Object} crud - The CRUD module used to handle data operations.
-     */
-    constructor(crud) {
-        this.crud = crud;
-        this.scheduledJobs = {};
-
-        // Listen for CRUD events related to cron jobs
-        process.on('crud-event', (event) => {
-            this.handleCrudEvent(event);
-        });
+function getNextExecutionTime(schedule) {
+    const now = new Date();
+    let currentDateTime = now;
 
-        // Start polling every 5 minutes
-        setInterval(() => {
-            this.pollForCronJobs();
-        }, 5 * 60 * 1000);
+    // Use startTime if it's greater than now, otherwise use now
+    if (schedule.startTime && new Date(schedule.startTime) > now) {
+        currentDateTime = new Date(schedule.startTime);
     }
 
-    /**
-     * Handles CRUD events to schedule cron jobs.
-     * @param {Object} data - The data object emitted from CRUD operations.
-     */
-    handleCrudEvent(data) {
-        // Check if the array is 'cron-job'
-        if (data.array !== 'cron-job') {
-            return;  // Ignore non-cron-job events
-        }
-
-        // Iterate over the jobs in the data.object array
-        for (let i = 0; i < data.object.length; i++) {
-            if (data.method === 'object.delete' || data.object[i].active === false) {
-                const timeoutId = this.scheduledJobs[data.object[i]._id];
-
-                if (timeoutId) {
-                    clearTimeout(timeoutId); // Cancel the timeout if it exists
-                    delete this.scheduledJobs[data.object[i]._id]; // Remove the reference
-                }
-
-                data.object.splice(i, 1);
-                i--;  // Adjust the index after removal
-
-                continue;
-            }
-
-            const nextExecutionTime = this.getNextExecutionTime(data.object[i].schedule);
-
-            if (nextExecutionTime) {
-                // TODO: Compare executionTime if equal continue
-                if (this.scheduledJobs[data.object[i]._id])
-                    continue
-
-                const timeUntilExecution = new Date(nextExecutionTime) - new Date();
-
-                data.object[i].nextExecutionTime = nextExecutionTime
-
-                // If the next execution is within the next 5 minutes, schedule the job
-                if (timeUntilExecution <= 5 * 60 * 1000 && timeUntilExecution > 0) {
-                    data.object[i].status = 'assigned'
-                    this.scheduleCronJob(data.object[i]);
-                }
-            } else {
-                data.object.splice(i, 1);
-                i--;  // Adjust the index after removal
-            }
-        }
-
-        this.updateCronJob(data.object);
+    // Apply skipDates: Skip the date if it matches any in skipDates
+    if (schedule.skipDates && schedule.skipDates.includes(currentDateTime.toISOString().split('T')[0])) {
+        currentDateTime = new Date(currentDateTime.getTime() + 24 * 60 * 60 * 1000);  // Skip to the next day
     }
 
-    /**
-     * Parses the schedule object and calculates the next execution time.
-     * Takes into account cronExpression, startTime, skipDates, time, daysOfWeek, daysOfMonth, months, endTime, etc.
-     * 
-     * @param {Object} schedule - The schedule object containing cronExpression, startTime, etc.
-     * @returns {string|null} nextExecutionTime - The calculated next execution time in ISO 8601 format, or null if endTime has passed.
-     */
-    getNextExecutionTime(schedule) {
-        const now = new Date();
-        let currentDateTime = now;
-
-        // Use startTime if it's greater than now, otherwise use now
-        if (schedule.startTime && new Date(schedule.startTime) > now) {
-            currentDateTime = new Date(schedule.startTime);
-        }
-
-        // Apply skipDates: Skip the date if it matches any in skipDates
-        if (schedule.skipDates && schedule.skipDates.includes(currentDateTime.toISOString().split('T')[0])) {
-            currentDateTime = new Date(currentDateTime.getTime() + 24 * 60 * 60 * 1000);  // Skip to the next day
-        }
-
-        // Apply daysOfWeek: If the current day is not in the allowed days, skip to the next valid day
-        if (schedule.daysOfWeek) {
-            const dayOfWeek = currentDateTime.toLocaleString('en-US', { weekday: 'long', timeZone: schedule.timezone || 'UTC' });
+    // Apply daysOfWeek: If the current day is not in the allowed days, skip to the next valid day
+    if (schedule.daysOfWeek) {
+        const dayOfWeek = currentDateTime.toLocaleString('en-US', { weekday: 'long', timeZone: schedule.timezone || 'UTC' });
 
-            while (!schedule.daysOfWeek.includes(dayOfWeek)) {
-                currentDateTime.setDate(currentDateTime.getDate() + 1);  // Move to the next day
-            }
+        while (!schedule.daysOfWeek.includes(dayOfWeek)) {
+            currentDateTime.setDate(currentDateTime.getDate() + 1);  // Move to the next day
         }
+    }
 
-        // Apply daysOfMonth: Ensure the next execution is on a valid day of the month
-        if (schedule.daysOfMonth) {
-            while (!schedule.daysOfMonth.includes(currentDateTime.getDate())) {
-                currentDateTime.setDate(currentDateTime.getDate() + 1);  // Move to the next day
-            }
+    // Apply daysOfMonth: Ensure the next execution is on a valid day of the month
+    if (schedule.daysOfMonth) {
+        while (!schedule.daysOfMonth.includes(currentDateTime.getDate())) {
+            currentDateTime.setDate(currentDateTime.getDate() + 1);  // Move to the next day
         }
+    }
 
-        // Apply months: Ensure the next execution falls within one of the allowed months
-        if (schedule.months) {
-            const monthName = currentDateTime.toLocaleString('en-US', { month: 'long', timeZone: schedule.timezone || 'UTC' });
+    // Apply months: Ensure the next execution falls within one of the allowed months
+    if (schedule.months) {
+        const monthName = currentDateTime.toLocaleString('en-US', { month: 'long', timeZone: schedule.timezone || 'UTC' });
 
-            while (!schedule.months.includes(monthName)) {
-                currentDateTime.setMonth(currentDateTime.getMonth() + 1);  // Move to the next month
-            }
+        while (!schedule.months.includes(monthName)) {
+            currentDateTime.setMonth(currentDateTime.getMonth() + 1);  // Move to the next month
         }
+    }
 
-        // Apply time: Set the execution time of day if specified
-        if (schedule.time) {
-            const [hours, minutes, seconds] = schedule.time.split(':');
-            currentDateTime.setHours(hours, minutes, seconds);
-        }
+    // Apply time: Set the execution time of day if specified
+    if (schedule.time) {
+        const [hours, minutes, seconds] = schedule.time.split(':');
+        currentDateTime.setHours(hours, minutes, seconds);
+    }
 
-        // Apply endTime: Ensure the next execution time does not exceed the endTime
-        if (schedule.endTime && new Date(currentDateTime) > new Date(schedule.endTime)) {
-            return null;  // No further executions after endTime
-        }
+    // Apply endTime: Ensure the next execution time does not exceed the endTime
+    if (schedule.endTime && new Date(currentDateTime) > new Date(schedule.endTime)) {
+        return null;  // No further executions after endTime
+    }
 
-        // Now run the cronParser to handle cronExpression (if present) or fallback to currentDateTime
-        if (schedule.cronExpression) {
+    // Now run the cronParser to handle cronExpression (if present) or fallback to currentDateTime
+    if (schedule.cronExpression) {
+        try {
             const interval = cronParser.parseExpression(schedule.cronExpression, {
                 currentDate: currentDateTime,
                 tz: schedule.timezone || 'UTC'
             });
             return interval.next().toISOString();
+        } catch (err) {
+            console.error('[@cocreate/cron-jobs] Cron parsing failed:', err);
+            return null;
         }
-
-        return currentDateTime.toISOString();
     }
 
-    /**
-     * Schedules a cron job to be executed at a specific datetime.
-     * 
-     * @param {string} organization_id - The organization ID.
-     * @param {string} datetime - The time at which the job should be executed.
-     */
-    scheduleCronJob(object) {
-        const delay = new Date(object.nextExecutionTime) - new Date();
-
-        if (delay <= 0) {
-            this.executeCronJob(object);
-            return;
-        }
+    return currentDateTime.toISOString();
+}
+
+/**
+ * Marks the cron job status inside the platform database.
+ * Normalizes input array payloads to preserve safety across organization contexts.
+ */
+async function updateCronJob(object) {
+    if (!crud) return;
+    try {
+        const cronJobs = Array.isArray(object) ? object : [object];
 
-        console.log(`Scheduling cron job for org ${object.organization_id} in ${delay / 1000} seconds`);
-
-        // TODO: get clusterId, serverId and workerId
-        object = {
-            _id: object._id,
-            nextExecutionTime: object.nextExecutionTime,
-            status: object.status,
-            clusterId: 'id',
-            severId: 'id',
-            workerId: 'id',
-            organization_id: object.organization_id
+        for (const job of cronJobs) {
+            await crud.send({
+                method: 'object.update',
+                array: 'cron-jobs',
+                object: [job],
+                upsert: true,
+                organization_id: job.organization_id
+            });
+            console.log(`[@cocreate/cron-jobs] Cron job for org ${job.organization_id} updated.`);
         }
 
-        this.scheduledJobs[object._id] = setTimeout(() => {
-            this.executeCronJob(object);
-        }, delay);
+        if (cronJobs.length > 0 && cronJobs[0].organization_id) {
+            const firstJob = cronJobs[0];
+            await crud.send({
+                method: 'object.update',
+                array: 'organizations',
+                object: {
+                    _id: firstJob.organization_id,
+                    cronJobs
+                },
+                organization_id: process.env.organization_id
+            });
+            console.log(`[@cocreate/cron-jobs] Cron job list for org ${firstJob.organization_id} mapped.`);
+        }
+    } catch (error) {
+        console.error('[@cocreate/cron-jobs] Error updating cron job records:', error);
     }
+}
 
-    /**
-     * Executes the scheduled cron job.
-     * 
-     * @param {Object} schedule - The cron-job object containing job, schedule, etc.
-     */
-    async executeCronJob(object) {
-        console.log(`Executing cron job for org ${object.organization_id}`);
+/**
+ * Executes the scheduled cron job.
+ * @param {Object} object - The cron-job object containing job details, schedule parameters, etc.
+ */
+async function executeCronJob(object) {
+    console.log(`[@cocreate/cron-jobs] Executing cron job for org ${object.organization_id}`);
 
-        if (!object.job) {
-            let data = await this.crud.send({
+    try {
+        if (!object.job && crud) {
+            const data = await crud.send({
                 method: 'object.read',
                 array: 'cron-job',
                 object: { _id: object._id },
                 organization_id: object.organization_id
-            })
-            object = data.object[0]
-            console.log('Fetched cron job data:', object);
+            });
+            if (data.object && data.object[0]) {
+                object = data.object[0];
+            }
+            console.log('[@cocreate/cron-jobs] Fetched cron job data:', object);
         }
 
-        // TODO: execute cron using lazyloader.webhook()
-        object.nextExecutionTime = this.getNextExecutionTime(object.schedule);
+        // Target Action Pipeline execution placeholder:
+        // TODO: execute cron using lazyloader.webhook() or server-native lazyloader routing
+        
+        object.nextExecutionTime = getNextExecutionTime(object.schedule);
         if (!object.nextExecutionTime) {
-            object.active = false
-            object.status = 'completed'
+            object.active = false;
+            object.status = 'completed';
+        } else {
+            // Re-queue and release the lock for the next interval run
+            object.status = 'scheduled';
+            object.serverId = null;
+            object.workerId = null;
+        }
+
+        await updateCronJob(object);
+    } catch (error) {
+        console.error(`[@cocreate/cron-jobs] Error executing cron job ${object._id}:`, error);
+    }
+}
+
+/**
+ * Schedules a cron job to be executed at a specific datetime.
+ * @param {Object} object - The cron-job configuration footprint.
+ */
+function scheduleCronJob(object) {
+    const delay = new Date(object.nextExecutionTime) - new Date();
+
+    if (delay <= 0) {
+        executeCronJob(object);
+        return;
+    }
+
+    console.log(`[@cocreate/cron-jobs] Scheduling cron job for org ${object.organization_id} in ${delay / 1000} seconds`);
+
+    const scheduledObj = {
+        _id: object._id,
+        nextExecutionTime: object.nextExecutionTime,
+        status: object.status,
+        clusterId: 'default-cluster', 
+        serverId: server?.instanceId || server?.serverId || 'default-server',
+        workerId: server?.workerId !== undefined ? server.workerId : 'standalone',
+        organization_id: object.organization_id
+    };
+
+    scheduledJobs[object._id] = setTimeout(() => {
+        executeCronJob(scheduledObj);
+    }, delay);
+}
+
+/**
+ * Handles CRUD events to schedule cron jobs dynamically.
+ * @param {Object} data - The data object emitted from CRUD operations.
+ */
+async function handleCrudEvent(data) {
+    if (data.array !== 'cron-job') {
+        return;  // Ignore non-cron-job events
+    }
+
+    // Iterate over the jobs in the data.object array
+    for (let i = 0; i < data.object.length; i++) {
+        if (data.method === 'object.delete' || data.object[i].active === false) {
+            const timeoutId = scheduledJobs[data.object[i]._id];
+
+            if (timeoutId) {
+                clearTimeout(timeoutId); // Cancel the timeout if it exists
+                delete scheduledJobs[data.object[i]._id]; // Remove the reference
+            }
+
+            data.object.splice(i, 1);
+            i--;  // Adjust the index after removal
+            continue;
         }
 
-        this.updateCronJob(object);
+        const nextExecutionTime = getNextExecutionTime(data.object[i].schedule);
+
+        if (nextExecutionTime) {
+            // If already scheduled for the exact same block, skip duplicate scheduling
+            if (scheduledJobs[data.object[i]._id]) {
+                continue;
+            }
+
+            const timeUntilExecution = new Date(nextExecutionTime) - new Date();
+            data.object[i].nextExecutionTime = nextExecutionTime;
+
+            // If the next execution is within the next 5 minutes, schedule the job
+            if (timeUntilExecution <= 5 * 60 * 1000 && timeUntilExecution > 0) {
+                // Claim the job locally and coordinate across nodes/cores
+                data.object[i].status = 'assigned';
+                data.object[i].serverId = server?.instanceId || server?.serverId || 'default-server';
+                data.object[i].workerId = server?.workerId !== undefined ? server.workerId : 'standalone';
+                scheduleCronJob(data.object[i]);
+            }
+        } else {
+            data.object.splice(i, 1);
+            i--;  // Adjust the index after removal
+        }
     }
 
+    await updateCronJob(data.object);
+}
 
-    /**
-     * Polls the platform DB for cron jobs that are scheduled or potentially failed.
-     */
-    pollForCronJobs() {
-        console.log('Polling for cron jobs...');
+/**
+ * Polls the platform DB for cron jobs that are scheduled or potentially failed.
+ * Any worker process hosting active sockets/procedures for an organization can safely execute this.
+ */
+async function pollForCronJobs() {
+    if (!crud) return;
+    console.log(`[@cocreate/cron-jobs] [Worker ${server?.workerId}] Polling for active organizations' cron jobs...`);
 
-        const now = new Date();
-        const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
-        const oneMinuteAgo = new Date(now.getTime() - 1 * 60 * 1000);  // 1 minute past due jobs
+    const now = new Date();
+    const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
+    const oneMinuteAgo = new Date(now.getTime() - 1 * 60 * 1000);  // 1 minute past due jobs
 
-        this.crud.send({
+    try {
+        // Query organizations.
+        const data = await crud.send({
             method: 'object.read',
             array: 'organizations',
             filter: {
@@ -303,131 +287,142 @@ class CoCreateCronJobs {
                         {
                             $and: [
                                 { 'cron-jobs.nextExecutionTime': { $elemMatch: { $lte: fiveMinutesFromNow, $gte: now } } }, // Match jobs in array within 5 minutes
-                                { 'cron-jobs.status': { $elemMatch: { $ne: 'assigned' } } },   // Not already assigned
+                                { 'cron-jobs.status': { $elemMatch: { $ne: 'assigned' } } },   // Not already claimed/assigned
                                 { 'cron-jobs.active': { $elemMatch: { $ne: false } } }   // Is active
                             ]
                         },
                         {
                             $and: [
-                                { 'cron-jobs.nextExecutionTime': { $elemMatch: { $lt: oneMinuteAgo } } },   // Past due by 1 minute
-                                { 'cron-jobs.status': { $elemMatch: { $eq: 'assigned' } } },    // Assigned but not started
-                                { 'cron-jobs.active': { $elemMatch: { $ne: false } } }   // Is active                              
+                                { 'cron-jobs.nextExecutionTime': { $elemMatch: { $lt: oneMinuteAgo } } },   // Past due by 1 minute (possible crash recovery)
+                                { 'cron-jobs.status': { $elemMatch: { $eq: 'assigned' } } },    // Marked assigned but execution failed to clear/update it
+                                { 'cron-jobs.active': { $elemMatch: { $ne: false } } }   // Is active                           
                             ]
                         }
                     ]
                 }
             },
             organization_id: process.env.organization_id
-        }).then(data => {
-            for (let i = 0; i < data.object.length; i++) {
-                const cronJobs = data.object[i].cronJobs;
-                if (!cronJobs)
-                    return
-
-                // Check each cron job in the organization's `cron-jobs` array
-                for (let j = 0; j < cronJobs; j++) {
-                    if (this.scheduledJobs[cronJobs[j]._id])
-                        return
-
-                    cronJobs[j].status = 'assigned'
-
-                    // TODO: get clusterId, serverId and workerId
-                    cronJobs[j].clusterId = 'id'
-                    cronJobs[j].severId = 'id'
-                    cronJobs[j].workerId = 'id'
-                    cronJobs[j].organization_id = data.object[i].organization_id
-
-                    this.scheduleCronJob(cronJobs[j]);
-                }
-
-                this.updateCronJob(cronJobs);
-            }
-        }).catch(error => {
-            console.error('Error polling for cron jobs:', error);
         });
-    }
 
-    /**
-     * Marks the cron job as failed after it is detected as past due and not started.
-     */
-    updateCronJob(object) {
-        if (!Array.isArray(object))
-            object = [object]
+        if (!data || !data.object) return;
 
-        for (let i = 0; i < object.length; i++) {
-            this.crud.send({
-                method: 'object.update',
-                array: 'cron-jobs',
-                object,
-                upsert: true,
-                organization_id: object.organization_id
-            }).then(() => {
-                console.log(`Cron job for org ${object.organization_id} updated.`);
-            }).catch(error => {
-                console.error(`Error updating cron job for org ${object.organization_id}:`, error);
-            });
+        for (let i = 0; i < data.object.length; i++) {
+            const cronJobs = data.object[i].cronJobs;
+            if (!cronJobs) continue;
+
+            const organizationId = data.object[i].organization_id;
+
+            // Check each cron job in the organization's `cron-jobs` array
+            for (let j = 0; j < cronJobs.length; j++) {
+                if (scheduledJobs[cronJobs[j]._id]) continue;
+
+                // Set assignment properties to claim this job cluster-wide
+                cronJobs[j].status = 'assigned';
+                cronJobs[j].clusterId = 'default-cluster';
+                cronJobs[j].serverId = server?.instanceId || server?.serverId || 'default-server';
+                cronJobs[j].workerId = server?.workerId !== undefined ? server.workerId : 'standalone';
+                cronJobs[j].organization_id = organizationId;
 
+                scheduleCronJob(cronJobs[j]);
+            }
+
+            await updateCronJob(cronJobs);
         }
+    } catch (error) {
+        console.error('[@cocreate/cron-jobs] Error polling for cron jobs:', error);
+    }
+}
 
-        const cronJobs = object
-        this.crud.send({
-            method: 'object.update',
+/**
+ * Adds a cron job reference to the platform database.
+ * @param {string} organization_id - The organization ID.
+ * @param {string} datetime - The datetime of the cron job to add to the platform DB.
+ */
+async function addToPlatformDB(organization_id, datetime) {
+    if (!crud) return;
+    console.log(`[@cocreate/cron-jobs] Adding cron job reference to platform DB for org ${organization_id}`);
+
+    try {
+        await crud.send({
+            method: 'object.read',
             array: 'organizations',
-            object: {
-                _id: object.organization_id,
-                cronJobs
-            },
+            object: { _id: organization_id, nextCron: datetime },
             organization_id: process.env.organization_id
-        }).then(() => {
-            console.log(`Cron job for org ${object.organization_id} updated.`);
-        }).catch(error => {
-            console.error(`Error updating cron job for org ${object.organization_id}:`, error);
         });
+        console.log(`[@cocreate/cron-jobs] Platform DB updated for org ${organization_id}`);
+    } catch (error) {
+        console.error(`[@cocreate/cron-jobs] Error updating platform DB for org ${organization_id}:`, error);
     }
+}
 
-    /**
-     * Adds a cron job reference to the platform database.
-     * 
-     * @param {string} organization_id - The organization ID.
-     * @param {string} datetime - The datetime of the cron job to add to the platform DB.
-     */
-    addToPlatformDB(organization_id, datetime) {
-        console.log(`Adding cron job reference to platform DB for org ${organization_id}`);
+/**
+ * Finds and schedules the next cron job for the organization after one is executed.
+ * @param {string} organization_id - The organization ID.
+ */
+async function findNextCronJob(organization_id) {
+    if (!crud) return;
+    console.log(`[@cocreate/cron-jobs] Finding next cron job for org ${organization_id}`);
 
-        this.crud.send({
+    try {
+        const nextJob = await crud.send({
             method: 'object.read',
-            array: 'organizations',
-            object: { _id: organization_id, nextCron: datetime },
-            organization_id: process.env.organization_id
-        }).then(() => {
-            console.log(`Platform DB updated for org ${organization_id}`);
-        }).catch(error => {
-            console.error(`Error updating platform DB for org ${organization_id}:`, error);
+            array: 'cron-job',
+            $filter: {
+                query: { organization_id },
+                sort: [{ key: 'datetime', direction: 'asc' }],
+                limit: 1
+            },
+            organization_id
         });
+
+        if (nextJob && nextJob.object && nextJob.object.length > 0) {
+            const { datetime } = nextJob.object[0];
+            scheduleCronJob({ ...nextJob.object[0], nextExecutionTime: datetime });
+        }
+    } catch (error) {
+        console.error(`[@cocreate/cron-jobs] Error finding next cron job for org ${organization_id}:`, error);
     }
+}
 
-    /**
-    * Finds and schedules the next cron job for the organization after one is executed.
-    * 
-    * @param {string} organization_id - The organization ID.
-    */
-    findNextCronJob(organization_id) {
-        console.log(`Finding next cron job for org ${organization_id}`);
-
-        this.crud.read({
-            collection: 'cron-job',
-            query: { organization_id },
-            sort: { datetime: 1 },
-            limit: 1
-        }).then(nextJob => {
-            if (nextJob.length > 0) {
-                const { datetime } = nextJob[0];
-                this.scheduleCronJob(organization_id, datetime);
-            }
-        }).catch(error => {
-            console.error(`Error finding next cron job for org ${organization_id}:`, error);
+/**
+ * Self-Activating Auto-Initialization Loop.
+ * Runs on static module import, polling background state to detect when the 
+ * parent server core has fully executed its async initialization blocks.
+ */
+async function init() {
+    if (server && server.isInitialized && server.crud && server.wsManager) {
+        crud = server.crud;
+        wsManager = server.wsManager;
+
+        // Handle incoming realtime CRUD operations to dynamically reschedule active jobs
+        process.on('crud-event', (event) => {
+            handleCrudEvent(event);
         });
+        
+        // Initial boot poll
+        pollForCronJobs();
+
+        // Setup the 5-minute interval cycle
+        setInterval(() => {
+            pollForCronJobs();
+        }, 5 * 60 * 1000);
+        
+    } else {
+        // If the server core isn't fully booted/initialized yet, retry in 500ms
+        setTimeout(init, 500);
     }
 }
 
-module.exports = CoCreateCronJobs;
+// Start auto-activation monitoring sequence instantly upon import evaluation
+init();
+
+export default {
+    init,
+    getNextExecutionTime,
+    executeCronJob,
+    scheduleCronJob,
+    handleCrudEvent,
+    pollForCronJobs,
+    addToPlatformDB,
+    findNextCronJob
+};