agendash 2.0.0 → 3.1.0

package/lib/controllers/agendash.js

@@ -1,20 +1,23 @@
-'use strict';
-const semver = require('semver');
-const {ObjectID} = require('mongodb'); // We rely on the Agenda's "mongodb", thus our package.json lists "*" as required version
+"use strict";
+const semver = require("semver");
+const { ObjectId } = require("mongodb"); // We rely on the Agenda's "mongodb", thus our package.json lists "*" as required version
 
-module.exports = function(agenda, options) {
+module.exports = function (agenda, options) {
   options = options || {};
 
-  agenda.on('ready', () => {
+  agenda.on("ready", () => {
     const collection = agenda._collection.collection || agenda._collection;
-    collection.createIndexes([
-      {key: {nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1}},
-      {key: {name: 1, nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1}}
-    ], error => {
-      if (error) {
-        // Ignoring for now
+    collection.createIndexes(
+      [
+        { key: { nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1 } },
+        { key: { name: 1, nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1 } },
+      ],
+      (error) => {
+        if (error) {
+          // Ignoring for now
+        }
       }
-    });
+    );
 
     // Mongoose internals changed at some point. This will fix crash for older versions.
     const mdb = agenda._mdb.admin ? agenda._mdb : agenda._mdb.db;
@@ -24,14 +27,14 @@ module.exports = function(agenda, options) {
         throw error;
       }
 
-      if (!semver.satisfies(serverInfo.version, '>=2.6.0')) {
-        throw new Error('MongoDB version not supported');
+      if (!semver.satisfies(semver.coerce(serverInfo.version), ">=3.6.0")) {
+        throw new Error("MongoDB version not supported");
       }
     });
   });
 
   // Options = {query = '', property = '', isObjectId = false, limit, skip}
-  const getJobs = function(job, state, options) {
+  const getJobs = function (job, state, options) {
     const preMatch = {};
     if (job) {
       preMatch.name = job;
@@ -39,11 +42,11 @@ module.exports = function(agenda, options) {
 
     if (options.query && options.property) {
       if (options.isObjectId) {
-        preMatch[options.property] = ObjectID.createFromHexString(options.query);
+        preMatch[options.property] = ObjectId(options.query);
       } else if (/^\d+$/.test(options.query)) {
         preMatch[options.property] = Number.parseInt(options.query, 10);
       } else {
-        preMatch[options.property] = {$regex: options.query, $options: 'i'};
+        preMatch[options.property] = { $regex: options.query, $options: "i" };
       }
     }
 
@@ -53,82 +56,185 @@ module.exports = function(agenda, options) {
     }
 
     const collection = agenda._collection.collection || agenda._collection;
-    return collection.aggregate([
-      {$match: preMatch},
-      {$sort: {
-        nextRunAt: -1,
-        lastRunAt: -1,
-        lastFinishedAt: -1
-      }},
-      {$project: {
-        job: '$$ROOT',
-        _id: '$$ROOT._id',
-        running: {$and: [
-          '$lastRunAt',
-          {$gt: ['$lastRunAt', '$lastFinishedAt']}
-        ]},
-        scheduled: {$and: [
-          '$nextRunAt',
-          {$gte: ['$nextRunAt', new Date()]}
-        ]},
-        queued: {$and: [
-          '$nextRunAt',
-          {$gte: [new Date(), '$nextRunAt']},
-          {$gte: ['$nextRunAt', '$lastFinishedAt']}
-        ]},
-        completed: {$and: [
-          '$lastFinishedAt',
-          {$gt: ['$lastFinishedAt', '$failedAt']}
-        ]},
-        failed: {$and: [
-          '$lastFinishedAt',
-          '$failedAt',
-          {$eq: ['$lastFinishedAt', '$failedAt']}
-        ]},
-        repeating: {$and: [
-          '$repeatInterval',
-          {$ne: ['$repeatInterval', null]}
-        ]}
-      }},
-      {$match: postMatch},
-      {$facet: {
-        pages: [
-          {$count: 'totalMatchs'},
-          {$project: {
-            totalPages: {$ceil: {$divide: ['$totalMatchs', options.limit]}}
-          }}
-        ],
-        filtered: [
-          {$skip: options.skip},
-          {$limit: options.limit}
-        ]
-      }}
-    ]).toArray();
+    return collection
+      .aggregate([
+        { $match: preMatch },
+        {
+          $sort: {
+            nextRunAt: -1,
+            lastRunAt: -1,
+            lastFinishedAt: -1,
+          },
+        },
+        {
+          $project: {
+            job: "$$ROOT",
+            _id: "$$ROOT._id",
+            running: {
+              $and: ["$lastRunAt", { $gt: ["$lastRunAt", "$lastFinishedAt"] }],
+            },
+            scheduled: {
+              $and: ["$nextRunAt", { $gte: ["$nextRunAt", new Date()] }],
+            },
+            queued: {
+              $and: [
+                "$nextRunAt",
+                { $gte: [new Date(), "$nextRunAt"] },
+                { $gte: ["$nextRunAt", "$lastFinishedAt"] },
+              ],
+            },
+            completed: {
+              $and: [
+                "$lastFinishedAt",
+                { $gt: ["$lastFinishedAt", "$failedAt"] },
+              ],
+            },
+            failed: {
+              $and: [
+                "$lastFinishedAt",
+                "$failedAt",
+                { $eq: ["$lastFinishedAt", "$failedAt"] },
+              ],
+            },
+            repeating: {
+              $and: ["$repeatInterval", { $ne: ["$repeatInterval", null] }],
+            },
+          },
+        },
+        { $match: postMatch },
+        {
+          $facet: {
+            pages: [
+              { $count: "totalMatchs" },
+              {
+                $project: {
+                  totalPages: {
+                    $ceil: { $divide: ["$totalMatchs", options.limit] },
+                  },
+                },
+              },
+            ],
+            filtered: [{ $skip: options.skip }, { $limit: options.limit }],
+          },
+        },
+      ])
+      .toArray();
   };
 
-  const getOverview = async() => {
+  const getOverview = async () => {
     const collection = agenda._collection.collection || agenda._collection;
-    const results = await collection.aggregate([
-      {$group: {
-        _id: '$name',
-        displayName: {$first: '$name'},
-        meta: {$addToSet: {
-          type: '$type',
-          priority: '$priority',
-          repeatInterval: '$repeatInterval',
-          repeatTimezone: '$repeatTimezone'
-        }},
-        total: {$sum: 1},
-        running: {$sum: {$cond: [{$and: ['$lastRunAt', {$gt: ['$lastRunAt', '$lastFinishedAt']}]}, 1, 0]}},
-        scheduled: {$sum: {$cond: [{$and: ['$nextRunAt', {$gte: ['$nextRunAt', new Date()]}]}, 1, 0]}},
-        queued: {$sum: {$cond: [{$and: ['$nextRunAt', {$gte: [new Date(), '$nextRunAt']}, {$gte: ['$nextRunAt', '$lastFinishedAt']}]}, 1, 0]}},
-        completed: {$sum: {$cond: [{$and: ['$lastFinishedAt', {$gt: ['$lastFinishedAt', '$failedAt']}]}, 1, 0]}},
-        failed: {$sum: {$cond: [{$and: ['$lastFinishedAt', '$failedAt', {$eq: ['$lastFinishedAt', '$failedAt']}]}, 1, 0]}},
-        repeating: {$sum: {$cond: [{$and: ['$repeatInterval', {$ne: ['$repeatInterval', null]}]}, 1, 0]}}
-      }}
-    ]).toArray();
-    const states = {total: 0, running: 0, scheduled: 0, queued: 0, completed: 0, failed: 0, repeating: 0};
-    const totals = {displayName: 'All Jobs', ...states};
+    const results = await collection
+      .aggregate([
+        {
+          $group: {
+            _id: "$name",
+            displayName: { $first: "$name" },
+            meta: {
+              $addToSet: {
+                type: "$type",
+                priority: "$priority",
+                repeatInterval: "$repeatInterval",
+                repeatTimezone: "$repeatTimezone",
+              },
+            },
+            total: { $sum: 1 },
+            running: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      "$lastRunAt",
+                      { $gt: ["$lastRunAt", "$lastFinishedAt"] },
+                    ],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+            scheduled: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: ["$nextRunAt", { $gte: ["$nextRunAt", new Date()] }],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+            queued: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      "$nextRunAt",
+                      { $gte: [new Date(), "$nextRunAt"] },
+                      { $gte: ["$nextRunAt", "$lastFinishedAt"] },
+                    ],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+            completed: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      "$lastFinishedAt",
+                      { $gt: ["$lastFinishedAt", "$failedAt"] },
+                    ],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+            failed: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      "$lastFinishedAt",
+                      "$failedAt",
+                      { $eq: ["$lastFinishedAt", "$failedAt"] },
+                    ],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+            repeating: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      "$repeatInterval",
+                      { $ne: ["$repeatInterval", null] },
+                    ],
+                  },
+                  1,
+                  0,
+                ],
+              },
+            },
+          },
+        },
+      ])
+      .toArray();
+    const states = {
+      total: 0,
+      running: 0,
+      scheduled: 0,
+      queued: 0,
+      completed: 0,
+      failed: 0,
+      repeating: 0,
+    };
+    const totals = { displayName: "All Jobs", ...states };
 
     for (const job of results) {
       for (const state of Object.keys(states)) {
@@ -140,38 +246,49 @@ module.exports = function(agenda, options) {
     return results;
   };
 
-  const api = async function(job, state, {query: q, property, isObjectId, skip, limit}) {
+  const api = async function (
+    job,
+    state,
+    { query: q, property, isObjectId, skip, limit }
+  ) {
     if (!agenda) {
-      return Promise.reject(new Error('Agenda instance is not ready'));
+      return Promise.reject(new Error("Agenda instance is not ready"));
     }
 
     limit = Number.parseInt(limit, 10) || 200;
     skip = Number.parseInt(skip, 10) || 0;
 
-    const [overview, jobs] = await Promise.all([getOverview(), getJobs(job, state, {query: q, property, isObjectId, skip, limit})]);
+    const [overview, jobs] = await Promise.all([
+      getOverview(),
+      getJobs(job, state, { query: q, property, isObjectId, skip, limit }),
+    ]);
     const apiResponse = {
       overview,
       jobs: jobs[0].filtered,
-      totalPages: jobs[0].pages[0] ? jobs[0].pages[0].totalPages : 0
+      totalPages: jobs[0].pages[0] ? jobs[0].pages[0].totalPages : 0,
     };
-    apiResponse.title = options.title || 'Agendash';
+    apiResponse.title = options.title || "Agendash";
     apiResponse.currentRequest = {
-      title: options.title || 'Agendash',
-      job: job || 'All Jobs',
-      state
+      title: options.title || "Agendash",
+      job: job || "All Jobs",
+      state,
     };
     return apiResponse;
   };
 
-  const requeueJobs = async jobIds => {
+  const requeueJobs = async (jobIds) => {
     if (!agenda) {
-      return Promise.reject(new Error('Agenda instance is not ready'));
+      return Promise.reject(new Error("Agenda instance is not ready"));
     }
 
     const collection = agenda._collection.collection || agenda._collection;
-    const jobs = await collection.find({_id: {$in: jobIds.map(jobId => collection.s.pkFactory(jobId))}}).toArray();
+    const jobs = await collection
+      .find({
+        _id: { $in: jobIds.map((jobId) => ObjectId(jobId)) },
+      })
+      .toArray();
     if (jobs.length === 0) {
-      throw new Error('Job not found');
+      throw new Error("Job not found");
     }
 
     for (const job of jobs) {
@@ -180,21 +297,22 @@ module.exports = function(agenda, options) {
       await newJob.save();
     }
 
-    return 'Jobs create successfully';
+    return "Jobs create successfully";
   };
 
-  const deleteJobs = jobIds => {
+  const deleteJobs = (jobIds) => {
     if (!agenda) {
-      return Promise.reject(new Error('Agenda instance is not ready'));
+      return Promise.reject(new Error("Agenda instance is not ready"));
     }
 
-    const collection = agenda._collection.collection || agenda._collection;
-    return agenda.cancel({_id: {$in: jobIds.map(jobId => collection.s.pkFactory(jobId))}});
+    return agenda.cancel({
+      _id: { $in: jobIds.map((jobId) => ObjectId(jobId)) },
+    });
   };
 
   const createJob = (jobName, jobSchedule, jobRepeatEvery, jobData) => {
     if (!agenda) {
-      return Promise.reject(new Error('Agenda instance is not ready'));
+      return Promise.reject(new Error("Agenda instance is not ready"));
     }
 
     // @TODO: Need to validate user input.
@@ -207,7 +325,7 @@ module.exports = function(agenda, options) {
     } else if (jobRepeatEvery) {
       job.repeatEvery(jobRepeatEvery);
     } else {
-      return Promise.reject(new Error('Jobs not created'));
+      return Promise.reject(new Error("Jobs not created"));
     }
 
     return job.save();
@@ -217,6 +335,6 @@ module.exports = function(agenda, options) {
     api,
     requeueJobs,
     deleteJobs,
-    createJob
+    createJob,
   };
 };

package/lib/csp.js

@@ -0,0 +1,28 @@
+const CSP = {
+  "default-src": [
+    "'self'",
+  ],
+  "script-src": [
+    "https://code.jquery.com",
+    "https://cdn.jsdelivr.net",
+    "https://cdnjs.cloudflare.com",
+    "https://stackpath.bootstrapcdn.com",
+    "'unsafe-inline'",
+    "'unsafe-eval'",
+    "'self'",
+  ],
+  "style-src": [
+    "https://cdn.jsdelivr.net",
+    "https://stackpath.bootstrapcdn.com",
+    "https://fonts.googleapis.com",
+    "https://unpkg.com",
+    "'self'",
+  ],
+  "font-src": [
+    "https://fonts.gstatic.com",
+  ],
+};
+
+module.exports = Object.entries(CSP)
+    .map(([type, values]) => `${type} ${values.join(" ")}`)
+    .join("; ")

package/lib/middlewares/README.md

@@ -5,6 +5,7 @@
 Works with [Hapijs](https://hapijs.com/) >= v18
 
 ### usage
+
 First install the dependencies in your app:
 
 ```bash
@@ -12,11 +13,12 @@ npm install @hapi/hapi @hapi/inert agenda agendash
 ```
 
 Then use it as follows:
+
 ```javascript
 'use strict';
 
 const Hapi = require('hapi');
-const Agenda = require('agenda');
+const { Agenda } = require('agenda');
 const Agendash = require('agendash');
 
 var agenda = new Agenda({

package/lib/middlewares/express.js

@@ -1,25 +1,46 @@
-const path = require('path');
-const express = require('express');
-const bodyParser = require('body-parser');
+const path = require("path");
+const express = require("express");
+const bodyParser = require("body-parser");
+const csp = require("../csp");
 
-module.exports = agendash => {
-  const {api, requeueJobs, deleteJobs, createJob} = agendash;
+module.exports = (agendash) => {
+  const { api, requeueJobs, deleteJobs, createJob } = agendash;
   const app = express();
   app.use(bodyParser.json());
-  app.use(bodyParser.urlencoded({extended: false}));
-  app.use('/', express.static(path.join(__dirname, '../../public')));
+  app.use(bodyParser.urlencoded({ extended: false }));
 
-  app.get('/api', async(request, response) => {
+  app.use((req, res, next) => {
+    res.header("Content-Security-Policy", csp);
+    next();
+  });
+
+  app.use("/", express.static(path.join(__dirname, "../../public")));
+
+  app.get("/api", async (request, response) => {
     try {
-      const {job, state, skip, limit, q, property, isObjectId} = request.query;
-      const apiResponse = await api(job, state, {query: q, property, isObjectId, skip, limit});
+      const {
+        job,
+        state,
+        skip,
+        limit,
+        q,
+        property,
+        isObjectId,
+      } = request.query;
+      const apiResponse = await api(job, state, {
+        query: q,
+        property,
+        isObjectId,
+        skip,
+        limit,
+      });
       response.json(apiResponse);
     } catch (error) {
       response.status(400).json(error);
     }
   });
 
-  app.post('/api/jobs/requeue', async(request, response) => {
+  app.post("/api/jobs/requeue", async (request, response) => {
     try {
       const newJobs = await requeueJobs(request.body.jobIds);
       response.send(newJobs);
@@ -28,23 +49,28 @@ module.exports = agendash => {
     }
   });
 
-  app.post('/api/jobs/delete', async(request, response) => {
+  app.post("/api/jobs/delete", async (request, response) => {
     try {
       const deleted = await deleteJobs(request.body.jobIds);
       if (deleted) {
-        response.json({deleted: true});
+        response.json({ deleted: true });
       } else {
-        response.json({message: 'Jobs not deleted'});
+        response.json({ message: "Jobs not deleted" });
       }
     } catch (error) {
       response.status(404).json(error);
     }
   });
 
-  app.post('/api/jobs/create', async(request, response) => {
+  app.post("/api/jobs/create", async (request, response) => {
     try {
-      await createJob(request.body.jobName, request.body.jobSchedule, request.body.jobRepeatEvery, request.body.jobData);
-      response.json({created: true});
+      await createJob(
+        request.body.jobName,
+        request.body.jobSchedule,
+        request.body.jobRepeatEvery,
+        request.body.jobData
+      );
+      response.json({ created: true });
     } catch (error) {
       response.status(400).json(error);
     }

package/lib/middlewares/fastify.js

@@ -0,0 +1,77 @@
+const path = require("path");
+const csp = require("../csp");
+
+module.exports = (agendash) => (instance, opts, done) => {
+  const { api, requeueJobs, deleteJobs, createJob } = agendash;
+
+  instance.register(require("fastify-static"), {
+    root: path.join(__dirname, "../../public"),
+  });
+
+  instance.get("/", function (req, reply) {
+    reply.header("Content-Security-Policy", csp);
+    return reply.sendFile("index.html");
+  });
+
+  instance.get("/api", async (request, response) => {
+    try {
+      const {
+        job,
+        state,
+        skip,
+        limit,
+        q,
+        property,
+        isObjectId,
+      } = request.query;
+      const apiResponse = await api(job, state, {
+        query: q,
+        property,
+        isObjectId,
+        skip,
+        limit,
+      });
+      response.send(apiResponse);
+    } catch (error) {
+      response.status(400).send(error);
+    }
+  });
+
+  instance.post("/api/jobs/requeue", async (request, response) => {
+    try {
+      const newJobs = await requeueJobs(request.body.jobIds);
+      response.send(newJobs);
+    } catch (error) {
+      response.status(404).send(error);
+    }
+  });
+
+  instance.post("/api/jobs/delete", async (request, response) => {
+    try {
+      const deleted = await deleteJobs(request.body.jobIds);
+      if (deleted) {
+        response.send({ deleted: true });
+      } else {
+        response.send({ message: "Jobs not deleted" });
+      }
+    } catch (error) {
+      response.status(404).send(error);
+    }
+  });
+
+  instance.post("/api/jobs/create", async (request, response) => {
+    try {
+      await createJob(
+        request.body.jobName,
+        request.body.jobSchedule,
+        request.body.jobRepeatEvery,
+        request.body.jobData
+      );
+      response.send({ created: true });
+    } catch (error) {
+      response.status(400).send(error);
+    }
+  });
+
+  done();
+};