Move bulk of webhook logic to plugin (#4866)

* Move bulk of webhook logic to plugin

* Re-enable cleanup task

* cron tasks

server/routes/api/cron.ts

@@ -3,12 +3,7 @@ import { Context } from "koa";
 import Router from "koa-router";
 import env from "@server/env";
 import { AuthenticationError } from "@server/errors";
-import CleanupDeletedDocumentsTask from "@server/queues/tasks/CleanupDeletedDocumentsTask";
-import CleanupDeletedTeamsTask from "@server/queues/tasks/CleanupDeletedTeamsTask";
-import CleanupExpiredAttachmentsTask from "@server/queues/tasks/CleanupExpiredAttachmentsTask";
-import CleanupExpiredFileOperationsTask from "@server/queues/tasks/CleanupExpiredFileOperationsTask";
-import CleanupWebhookDeliveriesTask from "@server/queues/tasks/CleanupWebhookDeliveriesTask";
-import InviteReminderTask from "@server/queues/tasks/InviteReminderTask";
+import tasks from "@server/queues/tasks";
 
 const router = new Router();
 
@@ -34,17 +29,12 @@ const cronHandler = async (ctx: Context) => {
     throw AuthenticationError("Invalid secret token");
   }
 
-  await CleanupDeletedDocumentsTask.schedule({ limit });
-
-  await CleanupExpiredFileOperationsTask.schedule({ limit });
-
-  await CleanupExpiredAttachmentsTask.schedule({ limit });
-
-  await CleanupDeletedTeamsTask.schedule({ limit });
-
-  await CleanupWebhookDeliveriesTask.schedule({ limit });
-
-  await InviteReminderTask.schedule();
+  for (const name in tasks) {
+    const TaskClass = tasks[name];
+    if (TaskClass.cron) {
+      await TaskClass.schedule({ limit });
+    }
+  }
 
   ctx.body = {
     success: true,

server/routes/api/index.ts

@@ -32,7 +32,6 @@ import subscriptions from "./subscriptions";
 import team from "./team";
 import users from "./users";
 import views from "./views";
-import webhookSubscriptions from "./webhookSubscriptions";
 
 const api = new Koa<AppState, AppContext>();
 const router = new Router();
@@ -82,7 +81,6 @@ router.use("/", attachments.routes());
 router.use("/", utils.routes());
 router.use("/", groups.routes());
 router.use("/", fileOperationsRoute.routes());
-router.use("/", webhookSubscriptions.routes());
 
 if (env.ENVIRONMENT === "development") {
   router.use("/", developer.routes());

server/routes/api/webhookSubscriptions.ts

@@ -1,161 +0,0 @@
-import Router from "koa-router";
-import { compact, isEmpty } from "lodash";
-import { ValidationError } from "@server/errors";
-import auth from "@server/middlewares/authentication";
-import { WebhookSubscription, Event } from "@server/models";
-import { authorize } from "@server/policies";
-import { presentWebhookSubscription } from "@server/presenters";
-import { WebhookSubscriptionEvent, APIContext } from "@server/types";
-import { assertArray, assertPresent, assertUuid } from "@server/validation";
-import pagination from "./middlewares/pagination";
-
-const router = new Router();
-
-router.post(
-  "webhookSubscriptions.list",
-  auth({ admin: true }),
-  pagination(),
-  async (ctx: APIContext) => {
-    const { user } = ctx.state.auth;
-    authorize(user, "listWebhookSubscription", user.team);
-    const webhooks = await WebhookSubscription.findAll({
-      where: {
-        teamId: user.teamId,
-      },
-      order: [["createdAt", "DESC"]],
-      offset: ctx.state.pagination.offset,
-      limit: ctx.state.pagination.limit,
-    });
-
-    ctx.body = {
-      pagination: ctx.state.pagination,
-      data: webhooks.map(presentWebhookSubscription),
-    };
-  }
-);
-
-router.post(
-  "webhookSubscriptions.create",
-  auth({ admin: true }),
-  async (ctx: APIContext) => {
-    const { user } = ctx.state.auth;
-    authorize(user, "createWebhookSubscription", user.team);
-
-    const { name, url, secret } = ctx.request.body;
-    const events: string[] = compact(ctx.request.body.events);
-    assertPresent(name, "name is required");
-    assertPresent(url, "url is required");
-    assertArray(events, "events is required");
-    if (events.length === 0) {
-      throw ValidationError("events are required");
-    }
-
-    const webhookSubscription = await WebhookSubscription.create({
-      name,
-      events,
-      createdById: user.id,
-      teamId: user.teamId,
-      url,
-      enabled: true,
-      secret: isEmpty(secret) ? undefined : secret,
-    });
-
-    const event: WebhookSubscriptionEvent = {
-      name: "webhookSubscriptions.create",
-      modelId: webhookSubscription.id,
-      teamId: user.teamId,
-      actorId: user.id,
-      data: {
-        name,
-        url,
-        events,
-      },
-      ip: ctx.request.ip,
-    };
-    await Event.create(event);
-
-    ctx.body = {
-      data: presentWebhookSubscription(webhookSubscription),
-    };
-  }
-);
-
-router.post(
-  "webhookSubscriptions.delete",
-  auth({ admin: true }),
-  async (ctx: APIContext) => {
-    const { id } = ctx.request.body;
-    assertUuid(id, "id is required");
-    const { user } = ctx.state.auth;
-    const webhookSubscription = await WebhookSubscription.findByPk(id);
-
-    authorize(user, "delete", webhookSubscription);
-
-    await webhookSubscription.destroy();
-
-    const event: WebhookSubscriptionEvent = {
-      name: "webhookSubscriptions.delete",
-      modelId: webhookSubscription.id,
-      teamId: user.teamId,
-      actorId: user.id,
-      data: {
-        name: webhookSubscription.name,
-        url: webhookSubscription.url,
-        events: webhookSubscription.events,
-      },
-      ip: ctx.request.ip,
-    };
-    await Event.create(event);
-  }
-);
-
-router.post(
-  "webhookSubscriptions.update",
-  auth({ admin: true }),
-  async (ctx: APIContext) => {
-    const { id } = ctx.request.body;
-    assertUuid(id, "id is required");
-    const { user } = ctx.state.auth;
-
-    const { name, url, secret } = ctx.request.body;
-    const events: string[] = compact(ctx.request.body.events);
-    assertPresent(name, "name is required");
-    assertPresent(url, "url is required");
-    assertArray(events, "events is required");
-    if (events.length === 0) {
-      throw ValidationError("events are required");
-    }
-
-    const webhookSubscription = await WebhookSubscription.findByPk(id);
-
-    authorize(user, "update", webhookSubscription);
-
-    await webhookSubscription.update({
-      name,
-      url,
-      events,
-      enabled: true,
-      secret: isEmpty(secret) ? undefined : secret,
-    });
-
-    const event: WebhookSubscriptionEvent = {
-      name: "webhookSubscriptions.update",
-      modelId: webhookSubscription.id,
-      teamId: user.teamId,
-      actorId: user.id,
-      data: {
-        name: webhookSubscription.name,
-        url: webhookSubscription.url,
-        events: webhookSubscription.events,
-      },
-      ip: ctx.request.ip,
-    };
-    await Event.create(event);
-
-    ctx.body = {
-      data: presentWebhookSubscription(webhookSubscription),
-    };
-  }
-);
-
-export default router;