just-cron 0.6.1

package/just-cron.js

@@ -0,0 +1,329 @@
+// just-cron.js  (improved 2025 version with simple verbose logging)
+// verbose: function = logging, null/undefined/false = silent
+import cron from 'node-cron';
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+class JustCron {
+  #db;
+  #scheduled = new Map();     // job.id → { task: cron.Schedule, isRunning: () => boolean }
+  #onJobRun;
+  #log = () => {};            // default: silent
+
+  constructor(options = {}) {
+    const {
+      dbPath = join(process.cwd(), 'cron-jobs.db'),
+      timezone = 'Asia/Singapore',
+      jobsDir = join(process.cwd(), 'jobs'),
+      maxConsecutiveFailures = 5,
+      onJobRun = this.#defaultJobRunner.bind(this),
+      verbose = null,           // function → log, null/undefined/false → silent
+    } = options;
+
+    this.dbPath = dbPath;
+    this.timezone = timezone;
+    this.jobsDir = jobsDir;
+    this.maxConsecutiveFailures = maxConsecutiveFailures;
+    this.#onJobRun = onJobRun;
+
+    // Logging setup
+    if (typeof verbose === 'function') {
+      this.#log = verbose;
+    } else if (verbose != null && verbose !== false) {
+      throw new TypeError(
+        'JustCron: verbose must be a function (logging) or null/undefined/false (silent)'
+      );
+    }
+    // otherwise → remains () => {} (silent)
+
+    this.#db = new Database(this.dbPath, { verbose: this.#log });
+    this.#initializeDatabase();
+  }
+
+  #initializeDatabase() {
+    this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id                    INTEGER PRIMARY KEY AUTOINCREMENT,
+        name                  TEXT UNIQUE NOT NULL,
+        schedule              TEXT NOT NULL,
+        description           TEXT NOT NULL,
+        file_path             TEXT,
+        active                INTEGER DEFAULT 1 CHECK(active IN (0,1)),
+        last_run              TEXT,
+        last_run_start        TEXT,
+        last_error            TEXT,
+        consecutive_failures  INTEGER DEFAULT 0,
+        created_at            TEXT DEFAULT (datetime('now')),
+        updated_at            TEXT DEFAULT (datetime('now'))
+      )
+    `);
+
+    this.#db.exec(`CREATE INDEX IF NOT EXISTS idx_name ON jobs(name)`);
+    this.#db.exec(`CREATE INDEX IF NOT EXISTS idx_active ON jobs(active)`);
+  }
+
+  #defaultJobRunner(job) {
+    this.#log(`──── ${new Date().toISOString()} ──── ${job.name} (fallback — no handler)`);
+    this.#log(`  • Schedule:     ${job.schedule}`);
+    this.#log(`  • File:         ${job.file_path || '(none)'}`);
+    this.#log(`  • Description:  ${job.description}`);
+    this.#log('────');
+  }
+
+  /**
+   * Start the cron manager: load & schedule all active jobs
+   * @returns {number} how many jobs were successfully scheduled
+   */
+  start() {
+    this.stopAll();
+
+    const rows = this.#db
+      .prepare('SELECT * FROM jobs WHERE active = 1')
+      .all();
+
+    let count = 0;
+
+    for (const row of rows) {
+      if (this.#scheduleSingleJob(row)) {
+        count++;
+      }
+    }
+
+    this.#log(`JustCron → started & scheduled ${count} active job(s)`);
+    return count;
+  }
+
+  #scheduleSingleJob(job) {
+    if (!cron.validate(job.schedule)) {
+      this.#log(`Invalid cron expression → ${job.name}: ${job.schedule}`);
+      return false;
+    }
+
+    let isRunning = false;
+
+    const task = cron.schedule(
+      job.schedule,
+      async () => {
+        if (isRunning) {
+          this.#log(`[skip] ${job.name} still running — overlap prevented`);
+          return;
+        }
+
+        isRunning = true;
+        const startTime = new Date().toISOString();
+
+        try {
+          await this.#executeJob(job);
+
+          // Success
+          this.#db.prepare(`
+            UPDATE jobs
+            SET last_run           = datetime('now'),
+                last_run_start     = ?,
+                last_error         = NULL,
+                consecutive_failures = 0,
+                updated_at         = datetime('now')
+            WHERE id = ?
+          `).run(startTime, job.id);
+
+          this.#log(`→ OK → ${job.name}`);
+        } catch (err) {
+          const msg = (err.message || String(err)).slice(0, 1000);
+
+          let newFailures = job.consecutive_failures + 1;
+          let shouldDisable = newFailures >= this.maxConsecutiveFailures;
+
+          this.#db.prepare(`
+            UPDATE jobs
+            SET last_run            = datetime('now'),
+                last_run_start      = ?,
+                last_error          = ?,
+                consecutive_failures = ?,
+                active              = CASE WHEN ? THEN 0 ELSE active END,
+                updated_at          = datetime('now')
+            WHERE id = ?
+          `).run(
+            startTime,
+            msg,
+            newFailures,
+            shouldDisable ? 1 : 0,
+            job.id
+          );
+
+          this.#log(`→ FAILED → ${job.name} (${newFailures}/${this.maxConsecutiveFailures}) ${msg}`);
+
+          if (shouldDisable) {
+            this.#log(`→ Auto-disabled job ${job.name} after ${newFailures} failures`);
+          }
+        } finally {
+          isRunning = false;
+        }
+      },
+      { timezone: this.timezone }
+    );
+
+    this.#scheduled.set(job.id, { task, isRunning: () => isRunning });
+    return true;
+  }
+
+  async #executeJob(job) {
+    if (!job.file_path) {
+      await this.#onJobRun(job);
+      return;
+    }
+
+    const fullPath = join(this.jobsDir, job.file_path);
+
+    try {
+      const module = await import(fullPath);
+
+      if (typeof module.default === 'function') {
+        await module.default(job);
+      } else if (typeof module.run === 'function') {
+        await module.run(job);
+      } else {
+        throw new Error(`No default or .run() export found in ${job.file_path}`);
+      }
+    } catch (err) {
+      throw new Error(`Job module failed: ${err.message}`);
+    }
+  }
+
+  /**
+   * Add new job
+   */
+  addJob(name, schedule, description, file_path = null, active = true) {
+    if (!cron.validate(schedule)) {
+      this.#log(`Invalid cron pattern: ${schedule}`);
+      return null;
+    }
+
+    try {
+      const info = this.#db.prepare(`
+        INSERT INTO jobs (name, schedule, description, file_path, active)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(
+        String(name).trim(),
+        String(schedule).trim(),
+        String(description).trim(),
+        file_path ? String(file_path).trim() : null,
+        active ? 1 : 0
+      );
+
+      const job = this.#db
+        .prepare('SELECT * FROM jobs WHERE id = ?')
+        .get(info.lastInsertRowid);
+
+      if (job.active) {
+        this.#scheduleSingleJob(job);
+      }
+
+      return job;
+    } catch (err) {
+      if (err.code === 'SQLITE_CONSTRAINT') {
+        this.#log(`Job name already exists: "${name}"`);
+      } else {
+        this.#log(`addJob failed: ${err.message}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Trigger job immediately (bypasses schedule)
+   */
+  async runNow(id) {
+    const job = this.#db.prepare('SELECT * FROM jobs WHERE id = ?').get(id);
+    if (!job) return false;
+
+    this.#log(`Manual trigger → ${job.name}`);
+
+    try {
+      await this.#executeJob(job);
+      this.#db.prepare(`
+        UPDATE jobs
+        SET last_run = datetime('now'),
+            last_error = NULL,
+            consecutive_failures = 0,
+            updated_at = datetime('now')
+        WHERE id = ?
+      `).run(id);
+      return true;
+    } catch (err) {
+      const msg = (err.message || String(err)).slice(0, 1000);
+      this.#log(`Manual run failed → ${job.name}: ${msg}`);
+
+      this.#db.prepare(`
+        UPDATE jobs
+        SET last_error = ?,
+            consecutive_failures = consecutive_failures + 1,
+            updated_at = datetime('now')
+        WHERE id = ?
+      `).run(msg, id);
+      return false;
+    }
+  }
+
+  toggleJob(id) {
+    const job = this.#db.prepare('SELECT * FROM jobs WHERE id = ?').get(id);
+    if (!job) {
+      this.#log(`Job not found: id = ${id}`);
+      return null;
+    }
+
+    const newActive = job.active ? 0 : 1;
+
+    this.#db.prepare(`
+      UPDATE jobs
+      SET active = ?, updated_at = datetime('now')
+      WHERE id = ?
+    `).run(newActive, id);
+
+    if (newActive) {
+      const updated = this.#db.prepare('SELECT * FROM jobs WHERE id = ?').get(id);
+      this.#scheduleSingleJob(updated);
+      this.#log(`Job ${job.name} enabled`);
+    } else {
+      this.stopJob(id);
+      this.#log(`Job ${job.name} disabled`);
+    }
+
+    return this.#db.prepare('SELECT * FROM jobs WHERE id = ?').get(id);
+  }
+
+  stopJob(id) {
+    const entry = this.#scheduled.get(id);
+    if (entry) {
+      entry.task.stop();
+      this.#scheduled.delete(id);
+      this.#log(`Stopped job id=${id}`);
+    }
+  }
+
+  stopAll() {
+    for (const entry of this.#scheduled.values()) {
+      entry.task.stop();
+    }
+    this.#scheduled.clear();
+    this.#log('All scheduled jobs stopped');
+  }
+
+  getAllJobs() {
+    return this.#db.prepare('SELECT * FROM jobs ORDER BY created_at DESC').all();
+  }
+
+  getActiveJobs() {
+    return this.#db.prepare('SELECT * FROM jobs WHERE active = 1 ORDER BY name').all();
+  }
+
+  close() {
+    this.stopAll();
+    this.#db.close();
+    this.#log('JustCron closed');
+  }
+}
+
+export default JustCron;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "just-cron",
+  "version": "0.6.1",
+  "description": "a light-weight persistent cron in nodejs using sqlite3",
+  "keywords": [
+    "cron",
+    "just-cron",
+    "just",
+    "schedule"
+  ],
+  "homepage": "https://github.com/just-node/just-cron#readme",
+  "bugs": {
+    "url": "https://github.com/just-node/just-cron/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-node/just-cron.git"
+  },
+  "license": "MIT",
+  "author": "littlejustnode",
+  "type": "module",
+  "main": "just-cron.js",
+  "scripts": {
+    "test": ""
+  }
+}