agendash 1.0.0 → 3.0.0

package/bin/agendash-standalone-koa.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+const { Agenda } = require("agenda");
+const agendash = require("../app");
+const Koa = require("koa");
+const program = require("commander");
+
+program
+  .option(
+    "-d, --db <db>",
+    "[required] Mongo connection string, same as Agenda connection string"
+  )
+  .option(
+    "-c, --collection <collection>",
+    "[optional] Mongo collection, same as Agenda collection name, default agendaJobs",
+    "agendaJobs"
+  )
+  .option(
+    "-p, --port <port>",
+    "[optional] Server port, default 3000",
+    (n, d) => Number(n) || d,
+    3000
+  )
+  .option(
+    "-t, --title <title>",
+    "[optional] Page title, default Agendash",
+    "Agendash"
+  )
+  .parse(process.argv);
+
+if (!program.db) {
+  console.error("--db required");
+  process.exit(1);
+}
+
+const init = async () => {
+  const agenda = new Agenda().database(program.db, program.collection);
+
+  const app = new Koa();
+  const middlewares = agendash(agenda, {
+    middleware: "koa",
+  });
+  for (const middleware of middlewares) {
+    app.use(middleware);
+  }
+
+  await app.listen(program.port);
+  console.log("Server running on port %s", program.port);
+};
+
+process.on("unhandledRejection", (error) => {
+  console.log(error);
+  process.exit(1);
+});
+
+init();

package/bin/agendash-standalone.js

@@ -1,32 +1,64 @@
 #!/usr/bin/env node
-'use strict';
-const http = require('http');
-const Agenda = require('agenda');
-const express = require('express');
-const program = require('commander');
+"use strict";
+const http = require("http");
+const { Agenda } = require("agenda");
+const agendash = require("../app");
+const express = require("express");
+const program = require("commander");
 
 program
-  .option('-d, --db <db>', '[required] Mongo connection string, same as Agenda connection string')
-  .option('-c, --collection <collection>', '[optional] Mongo collection, same as Agenda collection name, default agendaJobs', 'agendaJobs')
-  .option('-p, --port <port>', '[optional] Server port, default 3000', (n, d) => Number(n) || d, 3000)
-  .option('-t, --title <title>', '[optional] Page title, default Agendash', 'Agendash')
+  .option(
+    "-d, --db <db>",
+    "[required] Mongo connection string, same as Agenda connection string"
+  )
+  .option(
+    "-c, --collection <collection>",
+    "[optional] Mongo collection, same as Agenda collection name, default agendaJobs",
+    "agendaJobs"
+  )
+  .option(
+    "-p, --port <port>",
+    "[optional] Server port, default 3000",
+    (n, d) => Number(n) || d,
+    3000
+  )
+  .option(
+    "-t, --title <title>",
+    "[optional] Page title, default Agendash",
+    "Agendash"
+  )
+  .option(
+    "-p, --path <path>",
+    "[optional] Path to bind Agendash to, default /",
+    "/"
+  )
   .parse(process.argv);
 
 if (!program.db) {
-  console.error('--db required');
+  console.error("--db required");
+  process.exit(1);
+}
+
+if (!program.path.startsWith("/")) {
+  console.error("--path must begin with /");
   process.exit(1);
 }
 
 const app = express();
 
 const agenda = new Agenda().database(program.db, program.collection);
-app.use('/', require('../app')(agenda, {
-  title: program.title
-}));
+app.use(
+  program.path,
+  agendash(agenda, {
+    title: program.title,
+  })
+);
 
-app.set('port', program.port);
+app.set("port", program.port);
 
 const server = http.createServer(app);
 server.listen(program.port, () => {
-  console.log(`Agendash started http://localhost:${program.port}`);
+  console.log(
+    `Agendash started http://localhost:${program.port}${program.path}`
+  );
 });

package/entrypoint.sh

@@ -2,4 +2,4 @@
 
 set +e
 
-exec node ./bin/agendash-standalone.js --db=$MONGODB_URI --collection=$COLLECTION
+exec node ./bin/agendash-standalone.js --db=$MONGODB_URI --collection=$COLLECTION --path=$BASE_PATH

package/lib/controllers/agendash.js

@@ -0,0 +1,340 @@
+"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) {
+  options = options || {};
+
+  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
+        }
+      }
+    );
+
+    // Mongoose internals changed at some point. This will fix crash for older versions.
+    const mdb = agenda._mdb.admin ? agenda._mdb : agenda._mdb.db;
+
+    mdb.admin().serverInfo((error, serverInfo) => {
+      if (error) {
+        throw error;
+      }
+
+      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 preMatch = {};
+    if (job) {
+      preMatch.name = job;
+    }
+
+    if (options.query && options.property) {
+      if (options.isObjectId) {
+        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" };
+      }
+    }
+
+    const postMatch = {};
+    if (state) {
+      postMatch[state] = true;
+    }
+
+    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();
+  };
+
+  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 };
+
+    for (const job of results) {
+      for (const state of Object.keys(states)) {
+        totals[state] += job[state];
+      }
+    }
+
+    results.unshift(totals);
+    return results;
+  };
+
+  const api = async function (
+    job,
+    state,
+    { query: q, property, isObjectId, skip, limit }
+  ) {
+    if (!agenda) {
+      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 apiResponse = {
+      overview,
+      jobs: jobs[0].filtered,
+      totalPages: jobs[0].pages[0] ? jobs[0].pages[0].totalPages : 0,
+    };
+    apiResponse.title = options.title || "Agendash";
+    apiResponse.currentRequest = {
+      title: options.title || "Agendash",
+      job: job || "All Jobs",
+      state,
+    };
+    return apiResponse;
+  };
+
+  const requeueJobs = async (jobIds) => {
+    if (!agenda) {
+      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) => ObjectId(jobId)) },
+      })
+      .toArray();
+    if (jobs.length === 0) {
+      throw new Error("Job not found");
+    }
+
+    for (const job of jobs) {
+      const newJob = agenda.create(job.name, job.data);
+      // eslint-disable-next-line no-await-in-loop
+      await newJob.save();
+    }
+
+    return "Jobs create successfully";
+  };
+
+  const deleteJobs = (jobIds) => {
+    if (!agenda) {
+      return Promise.reject(new Error("Agenda instance is not ready"));
+    }
+
+    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"));
+    }
+
+    // @TODO: Need to validate user input.
+    const job = agenda.create(jobName, jobData);
+    if (jobSchedule && jobRepeatEvery) {
+      job.repeatAt(jobSchedule);
+      job.repeatEvery(jobRepeatEvery);
+    } else if (jobSchedule) {
+      job.schedule(jobSchedule);
+    } else if (jobRepeatEvery) {
+      job.repeatEvery(jobRepeatEvery);
+    } else {
+      return Promise.reject(new Error("Jobs not created"));
+    }
+
+    return job.save();
+  };
+
+  return {
+    api,
+    requeueJobs,
+    deleteJobs,
+    createJob,
+  };
+};

package/lib/middlewares/README.md

@@ -1,17 +1,24 @@
 # Middlewares
+
 ## Hapi
-Works with [Hapijs](https://hapijs.com/) >= v17
+
+Works with [Hapijs](https://hapijs.com/) >= v18
+
 ### usage
+
 First install the dependencies in your app:
+
 ```bash
-npm install hapi inert agenda agendash
+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({
@@ -26,7 +33,7 @@ const server = Hapi.server({
 const init = async () => {
 
   await server.register(
-    require('inert'),
+    require('@hapi/inert'),
     {
       plugin: Agendash(agenda, {
         middleware: 'hapi'
@@ -49,4 +56,4 @@ process.on('unhandledRejection', (err) => {
 });
 
 init();
-```
+```

package/lib/middlewares/express.js

@@ -1,48 +1,72 @@
-'use strict';
-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");
 
-module.exports = 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.use("/", express.static(path.join(__dirname, "../../public")));
 
-  app.get('/api', (req, res) => {
-    agendash.api(req.query.job, req.query.state, (err, apiResponse) => {
-      if (err) {
-        return res.status(400).json(err);
-      }
-      res.json(apiResponse);
-    });
+  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,
+      });
+      response.json(apiResponse);
+    } catch (error) {
+      response.status(400).json(error);
+    }
   });
 
-  app.post('/api/jobs/requeue', (req, res) => {
-    agendash.requeueJobs(req.body.jobIds, (err, newJobs) => {
-      if (err || !newJobs) {
-        return res.status(404).json(err);
-      }
-      res.json(newJobs);
-    });
+  app.post("/api/jobs/requeue", async (request, response) => {
+    try {
+      const newJobs = await requeueJobs(request.body.jobIds);
+      response.send(newJobs);
+    } catch (error) {
+      response.status(404).json(error);
+    }
   });
 
-  app.post('/api/jobs/delete', (req, res) => {
-    agendash.deleteJobs(req.body.jobIds, err => {
-      if (err) {
-        return res.status(404).json(err);
+  app.post("/api/jobs/delete", async (request, response) => {
+    try {
+      const deleted = await deleteJobs(request.body.jobIds);
+      if (deleted) {
+        response.json({ deleted: true });
+      } else {
+        response.json({ message: "Jobs not deleted" });
       }
-      return res.json({deleted: true});
-    });
+    } catch (error) {
+      response.status(404).json(error);
+    }
   });
 
-  app.post('/api/jobs/create', (req, res) => {
-    agendash.createJob(req.body.jobName, req.body.jobSchedule, req.body.jobRepeatEvery, req.body.jobData, err => {
-      if (err) {
-        return res.status(404).json(err);
-      }
-      return res.json({created: true});
-    });
+  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 });
+    } catch (error) {
+      response.status(400).json(error);
+    }
   });
 
   return app;