agendash 4.0.0 → 6.0.1

package/lib/controllers/agendash.js

@@ -1,341 +0,0 @@
-"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] = new 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: {
-            repeatInterval: -1,
-            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) => new 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) => new 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/csp.js

@@ -1,28 +0,0 @@
-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

@@ -1,59 +0,0 @@
-# Middlewares
-
-## Hapi
-
-Works with [Hapijs](https://hapijs.com/) >= v18
-
-### usage
-
-First install the dependencies in your app:
-
-```bash
-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 Agendash = require('agendash');
-
-var agenda = new Agenda({
-    db: { address: '<mongoUrl>'
-});
-
-const server = Hapi.server({
-  port: 3000,
-  host: 'localhost'
-});
-
-const init = async () => {
-
-  await server.register(
-    require('@hapi/inert'),
-    {
-      plugin: Agendash(agenda, {
-        middleware: 'hapi'
-        // can place other options (e.g. title) here
-      }),
-      options: {},
-      routes: {
-        prefix: '/agendash'
-      }
-    }
-  );
-
-  await server.start();
-  console.log(`Server running at: ${server.info.uri}`);
-};
-
-process.on('unhandledRejection', (err) => {
-  console.log(err);
-  process.exit(1);
-});
-
-init();
-```

package/lib/middlewares/express.js

@@ -1,80 +0,0 @@
-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;
-  const app = express();
-  app.use(bodyParser.json());
-  app.use(bodyParser.urlencoded({ extended: false }));
-
-  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,
-      });
-      response.json(apiResponse);
-    } catch (error) {
-      response.status(400).json(error);
-    }
-  });
-
-  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", async (request, response) => {
-    try {
-      const deleted = await deleteJobs(request.body.jobIds);
-      if (deleted) {
-        response.json({ deleted: true });
-      } else {
-        response.json({ message: "Jobs not deleted" });
-      }
-    } catch (error) {
-      response.status(404).json(error);
-    }
-  });
-
-  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;
-};

package/lib/middlewares/fastify.js

@@ -1,77 +0,0 @@
-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();
-};

package/lib/middlewares/hapi.js

@@ -1,101 +0,0 @@
-const path = require("path");
-const pack = require("../../package.json");
-const csp = require("../csp");
-
-module.exports = (agendash) => {
-  const { api, requeueJobs, deleteJobs, createJob } = agendash;
-  return {
-    pkg: pack,
-    register: (server, options) => {
-      server.ext("onPreResponse", (req, h) => {
-        req.response.header("Content-Security-Policy", csp);
-        return h.continue;
-      });
-
-      server.route([
-        {
-          method: "GET",
-          path: "/{param*}",
-          handler: {
-            directory: {
-              path: path.join(__dirname, "../../public"),
-            },
-          },
-          config: {
-            auth: options.auth || false,
-          },
-        },
-        {
-          method: "GET",
-          path: "/api",
-          handler(request) {
-            const {
-              job,
-              state,
-              limit,
-              skip,
-              q,
-              property,
-              isObjectId,
-            } = request.query;
-            return api(job, state, {
-              query: q,
-              property,
-              isObjectId,
-              skip,
-              limit,
-            });
-          },
-          config: {
-            auth: options.auth || false,
-          },
-        },
-        {
-          method: "POST",
-          path: "/api/jobs/requeue",
-          handler(request) {
-            return requeueJobs(request.payload.jobIds);
-          },
-          config: {
-            auth: options.auth || false,
-          },
-        },
-        {
-          method: "POST",
-          path: "/api/jobs/delete",
-          async handler(request, h) {
-            const deleted = await deleteJobs(request.payload.jobIds);
-            if (deleted) {
-              return h.response({ deleted: true });
-            }
-
-            return h.code(404);
-          },
-          config: {
-            auth: options.auth || false,
-          },
-        },
-        {
-          method: "POST",
-          path: "/api/jobs/create",
-          async handler(request, h) {
-            const created = await createJob(
-              request.payload.jobName,
-              request.payload.jobSchedule,
-              request.payload.jobRepeatEvery,
-              request.payload.jobData
-            );
-            if (created) {
-              return h.response({ created: true });
-            }
-
-            return h.code(404);
-          },
-          config: {
-            auth: options.auth || false,
-          },
-        },
-      ]);
-    },
-  };
-};